diff --git a/.github/workflows/ci-build.yml b/.github/workflows/ci-build.yml
index ebafe1cf8..e5f9f3baf 100644
--- a/.github/workflows/ci-build.yml
+++ b/.github/workflows/ci-build.yml
@@ -21,7 +21,7 @@ jobs:
         lfs: true
 
     - name: Setup .NET (With cache)
-      uses: actions/setup-dotnet@v5.0.1
+      uses: actions/setup-dotnet@v5.3.0
       with:
         dotnet-version: |
             6.0.x
@@ -37,12 +37,20 @@ jobs:
             **/global.json
             **/nuget.config
 
-    - name: NBGV
+    - name: Install (or update) nbgv tool
+      run: dotnet tool update --global nbgv
+
+    - name: Set NBGV cloud variables
+      run: nbgv cloud -a
+
+    - name: Expose NBGV version as step outputs
       id: nbgv
-      uses: dotnet/nbgv@v0.5.1
-      with:
-        setAllVars: true
-        
+      shell: pwsh
+      run: |
+        $ErrorActionPreference = 'Stop'
+        "SemVer2=$env:NBGV_SemVer2" >> $env:GITHUB_OUTPUT
+        "PrereleaseVersion=$env:NBGV_PrereleaseVersion" >> $env:GITHUB_OUTPUT
+
     - name: NuGet Restore
       run: dotnet restore DynamicData.sln
       working-directory: src
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 643ae46fd..50f8371d1 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -40,7 +40,7 @@ jobs:
         Write-Host "OK: publishing from '$env:REF_NAME'."
 
     - name: Setup .NET (With cache)
-      uses: actions/setup-dotnet@v5.0.1
+      uses: actions/setup-dotnet@v5.3.0
       with:
         dotnet-version: |
             6.0.x
@@ -56,11 +56,19 @@ jobs:
             **/global.json
             **/nuget.config
 
-    - name: NBGV
+    - name: Install (or update) nbgv tool
+      run: dotnet tool update --global nbgv
+
+    - name: Set NBGV cloud variables
+      run: nbgv cloud -a
+
+    - name: Expose NBGV version as step outputs
       id: nbgv
-      uses: dotnet/nbgv@v0.5.1
-      with:
-        setAllVars: true
+      shell: pwsh
+      run: |
+        $ErrorActionPreference = 'Stop'
+        "SemVer2=$env:NBGV_SemVer2" >> $env:GITHUB_OUTPUT
+        "PrereleaseVersion=$env:NBGV_PrereleaseVersion" >> $env:GITHUB_OUTPUT
 
     - name: Verify version matches branch policy
       shell: pwsh
@@ -126,21 +134,24 @@ jobs:
           if ($LASTEXITCODE -ne 0) { throw "dotnet nuget push failed for $($pkg.Name) (exit $LASTEXITCODE)." }
         }
 
-    - name: Changelog
-      uses: glennawatson/ChangeLog@0464dd89b26f61fecf24b41d675f8ffdb11c4c3f # v1
-      id: changelog
+    - name: Install GitReleaseNoteGenerator
+      run: dotnet tool install -g GitReleaseNoteGenerator
+
+    - name: Generate release notes
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+        RELEASE_VERSION: ${{ steps.nbgv.outputs.SemVer2 }}
+      shell: pwsh
+      run: git-release-notes --release-version "$env:RELEASE_VERSION" --output-file release-notes.md
 
     - name: Create GitHub Release
       env:
         GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         TAG: ${{ steps.nbgv.outputs.SemVer2 }}
         IS_PRERELEASE: ${{ steps.nbgv.outputs.PrereleaseVersion != '' }}
-        BODY: ${{ steps.changelog.outputs.commitLog }}
       shell: pwsh
       run: |
         $ErrorActionPreference = 'Stop'
-        $notesPath = Join-Path $env:RUNNER_TEMP 'release-notes.md'
-        Set-Content -Path $notesPath -Value $env:BODY -Encoding utf8 -NoNewline
-        $cmd = @('release', 'create', $env:TAG, '--title', $env:TAG, '--notes-file', $notesPath, '--target', $env:GITHUB_SHA)
+        $cmd = @('release', 'create', $env:TAG, '--title', $env:TAG, '--notes-file', 'release-notes.md', '--target', $env:GITHUB_SHA)
         if ($env:IS_PRERELEASE -eq 'true') { $cmd += '--prerelease' }
         gh @cmd
diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets
index 347ab888d..d341fbbbd 100644
--- a/src/Directory.Build.targets
+++ b/src/Directory.Build.targets
@@ -3,6 +3,13 @@
     <Product>$(AssemblyName) ($(TargetFramework))</Product>
   </PropertyGroup>
 
+  <ItemGroup>
+    <!-- Automatic file nesting, for .cs files-->
+    <Compile Update="**\*.*.cs">
+      <DependentUpon>$([System.Text.RegularExpressions.Regex]::Replace(%(Filename), '\.[^\.]+$', '.cs'))</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
   <PropertyGroup Condition="$(TargetFramework.StartsWith('net4'))">
     <DefineConstants>$(DefineConstants);P_LINQ;SUPPORTS_BINDINGLIST</DefineConstants>
   </PropertyGroup>
diff --git a/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet9_0.verified.txt b/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet9_0.verified.txt
index ff1f94916..a225bfe5f 100644
--- a/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet9_0.verified.txt
+++ b/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet9_0.verified.txt
@@ -1964,6 +1964,14 @@ namespace DynamicData
             where TDestination :  notnull
             where TSource :  notnull
             where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.CancellationToken, System.Threading.Tasks.Task<TDestination>> transformFactory, DynamicData.TransformAsyncOptions options)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.CancellationToken, System.Threading.Tasks.Task<TDestination>> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
         public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformImmutable<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory)
             where TDestination :  notnull
             where TSource :  notnull
@@ -2108,6 +2116,14 @@ namespace DynamicData
             where TDestination :  notnull
             where TSource :  notnull
             where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.CancellationToken, System.Threading.Tasks.Task<TDestination>> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, DynamicData.TransformAsyncOptions options)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.CancellationToken, System.Threading.Tasks.Task<TDestination>> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
         public static System.IObservable<DynamicData.IChangeSet<DynamicData.Node<TObject, TKey>, TKey>> TransformToTree<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey> pivotOn, System.IObservable<System.Func<DynamicData.Node<TObject, TKey>, bool>>? predicateChanged = null)
             where TObject :  class
             where TKey :  notnull { }
@@ -2481,6 +2497,9 @@ namespace DynamicData
         public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, int, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
             where TSource :  notnull
             where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, int, System.Threading.CancellationToken, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
         public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.IObservableList<TDestination>> manySelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null)
             where TDestination :  notnull
             where TSource :  notnull { }
@@ -3100,4 +3119,4 @@ namespace DynamicData.Tests
         public void Dispose() { }
         protected virtual void Dispose(bool isDisposing) { }
     }
-}
+}
\ No newline at end of file
diff --git a/src/DynamicData.Tests/AggregationTests/SumFixture.ForCache.cs b/src/DynamicData.Tests/AggregationTests/SumFixture.ForCache.cs
new file mode 100644
index 000000000..078a8f1b0
--- /dev/null
+++ b/src/DynamicData.Tests/AggregationTests/SumFixture.ForCache.cs
@@ -0,0 +1,517 @@
+using System;
+
+using DynamicData.Aggregation;
+using DynamicData.Tests.Domain;
+using DynamicData.Tests.Utilities;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.AggregationTests;
+
+public partial class SumFixture
+{
+    public class ForCache
+    {
+        [Theory]
+        [InlineData(1, 10)]
+        [InlineData(3, 60)]
+        public void ItemsAreAdded_SumReflectsAllItems(int itemCount, int expectedSum)
+        {
+            var ages = new[] { 10, 20, 30 };
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().BeEmpty("no items have been added to the source");
+
+            // UUT Action
+            for (var i = 0; i < itemCount; i++)
+            {
+                source.AddOrUpdate(new Person(((char)('A' + i)).ToString(), ages[i]));
+            }
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(itemCount, "each AddOrUpdate should produce a new sum emission");
+            results.RecordedValues[^1].Should().Be(expectedSum, $"the sum of the first {itemCount} ages should be {expectedSum}");
+        }
+
+        [Theory]
+        [InlineData("A", 50)]
+        [InlineData("B", 40)]
+        [InlineData("C", 30)]
+        public void ItemIsRemoved_SumReflectsRemoval(string keyToRemove, int expectedSum)
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(60, "the sum of ages 10 + 20 + 30 is 60");
+
+            // UUT Action
+            source.Remove(keyToRemove);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after the removal");
+            results.RecordedValues[^1].Should().Be(expectedSum, $"removing '{keyToRemove}' should leave a sum of {expectedSum}");
+        }
+
+        [Fact]
+        public void ItemIsUpdated_SumReflectsNewValue()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(30, "the sum of ages 10 + 20 is 30");
+
+            // UUT Action: update "B" from age 20 to age 50 (same key, new value)
+            source.AddOrUpdate(new Person("B", 50));
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after the update");
+            results.RecordedValues[^1].Should().Be(60, "updating 'B' from 20 to 50 should change the sum from 30 to 60");
+        }
+
+        [Fact]
+        public void MultipleChangesInBatch_SingleSumEmitted()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().BeEmpty("no items have been added to the source");
+
+            // UUT Action: add 3 items in a single batch
+            source.Edit(updater =>
+            {
+                updater.AddOrUpdate(new Person("A", 10));
+                updater.AddOrUpdate(new Person("B", 20));
+                updater.AddOrUpdate(new Person("C", 30));
+            });
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("a batched edit should produce exactly one sum emission")
+                .Which.Should().Be(60, "the sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void SourceIsEmpty_NoSumEmitted()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void AllItemsRemoved_SumReturnsToZero()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(60, "the sum of ages 10 + 20 + 30 is 60");
+
+            // UUT Action: remove all items in a single batch
+            source.Edit(updater => updater.Clear());
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after clearing");
+            results.RecordedValues[^1].Should().Be(0, "all items were removed so the sum should return to zero");
+        }
+
+        [Fact]
+        public void SourceCompletesAfterEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing the pre-existing item")
+                .Which.Should().Be(10, "the sum of a single age of 10 is 10");
+
+            // UUT Action
+            source.Complete();
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source has completed");
+        }
+
+        [Fact]
+        public void SourceCompletesWithoutEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().BeEmpty("no items were added to the source");
+
+            // UUT Action
+            source.Complete();
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source has completed");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceCompletesImmediately_InitialSumAndCompletionPropagate()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+            source.Complete();
+
+            // UUT Construction: source is already completed, with pre-existing items.
+            // Subscription should produce both an initial sum and a completion, synchronously.
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source was already completed at the time of subscription");
+            results.RecordedValues.Should().ContainSingle("an initial sum value should still be emitted, even when the source completes immediately upon subscription")
+                .Which.Should().Be(60, "the sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void SourceCompletesImmediatelyWithoutEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.Complete();
+
+            // UUT Construction: source is already completed, with no items.
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source was already completed at the time of subscription");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceErrorsAfterEmitting_ErrorPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing the pre-existing item");
+
+            // UUT Action
+            var error = new Exception("Test error");
+            source.SetError(error);
+
+            results.Error.Should().BeSameAs(error, "the error from the source should propagate to the subscriber");
+            results.HasCompleted.Should().BeFalse("an error is not a completion");
+        }
+
+        [Fact]
+        public void SourceErrorsWithoutEmitting_ErrorPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().BeEmpty("no items were added to the source");
+
+            // UUT Action
+            var error = new Exception("Test error");
+            source.SetError(error);
+
+            results.Error.Should().BeSameAs(error, "the error from the source should propagate to the subscriber");
+            results.HasCompleted.Should().BeFalse("an error is not a completion");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceFailsImmediately_ErrorPropagates()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            var error = new Exception("Test error");
+            source.SetError(error);
+
+            // UUT Construction: source is already in error state.
+            // The error should propagate synchronously upon subscription.
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeSameAs(error, "the error from the source should propagate to the subscriber immediately upon subscription");
+            results.HasCompleted.Should().BeFalse("an error is not a completion");
+        }
+
+        [Fact]
+        public void NullableValuesAreTreatedAsZero()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", new int?(10), "F", null));
+            source.AddOrUpdate(new Person("B", null, "F", null));
+            source.AddOrUpdate(new Person("C", new int?(30), "F", null));
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(p => p.AgeNullable)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(40, "null values should be treated as zero, so the sum should be 10 + 0 + 30 = 40");
+        }
+
+        [Theory]
+        [InlineData(new[] { 10, 20, 30 }, 60)]
+        [InlineData(new[] { int.MaxValue }, int.MaxValue)]
+        [InlineData(new[] { int.MinValue }, int.MinValue)]
+        [InlineData(new[] { int.MaxValue, -1 }, int.MaxValue - 1)]
+        [InlineData(new[] { int.MinValue, 1 }, int.MinValue + 1)]
+        public void ItemsAreAdded_SumIsCorrect_ForInt(int[] ages, int expectedSum)
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            for (var i = 0; i < ages.Length; i++)
+            {
+                source.AddOrUpdate(new Person(((char)('A' + i)).ToString(), ages[i]));
+            }
+
+            using var subscription = source.Connect()
+                .Sum(p => p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(expectedSum, $"the int sum of [{string.Join(", ", ages)}] is {expectedSum}");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableInt()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", new int?(10), "F", null));
+            source.AddOrUpdate(new Person("B", new int?(20), "F", null));
+            source.AddOrUpdate(new Person("C", new int?(30), "F", null));
+
+            using var subscription = source.Connect()
+                .Sum(p => p.AgeNullable)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60, "the nullable int sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForLong()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (long)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60L, "the long sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableLong()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (long?)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60L, "the nullable long sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForDouble()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (double)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60.0, "the double sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableDouble()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (double?)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60.0, "the nullable double sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForDecimal()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (decimal)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60M, "the decimal sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableDecimal()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (decimal?)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60M, "the nullable decimal sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForFloat()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (float)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60F, "the float sum of ages 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableFloat()
+        {
+            using var source = new TestSourceCache<Person, string>(p => p.Name);
+
+            source.AddOrUpdate(new Person("A", 10));
+            source.AddOrUpdate(new Person("B", 20));
+            source.AddOrUpdate(new Person("C", 30));
+
+            using var subscription = source.Connect()
+                .Sum(p => (float?)p.Age)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60F, "the nullable float sum of ages 10 + 20 + 30 is 60");
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/AggregationTests/SumFixture.ForList.cs b/src/DynamicData.Tests/AggregationTests/SumFixture.ForList.cs
new file mode 100644
index 000000000..9e9108602
--- /dev/null
+++ b/src/DynamicData.Tests/AggregationTests/SumFixture.ForList.cs
@@ -0,0 +1,413 @@
+using System;
+using System.Linq;
+
+using DynamicData.Aggregation;
+using DynamicData.Tests.Utilities;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.AggregationTests;
+
+public partial class SumFixture
+{
+    public class ForList
+    {
+        [Theory]
+        [InlineData(1, 10)]
+        [InlineData(3, 60)]
+        public void ItemsAreAdded_SumReflectsAllItems(int itemCount, int expectedSum)
+        {
+            var items = new[] { 10, 20, 30 };
+            using var source = new TestSourceList<int>();
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().BeEmpty("no items have been added to the source");
+
+            // UUT Action
+            source.AddRange(items.Take(itemCount));
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("an AddRange produces a single changeset")
+                .Which.Should().Be(expectedSum, $"the sum of the first {itemCount} items should be {expectedSum}");
+        }
+
+        [Theory]
+        [InlineData(0, 50)]
+        [InlineData(1, 40)]
+        [InlineData(2, 30)]
+        public void ItemIsRemoved_SumReflectsRemoval(int removalIndex, int expectedSum)
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(60, "the sum of items 10 + 20 + 30 is 60");
+
+            // UUT Action
+            source.RemoveAt(removalIndex);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after the removal");
+            results.RecordedValues[^1].Should().Be(expectedSum, $"removing item at index {removalIndex} should leave a sum of {expectedSum}");
+        }
+
+        [Fact]
+        public void ItemIsReplaced_SumReflectsReplacement()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(60, "the sum of items 10 + 20 + 30 is 60");
+
+            // UUT Action: replace item at index 1 (value 20) with 50
+            source.ReplaceAt(1, 50);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after the replacement");
+            results.RecordedValues[^1].Should().Be(90, "replacing 20 with 50 should change the sum from 60 to 90");
+        }
+
+        [Fact]
+        public void ItemsAreCleared_SumReturnsToZero()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items")
+                .Which.Should().Be(60, "the sum of items 10 + 20 + 30 is 60");
+
+            // UUT Action
+            source.Clear();
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().HaveCount(2, "one additional sum value should have been emitted after clearing");
+            results.RecordedValues[^1].Should().Be(0, "all items were removed so the sum should return to zero");
+        }
+
+        [Fact]
+        public void SourceIsEmpty_NoSumEmitted()
+        {
+            using var source = new TestSourceList<int>();
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceCompletesAfterEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeFalse("the source can still publish notifications");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items");
+
+            // UUT Action
+            source.Complete();
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source has completed");
+        }
+
+        [Fact]
+        public void SourceCompletesWithoutEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceList<int>();
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.RecordedValues.Should().BeEmpty("no items were added to the source");
+
+            // UUT Action
+            source.Complete();
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source has completed");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceCompletesImmediately_InitialSumAndCompletionPropagate()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+            source.Complete();
+
+            // UUT Construction: source is already completed, with pre-existing items.
+            // Subscription should produce both an initial sum and a completion, synchronously.
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source was already completed at the time of subscription");
+            results.RecordedValues.Should().ContainSingle("an initial sum value should still be emitted, even when the source completes immediately upon subscription")
+                .Which.Should().Be(60, "the sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void SourceCompletesImmediatelyWithoutEmitting_CompletionPropagates()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.Complete();
+
+            // UUT Construction: source is already completed, with no items.
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.HasCompleted.Should().BeTrue("the source was already completed at the time of subscription");
+            results.RecordedValues.Should().BeEmpty("no items were added so no sum values should have been emitted");
+        }
+
+        [Fact]
+        public void SourceErrorsAfterEmitting_ErrorPropagates()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            // UUT Construction
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeNull("no errors should have occurred");
+            results.RecordedValues.Should().ContainSingle("one changeset was published containing all pre-existing items");
+
+            // UUT Action
+            var error = new Exception("Test error");
+            source.SetError(error);
+
+            results.Error.Should().BeSameAs(error, "the error from the source should propagate to the subscriber");
+            results.HasCompleted.Should().BeFalse("an error is not a completion");
+        }
+
+        [Fact]
+        public void SourceFailsImmediately_ErrorPropagates()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+            var error = new Exception("Test error");
+            source.SetError(error);
+
+            // UUT Construction: source is already in error state.
+            // The error should propagate synchronously upon subscription.
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .ValidateSynchronization()
+                .RecordValues(out var results);
+
+            results.Error.Should().BeSameAs(error, "the error from the source should propagate to the subscriber immediately upon subscription");
+            results.HasCompleted.Should().BeFalse("an error is not a completion");
+        }
+
+        [Theory]
+        [InlineData(new[] { 10, 20, 30 }, 60)]
+        [InlineData(new[] { int.MaxValue }, int.MaxValue)]
+        [InlineData(new[] { int.MinValue }, int.MinValue)]
+        [InlineData(new[] { int.MaxValue, -1 }, int.MaxValue - 1)]
+        [InlineData(new[] { int.MinValue, 1 }, int.MinValue + 1)]
+        public void ItemsAreAdded_SumIsCorrect_ForInt(int[] values, int expectedSum)
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(values);
+
+            using var subscription = source.Connect()
+                .Sum(x => x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(expectedSum, $"the int sum of [{string.Join(", ", values)}] is {expectedSum}");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableInt()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (int?)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60, "the nullable int sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForLong()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (long)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60L, "the long sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableLong()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (long?)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60L, "the nullable long sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForDouble()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (double)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60.0, "the double sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableDouble()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (double?)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60.0, "the nullable double sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForDecimal()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (decimal)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60M, "the decimal sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableDecimal()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (decimal?)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60M, "the nullable decimal sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForFloat()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (float)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60F, "the float sum of items 10 + 20 + 30 is 60");
+        }
+
+        [Fact]
+        public void ItemsAreAdded_SumIsCorrect_ForNullableFloat()
+        {
+            using var source = new TestSourceList<int>();
+
+            source.AddRange(new[] { 10, 20, 30 });
+
+            using var subscription = source.Connect()
+                .Sum(x => (float?)x)
+                .RecordValues(out var results);
+
+            results.RecordedValues[^1].Should().Be(60F, "the nullable float sum of items 10 + 20 + 30 is 60");
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/AggregationTests/SumFixture.cs b/src/DynamicData.Tests/AggregationTests/SumFixture.cs
deleted file mode 100644
index 6fecbcabc..000000000
--- a/src/DynamicData.Tests/AggregationTests/SumFixture.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-using System;
-
-using DynamicData.Aggregation;
-using DynamicData.Tests.Domain;
-
-using FluentAssertions;
-
-using Xunit;
-
-namespace DynamicData.Tests.AggregationTests;
-
-public class SumFixture : IDisposable
-{
-    private readonly SourceCache<Person, string> _source;
-
-    public SumFixture() => _source = new SourceCache<Person, string>(p => p.Name);
-
-    [Fact]
-    public void AddedItemsContributeToSum()
-    {
-        var sum = 0;
-        double dev = 0;
-
-        var accumulator = _source.Connect().Sum(p => p.Age).Subscribe(x => sum = x);
-        var deviation = _source.Connect().StdDev(p => p.Age, (int)0).Subscribe(x => dev = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-        dev.Should().Be(7.0710678118654755, "");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumLong()
-    {
-        long sum = 0;
-        double dev = 0;
-
-        var accumulator = _source.Connect().Sum(p => Convert.ToInt64(p.Age)).Subscribe(x => sum = x);
-        var deviation = _source.Connect().StdDev(p => p.Age, (long)0).Subscribe(x => dev = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-        dev.Should().Be(7.0710678118654755, "");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumFloat()
-    {
-        float sum = 0;
-        double dev = 0;
-
-        var accumulator = _source.Connect().Sum(p => Convert.ToSingle(p.Age)).Subscribe(x => sum = x);
-        var deviation = _source.Connect().StdDev(p => p.Age, (float)0).Subscribe(x => dev = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-        dev.Should().Be(7.0710678118654755, "");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumDouble()
-    {
-        double sum = 0;
-        double dev = 0;
-
-        var accumulator = _source.Connect().Sum(p => Convert.ToDouble(p.Age)).Subscribe(x => sum = x);
-        var deviation = _source.Connect().StdDev(p => p.Age, (double)0).Subscribe(x => dev = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-        dev.Should().Be(7.0710678118654755, "");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumDecimal()
-    {
-        decimal sum = 0;
-        decimal dev = 0;
-
-        var accumulator = _source.Connect().Sum(p => Convert.ToDecimal(p.Age)).Subscribe(x => sum = x);
-        var deviation = _source.Connect().StdDev(p => p.Age, (decimal)0).Subscribe(x => dev = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-        dev.Should().Be(7.0710678118654752440084436210M, "");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumNullable()
-    {
-        var sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => p.AgeNullable).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", new int?(10), "F", null));
-        _source.AddOrUpdate(new Person("B", new int?(20), "F", null));
-        _source.AddOrUpdate(new Person("C", new int?(30), "F", null));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumLongNullable()
-    {
-        long sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => (long?)(p.AgeNullable.HasValue ? Convert.ToInt64(p.AgeNullable) : default)).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", new int?(10), "F", null));
-        _source.AddOrUpdate(new Person("B", new int?(20), "F", null));
-        _source.AddOrUpdate(new Person("C", new int?(30), "F", null));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumFloatNullable()
-    {
-        float sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => (float?)(p.AgeNullable.HasValue ? Convert.ToSingle(p.AgeNullable) : default)).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", new int?(10), "F", null));
-        _source.AddOrUpdate(new Person("B", new int?(20), "F", null));
-        _source.AddOrUpdate(new Person("C", new int?(30), "F", null));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumDoubleNullable()
-    {
-        double sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => (double?)(p.AgeNullable.HasValue ? Convert.ToDouble(p.AgeNullable) : default)).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", new int?(10), "F", null));
-        _source.AddOrUpdate(new Person("B", new int?(20), "F", null));
-        _source.AddOrUpdate(new Person("C", new int?(30), "F", null));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void AddedItemsContributeToSumDecimalNullable()
-    {
-        decimal sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => (decimal?)(p.AgeNullable.HasValue ? Convert.ToDecimal(p.AgeNullable) : default)).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", new int?(10), "F", null));
-        _source.AddOrUpdate(new Person("B", new int?(20), "F", null));
-        _source.AddOrUpdate(new Person("C", new int?(30), "F", null));
-
-        sum.Should().Be(60, "Accumulated value should be 60");
-
-        accumulator.Dispose();
-    }
-
-    public void Dispose() => _source.Dispose();
-
-    [Fact]
-    public void InlineChangeReEvaluatesTotals()
-    {
-        var sum = 0;
-
-        var somepropChanged = _source.Connect().WhenValueChanged(p => p.Age);
-
-        var accumulator = _source.Connect().Sum(p => p.Age).InvalidateWhen(somepropChanged).Subscribe(x => sum = x);
-
-        var personb = new Person("B", 5);
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(personb);
-        _source.AddOrUpdate(new Person("C", 30));
-
-        sum.Should().Be(45, "Sum should be 45 after inline change");
-
-        personb.Age = 20;
-
-        sum.Should().Be(60, "Sum should be 60 after inline change");
-        accumulator.Dispose();
-    }
-
-    [Fact]
-    public void RemoveProduceCorrectResult()
-    {
-        var sum = 0;
-
-        var accumulator = _source.Connect().Sum(p => p.Age).Subscribe(x => sum = x);
-
-        _source.AddOrUpdate(new Person("A", 10));
-        _source.AddOrUpdate(new Person("B", 20));
-        _source.AddOrUpdate(new Person("C", 30));
-
-        _source.Remove("A");
-        sum.Should().Be(50, "Accumulated value should be 50 after remove");
-        accumulator.Dispose();
-    }
-}
diff --git a/src/DynamicData.Tests/Binding/WhenPropertyChangedBehaviorFixture.cs b/src/DynamicData.Tests/Binding/WhenPropertyChangedBehaviorFixture.cs
new file mode 100644
index 000000000..48a60e35d
--- /dev/null
+++ b/src/DynamicData.Tests/Binding/WhenPropertyChangedBehaviorFixture.cs
@@ -0,0 +1,275 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+using DynamicData.Binding;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Binding;
+
+/// <summary>
+/// Single-threaded contract tests for <see cref="NotifyPropertyChangedEx.WhenPropertyChanged{TObject, TProperty}"/>:
+/// handler attachment ordering, no-dedup semantics, deep-chain re-walks on swaps.
+/// </summary>
+public sealed class WhenPropertyChangedBehaviorFixture
+{
+    [Fact]
+    public void Shallow_NotifyInitialFalse_SubscribesHandlerBeforeReturning()
+    {
+        // notifyOnInitialValue=false: Subscribe must return only after the PropertyChanged handler
+        // is attached. A setter that fires immediately after Subscribe returns must reach the
+        // observer.
+        var model = new TestModel { Value = 10 };
+        var emissions = new List<int>();
+
+        using var sub = model.WhenPropertyChanged(m => m.Value, notifyOnInitialValue: false)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        model.Value = 20;
+
+        emissions.Should().Equal(new[] { 20 });
+    }
+
+    [Fact]
+    public void Shallow_NotifyInitialTrue_DoesNotDedupSameValuedEvents()
+    {
+        var model = new TestModel { Value = 10 };
+        var emissions = new List<int>();
+
+        using var sub = model.WhenPropertyChanged(m => m.Value, notifyOnInitialValue: true)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        model.Value = 10;
+        model.Value = 10;
+        model.Value = 10;
+
+        emissions.Should().Equal(new[] { 10, 10, 10, 10 });
+    }
+
+    [Fact]
+    public void Shallow_NotifyInitialFalse_DoesNotDedupSameValuedEvents()
+    {
+        var model = new TestModel { Value = 10 };
+        var emissions = new List<int>();
+
+        using var sub = model.WhenPropertyChanged(m => m.Value, notifyOnInitialValue: false)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        model.Value = 42;
+        model.Value = 42;
+
+        emissions.Should().Equal(new[] { 42, 42 });
+    }
+
+    [Fact]
+    public void DeepChain_NotifyInitialTrue_DoesNotDedupSameValuedEvents()
+    {
+        var parent = new ParentModel { Child = new ChildModel { Age = 1 } };
+        var emissions = new List<int>();
+
+        using var sub = parent.WhenPropertyChanged(p => p.Child!.Age, notifyOnInitialValue: true)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        parent.Child!.Age = 1;
+        parent.Child!.Age = 1;
+        parent.Child!.Age = 1;
+
+        emissions.Should().Equal(new[] { 1, 1, 1, 1 });
+    }
+
+    [Fact]
+    public void DeepChain_NotifyInitialFalse_DoesNotDedupSameValuedEvents()
+    {
+        var parent = new ParentModel { Child = new ChildModel { Age = 1 } };
+        var emissions = new List<int>();
+
+        using var sub = parent.WhenPropertyChanged(p => p.Child!.Age, notifyOnInitialValue: false)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        parent.Child!.Age = 7;
+        parent.Child!.Age = 7;
+
+        emissions.Should().Equal(new[] { 7, 7 });
+    }
+
+    [Fact]
+    public void DeepChain_PostSwap_LeafEventOnNewChild_Captured()
+    {
+        // After parent.Child is reassigned, the leaf-level subscription must be re-attached
+        // against the new child. A subsequent leaf mutation on the new child must be captured.
+        var parent = new ParentModel { Child = new ChildModel { Age = 10 } };
+        var emissions = new List<int>();
+
+        using var sub = parent.WhenPropertyChanged(p => p.Child!.Age, notifyOnInitialValue: true)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        var newChild = new ChildModel { Age = 20 };
+        parent.Child = newChild;
+        newChild.Age = 30;
+
+        emissions.Should().Equal(new[] { 10, 20, 30 });
+    }
+
+    [Fact]
+    public void DeepChain_MidChainSwap_DeeperLevelsRetargetCorrectly()
+    {
+        // Mid-chain swap on a 4-level chain. When level 3 is reassigned, the leaf subscription
+        // must re-attach against the new subtree; events on the old subtree must be ignored
+        // (its notifier subscription was disposed).
+        var l1 = new Level1
+        {
+            Child = new Level2
+            {
+                Child = new Level3
+                {
+                    Child = new Level4 { Leaf = 10 },
+                },
+            },
+        };
+
+        var emissions = new List<int>();
+        using var sub = l1.WhenPropertyChanged(x => x.Child!.Child!.Child!.Leaf, notifyOnInitialValue: true)
+            .Subscribe(pv => emissions.Add(pv.Value));
+
+        emissions.Should().Equal(new[] { 10 }, "initial emission");
+
+        var originalLeaf = l1.Child!.Child!.Child!;
+
+        var newL4 = new Level4 { Leaf = 20 };
+        l1.Child!.Child!.Child = newL4;
+
+        emissions.Should().Equal(new[] { 10, 20 }, "mid-chain swap emits the new leaf value");
+
+        newL4.Leaf = 30;
+        emissions.Should().Equal(new[] { 10, 20, 30 }, "leaf event on new subtree is captured");
+
+        originalLeaf.Leaf = 999;
+        emissions.Should().Equal(new[] { 10, 20, 30 }, "leaf event on detached subtree is ignored");
+    }
+
+    private sealed class TestModel : INotifyPropertyChanged
+    {
+        private int _value;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Value
+        {
+            get => _value;
+            set
+            {
+                _value = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            }
+        }
+    }
+
+    private sealed class ParentModel : INotifyPropertyChanged
+    {
+        private ChildModel? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public ChildModel? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class ChildModel : INotifyPropertyChanged
+    {
+        private int _age;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Age
+        {
+            get => _age;
+            set
+            {
+                _age = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Age)));
+            }
+        }
+    }
+
+    private sealed class Level1 : INotifyPropertyChanged
+    {
+        private Level2? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Level2? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Level2 : INotifyPropertyChanged
+    {
+        private Level3? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Level3? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Level3 : INotifyPropertyChanged
+    {
+        private Level4? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Level4? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Level4 : INotifyPropertyChanged
+    {
+        private int _leaf;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Leaf
+        {
+            get => _leaf;
+            set
+            {
+                _leaf = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Leaf)));
+            }
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/Binding/WhenPropertyChangedRaceFixture.cs b/src/DynamicData.Tests/Binding/WhenPropertyChangedRaceFixture.cs
new file mode 100644
index 000000000..9da900efe
--- /dev/null
+++ b/src/DynamicData.Tests/Binding/WhenPropertyChangedRaceFixture.cs
@@ -0,0 +1,474 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using DynamicData.Binding;
+using DynamicData.Tests.Utilities;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Binding;
+
+/// <summary>
+/// Multi-threaded race tests for <see cref="NotifyPropertyChangedEx.WhenPropertyChanged{TObject, TProperty}"/>.
+/// Each test forces concurrency between the operator's subscribe call (or chain re-walk) and one or more
+/// <see cref="System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> notifiers firing on other threads.
+/// </summary>
+public sealed class WhenPropertyChangedRaceFixture
+{
+    private static readonly TimeSpan ConditionTimeout = TimeSpan.FromSeconds(30);
+
+    [Fact]
+    public async Task DeepChain_ConcurrentParentSwap_LeafEventOnWinnerNotDropped()
+    {
+        // Two threads concurrently swap parent.Child. After both swaps complete, a leaf mutation
+        // on the current child must be captured. SharedDeliveryQueue serialises the level-0
+        // signals on the drainer, so the final level-1 subscription always targets parent.Child's
+        // current value.
+        const int iterations = 50;
+        var losses = 0;
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            var parent = new ParentModel { Child = new ChildModel { Age = 0 } };
+            var emissions = new List<int>();
+
+            using var sub = parent.WhenPropertyChanged(p => p.Child!.Age, notifyOnInitialValue: false)
+                .Subscribe(pv => { lock (emissions) emissions.Add(pv.Value); });
+
+            var newChild1 = new ChildModel { Age = 1 };
+            var newChild2 = new ChildModel { Age = 2 };
+
+            using var barrier = new Barrier(2);
+            var taskA = Task.Run(() => { barrier.SignalAndWait(); parent.Child = newChild1; });
+            var taskB = Task.Run(() => { barrier.SignalAndWait(); parent.Child = newChild2; });
+            await Task.WhenAll(taskA, taskB).WaitAsync(ConditionTimeout);
+
+            var winner = parent.Child;
+            if (winner is null)
+            {
+                continue;
+            }
+
+            winner.Age = 99;
+
+            WaitForCondition(() => { lock (emissions) return emissions.Contains(99); });
+
+            lock (emissions)
+            {
+                if (!emissions.Contains(99))
+                {
+                    losses++;
+                }
+            }
+        }
+
+        losses.Should().Be(0, $"out of {iterations} iterations, {losses} dropped the leaf event on the post-swap winner");
+    }
+
+    [Fact]
+    public async Task DeepChain_FiveLevels_AllLevelsMutatedConcurrently_FinalEmissionMatchesActual()
+    {
+        // Torture: five worker threads each mutating at a different level of a 5-level chain.
+        // Mutations that land on detached subtrees are ignored (their notifier subscriptions were
+        // disposed by ResubscribeFrom). Mutations on the live chain reach the drainer.
+        //
+        // Three invariants per iteration:
+        //   (a) Rx contract: ValidateSynchronization catches any concurrent OnNext on the user
+        //       observer (a SharedDeliveryQueue serialisation failure).
+        //   (b) Value legality: every emission must be a value that some thread legitimately
+        //       wrote.
+        //   (c) Final consistency: after Task.WhenAll the drainer continues until the queue is
+        //       empty. The last processed signal triggers a ReadCurrent against the now-frozen
+        //       chain state, so emissions.Last() == ReadCurrent().
+        const int iterations = 50;
+        const int mutationsPerThread = 200;
+        var mismatches = 0;
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            var root = NewDeepChain(0);
+            var emissions = new List<int>();
+
+            using var sub = root.WhenPropertyChanged(r => r.Child!.Child!.Child!.Child!.Leaf, notifyOnInitialValue: true)
+                .ValidateSynchronization()
+                .Subscribe(pv => { lock (emissions) emissions.Add(pv.Value); });
+
+            using var barrier = new Barrier(5);
+            var iterSeed = iter * 10_000;
+            var tasks = new[]
+            {
+                Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < mutationsPerThread; i++)
+                    {
+                        root.Child = NewDeep2(iterSeed + 40_000 + i);
+                    }
+                }),
+                Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < mutationsPerThread; i++)
+                    {
+                        var l2 = root.Child;
+                        if (l2 is not null) l2.Child = NewDeep3(iterSeed + 30_000 + i);
+                    }
+                }),
+                Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < mutationsPerThread; i++)
+                    {
+                        var l3 = root.Child?.Child;
+                        if (l3 is not null) l3.Child = NewDeep4(iterSeed + 20_000 + i);
+                    }
+                }),
+                Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < mutationsPerThread; i++)
+                    {
+                        var l4 = root.Child?.Child?.Child;
+                        if (l4 is not null) l4.Child = new Deep5 { Leaf = iterSeed + 10_000 + i };
+                    }
+                }),
+                Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < mutationsPerThread; i++)
+                    {
+                        var l5 = root.Child?.Child?.Child?.Child;
+                        if (l5 is not null) l5.Leaf = i;
+                    }
+                }),
+            };
+
+            await Task.WhenAll(tasks).WaitAsync(ConditionTimeout);
+
+            var actualFinal = root.Child!.Child!.Child!.Child!.Leaf;
+
+            WaitForCondition(() => { lock (emissions) return emissions.Count > 0 && emissions[^1] == actualFinal; });
+
+            var legal = new HashSet<int> { 0 };
+            for (var i = 0; i < mutationsPerThread; i++)
+            {
+                legal.Add(i);
+                legal.Add(iterSeed + 10_000 + i);
+                legal.Add(iterSeed + 20_000 + i);
+                legal.Add(iterSeed + 30_000 + i);
+                legal.Add(iterSeed + 40_000 + i);
+            }
+
+            lock (emissions)
+            {
+                emissions.Should().NotBeEmpty($"iter {iter}: notifyOnInitialValue=true requires at least the initial emission");
+                emissions[0].Should().Be(0, $"iter {iter}: first emission must be the initial value");
+
+                var illegal = emissions.Where(v => !legal.Contains(v)).ToList();
+                illegal.Should().BeEmpty($"iter {iter}: every emission must be a value some thread wrote; saw {string.Join(",", illegal.Take(5))}");
+
+                if (emissions.Count == 0 || emissions[^1] != actualFinal)
+                {
+                    mismatches++;
+                }
+            }
+        }
+
+        mismatches.Should().Be(0, $"out of {iterations} iterations, {mismatches} ended with the last emission not matching the actual final chain leaf");
+    }
+
+    [Fact(Skip = "AutoRefresh has a separate concurrency bug; tracked separately")]
+    public async Task AutoRefreshThenFilter_ConcurrentAddsAndPropertyActivation_AllItemsObserved()
+    {
+        // One adder thread sequentially adds items to the cache while a single flipper thread
+        // concurrently sets each item's Activated to true. Final filter contents must include
+        // every item (every item ends Activated=true).
+        //
+        // KeyedActivable's setter only raises PropertyChanged on actual value change, so a
+        // dropped false->true transition is unrecoverable.
+        //
+        // The race lives in AutoRefresh's internal Publish multicast: Sub 1 (Filter path)
+        // receives the Add and reads the property before Sub 2 (MergeMany) subscribes the
+        // per-item refresh handler. A concurrent flip landing in that gap is dropped. This
+        // is not a WhenPropertyChanged issue: AutoRefresh calls WhenPropertyChanged with
+        // notifyInitial=false, so the per-item subscribe attaches the handler immediately
+        // and has no internal race window.
+        const int iterations = 100;
+        const int itemCount = 200;
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            using var cache = new SourceCache<KeyedActivable, int>(x => x.Id);
+            var items = Enumerable.Range(0, itemCount).Select(i => new KeyedActivable(i)).ToList();
+
+            using var results = cache.Connect()
+                .AutoRefresh(x => x.Activated)
+                .Filter(x => x.Activated)
+                .AsAggregator();
+
+            using var barrier = new Barrier(2);
+
+            var adder = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                foreach (var item in items) cache.AddOrUpdate(item);
+            });
+
+            var flipper = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                foreach (var item in items) item.Activated = true;
+            });
+
+            await Task.WhenAll(adder, flipper).WaitAsync(ConditionTimeout);
+
+            var expected = items.Select(x => x.Id).ToHashSet();
+            WaitForCondition(() => results.Data.Keys.ToHashSet().SetEquals(expected));
+
+            var actual = results.Data.Keys.ToHashSet();
+            actual.Should().BeEquivalentTo(expected, $"iter {iter}: every item ends Activated=true and must appear in the filter (missing: {string.Join(",", expected.Except(actual))})");
+            results.Error.Should().BeNull($"iter {iter}: pipeline must not error");
+        }
+    }
+
+    [Fact(Skip = "AutoRefresh has a separate concurrency bug; tracked separately")]
+    public async Task AutoRefreshThenFilter_DualSubscribers_AllItemsObserved()
+    {
+        // Two independent cache subscribers running on the ThreadPool:
+        //   Sub 1 (mutator): on every Add change, flips item.Activated to true
+        //   Sub 2 (filter chain): AutoRefresh + Filter (filter = Activated)
+        // Items start with Activated=false (filtered out). The mutator flips every item, so
+        // the final filter contents must include every item.
+        //
+        // Same root cause as the single-flipper variant above: AutoRefresh's internal Publish
+        // multicasts the Add to the Filter path before MergeMany subscribes the per-item
+        // refresh handler. The mutator's flip can land in that gap and be dropped.
+        const int iterations = 100;
+        const int itemCount = 200;
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            using var cache = new SourceCache<KeyedActivable, int>(x => x.Id);
+            var items = Enumerable.Range(0, itemCount).Select(i => new KeyedActivable(i)).ToList();
+
+            using var mutator = cache.Connect()
+                .ObserveOn(TaskPoolScheduler.Default)
+                .Subscribe(changes =>
+                {
+                    foreach (var change in changes)
+                    {
+                        if (change.Reason == ChangeReason.Add)
+                        {
+                            change.Current.Activated = true;
+                        }
+                    }
+                });
+
+            using var results = cache.Connect()
+                .ObserveOn(TaskPoolScheduler.Default)
+                .AutoRefresh(x => x.Activated)
+                .Filter(x => x.Activated)
+                .AsAggregator();
+
+            foreach (var item in items) cache.AddOrUpdate(item);
+
+            var expected = items.Select(x => x.Id).ToHashSet();
+            WaitForCondition(() => results.Data.Keys.ToHashSet().SetEquals(expected));
+
+            var actual = results.Data.Keys.ToHashSet();
+            actual.Should().BeEquivalentTo(expected, $"iter {iter}: every item was flipped to Activated=true by the mutator and must appear in the filter (missing: {string.Join(",", expected.Except(actual))})");
+            results.Error.Should().BeNull($"iter {iter}: pipeline must not error");
+        }
+    }
+
+    private static Deep1 NewDeepChain(int leaf) =>
+        new Deep1 { Child = NewDeep2(leaf) };
+
+    private static Deep2 NewDeep2(int leaf) =>
+        new Deep2 { Child = NewDeep3(leaf) };
+
+    private static Deep3 NewDeep3(int leaf) =>
+        new Deep3 { Child = NewDeep4(leaf) };
+
+    private static Deep4 NewDeep4(int leaf) =>
+        new Deep4 { Child = new Deep5 { Leaf = leaf } };
+
+    private static void WaitForCondition(Func<bool> condition, TimeSpan? timeout = null) =>
+        SpinWait.SpinUntil(condition, timeout ?? ConditionTimeout);
+
+    private sealed class Item : INotifyPropertyChanged
+    {
+        private int _value;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Id { get; init; }
+
+        public int Value
+        {
+            get => _value;
+            set
+            {
+                _value = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            }
+        }
+    }
+
+    private sealed class ParentModel : INotifyPropertyChanged
+    {
+        private ChildModel? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public ChildModel? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class ChildModel : INotifyPropertyChanged
+    {
+        private int _age;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Age
+        {
+            get => _age;
+            set
+            {
+                _age = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Age)));
+            }
+        }
+    }
+
+    private sealed class Deep1 : INotifyPropertyChanged
+    {
+        private Deep2? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Deep2? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Deep2 : INotifyPropertyChanged
+    {
+        private Deep3? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Deep3? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Deep3 : INotifyPropertyChanged
+    {
+        private Deep4? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Deep4? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Deep4 : INotifyPropertyChanged
+    {
+        private Deep5? _child;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public Deep5? Child
+        {
+            get => _child;
+            set
+            {
+                _child = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Child)));
+            }
+        }
+    }
+
+    private sealed class Deep5 : INotifyPropertyChanged
+    {
+        private int _leaf;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Leaf
+        {
+            get => _leaf;
+            set
+            {
+                _leaf = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Leaf)));
+            }
+        }
+    }
+
+    private sealed class KeyedActivable : INotifyPropertyChanged
+    {
+        private bool _activated;
+
+        public KeyedActivable(int id)
+        {
+            Id = id;
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public int Id { get; }
+
+        public bool Activated
+        {
+            get => _activated;
+            set
+            {
+                if (_activated == value) return;
+                _activated = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Activated)));
+            }
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshFixture.Base.cs b/src/DynamicData.Tests/Cache/AutoRefreshFixture.Base.cs
new file mode 100644
index 000000000..ebdc26950
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshFixture.Base.cs
@@ -0,0 +1,617 @@
+using System;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+using Microsoft.Reactive.Testing;
+
+using FluentAssertions;
+using Xunit;
+
+using DynamicData.Tests.Utilities;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshFixture
+{
+    public abstract class Base
+    {
+        [Fact]
+        public void ChangeSetBufferIsGiven_PropertyChangedNotificationsAreBufferedOnScheduler()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+
+            var scheduler = new TestScheduler();
+
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:             source.Connect(),
+                    changeSetBuffer:    TimeSpan.FromSeconds(10),
+                    scheduler:          scheduler)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish property change notification)
+            ++item2.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the property change notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (advance time, within buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(5).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the buffer window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            
+            // UUT Action (advance time, to buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(10).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "a buffer window expired");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published a property change notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (publish property change notification)
+            ++item1.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the property change notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (advance time, within buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(15).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the buffer window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish additional property change notification)
+            ++item3.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the property change notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (advance time, to buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(20).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Count().Should().Be(1, "a buffer window expired");
+            results.RecordedChangeSets.Skip(2).First().Count.Should().Be(2, "2 items published a property change notification");
+            results.RecordedChangeSets.Skip(2).First().Refreshes.Should().Be(2, "2 items published a property change notification");
+            results.RecordedChangeSets.Skip(2).First().Select(change => change.Current).Should().BeEquivalentTo(new[] { item1, item3 }, "items #2 and #3 published property change notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (normal refresh)
+            source.Refresh(item2);
+            
+            // Normal refreshes should not be buffered
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(3).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedChangeSets.Skip(3).First().Count.Should().Be(1, "1 item was refreshed, within the source");
+            results.RecordedChangeSets.Skip(3).First().Refreshes.Should().Be(1, "1 item was refreshed, within the source");
+            results.RecordedChangeSets.Skip(3).First().First().Current.Should().Be(item2, "item #2 was refreshed, within the source");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+    
+        [Fact]
+        public void ItemIsAdded_SubscribesToPropertyChanged()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            item1.HasSubscriptions.Should().BeTrue("the PropertyChanged event should be subscribed to, for each added item");
+            item2.HasSubscriptions.Should().BeTrue("the PropertyChanged event should be subscribed to, for each added item");
+            item3.HasSubscriptions.Should().BeTrue("the PropertyChanged event should be subscribed to, for each added item");
+        }
+        
+        [Fact]
+        public void ItemIsMoved_NotificationPropagates()
+        {
+            // Setup
+            using var source = new Subject<IChangeSet<Item, int>>();
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            var items = new [] { item1, item2, item3 };
+            
+            var initialChangeset = new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(reason: ChangeReason.Add, key: item1.Id, current: item1, index: 0),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item2.Id, current: item2, index: 1),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item3.Id, current: item3, index: 2)
+            };
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Prepend(initialChangeset))
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(items, "3 items were added to the source");
+            results.RecordedItemsSorted.Should().BeEquivalentTo(
+                items,
+                options => options.WithStrictOrdering(),
+                "item indexes should propagate");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            source.OnNext(new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(
+                    key:            item3.Id,
+                    current:        item3,
+                    currentIndex:   0,
+                    previousIndex:  2) 
+            });
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(items, "an item was moved within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            results.RecordedItemsSorted.Should().BeEquivalentTo(
+                new[] { item3, item1, item2 },
+                options => options.WithStrictOrdering(),
+                "an item was moved within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+        
+        [Fact]
+        public void ItemIsRefreshed_NotificationPropagates()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            // UUT Action
+            source.Refresh(item2);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item was refreshed within the source");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item was refreshed within the source");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 was refreshed within the source");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items were changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+
+        [Fact]
+        public void ItemIsRemoved_UnsubscribesFromPropertyChanged()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            source.Remove(item2);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "1 item was removed from the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            item2.HasSubscriptions.Should().BeFalse("removing an item should trigger unsubscription from its reevaluator");
+            item1.HasSubscriptions.Should().BeTrue("the item was not removed from the source");
+            item3.HasSubscriptions.Should().BeTrue("the item was not removed from the source");
+        }
+
+        [Fact]
+        public void ItemIsUpdated_ReSubscribesToPropertyChanged()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            var item4 = new Item() { Id = 2 };
+            source.AddOrUpdate(item4);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "1 item was replaced within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            item2.HasSubscriptions.Should().BeFalse("replacing an item should trigger unsubscription from its reevaluator");
+            item4.HasSubscriptions.Should().BeTrue("adding an item should invoke its reevaluator and subscribe to it");
+            item1.HasSubscriptions.Should().BeTrue("the item was not removed from the source");
+            item3.HasSubscriptions.Should().BeTrue("the item was not removed from the source");
+        }
+            
+        [Fact]
+        public void PropertyChangedOccurs_ItemRefreshes()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            ++item2.Value;
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published a property change notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+
+        [Fact]
+        public void PropertyChangeThrottleIsGiven_PropertyChangedNotificationsAreThrottledByScheduler()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+
+            var scheduler = new TestScheduler();
+
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:                 source.Connect(),
+                    propertyChangeThrottle: TimeSpan.FromSeconds(10),
+                    scheduler:              scheduler)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish property change notification)
+            ++item2.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the throttle window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish additional property change notification, immediately)
+            ++item2.Value;
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the throttle window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (advance time to end of throttle window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(10).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "the throttle window ended");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published property change notifications");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published property change notifications");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published property change notifications");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (publish property change notification)
+            ++item2.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the throttle window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish additional property change notification, within throttle window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(15).Ticks);
+            ++item2.Value;
+            scheduler.AdvanceBy(1);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the throttle window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (advance time to end of original throttle window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(20).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the throttle window should have been extended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (advance time to end of throttle window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(25).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Count().Should().Be(1, "the throttle window ended");
+            results.RecordedChangeSets.Skip(2).First().Count.Should().Be(1, "1 item published property change notifications");
+            results.RecordedChangeSets.Skip(2).First().Refreshes.Should().Be(1, "1 item published property change notifications");
+            results.RecordedChangeSets.Skip(2).First().First().Current.Should().Be(item2, "item #2 published property change notifications");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+    
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceCompletesWhenEmpty_CompletionPropagates(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+
+            // UUT Initialization & Action
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.Complete();
+
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeTrue("all notification sources have completed");
+        }
+
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceCompletesWhenNotEmpty_CompletionDoesNotPropagate(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization & Action (source completion)
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.Complete();
+
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("PropertyChanged events can still publish notifications");
+        }
+
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceFails_ErrorPropagates(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+            var error = new Exception("Test");
+            
+
+            // UUT Initialization & Action
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.SetError(error);
+
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.SetError(error);
+
+            results.Error.Should().Be(error, "upstream errors should propagate downstream");
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                results.RecordedChangeSets.Should().BeEmpty("an error occurred before the initial changeset");
+            else
+            {
+                results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+                results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            }
+        }
+
+        [Fact]
+        public void SourceIsNull_ThrowsException()
+            => FluentActions.Invoking(() => BuildUut(source: null!))
+                .Should()
+                .Throw<ArgumentNullException>();
+
+        [Fact]
+        public void SubscriptionIsDisposed_SubscriptionDisposalPropagates()
+        {
+            // Setup
+            using var source = new Subject<IChangeSet<Item, int>>();
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            var initialChangeset = new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(reason: ChangeReason.Add, key: item1.Id, current: item1),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item2.Id, current: item2),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item3.Id, current: item3)
+            };
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Prepend(initialChangeset))
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1, item2, item3 }, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            subscription.Dispose();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            source.HasObservers.Should().BeFalse("subscription disposal should propagate");
+            item1.HasSubscriptions.Should().BeFalse("subscription disposal should propagate");
+            item2.HasSubscriptions.Should().BeFalse("subscription disposal should propagate");
+            item3.HasSubscriptions.Should().BeFalse("subscription disposal should propagate");
+        }
+
+        protected abstract IObservable<IChangeSet<Item, int>> BuildUut(
+            IObservable<IChangeSet<Item, int>>  source,
+            TimeSpan?                           changeSetBuffer         = null,
+            TimeSpan?                           propertyChangeThrottle  = null,
+            IScheduler?                         scheduler               = null);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithPropertyAccessor.cs b/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithPropertyAccessor.cs
new file mode 100644
index 000000000..c948aedb8
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithPropertyAccessor.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+
+using FluentAssertions;
+using Xunit;
+
+using DynamicData.Tests.Utilities;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshFixture
+{
+    public class WithPropertyAccessor
+        : Base
+    {
+        [Fact(Skip = "Existing defect: propertyAccessor is not null checked, throws NRE on first notification, instead")]
+        public void PropertyAccessorIsNull_ThrowsException()
+            => FluentActions.Invoking(() => ObservableCacheEx.AutoRefresh(
+                    source:             Observable.Never<IChangeSet<Item, int>>(),
+                    propertyAccessor:   (null as Expression<Func<Item, int>>)!))
+                .Should()
+                .Throw<ArgumentNullException>();
+                
+        [Fact]
+        public void PropertyChangedNotificationDoesNotMatchPropertyAccessor_IgnoresNotification()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            ++item2.OtherValue;
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the property change notification should have been ignored");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+            
+        protected override IObservable<IChangeSet<Item, int>> BuildUut(
+                IObservable<IChangeSet<Item, int>>  source,
+                TimeSpan?                           changeSetBuffer         = null,
+                TimeSpan?                           propertyChangeThrottle  = null,
+                IScheduler?                         scheduler               = null)
+            => source.AutoRefresh(
+                propertyAccessor:       static item => item.Value,
+                changeSetBuffer:        changeSetBuffer,
+                propertyChangeThrottle: propertyChangeThrottle,
+                scheduler:              scheduler);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithoutPropertyAccessor.cs b/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithoutPropertyAccessor.cs
new file mode 100644
index 000000000..402d175ff
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshFixture.WithoutPropertyAccessor.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using System.Reactive.Concurrency;
+
+using FluentAssertions;
+using Xunit;
+
+using DynamicData.Tests.Utilities;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshFixture
+{
+    public class WithoutPropertyAccessor
+        : Base
+    {
+        [Fact]
+        public void PropertyChangedNotificationDoesNotSpecifyPropertyName_ItemRefreshes()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var item1 = new Item() { Id = 1 };
+            var item2 = new Item() { Id = 2 };
+            var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(source.Connect())
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            item2.RaiseAllPropertiesChanged();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published a property change notification");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published a property change notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+            
+        protected override IObservable<IChangeSet<Item, int>> BuildUut(
+                IObservable<IChangeSet<Item, int>>  source,
+                TimeSpan?                           changeSetBuffer         = null,
+                TimeSpan?                           propertyChangeThrottle  = null,
+                IScheduler?                         scheduler               = null)
+            => source.AutoRefresh(
+                changeSetBuffer:        changeSetBuffer,
+                propertyChangeThrottle: propertyChangeThrottle,
+                scheduler:              scheduler);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshFixture.cs b/src/DynamicData.Tests/Cache/AutoRefreshFixture.cs
index b3d36aa41..be5b936a3 100644
--- a/src/DynamicData.Tests/Cache/AutoRefreshFixture.cs
+++ b/src/DynamicData.Tests/Cache/AutoRefreshFixture.cs
@@ -1,127 +1,66 @@
-using System;
-using System.Linq;
-using System.Reactive.Linq;
-
-using DynamicData.Binding;
-using DynamicData.Tests.Domain;
-
-using FluentAssertions;
-
-using Xunit;
+using System.ComponentModel;
 
 namespace DynamicData.Tests.Cache;
 
-public class AutoRefreshFixture
+public static partial class AutoRefreshFixture
 {
-    [Fact]
-    public void AutoRefresh()
+    public enum NotificationStrategy
     {
-        var items = Enumerable.Range(1, 100).Select(i => new Person("Person" + i, 1)).ToArray();
-
-        //result should only be true when all items are set to true
-        using var cache = new SourceCache<Person, string>(m => m.Name);
-        using var results = cache.Connect().AutoRefresh(p => p.Age).AsAggregator();
-        cache.AddOrUpdate(items);
-
-        results.Data.Count.Should().Be(100);
-        results.Messages.Count.Should().Be(1);
-
-        items[0].Age = 10;
-        results.Data.Count.Should().Be(100);
-        results.Messages.Count.Should().Be(2);
-
-        results.Messages[1].First().Reason.Should().Be(ChangeReason.Refresh);
-
-        //remove an item and check no change is fired
-        var toRemove = items[1];
-        cache.Remove(toRemove);
-        results.Data.Count.Should().Be(99);
-        results.Messages.Count.Should().Be(3);
-        toRemove.Age = 100;
-        results.Messages.Count.Should().Be(3);
-
-        //add it back in and check it updates
-        cache.AddOrUpdate(toRemove);
-        results.Messages.Count.Should().Be(4);
-        toRemove.Age = 101;
-        results.Messages.Count.Should().Be(5);
-
-        results.Messages.Last().First().Reason.Should().Be(ChangeReason.Refresh);
-    }
-
-    [Fact]
-    public void AutoRefreshFromObservable()
-    {
-        var items = Enumerable.Range(1, 100).Select(i => new Person("Person" + i, 1)).ToArray();
-
-        //result should only be true when all items are set to true
-        using var cache = new SourceCache<Person, string>(m => m.Name);
-        using var results = cache.Connect().AutoRefreshOnObservable(p => p.WhenAnyPropertyChanged()).AsAggregator();
-        cache.AddOrUpdate(items);
-
-        results.Data.Count.Should().Be(100);
-        results.Messages.Count.Should().Be(1);
-
-        items[0].Age = 10;
-        results.Data.Count.Should().Be(100);
-        results.Messages.Count.Should().Be(2);
-
-        results.Messages[1].First().Reason.Should().Be(ChangeReason.Refresh);
-
-        //remove an item and check no change is fired
-        var toRemove = items[1];
-        cache.Remove(toRemove);
-        results.Data.Count.Should().Be(99);
-        results.Messages.Count.Should().Be(3);
-        toRemove.Age = 100;
-        results.Messages.Count.Should().Be(3);
-
-        //add it back in and check it updates
-        cache.AddOrUpdate(toRemove);
-        results.Messages.Count.Should().Be(4);
-        toRemove.Age = 101;
-        results.Messages.Count.Should().Be(5);
-
-        results.Messages.Last().First().Reason.Should().Be(ChangeReason.Refresh);
+        Immediate,
+        Asynchronous
     }
 
-    [Fact]
-    public void MakeSelectMagicWorkWithObservable()
+    public class Item
+        : INotifyPropertyChanged
     {
-        var initialItem = new IntHolder(1, "Initial Description");
-
-        var sourceList = new SourceList<IntHolder>();
-        sourceList.Add(initialItem);
-
-        var descriptionStream = sourceList.Connect().AutoRefresh(intHolder => intHolder!.Description).Transform(intHolder => intHolder!.Description, true).Do(x => { }) // <--- Add break point here to check the overload fixes it
-            .Bind(out var resultCollection);
-
-        using (descriptionStream.Subscribe())
+        public static int SelectId(Item item)
+            => item.Id;
+    
+        public required int Id
         {
-            var newDescription = "New Description";
-            initialItem.Description = newDescription;
-
-            newDescription.Should().Be(resultCollection[0]);
-            //Assert.AreEqual(newDescription, resultCollection[0]);
+            get => _id;
+            init => _id = value;
         }
-    }
-
-    public class IntHolder(int value, string description) : AbstractNotifyPropertyChanged
-    {
-        public string _description_ = description;
-
-        public int _value = value;
-
-        public string Description
+            
+        public bool HasSubscriptions
+            => PropertyChanged is not null;
+            
+        public int OtherValue
         {
-            get => _description_;
-            set => SetAndRaise(ref _description_, value);
+            get => _otherValue;
+            set
+            {
+                if (_otherValue == value)
+                    return;
+                        
+                _otherValue = value;
+
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(OtherValue)));
+            }
         }
-
+            
         public int Value
         {
             get => _value;
-            set => SetAndRaise(ref _value, value);
+            set
+            {
+                if (_value == value)
+                    return;
+                        
+                _value = value;
+
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            }
         }
+        
+        public event PropertyChangedEventHandler? PropertyChanged;
+        
+        public void RaiseAllPropertiesChanged()
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(string.Empty));
+        
+        private readonly int _id;
+            
+        private int _otherValue;
+        private int _value;
     }
 }
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.Base.cs b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.Base.cs
new file mode 100644
index 000000000..a09e0ea9c
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.Base.cs
@@ -0,0 +1,777 @@
+using System;
+using System.Linq;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+using Microsoft.Reactive.Testing;
+
+using FluentAssertions;
+using Xunit;
+
+using DynamicData.Tests.Utilities;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshOnObservableFixture
+{
+    public abstract class Base
+    {
+        [Fact]
+        public void ChangeSetBufferIsGiven_ReevaluatorNotificationsAreBufferedOnScheduler()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+
+            var scheduler = new TestScheduler();
+
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:             source.Connect(),
+                    reevaluator:        Item.ObserveValueChanged,
+                    changeSetBuffer:    TimeSpan.FromSeconds(10),
+                    scheduler:          scheduler)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish reevaluator notification)
+            ++item2.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the reevaluator notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (advance time, within buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(5).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("the buffer window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            
+            // UUT Action (advance time, to buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(10).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "a buffer window expired");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published a reevaluator notification");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published a reevaluator notification");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published a reevaluator notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+
+            // UUT Action (publish reevaluator notification)
+            ++item1.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the reevaluator notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (advance time, within buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(15).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the buffer window has not yet ended");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (publish additional reevaluator notification)
+            ++item3.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Should().BeEmpty("the reevaluator notification should have been buffered");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (advance time, to buffer window)
+            scheduler.AdvanceTo(TimeSpan.FromSeconds(20).Ticks);
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Count().Should().Be(1, "a buffer window expired");
+            results.RecordedChangeSets.Skip(2).First().Count.Should().Be(2, "2 items published a reevaluator notification");
+            results.RecordedChangeSets.Skip(2).First().Refreshes.Should().Be(2, "2 items published a reevaluator notification");
+            results.RecordedChangeSets.Skip(2).First().Select(change => change.Current).Should().BeEquivalentTo(new[] { item1, item3 }, "items #2 and #3 published reevaluator notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (normal refresh)
+            source.Refresh(item2);
+            
+            // Normal refreshes should not be buffered
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(3).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedChangeSets.Skip(3).First().Count.Should().Be(1, "1 item was refreshed, within the source");
+            results.RecordedChangeSets.Skip(3).First().Refreshes.Should().Be(1, "1 item was refreshed, within the source");
+            results.RecordedChangeSets.Skip(3).First().First().Current.Should().Be(item2, "item #2 was refreshed, within the source");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items should have changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+    
+        [Fact]
+        public void ItemIsAdded_SubscribesToReevaluator()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            item1.HasObservers.Should().BeTrue("the reevaluator should be invoked and subscribed to, for each added item");
+            item2.HasObservers.Should().BeTrue("the reevaluator should be invoked and subscribed to, for each added item");
+            item3.HasObservers.Should().BeTrue("the reevaluator should be invoked and subscribed to, for each added item");
+        }
+        
+        [Fact]
+        public void ItemIsMoved_NotificationPropagates()
+        {
+            // Setup
+            using var source = new Subject<IChangeSet<Item, int>>();
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            var items = new[] { item1, item2, item3 };
+            
+            var initialChangeset = new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(reason: ChangeReason.Add, key: item1.Id, current: item1, index: 0),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item2.Id, current: item2, index: 1),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item3.Id, current: item3, index: 2)
+            };
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Prepend(initialChangeset),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(items, "3 items were added to the source");
+            results.RecordedItemsSorted.Should().BeEquivalentTo(
+                items,
+                options => options.WithStrictOrdering(),
+                "item indexes should propagate");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            source.OnNext(new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(
+                    key:            item3.Id,
+                    current:        item3,
+                    currentIndex:   0,
+                    previousIndex:  2) 
+            });
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(items, "an item was moved within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            results.RecordedItemsSorted.Should().BeEquivalentTo(
+                new[] { item3, item1, item2 },
+                options => options.WithStrictOrdering(),
+                "an item was moved within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+        
+        [Fact]
+        public void ItemIsRefreshed_NotificationPropagates()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+            var reevaluatorInvocationCount = 0;
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    item =>
+                    {
+                        ++reevaluatorInvocationCount;
+                        return Item.ObserveValueChanged(item);
+                    })
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            reevaluatorInvocationCount.Should().Be(3, "the reevaluator should be invoked and subscribed to, for each added item");
+
+            // UUT Action
+            source.Refresh(item2);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item was refreshed within the source");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item was refreshed within the source");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 was refreshed within the source");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no items were changed, within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            reevaluatorInvocationCount.Should().Be(3, "the reevaluator should only be invoked for items being added to the collection.");
+        }
+
+        [Fact]
+        public void ItemIsRemoved_UnsubscribesFromReevaluator()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            source.Remove(item2);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "1 item was removed from the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            item2.HasObservers.Should().BeFalse("removing an item should trigger unsubscription from its reevaluator");
+            item1.HasObservers.Should().BeTrue("the item was not removed from the source");
+            item3.HasObservers.Should().BeTrue("the item was not removed from the source");
+        }
+
+        [Fact]
+        public void ItemIsUpdated_ReInvokesReevaluator()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            using var item4 = new Item() { Id = 2 };
+            source.AddOrUpdate(item4);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "one source operation was performed");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "1 item was replaced within the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            item2.HasObservers.Should().BeFalse("replacing an item should trigger unsubscription from its reevaluator");
+            item4.HasObservers.Should().BeTrue("adding an item should invoke its reevaluator and subscribe to it");
+            item1.HasObservers.Should().BeTrue("the item was not removed from the source");
+            item3.HasObservers.Should().BeTrue("the item was not removed from the source");
+            
+            
+            // UUT Action (updated item publishes reevaluator notification)
+            ++item4.Value;
+            
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(2).Count().Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(2).First().Count.Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(2).First().Refreshes.Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(2).First().First().Current.Should().Be(item4, "item #4 published a reevaluation notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+            
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void ReevaluatorCompletesWhenNotOnlyItemInSource_CompletionWaitsForSourceCompletionAndOtherReevaluatorCompletions(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization & Action (initial completion)
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                item2.Complete();
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                item2.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("not all notification sources have completed");
+
+
+            // UUT Action (remaining reevaluator completions)
+            item1.Complete();
+            item3.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            
+            // UUT Action (source completion)
+            source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeTrue("all notification sources have completed");
+        }
+            
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void ReevaluatorCompletesWhenOnlyItemInSource_CompletionWaitsForSourceCompletion(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item = new Item() { Id = 1 };
+            
+            source.AddOrUpdate(item);
+            
+
+            // UUT Initialization & Action (reevaluator completion)
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                item.Complete();
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                item.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "1 item was added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action (source completion)
+            source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeTrue("all notification sources have completed");
+        }
+            
+        [Fact]
+        public void ReevaluatorEmitsAsynchronously_ItemRefreshes()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            ++item2.Value;
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(1).First().Count.Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(1).First().Refreshes.Should().Be(1, "1 item published a reevaluation notification");
+            results.RecordedChangeSets.Skip(1).First().First().Current.Should().Be(item2, "item #2 published a reevaluation notification");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+          
+        [Fact(Skip = "Existing defect, #1099")]
+        public void ReevaluatorEmitsImmediately_ItemDoesNotRefresh()
+        {
+            // Setup
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization & Action
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValue)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedChangeSets[0].Refreshes.Should().Be(0, "re-evaluation notifications should be ignored within the initial subscription frame");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+        }
+            
+        [Theory(Skip = "Existing defect. Docs say that ignoring reevaluator exceptions is intentional, but it shouldn't be. Basic RX philosophy is that exceptions should basically always propagate.")]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void ReevaluatorFails_ErrorPropagates(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+            var error = new Exception("Test");
+            
+
+            // UUT Initialization & Action
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                item2.SetError(error);
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                item2.SetError(error);
+
+            results.Error.Should().Be(error, "upstream errors should propagate downstream");
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                results.RecordedChangeSets.Should().BeEmpty("an error occurred during processing of the initial changeset");
+            else
+            {
+                results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+                results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            }
+        }
+            
+        [Fact(Skip = "Existing defect. Docs say that ignoring reevaluator exceptions is intentional, but it shouldn't be. Basic RX philosophy is that exceptions should basically always propagate.")]
+        public void ReevaluatorThrows_ExceptionPropagates()
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            var error = new Exception("Test");
+
+
+            // UUT Initialization
+            using var subscription = BuildUut<Unit>(
+                    source:         source.Connect(),
+                    reevaluator:    _ => throw error)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Should().BeEmpty("no initial changesets were published");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+            
+            // UUT Action
+            using var item = new Item() { Id = 1 };
+            source.AddOrUpdate(item);
+
+            results.Error.Should().Be(error, "upstream errors should propagate downstream");
+            results.RecordedChangeSets.Should().BeEmpty("an error occurred during processing of the initial changeset");
+        }
+            
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceCompletesWhenEmpty_CompletionPropagates(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+
+            // UUT Initialization & Action
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.Complete();
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeTrue("all notification sources have completed");
+        }
+
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceCompletesWhenNotEmpty_CompletionWaitsForReevaluatorCompletions(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+
+            // UUT Initialization & Action (source completion)
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.Complete();
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("not all notification sources have completed");
+
+
+            // UUT Action (initial reevaluator completion)
+            item2.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("not all notification sources have completed");
+
+
+            // UUT Action (remaining reevaluator completions)
+            item1.Complete();
+            item3.Complete();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeTrue("all notification sources have completed");
+        }
+
+        [Theory]
+        [InlineData(NotificationStrategy.Immediate)]
+        [InlineData(NotificationStrategy.Asynchronous)]
+        public void SourceFails_ErrorPropagates(NotificationStrategy notificationStrategy)
+        {
+            // Setup 
+            using var source = new TestSourceCache<Item, int>(Item.SelectId);
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            source.AddOrUpdate(new[] { item1, item2, item3 });
+            
+            var error = new Exception("Test");
+            
+
+            // UUT Initialization & Action
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                source.SetError(error);
+
+            using var subscription = BuildUut(
+                    source:         source.Connect(),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            if (notificationStrategy is NotificationStrategy.Asynchronous)
+                source.SetError(error);
+
+            results.Error.Should().Be(error, "upstream errors should propagate downstream");
+            if (notificationStrategy is NotificationStrategy.Immediate)
+                results.RecordedChangeSets.Should().BeEmpty("an error occurred before the initial changeset");
+            else
+            {
+                results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+                results.RecordedItemsByKey.Values.Should().BeEquivalentTo(source.Items, "3 items were added to the source");
+            }
+        }
+
+        [Fact]
+        public void SourceIsNull_ThrowsException()
+            => FluentActions.Invoking(() => BuildUut(
+                    source:         null!,
+                    reevaluator:    Item.ObserveValueChanged))
+                .Should()
+                .Throw<ArgumentNullException>();
+
+        [Fact]
+        public void SubscriptionIsDisposed_SubscriptionDisposalPropagates()
+        {
+            // Setup
+            using var source = new Subject<IChangeSet<Item, int>>();
+
+            using var item1 = new Item() { Id = 1 };
+            using var item2 = new Item() { Id = 2 };
+            using var item3 = new Item() { Id = 3 };
+            
+            var initialChangeset = new ChangeSet<Item, int>()
+            {
+                new Change<Item, int>(reason: ChangeReason.Add, key: item1.Id, current: item1),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item2.Id, current: item2),
+                new Change<Item, int>(reason: ChangeReason.Add, key: item3.Id, current: item3)
+            };
+            
+
+            // UUT Initialization
+            using var subscription = BuildUut(
+                    source:         source.Prepend(initialChangeset),
+                    reevaluator:    Item.ObserveValueChanged)
+                .ValidateSynchronization()
+                .ValidateChangeSets(Item.SelectId)
+                .RecordCacheItems(out var results);
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Count.Should().Be(1, "the initial changeset should propagate");
+            results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1, item2, item3 }, "3 items were added to the source");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+
+
+            // UUT Action
+            subscription.Dispose();
+
+            results.Error.Should().BeNull();
+            results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations were performed");
+            results.HasCompleted.Should().BeFalse("the source has not completed");
+            
+            source.HasObservers.Should().BeFalse("subscription disposal should propagate");
+            item1.HasObservers.Should().BeFalse("subscription disposal should propagate");
+            item2.HasObservers.Should().BeFalse("subscription disposal should propagate");
+            item3.HasObservers.Should().BeFalse("subscription disposal should propagate");
+        }
+
+        protected abstract IObservable<IChangeSet<Item, int>> BuildUut<TAny>(
+            IObservable<IChangeSet<Item, int>>  source,
+            Func<Item, IObservable<TAny>>       reevaluator,
+            TimeSpan?                           changeSetBuffer = null,
+            IScheduler?                         scheduler       = null);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithKey.cs b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithKey.cs
new file mode 100644
index 000000000..4fa7ec9d7
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithKey.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshOnObservableFixture
+{
+    public class WithKey
+        : Base
+    {
+        [Fact]
+        public void ReevaluatorIsNull_ThrowsException()
+            => FluentActions.Invoking(() => ObservableCacheEx.AutoRefreshOnObservable(
+                    source:         Observable.Never<IChangeSet<Item, int>>(),
+                    reevaluator:    (null as Func<Item, int, IObservable<Unit>>)!))
+                .Should()
+                .Throw<ArgumentNullException>();
+            
+        protected override IObservable<IChangeSet<Item, int>> BuildUut<TAny>(
+                IObservable<IChangeSet<Item, int>>  source,
+                Func<Item, IObservable<TAny>>       reevaluator,
+                TimeSpan?                           changeSetBuffer = null,
+                IScheduler?                         scheduler       = null)
+            => source.AutoRefreshOnObservable(
+                reevaluator:        (item, _) => reevaluator.Invoke(item),
+                changeSetBuffer:    changeSetBuffer,
+                scheduler:          scheduler);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithoutKey.cs b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithoutKey.cs
new file mode 100644
index 000000000..3e96d6e96
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.WithoutKey.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshOnObservableFixture
+{
+    public class WithoutKey
+        : Base
+    {
+        [Fact(Skip = "Existing defect: reevaluator is not null checked, throws NRW on first notification, instead")]
+        public void ReevaluatorIsNull_ThrowsException()
+            => FluentActions.Invoking(() => ObservableCacheEx.AutoRefreshOnObservable(
+                    source:         Observable.Never<IChangeSet<Item, int>>(),
+                    reevaluator:    (null as Func<Item, IObservable<Unit>>)!))
+                .Should()
+                .Throw<ArgumentNullException>();
+            
+        protected override IObservable<IChangeSet<Item, int>> BuildUut<TAny>(
+                IObservable<IChangeSet<Item, int>>  source,
+                Func<Item, IObservable<TAny>>       reevaluator,
+                TimeSpan?                           changeSetBuffer = null,
+                IScheduler?                         scheduler       = null)
+            => source.AutoRefreshOnObservable(
+                reevaluator:        reevaluator,
+                changeSetBuffer:    changeSetBuffer,
+                scheduler:          scheduler);
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.cs b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.cs
new file mode 100644
index 000000000..4e6f974a2
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/AutoRefreshOnObservableFixture.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Reactive;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Threading;
+
+namespace DynamicData.Tests.Cache;
+
+public static partial class AutoRefreshOnObservableFixture
+{
+    public enum NotificationStrategy
+    {
+        Immediate,
+        Asynchronous
+    }
+
+    public sealed class Item
+        : IDisposable
+    {
+        public static IObservable<int> ObserveValue(Item item)
+            => Observable.Create<int>(observer =>
+            {
+                observer.OnNext(item._value);
+                return item._valueChanged.SubscribeSafe(observer);
+            });
+            
+        public static IObservable<Unit> ObserveValueChanged(Item item)
+            => item._valueChanged.Select(static _ => Unit.Default);
+            
+        public static int SelectId(Item item)
+            => item.Id;
+    
+        public Item()
+            => _valueChanged = new();
+        
+        public required int Id
+        {
+            get => _id;
+            init => _id = value;
+        }
+            
+        public bool HasObservers
+            => _valueChanged.HasObservers;
+            
+        public int Value
+        {
+            get => _value;
+            set
+            {
+                if (_value == value)
+                    return;
+                        
+                _value = value;
+                _valueChanged.OnNext(value);
+            }
+        }
+        
+        public void Complete()
+            => _valueChanged.OnCompleted();
+        
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _hasDisposed, true))
+                return;
+            
+            _valueChanged.OnCompleted();
+            _valueChanged.Dispose();
+        }
+        
+        public void SetError(Exception error)
+            => _valueChanged.OnError(error);
+            
+        private readonly int            _id;
+        private readonly Subject<int>   _valueChanged;
+            
+        private bool    _hasDisposed;
+        private int     _value;
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicate.cs b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicate.cs
new file mode 100644
index 000000000..e5440f71b
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicate.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.Cache;
+
+public static partial class FilterFixture
+{
+    public static partial class DynamicPredicate;
+}
diff --git a/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateAndReFiltering.cs b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateAndReFiltering.cs
new file mode 100644
index 000000000..97ddee168
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateAndReFiltering.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.Cache;
+
+public static partial class FilterFixture
+{
+    public static partial class DynamicPredicateAndReFiltering;
+}
diff --git a/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateState.cs b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateState.cs
new file mode 100644
index 000000000..5d191eb59
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/FilterFixture.DynamicPredicateState.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.Cache;
+
+public static partial class FilterFixture
+{
+    public static partial class DynamicPredicateState;
+}
diff --git a/src/DynamicData.Tests/Cache/FilterFixture.Static.cs b/src/DynamicData.Tests/Cache/FilterFixture.Static.cs
index f3d61ac0a..1ca4de0cd 100644
--- a/src/DynamicData.Tests/Cache/FilterFixture.Static.cs
+++ b/src/DynamicData.Tests/Cache/FilterFixture.Static.cs
@@ -6,6 +6,9 @@
 using Xunit;
 
 using DynamicData.Tests.Utilities;
+using DynamicData.Tests.Domain;
+using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace DynamicData.Tests.Cache;
 
@@ -86,5 +89,55 @@ protected override IObservable<IChangeSet<Item, int>> BuildUut(
             => source.Filter(
                 filter:                     predicate,
                 suppressEmptyChangeSets:    suppressEmptyChangeSets);
+        [Fact]
+        public void AutoRefreshRemoveKeyFilterUpdate_CollectionUpdated()
+        {
+            RandomPersonGenerator generator = new();
+            using var source = new SourceCache<Person, string>(p => p.Key);
+            var people = generator.Take(100).ToArray();
+            var average = people.Average(x => x.Age);
+            ReadOnlyObservableCollection<Person> collection;
+            using var subscription = source.Connect()
+                .AutoRefresh(x => x.Age)
+                .RemoveKey()
+                .Filter(x => x.Age < average)
+                .Bind(out collection)
+                .Subscribe();
+            source.AddOrUpdate(people);
+
+            Assert.Equivalent(people.Where(x => x.Age < average), collection);
+
+            foreach (var person in people)
+            {
+                person.Age = person.Age + 1;
+            }
+            Assert.Equivalent(people.Where(x => x.Age < average), collection);
+        }
+
+        [Fact]
+        public void AutoRefreshFilterRemoveKeyUpdate_CollectionUpdated()
+        {
+            RandomPersonGenerator generator = new();
+            using var source = new SourceCache<Person, string>(p => p.Key);
+            var people = generator.Take(100).ToArray();
+            var average = people.Average(x => x.Age);
+            ReadOnlyObservableCollection<Person> collection;
+            using var subscription = source.Connect()
+                .AutoRefresh(x => x.Age)
+                .Filter(x => x.Age < average)
+                .RemoveKey()
+                .Bind(out collection)
+                .Subscribe();
+            source.AddOrUpdate(people);
+
+            Assert.Equivalent(people.Where(x => x.Age < average), collection);
+
+            foreach (var person in people)
+            {
+                person.Age = person.Age + 1;
+            }
+            Assert.Equivalent(people.Where(x => x.Age < average), collection);
+        }
     }
+
 }
diff --git a/src/DynamicData.Tests/Cache/FilterImmutableFixture.cs b/src/DynamicData.Tests/Cache/FilterImmutableFixture.cs
index a86e7438f..5abf88761 100644
--- a/src/DynamicData.Tests/Cache/FilterImmutableFixture.cs
+++ b/src/DynamicData.Tests/Cache/FilterImmutableFixture.cs
@@ -4,6 +4,8 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
+using DynamicData.Tests.Utilities;
+
 using FluentAssertions;
 using Xunit;
 
@@ -16,9 +18,10 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
     {
         using var source = new Subject<IChangeSet<Item, int>>();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         // Add items
@@ -31,8 +34,8 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Count.Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item1 }, "2 items were added, with 1 excluded");
+        results.RecordedChangeSets.Count.Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1 }, "2 items were added, with 1 excluded");
 
 
         // Replace items, changing inclusion
@@ -45,8 +48,8 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Skip(1).Count().Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item4 }, "2 items were replaced, with 1 excluded");
+        results.RecordedChangeSets.Skip(1).Count().Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item4 }, "2 items were replaced, with 1 excluded");
 
 
         // Replace items, not changing inclusion
@@ -59,8 +62,8 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Skip(2).Count().Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item6 }, "2 items were replaced, with 1 excluded");
+        results.RecordedChangeSets.Skip(2).Count().Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item6 }, "2 items were replaced, with 1 excluded");
 
 
         // Refresh items
@@ -71,8 +74,8 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Skip(3).Count().Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item6 }, "2 items were refreshed, with 1 excluded");
+        results.RecordedChangeSets.Skip(3).Count().Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item6 }, "2 items were refreshed, with 1 excluded");
 
 
         // Remove items
@@ -83,18 +86,18 @@ public void ItemsAreManipulated_UnmatchedItemsAreExcludedAndIndexesAreDiscarded(
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Skip(4).Count().Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEmpty("2 items were removed, with one excluded");
+        results.RecordedChangeSets.Skip(4).Count().Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Should().BeEmpty("2 items were removed, with one excluded");
 
 
-        results.Messages.SelectMany(static changes => changes).Should().AllSatisfy(
+        results.RecordedChangeSets.SelectMany(static changes => changes).Should().AllSatisfy(
             change =>
             {
                 change.CurrentIndex.Should().Be(-1);
                 change.PreviousIndex.Should().Be(-1);
             },
             because: "indexes should not be preserved");
-        results.IsCompleted.Should().BeFalse();
+        results.HasCompleted.Should().BeFalse();
     }
 
     [Fact]
@@ -102,9 +105,10 @@ public void ItemsAreMoved_ChangesAreNotPropagated()
     {
         using var source = new Subject<IChangeSet<Item, int>>();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
         // Initial setup
         var item1 = new Item() { Id = 1, IsIncluded = true };
@@ -116,18 +120,18 @@ public void ItemsAreMoved_ChangesAreNotPropagated()
             new(reason: ChangeReason.Add, key: item2.Id, current: item2, index: 1),
             new(reason: ChangeReason.Add, key: item3.Id, current: item3, index: 2)
         });
-        results.Messages.Clear();
+        var changeSetsBeforeMove = results.RecordedChangeSets.Count;
 
 
         // Move items
         source.OnNext(new ChangeSet<Item, int>()
         {
             new(reason: ChangeReason.Moved, key: item1.Id, current: item1, previous: default, currentIndex: 2, previousIndex: 0),
-            new(reason: ChangeReason.Moved, key: item2.Id, current: item1, previous: default, currentIndex: 0, previousIndex: 1)
+            new(reason: ChangeReason.Moved, key: item2.Id, current: item2, previous: default, currentIndex: 0, previousIndex: 1)
         });
 
         results.Error.Should().BeNull();
-        results.Messages.Should().BeEmpty("move operations should not be propagated");
+        results.RecordedChangeSets.Skip(changeSetsBeforeMove).Should().BeEmpty("move operations should not be propagated");
     }
 
     [Fact]
@@ -144,9 +148,10 @@ public void PredicateThrows_ExceptionIsCaptured()
 
         var error = new Exception();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: _ => throw error)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         var item1 = new Item() { Id = 1, IsIncluded = true };
@@ -156,8 +161,8 @@ public void PredicateThrows_ExceptionIsCaptured()
         });
 
         results.Error.Should().Be(error);
-        results.Messages.Should().BeEmpty("no source operations should have been processed");
-        results.IsCompleted.Should().BeFalse();
+        results.RecordedChangeSets.Should().BeEmpty("no source operations should have been processed");
+        results.HasCompleted.Should().BeFalse();
     }
 
     [Fact]
@@ -165,9 +170,10 @@ public void SourceCompletes_CompletionIsPropagated()
     {
         using var source = new Subject<IChangeSet<Item, int>>();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         var item1 = new Item() { Id = 1, IsIncluded = true };
@@ -178,11 +184,11 @@ public void SourceCompletes_CompletionIsPropagated()
         source.OnCompleted();
 
         results.Error.Should().BeNull();
-        results.IsCompleted.Should().BeTrue();
-        results.Messages.Count.Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+        results.HasCompleted.Should().BeTrue();
+        results.RecordedChangeSets.Count.Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+
 
-        
         // Make sure no extraneous notifications are published.
         var item2 = new Item() { Id = 2, IsIncluded = true };
         source.OnNext(new ChangeSet<Item, int>()
@@ -190,7 +196,7 @@ public void SourceCompletes_CompletionIsPropagated()
             new(reason: ChangeReason.Add, key: item2.Id, current: item2)
         });
 
-        results.Messages.Skip(1).Should().BeEmpty("no source operations should have been processed");
+        results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations should have been processed");
     }
 
     [Fact]
@@ -210,17 +216,16 @@ public void SourceCompletesImmediately_CompletionIsPropagated()
             return Disposable.Empty;
         });
 
-        var error = new Exception();
-
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         results.Error.Should().BeNull();
-        results.IsCompleted.Should().BeTrue();
-        results.Messages.Count.Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+        results.HasCompleted.Should().BeTrue();
+        results.RecordedChangeSets.Count.Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
     }
 
     [Fact]
@@ -230,9 +235,10 @@ public void SourceErrors_ErrorIsPropagated()
 
         var error = new Exception();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         var item1 = new Item() { Id = 1, IsIncluded = true };
@@ -243,11 +249,11 @@ public void SourceErrors_ErrorIsPropagated()
         source.OnError(error);
 
         results.Error.Should().Be(error);
-        results.IsCompleted.Should().BeFalse();
-        results.Messages.Count.Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+        results.HasCompleted.Should().BeFalse();
+        results.RecordedChangeSets.Count.Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+
 
-        
         // Make sure no extraneous notifications are published.
         var item2 = new Item() { Id = 2, IsIncluded = true };
         source.OnNext(new ChangeSet<Item, int>()
@@ -255,7 +261,7 @@ public void SourceErrors_ErrorIsPropagated()
             new(reason: ChangeReason.Add, key: item2.Id, current: item2)
         });
 
-        results.Messages.Skip(1).Should().BeEmpty("no source operations should have been processed");
+        results.RecordedChangeSets.Skip(1).Should().BeEmpty("no source operations should have been processed");
     }
 
     [Fact]
@@ -276,15 +282,16 @@ public void SourceErrorsImmediately_ErrorIsPropagated()
             return Disposable.Empty;
         });
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         results.Error.Should().Be(error);
-        results.IsCompleted.Should().BeFalse();
-        results.Messages.Count.Should().Be(1, "1 source operation was performed");
-        results.Data.Items.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
+        results.HasCompleted.Should().BeFalse();
+        results.RecordedChangeSets.Count.Should().Be(1, "1 source operation was performed");
+        results.RecordedItemsByKey.Values.Should().BeEquivalentTo(new[] { item1 }, "1 item was added");
     }
 
     [Fact]
@@ -299,19 +306,20 @@ public void SuppressEmptyChangesetsIsFalse_EmptyChangesetsArePublished()
     {
         using var source = new Subject<IChangeSet<Item, int>>();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(
                 predicate: Item.Predicate,
                 suppressEmptyChangeSets: false)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         ManipulateExcludedItems(source);
 
         results.Error.Should().BeNull();
-        results.IsCompleted.Should().BeFalse();
-        results.Messages.Count.Should().Be(5, "5 source operations were performed");
-        results.Messages.Should().AllSatisfy(changes => changes.Should().BeEmpty(), "no included items were manipulated");
+        results.HasCompleted.Should().BeFalse();
+        results.RecordedChangeSets.Count.Should().Be(5, "5 source operations were performed");
+        results.RecordedChangeSets.Should().AllSatisfy(changes => changes.Should().BeEmpty(), "no included items were manipulated");
     }
 
     [Fact]
@@ -319,16 +327,17 @@ public void SuppressEmptyChangesetsIsTrue_EmptyChangesetsAreNotPublished()
     {
         using var source = new Subject<IChangeSet<Item, int>>();
 
-        using var results = source
+        using var subscription = source
             .FilterImmutable(predicate: Item.Predicate)
-            .AsAggregator();
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
 
 
         ManipulateExcludedItems(source);
 
         results.Error.Should().BeNull();
-        results.IsCompleted.Should().BeFalse();
-        results.Messages.Should().BeEmpty("no source operations should have generated changes");
+        results.HasCompleted.Should().BeFalse();
+        results.RecordedChangeSets.Should().BeEmpty("no source operations should have generated changes");
     }
 
     private static void ManipulateExcludedItems(ISubject<IChangeSet<Item, int>> source)
@@ -364,6 +373,40 @@ private static void ManipulateExcludedItems(ISubject<IChangeSet<Item, int>> sour
         });
     }
 
+    [Fact]
+    public void Update_PreviousMatchedCurrentDoesNot_EmitsRemoveCarryingPreviousAsCurrent()
+    {
+        // Per Change<T,K> contract, a Remove change carries the item that was removed in Current.
+        // For an Update where Previous matched the predicate but Current does not, the item that
+        // leaves the filtered view is Previous (it was downstream; Current never reached downstream).
+        using var source = new Subject<IChangeSet<Item, int>>();
+
+        using var subscription = source
+            .FilterImmutable(predicate: Item.Predicate)
+            .ValidateChangeSets(Item.KeySelector)
+            .RecordCacheItems(out var results);
+
+        var included = new Item() { Id = 1, IsIncluded = true };
+        var excluded = new Item() { Id = 1, IsIncluded = false };
+
+        source.OnNext(new ChangeSet<Item, int>()
+        {
+            new(reason: ChangeReason.Add, key: included.Id, current: included, index: 0)
+        });
+
+        source.OnNext(new ChangeSet<Item, int>()
+        {
+            new(reason: ChangeReason.Update, key: excluded.Id, current: excluded, previous: included, currentIndex: 0, previousIndex: 0)
+        });
+
+        var lastChangeSet = results.RecordedChangeSets[results.RecordedChangeSets.Count - 1];
+        lastChangeSet.Count.Should().Be(1);
+
+        var removeChange = lastChangeSet.Single();
+        removeChange.Reason.Should().Be(ChangeReason.Remove);
+        removeChange.Current.Should().BeSameAs(included, "Remove.Current must carry the item that left downstream (the previously-matching value), not the new value that never reached downstream");
+    }
+
     private class Item
     {
         public static readonly Func<Item, int> KeySelector
diff --git a/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheFixture.cs b/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheFixture.cs
index 37ca6b198..949ec35bf 100644
--- a/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheFixture.cs
+++ b/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheFixture.cs
@@ -5,6 +5,7 @@
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Threading.Tasks;
 using Bogus;
 using DynamicData.Kernel;
@@ -90,10 +91,11 @@ IObservable<MarketPrice> AddRemovePrices(Market market, int priceCount, int para
                 .Parallelize(priceCount, parallel, obs => obs.StressAddRemove(market.PricesCache, _ => GetRemoveTime(), scheduler))
                 .Finally(market.PricesCache.Dispose);
 
-        var merged = _marketCache.Connect().MergeManyChangeSets(market => market.LatestPrices);
-        using var priceResults = merged.AsAggregator();
-
+        var merged = _marketCache.Connect().MergeManyChangeSets(market => market.LatestPrices).Publish();
         var adding = true;
+        var cacheCompleted = merged.LastOrDefaultAsync().ToTask();
+        using var priceResults = merged.AsAggregator();
+        using var connect = merged.Connect();
 
         // Start asynchrononously modifying the parent list and the child lists
         using var addingSub = AddRemoveStress(marketCount, priceCount, Environment.ProcessorCount, TaskPoolScheduler.Default)
@@ -119,6 +121,9 @@ IObservable<MarketPrice> AddRemovePrices(Market market, int priceCount, int para
         }
         while (adding);
 
+        // Wait for the source cache to finish delivering all notifications.
+        await cacheCompleted;
+
         // Verify the results
         CheckResultContents(_marketCacheResults, priceResults);
     }
diff --git a/src/DynamicData.Tests/Cache/MergeManyChangeSetsListFixture.cs b/src/DynamicData.Tests/Cache/MergeManyChangeSetsListFixture.cs
index f7a4aa2a5..49f566907 100644
--- a/src/DynamicData.Tests/Cache/MergeManyChangeSetsListFixture.cs
+++ b/src/DynamicData.Tests/Cache/MergeManyChangeSetsListFixture.cs
@@ -5,6 +5,7 @@
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Threading.Tasks;
 using Bogus;
 using DynamicData.Kernel;
@@ -86,9 +87,11 @@ IObservable<Animal> AddRemoveAnimals(AnimalOwner owner, int animalCount, int par
                 .Parallelize(animalCount, parallel, obs => obs.StressAddRemove(owner.Animals, _ => GetRemoveTime(), scheduler))
                 .Finally(owner.Animals.Dispose);
 
-        var mergeAnimals = _animalOwners.Connect().MergeManyChangeSets(owner => owner.Animals.Connect());
-
+        var mergeAnimals = _animalOwners.Connect().MergeManyChangeSets(owner => owner.Animals.Connect()).Publish();
         var addingAnimals = true;
+        var cacheCompleted = mergeAnimals.LastOrDefaultAsync().ToTask();
+        using var animalResults = mergeAnimals.AsAggregator();
+        using var connect = mergeAnimals.Connect();
 
         // Start asynchrononously modifying the parent list and the child lists
         using var addAnimals = AddRemoveAnimalsStress(ownerCount, animalCount, Environment.ProcessorCount, TaskPoolScheduler.Default)
@@ -114,8 +117,12 @@ IObservable<Animal> AddRemoveAnimals(AnimalOwner owner, int animalCount, int par
         }
         while (addingAnimals);
 
-        // Verify the results
-        CheckResultContents();
+        // Wait for the source cache to finish delivering all notifications.
+        await cacheCompleted;
+
+        // Verify the results against the aggregator wired into the same Publish chain
+        // that cacheCompleted observes.
+        CheckResultContents(_animalOwners.Items, _animalOwnerResults, animalResults);
     }
 
     [Fact]
diff --git a/src/DynamicData.Tests/Cache/RemoveKeyFixture.cs b/src/DynamicData.Tests/Cache/RemoveKeyFixture.cs
new file mode 100644
index 000000000..04d27f619
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/RemoveKeyFixture.cs
@@ -0,0 +1,95 @@
+#region
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reactive.Disposables;
+
+using DynamicData.Binding;
+using DynamicData.Tests.Domain;
+
+using FluentAssertions;
+
+using Xunit;
+
+#endregion
+
+namespace DynamicData.Tests.Cache;
+
+public class RemoveKeyFixture : IDisposable
+{
+    private readonly RandomPersonGenerator _generator = new();
+
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Handled with CompositeDisposable")]
+    private readonly ISourceCache<Person, string> _source;
+
+    private readonly CompositeDisposable _cleanup = new();
+
+    public RemoveKeyFixture()
+    {
+        _source = new SourceCache<Person, string>(p => p.Key);
+        _cleanup.Add(_source);
+    }
+
+    public void Dispose() => _cleanup.Dispose();
+
+    [Fact]
+    public void CacheRemoveKey_Add_KeyIsRemoved()
+    {
+        ReadOnlyObservableCollection<Person> collection;
+        _cleanup.Add(
+            _source.Connect()
+                .RemoveKey()
+                .Bind(out collection)
+                .Subscribe()
+        );
+        var people = _generator.Take(100).ToArray();
+        _source.AddOrUpdate(people);
+
+        Assert.Equivalent(people, collection);
+    }
+
+    [Fact]
+    public void CacheRemoveKey_Filter_ItemsFilterKeyIsRemoved()
+    {
+        var people = _generator.Take(100).ToArray();
+        var average = people.Average(x => x.Age);
+
+        ReadOnlyObservableCollection<Person> collection;
+        _cleanup.Add(
+            _source.Connect()
+                .RemoveKey()
+                .Filter(x => x.Age < average)
+                .Bind(out collection)
+                .Subscribe()
+        );
+        _source.AddOrUpdate(people);
+
+        Assert.Equivalent(people.Where(x => x.Age < average), collection);
+    }
+
+    [Fact]
+    public void CacheRemoveKey_AutoRefreshUpdateITems_CollectionUpdated()
+    {
+        ReadOnlyObservableCollection<Person> collection;
+        _cleanup.Add(
+            _source.Connect()
+                .AutoRefresh(x => x.Age)
+                .RemoveKey()
+                .Bind(out collection)
+                .Subscribe()
+        );
+        var people = _generator.Take(100).ToArray();
+        _source.AddOrUpdate(people);
+
+        Assert.Equivalent(people, collection);
+
+        foreach (var person in people)
+        {
+            person.Age = person.Age + 1;
+        }
+        Assert.Equivalent(people, collection);
+    }
+
+}
diff --git a/src/DynamicData.Tests/Cache/SizeLimitFixture.cs b/src/DynamicData.Tests/Cache/SizeLimitFixture.cs
index bbc67f04d..378b7fa6d 100644
--- a/src/DynamicData.Tests/Cache/SizeLimitFixture.cs
+++ b/src/DynamicData.Tests/Cache/SizeLimitFixture.cs
@@ -72,8 +72,13 @@ public void AddMoreThanLimit()
     [Fact]
     public void AddMoreThanLimitInBatched()
     {
-        _source.AddOrUpdate(_generator.Take(10).ToArray());
-        _source.AddOrUpdate(_generator.Take(10).ToArray());
+        // _generator.Take(N) draws random Person rows from a finite name pool; a second
+        // Take(10) call can produce keys that collide with the first batch, turning an
+        // Add into an Update and breaking the per-message Adds count. Draw a larger pool
+        // up front, dedupe by Key, then split into two non-overlapping batches of 10.
+        var people = _generator.Take(60).DistinctBy(p => p.Key).Take(20).ToArray();
+        _source.AddOrUpdate(people.Take(10).ToArray());
+        _source.AddOrUpdate(people.Skip(10).Take(10).ToArray());
 
         _scheduler.Start();
 
@@ -96,12 +101,17 @@ public void InvokeLimitSizeToWhenOverLimit()
         var removesTriggered = false;
         var subscriber = _source.LimitSizeTo(10, _scheduler).Subscribe(removes => { removesTriggered = true; });
 
-        _source.AddOrUpdate(_generator.Take(10).ToArray());
+        // _generator.Take(N) draws random Person rows from a finite name pool; a second
+        // Take(10) call can produce keys that collide with the first batch, turning an
+        // Add into an Update and breaking the per-message Adds count. Draw a larger pool
+        // up front, dedupe by Key, then split into two non-overlapping batches of 10.
+        var people = _generator.Take(60).DistinctBy(p => p.Key).Take(20).ToArray();
+        _source.AddOrUpdate(people.Take(10).ToArray());
         _scheduler.AdvanceBy(TimeSpan.FromMilliseconds(150).Ticks);
 
         removesTriggered.Should().BeFalse();
 
-        _source.AddOrUpdate(_generator.Take(10).ToArray());
+        _source.AddOrUpdate(people.Skip(10).Take(10).ToArray());
 
         _scheduler.AdvanceBy(TimeSpan.FromMilliseconds(150).Ticks);
 
diff --git a/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Items.cs b/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Items.cs
new file mode 100644
index 000000000..4062e343b
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Items.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.Cache;
+
+public static partial class ToObservableChangeSetFixture
+{
+    public static partial class Items;
+}
diff --git a/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Sequences.cs b/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Sequences.cs
new file mode 100644
index 000000000..cc57d44dc
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/ToObservableChangeSetFixture.Sequences.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.Cache;
+
+public static partial class ToObservableChangeSetFixture
+{
+    public static partial class Sequences;
+}
diff --git a/src/DynamicData.Tests/Cache/TransformAsyncFixture.cs b/src/DynamicData.Tests/Cache/TransformAsyncFixture.cs
index 7483eccb4..b1cedaefe 100644
--- a/src/DynamicData.Tests/Cache/TransformAsyncFixture.cs
+++ b/src/DynamicData.Tests/Cache/TransformAsyncFixture.cs
@@ -200,7 +200,7 @@ public void Update()
     }
 
 
-   
+
 
     [Theory, InlineData(true), InlineData(false)]
     public void TransformOnRefresh(bool transformOnRefresh)
@@ -215,7 +215,7 @@ public void TransformOnRefresh(bool transformOnRefresh)
 
         results.Data.Count.Should().Be(1);
         results.Data.Lookup("SomeOne").Value.AgeGroup.Should().Be("Child");
-        
+
         person.Age = 21;
 
 
@@ -224,7 +224,28 @@ public void TransformOnRefresh(bool transformOnRefresh)
 
     }
 
-    
+    [Fact]
+    public void TransformAsyncCancelsTokenOnUnSubscribe()
+    {
+        using var source = new SourceCache<Person, string>(p => p.Name);
+        var tcs = new TaskCompletionSource<Person>();
+        using var sub = source.Connect()
+            .TransformAsync(async (c, p, key, cancel) =>
+            {
+                using (cancel.Register(() => tcs.SetCanceled(), useSynchronizationContext: false))
+                {
+                    return await tcs.Task.ConfigureAwait(false);
+                }
+            })
+            .Subscribe();
+
+        source.AddOrUpdate(new Person());
+
+        sub.Dispose();
+        Assert.True(tcs.Task.IsCanceled);
+    }
+
+
     [Theory, InlineData(10), InlineData(100)]
 
     public async Task WithMaxConcurrency(int maxConcurrency)
@@ -232,7 +253,7 @@ public async Task WithMaxConcurrency(int maxConcurrency)
         /* We need to test whether the max concurrency has any effect.
 
              If  maxConcurrency == 100, this test takes a little more than 100 ms
-             If maxConcurrency = 10, this test takes a little more than 1s 
+             If maxConcurrency = 10, this test takes a little more than 1s
 
             So it works, but how can it be tested in a scientific way ??
         */
diff --git a/src/DynamicData.Tests/Cache/TransformSafeAsyncFixture.cs b/src/DynamicData.Tests/Cache/TransformSafeAsyncFixture.cs
index 6c1f34eff..b0b26cfb6 100644
--- a/src/DynamicData.Tests/Cache/TransformSafeAsyncFixture.cs
+++ b/src/DynamicData.Tests/Cache/TransformSafeAsyncFixture.cs
@@ -208,6 +208,29 @@ public void TransformOnRefresh(bool transformOnRefresh)
     }
 
 
+    [Fact]
+    public void TransformSafeAsyncCancelsTokenOnUnSubscribe()
+    {
+        using var source = new SourceCache<Person, string>(p => p.Name);
+        var tcs = new TaskCompletionSource<Person>();
+        using var sub = source.Connect()
+            .TransformSafeAsync(async (c, p, key, cancel) =>
+            {
+                using (cancel.Register(() => tcs.SetCanceled(), useSynchronizationContext: false))
+                {
+                    return await tcs.Task.ConfigureAwait(false);
+                }
+            },
+            error => Assert.Fail($"Unexpected error: {error}")) // NOTE: Cancellation exception should not be called because the handler should be torn down with subscription
+            .Subscribe();
+
+        source.AddOrUpdate(new Person());
+
+        sub.Dispose();
+        Assert.True(tcs.Task.IsCanceled);
+    }
+
+
     [Theory, InlineData(10), InlineData(100)]
 
     public async Task WithMaxConcurrency(int maxConcurrency)
@@ -215,7 +238,7 @@ public async Task WithMaxConcurrency(int maxConcurrency)
         /* We need to test whether the max concurrency has any effect.
 
              If  maxConcurrency == 100, this test takes a little more than 100 ms
-             If maxConcurrency = 10, this test takes a little more than 1s 
+             If maxConcurrency = 10, this test takes a little more than 1s
 
             So it works, but how can it be tested in a scientific way ??
         */
diff --git a/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Items.cs b/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Items.cs
new file mode 100644
index 000000000..c6531d5fa
--- /dev/null
+++ b/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Items.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.List;
+
+public static partial class ToObservableChangeSetFixture
+{
+    public static partial class Items;
+}
diff --git a/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Sequences.cs b/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Sequences.cs
new file mode 100644
index 000000000..1a6445a49
--- /dev/null
+++ b/src/DynamicData.Tests/List/ToObservableChangeSetFixture.Sequences.cs
@@ -0,0 +1,6 @@
+namespace DynamicData.Tests.List;
+
+public static partial class ToObservableChangeSetFixture
+{
+    public static partial class Sequences;
+}
diff --git a/src/DynamicData.Tests/List/TransformAsyncFixture.cs b/src/DynamicData.Tests/List/TransformAsyncFixture.cs
index 9d0bdb447..be4b8f623 100755
--- a/src/DynamicData.Tests/List/TransformAsyncFixture.cs
+++ b/src/DynamicData.Tests/List/TransformAsyncFixture.cs
@@ -1,7 +1,8 @@
 using System;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
-
+using DynamicData.Kernel;
 using DynamicData.Tests.Domain;
 using FluentAssertions;
 using Xunit;
@@ -165,4 +166,25 @@ private void TransformOnRefresh()
 
         results.Messages.Last().First().Reason.Should().Be(ListChangeReason.Replace);
     }
+
+    [Fact]
+    public void TransformAsyncCancelsTokenOnUnSubscribe()
+    {
+        using var source = new SourceList<Person>();
+        var tcs = new TaskCompletionSource<Person>();
+        using var sub = source.Connect()
+            .TransformAsync<Person, Person>(async (c, p, count, cancel) =>
+            {
+                using (cancel.Register(() => tcs.SetCanceled(), useSynchronizationContext: false))
+                {
+                    return await tcs.Task.ConfigureAwait(false);
+                }
+            })
+            .Subscribe();
+
+        source.Add(new Person());
+
+        sub.Dispose();
+        Assert.True(tcs.Task.IsCanceled);
+    }
 }
diff --git a/src/DynamicData/Binding/ObservablePropertyFactory.cs b/src/DynamicData/Binding/ObservablePropertyFactory.cs
index d9f9be00c..1c1416f4f 100644
--- a/src/DynamicData/Binding/ObservablePropertyFactory.cs
+++ b/src/DynamicData/Binding/ObservablePropertyFactory.cs
@@ -1,12 +1,16 @@
-// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
 // Roland Pheasant licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq.Expressions;
 using System.Reactive;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 
+using DynamicData.Internal;
+
 namespace DynamicData.Binding;
 
 internal sealed class ObservablePropertyFactory<TObject, TProperty>
@@ -14,74 +18,258 @@ internal sealed class ObservablePropertyFactory<TObject, TProperty>
 {
     private readonly Func<TObject, bool, IObservable<PropertyValue<TObject, TProperty>>> _factory;
 
-    public ObservablePropertyFactory(Func<TObject, TProperty> valueAccessor, ObservablePropertyPart[] chain) =>
-        _factory = (t, notifyInitial) =>
+    public ObservablePropertyFactory(Func<TObject, TProperty> valueAccessor, ObservablePropertyPart[] chain)
+    {
+        // chain is leaf-first (output of SplitIntoSteps). Reverse once to root-to-leaf order.
+        var rootToLeaf = chain.AsEnumerable().Reverse().ToArray();
+        _factory = (source, notifyInitial) => Observable.Create<PropertyValue<TObject, TProperty>>(
+            observer => new DeepChainSubscription(observer, source, rootToLeaf, valueAccessor, notifyInitial));
+    }
+
+    public ObservablePropertyFactory(Expression<Func<TObject, TProperty>> expression)
+    {
+        // Shallow form: single property, no chain. Used when depth == 1. Skips SharedDeliveryQueue
+        // and Observable.FromEventPattern in favour of a direct PropertyChanged += handler for
+        // the high-frequency single-property hot path.
+        var memberName = expression.GetProperty().Name;
+        var accessor = expression.Compile();
+        _factory = (source, notifyInitial) => Observable.Create<PropertyValue<TObject, TProperty>>(
+            observer => new SinglePropertySubscription(observer, source, memberName, accessor, notifyInitial));
+    }
+
+    public IObservable<PropertyValue<TObject, TProperty>> Create(TObject source, bool notifyInitial) => _factory(source, notifyInitial);
+
+    // Single-property subscription. Attaches a direct PropertyChanged handler and synchronizes events. Used for
+    // x => x.Prop (depth == 1) where Observable.FromEventPattern would be needless overhead on the hot path.
+    //
+    // notifyInitial only controls whether the constructor synthesises an initial emission. There
+    // is no equality dedup at the subscribe seam: a same-valued PropertyChanged firing in the
+    // subscribe window is a legitimate event and must be delivered. The "never drop events"
+    // contract takes precedence over avoiding a benign duplicate.
+    private sealed class SinglePropertySubscription : IDisposable
+    {
+        private readonly TObject _source;
+        private readonly string _memberName;
+        private readonly Func<TObject, TProperty> _accessor;
+        private readonly IObserver<PropertyValue<TObject, TProperty>> _observer;
+        #if NET9_0_OR_GREATER
+        private readonly Lock _notificationGate;
+        #else
+        private readonly object _notificationGate;
+        #endif
+
+        public SinglePropertySubscription(
+            IObserver<PropertyValue<TObject, TProperty>> observer,
+            TObject source,
+            string memberName,
+            Func<TObject, TProperty> accessor,
+            bool notifyInitial)
         {
-            // 1) notify when values have changed
-            // 2) resubscribe when changed because it may be a child object which has changed
-            var valueHasChanged = GetNotifiers(t, chain).Merge().Take(1).Repeat();
+            _source = source;
+            _memberName = memberName;
+            _accessor = accessor;
+            _observer = observer;
+            _notificationGate = new();
+
+            // Attach PropertyChanged handler FIRST so events during the initial read are not missed.
+            _source.PropertyChanged += OnPropertyChanged;
+
             if (notifyInitial)
             {
-                valueHasChanged = Observable.Defer(() => Observable.Return(Unit.Default)).Concat(valueHasChanged);
+                EmitCurrent();
             }
+        }
 
-            return valueHasChanged.Select(_ => GetPropertyValue(t, chain, valueAccessor));
-        };
+        public void Dispose()
+        {
+            _source.PropertyChanged -= OnPropertyChanged;
+        }
 
-    public ObservablePropertyFactory(Expression<Func<TObject, TProperty>> expression)
+        private void OnPropertyChanged(object? sender, PropertyChangedEventArgs args)
+        {
+            if (args.PropertyName == _memberName)
+            {
+                EmitCurrent();
+            }
+        }
+
+        // Reads the current property value and forwards it through the queue. The accessor is
+        // user code and may throw; that exception routes to OnError. The downstream OnNext call
+        // is NOT wrapped: per the Rx contract, if the user observer throws, the exception
+        // propagates back to whoever invoked the PropertyChanged setter, matching what a plain
+        // Subject<T>.OnNext would do.
+        private void EmitCurrent()
+        {
+            lock (_notificationGate)
+            {
+                PropertyValue<TObject, TProperty> value;
+                try
+                {
+                    value = new PropertyValue<TObject, TProperty>(_source, _accessor(_source));
+                }
+                catch (Exception ex)
+                {
+                    _observer.OnError(ex);
+                    return;
+                }
+
+                _observer.OnNext(value);
+            }
+        }
+    }
+
+    // Deep-chain subscription.
+    //
+    // notifyInitial only controls whether ProcessSignal emits the current chain value during
+    // the InitialSetupSignal pass. There is no equality dedup at the subscribe seam: every
+    // chain event is delivered.
+    private sealed class DeepChainSubscription : IDisposable
     {
-        // this overload is used for shallow observations i.e. depth = 1, so no need for re-subscriptions
-        var member = expression.GetProperty();
-        var accessor = expression.Compile();
+        // Sentinel signal value enqueued during subscribe to perform the initial chain setup.
+        private const int InitialSetupSignal = -1;
+
+        private readonly TObject _source;
+        private readonly ObservablePropertyPart[] _rootToLeaf;
+        private readonly Func<TObject, TProperty> _valueAccessor;
+        private readonly bool _notifyInitial;
+        private readonly IObserver<PropertyValue<TObject, TProperty>> _observer;
+        #if NET9_0_OR_GREATER
+        private readonly Lock _notificationGate;
+        #else
+        private readonly object _notificationGate;
+        #endif
+        private readonly SerialDisposable[] _levelSlots;
+
+        // Pre-allocated per-level notifier callbacks. Indexed by level. ResubscribeFrom reuses
+        // these instead of allocating a fresh closure per re-walk.
+        private readonly Action<Unit>[] _levelCallbacks;
 
-        _factory = (t, notifyInitial) =>
+        public DeepChainSubscription(
+            IObserver<PropertyValue<TObject, TProperty>> observer,
+            TObject source,
+            ObservablePropertyPart[] rootToLeaf,
+            Func<TObject, TProperty> valueAccessor,
+            bool notifyInitial)
         {
-            PropertyValue<TObject, TProperty> Factory() => new(t, accessor(t));
+            _source = source;
+            _rootToLeaf = rootToLeaf;
+            _valueAccessor = valueAccessor;
+            _notifyInitial = notifyInitial;
+            _observer = observer;
+            _notificationGate = new();
 
-            var propertyChanged = Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(handler => t.PropertyChanged += handler, handler => t.PropertyChanged -= handler).Where(args => args.EventArgs.PropertyName == member.Name).Select(_ => Factory());
+            var depth = rootToLeaf.Length;
+            _levelSlots = new SerialDisposable[depth];
+            _levelCallbacks = new Action<Unit>[depth];
+            for (var i = 0; i < depth; i++)
+            {
+                _levelSlots[i] = new SerialDisposable();
+                var level = i;
+                _levelCallbacks[i] = _ => ProcessChange(level);
+            }
+
+            // Kick off initial chain setup via the drainer. The subscribe thread becomes the
+            // drainer (no one else is draining yet on a fresh subscription) and runs
+            // ProcessSignal(InitialSetupSignal) synchronously, which attaches the chain and
+            // emits the initial value.
+            ProcessChange(InitialSetupSignal);
+        }
 
-            if (!notifyInitial)
+        public void Dispose()
+        {
+            foreach (var slot in _levelSlots)
             {
-                return propertyChanged;
+                slot.Dispose();
             }
+        }
 
-            var initial = Observable.Defer(() => Observable.Return(Factory()));
-            return initial.Concat(propertyChanged);
-        };
-    }
+        private void ProcessChange(int level)
+        {
+            lock (_notificationGate)
+            {
+                // The chain walk (Invoker / notifier Factory / ReadCurrent's accessor) is user code and may throw;
+                // those exceptions route to OnError. The downstream OnNext call is NOT wrapped: per the Rx contract,
+                // if the user observer throws, the exception propagates back through the drainer, matching what a plain
+                // Subject<T> would do.
+                //
+                // The two cases (initial setup vs level-fire) collapse to:
+                //   startLevel = (initial) ? 0 : level + 1
+                //   emit       = (level-fire) || _notifyInitial
+                var isInitial = level == InitialSetupSignal;
+                var shouldEmit = !isInitial || _notifyInitial;
+                PropertyValue<TObject, TProperty> value;
+                try
+                {
+                    ResubscribeFrom(isInitial ? 0 : level + 1);
+                    if (!shouldEmit)
+                    {
+                        return;
+                    }
 
-    public IObservable<PropertyValue<TObject, TProperty>> Create(TObject source, bool notifyInitial) => _factory(source, notifyInitial);
+                    value = ReadCurrent();
+                }
+                catch (Exception ex)
+                {
+                    _observer.OnError(ex);
+                    return;
+                }
 
-    // create notifier for all parts of the property path
-    private static IEnumerable<IObservable<Unit>> GetNotifiers(TObject source, IEnumerable<ObservablePropertyPart> chain)
-    {
-        object? value = source;
-        foreach (var metadata in chain.Reverse())
+                _observer.OnNext(value);
+            }
+        }
+
+        private void ResubscribeFrom(int startLevel)
         {
-            var obs = metadata.Factory(value).Publish().RefCount();
-            value = metadata.Invoker(value);
-            yield return obs;
+            var depth = _rootToLeaf.Length;
+            if (startLevel >= depth)
+            {
+                return;
+            }
 
-            if (value is null)
+            object? value = _source;
+            for (var i = 0; i < startLevel; i++)
             {
-                yield break;
+                value = _rootToLeaf[i].Invoker(value);
+                if (value is null)
+                {
+                    for (var j = startLevel; j < depth; j++)
+                    {
+                        _levelSlots[j].Disposable = Disposable.Empty;
+                    }
+
+                    return;
+                }
+            }
+
+            for (var i = startLevel; i < depth; i++)
+            {
+                if (value is null)
+                {
+                    _levelSlots[i].Disposable = Disposable.Empty;
+                    continue;
+                }
+
+                var notifier = _rootToLeaf[i].Factory(value);
+                _levelSlots[i].Disposable = notifier.Subscribe(_levelCallbacks[i]);
+
+                value = _rootToLeaf[i].Invoker(value);
             }
         }
-    }
 
-    // walk the tree and break at a null, or return the value [should reduce this to a null an expression]
-    private static PropertyValue<TObject, TProperty> GetPropertyValue(TObject source, IEnumerable<ObservablePropertyPart> chain, Func<TObject, TProperty> valueAccessor)
-    {
-        object? value = source;
-        foreach (var metadata in chain.Reverse())
+        // Root-to-leaf chain walk. Stops at null and returns an unobtainable PropertyValue.
+        private PropertyValue<TObject, TProperty> ReadCurrent()
         {
-            value = metadata.Invoker(value);
-            if (value is null)
+            object? value = _source;
+            foreach (var metadata in _rootToLeaf)
             {
-                return new PropertyValue<TObject, TProperty>(source);
+                value = metadata.Invoker(value);
+                if (value is null)
+                {
+                    return new PropertyValue<TObject, TProperty>(_source);
+                }
             }
-        }
 
-        return new PropertyValue<TObject, TProperty>(source, valueAccessor(source));
+            return new PropertyValue<TObject, TProperty>(_source, _valueAccessor(_source));
+        }
     }
 }
diff --git a/src/DynamicData/Cache/Internal/ExpireAfter.cs b/src/DynamicData/Cache/Internal/ExpireAfter.cs
new file mode 100644
index 000000000..2c9239f51
--- /dev/null
+++ b/src/DynamicData/Cache/Internal/ExpireAfter.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace DynamicData.Cache.Internal;
+
+internal static partial class ExpireAfter;
diff --git a/src/DynamicData/Cache/Internal/Filter.cs b/src/DynamicData/Cache/Internal/Filter.cs
new file mode 100644
index 000000000..dabc3ba7d
--- /dev/null
+++ b/src/DynamicData/Cache/Internal/Filter.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace DynamicData.Cache.Internal;
+
+internal static partial class Filter;
diff --git a/src/DynamicData/Cache/Internal/FilterImmutable.cs b/src/DynamicData/Cache/Internal/FilterImmutable.cs
index f257b18a1..67f6ec02d 100644
--- a/src/DynamicData/Cache/Internal/FilterImmutable.cs
+++ b/src/DynamicData/Cache/Internal/FilterImmutable.cs
@@ -74,10 +74,16 @@ public IObservable<IChangeSet<TObject, TKey>> Run()
                             if (downstreamReason is { } reason)
                             {
                                 // Do not propagate indexes, we can't guarantee them to be correct, because we aren't caching items.
+                                //
+                                // For Update->Remove (Previous matched, Current does not), the item that leaves
+                                // downstream is Previous; Current never reached downstream. Per the Change<T,K>
+                                // contract, Remove.Current is the value being removed, so carry Previous here.
                                 downstreamChanges.Add(new(
                                     reason: reason,
                                     key: change.Key,
-                                    current: change.Current,
+                                    current: (reason is ChangeReason.Remove && change.Reason is ChangeReason.Update)
+                                        ? change.Previous.Value
+                                        : change.Current,
                                     previous: (reason is ChangeReason.Update)
                                         ? change.Previous
                                         : default));
diff --git a/src/DynamicData/Cache/Internal/TransformAsync.cs b/src/DynamicData/Cache/Internal/TransformAsync.cs
index 344adc621..2ace51ef9 100644
--- a/src/DynamicData/Cache/Internal/TransformAsync.cs
+++ b/src/DynamicData/Cache/Internal/TransformAsync.cs
@@ -9,7 +9,7 @@ namespace DynamicData.Cache.Internal;
 
 internal class TransformAsync<TDestination, TSource, TKey>(
     IObservable<IChangeSet<TSource, TKey>> source,
-    Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory,
+    Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>> transformFactory,
     Action<Error<TSource, TKey>>? exceptionCallback,
     IObservable<Func<TSource, TKey, bool>>? forceTransform = null,
     int? maximumConcurrency = null,
@@ -42,7 +42,7 @@ private IObservable<IChangeSet<TDestination, TKey>> DoTransform(ChangeAwareCache
         var toTransform = cache.KeyValues.Where(kvp => shouldTransform(kvp.Value.Source, kvp.Key)).Select(kvp =>
             new Change<TSource, TKey>(ChangeReason.Update, kvp.Key, kvp.Value.Source, kvp.Value.Source)).ToArray();
 
-        return toTransform.Select(change => Observable.Defer(() => Transform(change).ToObservable()))
+        return toTransform.Select(change => Observable.FromAsync(t => Transform(change, t)))
             .Merge(maximumConcurrency ?? int.MaxValue)
             .ToArray()
             .Select(transformed => ProcessUpdates(cache, transformed));
@@ -51,7 +51,7 @@ private IObservable<IChangeSet<TDestination, TKey>> DoTransform(ChangeAwareCache
     private IObservable<IChangeSet<TDestination, TKey>> DoTransform(
         ChangeAwareCache<TransformedItemContainer, TKey> cache, IChangeSet<TSource, TKey> changes)
     {
-        return changes.Select(change => Observable.FromAsync(() => Transform(change)))
+        return changes.Select(change => Observable.FromAsync(t => Transform(change, t)))
             .Merge(maximumConcurrency ?? int.MaxValue)
             .ToArray()
             .Select(transformed => ProcessUpdates(cache, transformed));
@@ -102,13 +102,13 @@ private ChangeSet<TDestination, TKey> ProcessUpdates(ChangeAwareCache<Transforme
         return new ChangeSet<TDestination, TKey>(transformed);
     }
 
-    private async Task<TransformResult> Transform(Change<TSource, TKey> change)
+    private async Task<TransformResult> Transform(Change<TSource, TKey> change, CancellationToken cancellationToken)
     {
         try
         {
             if (change.Reason is ChangeReason.Add or ChangeReason.Update || (change.Reason is ChangeReason.Refresh && transformOnRefresh))
             {
-                var destination = await transformFactory(change.Current, change.Previous, change.Key)
+                var destination = await transformFactory(change.Current, change.Previous, change.Key, cancellationToken)
                     .ConfigureAwait(false);
                 return new TransformResult(change, new TransformedItemContainer(change.Current, destination));
             }
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Adapt.cs b/src/DynamicData/Cache/ObservableCacheEx.Adapt.cs
new file mode 100644
index 000000000..f99f46747
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Adapt.cs
@@ -0,0 +1,69 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Injects a side effect into the changeset stream by calling <paramref name="adaptor"/>.<see cref="IChangeSetAdaptor{TObject, TKey}.Adapt(IChangeSet{TObject, TKey})"/>
+    /// for every changeset, then forwarding it downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe and adapt.</param>
+    /// <param name="adaptor">The <see cref="IChangeSetAdaptor{TObject, TKey}"/> whose Adapt method is called for each changeset.</param>
+    /// <returns>An observable that emits the same changesets as <paramref name="source"/>, after the adaptor has processed each one.</returns>
+    /// <remarks>
+    /// <para>
+    /// This is a thin wrapper around Rx's <c>Do</c> operator. The adaptor receives each changeset
+    /// as a side effect; the changeset itself is forwarded downstream unmodified.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="adaptor"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Adapt{TObject, TKey}(IObservable{ISortedChangeSet{TObject, TKey}}, ISortedChangeSetAdaptor{TObject, TKey})"/>
+    /// <seealso cref="Bind{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservableCollection{TObject}, IObservableCollectionAdaptor{TObject, TKey})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IChangeSetAdaptor<TObject, TKey> adaptor)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
+
+        return source.Do(adaptor.Adapt);
+    }
+
+    /// <inheritdoc cref="Adapt{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IChangeSetAdaptor{TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to observe and adapt.</param>
+    /// <param name="adaptor">The <see cref="ISortedChangeSetAdaptor{TObject, TKey}"/> whose Adapt method is called for each changeset.</param>
+    /// <remarks>This overload operates on <see cref="ISortedChangeSet{TObject, TKey}"/>. Delegates to Rx's <c>Do</c> operator.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, ISortedChangeSetAdaptor<TObject, TKey> adaptor)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
+
+        return source.Do(adaptor.Adapt);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AdaptSelector.cs b/src/DynamicData/Cache/ObservableCacheEx.AdaptSelector.cs
new file mode 100644
index 000000000..07c984029
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AdaptSelector.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    // TODO: Apply the Adapter to more places
+    private static Func<TObject, TKey, TResult> AdaptSelector<TObject, TKey, TResult>(Func<TObject, TResult> other)
+        where TObject : notnull
+        where TKey : notnull
+        where TResult : notnull => (obj, _) => other(obj);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AddOrUpdate.cs b/src/DynamicData/Cache/ObservableCacheEx.AddOrUpdate.cs
new file mode 100644
index 000000000..3b217f6ed
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AddOrUpdate.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Adds or updates the cache with the specified item, producing a changeset with a single <b>Add</b>
+    /// (if the key is new) or <b>Update</b> (if the key already exists).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
+    /// <remarks>
+    /// <para>Convenience method that wraps a single-item mutation inside <see cref="ISourceCache{TObject,TKey}.Edit"/>.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Produced when the key does not already exist in the cache.</description></item>
+    /// <item><term>Update</term><description>Produced when the key already exists. The previous value is included in the changeset.</description></item>
+    /// <item><term>Remove</term><description>Not produced by this method.</description></item>
+    /// <item><term>Refresh</term><description>Not produced by this method.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="EditDiff{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject}, IEqualityComparer{TObject})"/>
+    /// <seealso cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.AddOrUpdate(item));
+    }
+
+    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
+    /// <param name="equalityComparer">The <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item. When equal, the update is skipped.</param>
+    /// <remarks>This overload uses <paramref name="equalityComparer"/> to suppress no-op updates when the new value equals the existing one.</remarks>
+    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item, IEqualityComparer<TObject> equalityComparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.AddOrUpdate(item, equalityComparer));
+    }
+
+    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
+    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to add or update.</param>
+    /// <remarks>Batch overload. All items are added/updated inside a single <see cref="ISourceCache{TObject,TKey}.Edit"/> call, producing one changeset.</remarks>
+    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.AddOrUpdate(items));
+    }
+
+    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
+    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to add or update.</param>
+    /// <param name="equalityComparer">The <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item. When equal, the update is skipped.</param>
+    /// <remarks>Batch overload with equality comparison. All items are added/updated inside a single <see cref="ISourceCache{TObject,TKey}.Edit"/> call.</remarks>
+    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items, IEqualityComparer<TObject> equalityComparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.AddOrUpdate(items, equalityComparer));
+    }
+
+    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> to add or update items in.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to associate with the item.</param>
+    /// <remarks>This overload operates on <see cref="IIntermediateCache{TObject, TKey}"/>, which requires an explicit key parameter.</remarks>
+    public static void AddOrUpdate<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, TObject item, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        item.ThrowArgumentNullExceptionIfNull(nameof(item));
+
+        source.Edit(updater => updater.AddOrUpdate(item, key));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.And.cs b/src/DynamicData/Cache/ObservableCacheEx.And.cs
new file mode 100644
index 000000000..bae09dd4e
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.And.cs
@@ -0,0 +1,121 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Applied a logical And operator between the collections i.e items which are in all of the
+    /// sources are included.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    /// <exception cref="ArgumentNullException">source or others.</exception>
+    /// <seealso cref="ObservableListEx.And"/>
+    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return others is null || others.Length == 0
+            ? throw new ArgumentNullException(nameof(others))
+            : source.Combine(CombineOperator.And, others);
+    }
+
+    /// <summary>
+    /// Applied a logical And operator between the collections i.e items which are in all of the sources are included.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// others.
+    /// </exception>
+    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.And);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical And operator between the items in the outer observable list.
+    /// Items which are in all of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.And);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical And operator between the items in the outer observable list.
+    /// Items which are in all of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.And);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical And operator between the items in the outer observable list.
+    /// Items which are in all of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.And);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AsObservableCache.cs b/src/DynamicData/Cache/ObservableCacheEx.AsObservableCache.cs
new file mode 100644
index 000000000..3a9f58875
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AsObservableCache.cs
@@ -0,0 +1,78 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Wraps an <see cref="IObservableCache{TObject, TKey}"/> in a read-only facade, hiding the mutable API.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="IObservableCache{TObject, TKey}"/> to operate on.</param>
+    /// <returns>A read-only <see cref="IObservableCache{TObject, TKey}"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
+    public static IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this IObservableCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new AnonymousObservableCache<TObject, TKey>(source);
+    }
+
+    /// <summary>
+    /// Materializes a changeset stream into a queryable, read-only <see cref="IObservableCache{TObject, TKey}"/>.
+    /// The cache subscribes to the source on first access and maintains a live snapshot of all items.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a read-only cache.</param>
+    /// <param name="applyLocking">If <see langword="true"/> (default), all cache operations are synchronized. Set to <see langword="false"/> when the caller guarantees single-threaded access.</param>
+    /// <returns>A read-only observable cache that reflects the current state of the pipeline.</returns>
+    /// <remarks>
+    /// <para>
+    /// Disposing the returned cache unsubscribes from the source stream. The cache's <c>Connect()</c>
+    /// method provides a changeset stream of its own, which re-emits the current state on each new subscriber.
+    /// </para>
+    /// <para>When <paramref name="applyLocking"/> is <see langword="false"/>, a <see cref="LockFreeObservableCache{TObject, TKey}"/> is used internally.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservableCache{TObject, TKey})"/>
+    /// <seealso cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
+    public static IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, bool applyLocking = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (applyLocking)
+        {
+            return new AnonymousObservableCache<TObject, TKey>(source);
+        }
+
+        return new LockFreeObservableCache<TObject, TKey>(source);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AsyncDisposeMany.cs b/src/DynamicData/Cache/ObservableCacheEx.AsyncDisposeMany.cs
new file mode 100644
index 000000000..0a15843d5
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AsyncDisposeMany.cs
@@ -0,0 +1,80 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// <para>
+    /// Disposes items implementing <see cref="IDisposable"/> or <see cref="IAsyncDisposable"/> when they are removed or replaced,
+    /// and disposes all tracked items when the stream completes, errors, or the subscription is disposed.
+    /// </para>
+    /// <para>
+    /// Individual items are disposed <b>after</b> the changeset has been forwarded downstream, so downstream operators
+    /// see the removal before disposal occurs. Items implementing neither disposal interface are ignored.
+    /// </para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to track for async disposal on removal.</param>
+    /// <param name="disposalsCompletedAccessor">
+    /// <para>
+    /// Invoked once per subscription, providing an <see cref="IObservable{Unit}"/> that signals when all
+    /// <see cref="IAsyncDisposable.DisposeAsync()"/> calls have finished. The signal emits a single value
+    /// and then completes.
+    /// </para>
+    /// <para>
+    /// This is delivered on a separate channel from the main changeset stream so it can be observed even
+    /// if the source stream errors.
+    /// </para>
+    /// </param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Tracks the item. No disposal.</description></item>
+    ///   <item><term>Update</term><description>Disposes the <b>previous</b> value (if it differs by reference from the current). Tracks the new value.</description></item>
+    ///   <item><term>Remove</term><description>Disposes the removed item.</description></item>
+    ///   <item><term>Refresh</term><description>Passed through. No disposal.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// On stream completion, error, or subscription disposal, all items still in the cache are disposed.
+    /// <see cref="IDisposable"/> items are disposed synchronously; <see cref="IAsyncDisposable"/> items
+    /// are dispatched via the <paramref name="disposalsCompletedAccessor"/> signal.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="disposalsCompletedAccessor"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="DisposeMany{TObject,TKey}"/>
+    public static IObservable<IChangeSet<TObject, TKey>> AsyncDisposeMany<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Action<IObservable<Unit>> disposalsCompletedAccessor)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.AsyncDisposeMany<TObject, TKey>.Create(
+            source: source,
+            disposalsCompletedAccessor: disposalsCompletedAccessor);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AutoRefresh.cs b/src/DynamicData/Cache/ObservableCacheEx.AutoRefresh.cs
new file mode 100644
index 000000000..1e7bfb428
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AutoRefresh.cs
@@ -0,0 +1,90 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Automatically refresh downstream operators when any properties change.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for property-driven refresh signals.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements have successive property changes.</param>
+    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications, preventing excessive refresh invocations.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable change set with additional refresh changes.</returns>
+    /// <seealso cref="ObservableListEx.AutoRefresh"/>
+    public static IObservable<IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.AutoRefreshOnObservable(
+            (t, _) =>
+            {
+                if (propertyChangeThrottle is null)
+                {
+                    return t.WhenAnyPropertyChanged();
+                }
+
+                return t.WhenAnyPropertyChanged().Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
+            },
+            changeSetBuffer,
+            scheduler);
+    }
+
+    /// <summary>
+    /// Automatically refresh downstream operators when properties change.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for property-driven refresh signals.</param>
+    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that specify a property to observe changes. When it changes a Refresh is invoked.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements have successive property changes.</param>
+    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications, preventing excessive refresh invocations.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable change set with additional refresh changes.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey, TProperty>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TProperty>> propertyAccessor, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.AutoRefreshOnObservable(
+            (t, _) =>
+            {
+                if (propertyChangeThrottle is null)
+                {
+                    return t.WhenPropertyChanged(propertyAccessor, false);
+                }
+
+                return t.WhenPropertyChanged(propertyAccessor, false).Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
+            },
+            changeSetBuffer,
+            scheduler);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.AutoRefreshOnObservable.cs b/src/DynamicData/Cache/ObservableCacheEx.AutoRefreshOnObservable.cs
new file mode 100644
index 000000000..39a04294e
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.AutoRefreshOnObservable.cs
@@ -0,0 +1,67 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Automatically refresh downstream operator. The refresh is triggered when the observable receives a notification.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <typeparam name="TAny">The type of evaluation.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for observable-driven refresh signals.</param>
+    /// <param name="reevaluator">The <see cref="Func{TObject, IObservable{TAny}}"/> observable which acts on items within the collection and produces a value when the item should be refreshed.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements require a refresh.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable change set with additional refresh changes.</returns>
+    /// <seealso cref="ObservableListEx.AutoRefreshOnObservable"/>
+    public static IObservable<IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => source.AutoRefreshOnObservable((t, _) => reevaluator(t), changeSetBuffer, scheduler);
+
+    /// <summary>
+    /// Automatically refresh downstream operator. The refresh is triggered when the observable receives a notification.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <typeparam name="TAny">The type of evaluation.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for observable-driven refresh signals.</param>
+    /// <param name="reevaluator">The <see cref="Func{TObject, TKey, IObservable{TAny}}"/> observable which acts on items within the collection and produces a value when the item should be refreshed.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements require a refresh.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable change set with additional refresh changes.</returns>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> Per-item observable errors are silently ignored (not forwarded to the downstream observer). Only source stream errors propagate.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        reevaluator.ThrowArgumentNullExceptionIfNull(nameof(reevaluator));
+
+        return new AutoRefresh<TObject, TKey, TAny>(source, reevaluator, changeSetBuffer, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Batch.cs b/src/DynamicData/Cache/ObservableCacheEx.Batch.cs
new file mode 100644
index 000000000..1ed843deb
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Batch.cs
@@ -0,0 +1,64 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Collects changesets emitted within a time window and merges them into a single changeset.
+    /// Uses Rx's <c>Buffer</c> operator followed by <see cref="FlattenBufferResult{TObject, TKey}"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to batch.</param>
+    /// <param name="timeSpan">The <see cref="TimeSpan"/> time window for batching.</param>
+    /// <param name="scheduler">The scheduler for timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>An observable that emits merged changesets, one per time window.</returns>
+    /// <remarks>
+    /// <para>
+    /// All changesets received during the time window are concatenated into a single changeset.
+    /// This is useful for reducing UI update frequency when the source emits many rapid changes.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Buffered and included in the merged changeset at the end of the time window.</description></item>
+    /// <item><term>Update</term><description>Buffered and included in the merged changeset.</description></item>
+    /// <item><term>Remove</term><description>Buffered and included in the merged changeset.</description></item>
+    /// <item><term>Refresh</term><description>Buffered and included in the merged changeset.</description></item>
+    /// <item><term>OnCompleted</term><description>Any remaining buffered changes are flushed, then completion is forwarded.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> The merged changeset may contain contradictory changes (e.g., Add then Remove for the same key). Downstream operators handle this correctly, but raw inspection of the changeset may be surprising.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="BufferInitial{TObject, TKey}"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Batch<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan timeSpan, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Buffer(timeSpan, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.BatchIf.cs b/src/DynamicData/Cache/ObservableCacheEx.BatchIf.cs
new file mode 100644
index 000000000..99fb5ee13
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.BatchIf.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>This overload delegates to the primary overload with <c>initialPauseState: false</c>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => BatchIf(source, pauseIfTrueSelector, false, scheduler);
+
+    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>This overload delegates to the primary overload with default <c>initialPauseState: false</c>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, null, initialPauseState, scheduler: scheduler).Run();
+
+    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>This overload omits <c>initialPauseState</c> (defaults to <see langword="false"/>) but accepts a timeout.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, TimeSpan? timeOut = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => BatchIf(source, pauseIfTrueSelector, false, timeOut, scheduler);
+
+    /// <summary>
+    /// Conditionally buffers changesets while a pause signal is active, then flushes all buffered
+    /// changes as a single merged changeset when the signal resumes.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to conditionally buffer.</param>
+    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> that when <see langword="true"/>, buffering begins. When <see langword="false"/>, the buffer is flushed.</param>
+    /// <param name="initialPauseState">If <see langword="true"/>, starts in a paused (buffering) state.</param>
+    /// <param name="timeOut">A <see cref="TimeSpan"/> that maximum time the buffer stays open. When elapsed, the buffer is flushed regardless of pause state.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> for timeout timing.</param>
+    /// <returns>An observable that emits changesets, buffered or passthrough depending on pause state.</returns>
+    /// <remarks>
+    /// <para>
+    /// While paused, incoming changesets are accumulated. On resume (or timeout), all buffered changesets
+    /// are merged into a single changeset and emitted. While not paused, changesets pass through immediately.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Buffered while paused; forwarded immediately while active.</description></item>
+    /// <item><term>Update</term><description>Buffered while paused; forwarded immediately while active.</description></item>
+    /// <item><term>Remove</term><description>Buffered while paused; forwarded immediately while active.</description></item>
+    /// <item><term>Refresh</term><description>Buffered while paused; forwarded immediately while active.</description></item>
+    /// <item><term>OnError</term><description>Buffered data is lost.</description></item>
+    /// <item><term>OnCompleted</term><description>Any remaining buffered data is flushed before completion.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> If the source completes while paused, buffered data IS flushed before OnCompleted. However, if the source errors while paused, buffered data is lost.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pauseIfTrueSelector"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Batch{TObject, TKey}"/>
+    /// <seealso cref="BufferInitial{TObject, TKey}"/>
+    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, TimeSpan? timeOut = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
+
+        return new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, timeOut, initialPauseState, scheduler: scheduler).Run();
+    }
+
+    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to conditionally buffer.</param>
+    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> that controls buffering: <see langword="true"/> begins buffering, <see langword="false"/> flushes the buffer.</param>
+    /// <param name="initialPauseState">If <see langword="true"/>, starts in a paused (buffering) state.</param>
+    /// <param name="timer">An optional <see cref="IObservable{Unit}"/> timer. The buffer is flushed each time the timer produces a value, and buffering ceases when it completes.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <remarks>This overload accepts an explicit timer observable instead of a <see cref="TimeSpan"/> timeout.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, IObservable<Unit>? timer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, null, initialPauseState, timer, scheduler).Run();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Bind.cs b/src/DynamicData/Cache/ObservableCacheEx.Bind.cs
new file mode 100644
index 000000000..84991bd6e
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Bind.cs
@@ -0,0 +1,340 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    ///  Binds the results to the specified observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <param name="refreshThreshold">The number of changes before a reset notification is triggered.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    /// <seealso cref="ObservableListEx.Bind"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, int refreshThreshold = BindingOptions.DefaultResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        // if user has not specified different defaults, use system wide defaults instead.
+        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
+        var defaults = DynamicDataOptions.Binding;
+
+        var options = refreshThreshold == BindingOptions.DefaultResetThreshold
+            ? defaults
+            : defaults with { ResetThreshold = refreshThreshold };
+
+        return source?.Bind(destination, new ObservableCollectionAdaptor<TObject, TKey>(options)) ?? throw new ArgumentNullException(nameof(source));
+    }
+
+    /// <summary>
+    ///  Binds the results to the specified observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, BindingOptions options)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source?.Bind(destination, new ObservableCollectionAdaptor<TObject, TKey>(options)) ?? throw new ArgumentNullException(nameof(source));
+    }
+
+    /// <summary>
+    /// Binds the results to the specified binding collection using the specified update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <param name="updater">The <see cref="IObservableCollectionAdaptor{TObject, TKey}"/> that applies changes to the bound collection.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, IObservableCollectionAdaptor<TObject, TKey> updater)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+        updater.ThrowArgumentNullExceptionIfNull(nameof(updater));
+
+        return Observable.Create<IChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                var locker = InternalEx.NewLock();
+                return source.Synchronize(locker).Select(
+                    changes =>
+                    {
+                        updater.Adapt(changes, destination);
+                        return changes;
+                    }).SubscribeSafe(observer);
+            });
+    }
+
+    /// <summary>
+    /// Binds the results to the specified readonly observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
+    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, BindingOptions options)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        var target = new ObservableCollectionExtended<TObject>();
+        readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
+        return source.Bind(target, new ObservableCollectionAdaptor<TObject, TKey>(options));
+    }
+
+    /// <summary>
+    /// Binds the results to the specified readonly observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
+    /// <param name="resetThreshold">The number of changes before a reset notification is triggered.</param>
+    /// <param name="useReplaceForUpdates">When <see langword="true"/>, uses Replace instead of Remove/Add for updates in the bound collection. Not all platforms support replace notifications.</param>
+    /// <param name="adaptor">An optional <see cref="IObservableCollectionAdaptor{TObject, TKey}"/> that controls how the target collection is updated.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold, bool useReplaceForUpdates = BindingOptions.DefaultUseReplaceForUpdates, IObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (adaptor is not null)
+        {
+            var target = new ObservableCollectionExtended<TObject>();
+            readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
+            return source.Bind(target, adaptor);
+        }
+
+        // if user has not specified different defaults, use system wide defaults instead.
+        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
+        var defaults = DynamicDataOptions.Binding;
+
+        var options = resetThreshold == BindingOptions.DefaultResetThreshold && useReplaceForUpdates == BindingOptions.DefaultUseReplaceForUpdates
+            ? defaults
+            : defaults with { ResetThreshold = resetThreshold, UseReplaceForUpdates = useReplaceForUpdates };
+
+        return source.Bind(out readOnlyObservableCollection, options);
+    }
+
+    /// <summary>
+    ///  Binds the results to the specified observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source.Bind(destination, DynamicDataOptions.Binding);
+    }
+
+    /// <summary>
+    ///  Binds the results to the specified observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, BindingOptions options)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        var updater = new SortedObservableCollectionAdaptor<TObject, TKey>(options);
+        return source.Bind(destination, updater);
+    }
+
+    /// <summary>
+    /// Binds the results to the specified binding collection using the specified update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
+    /// <param name="updater">The <see cref="ISortedObservableCollectionAdaptor{TObject, TKey}"/> that applies changes to the bound collection.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, ISortedObservableCollectionAdaptor<TObject, TKey> updater)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+        updater.ThrowArgumentNullExceptionIfNull(nameof(updater));
+
+        return Observable.Create<ISortedChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                var locker = InternalEx.NewLock();
+                return source.Synchronize(locker).Select(
+                    changes =>
+                    {
+                        updater.Adapt(changes, destination);
+                        return changes;
+                    }).SubscribeSafe(observer);
+            });
+    }
+
+    /// <summary>
+    /// Binds the results to the specified readonly observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
+    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, BindingOptions options)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        var target = new ObservableCollectionExtended<TObject>();
+        var result = new ReadOnlyObservableCollection<TObject>(target);
+        var updater = new SortedObservableCollectionAdaptor<TObject, TKey>(options);
+        readOnlyObservableCollection = result;
+        return source.Bind(target, updater);
+    }
+
+    /// <summary>
+    /// Binds the results to the specified readonly observable collection using the default update algorithm.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
+    /// <param name="resetThreshold">The number of changes before a reset event is called on the observable collection.</param>
+    /// <param name="useReplaceForUpdates">When <see langword="true"/>, uses Replace instead of Remove/Add for updates in the bound collection. Not all platforms support replace notifications.</param>
+    /// <param name="adaptor">An <see cref="IChangeSetAdaptor{TObject, TKey}"/> that specify an adaptor to change the algorithm to update the target collection.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="System.ArgumentNullException">source.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold, bool useReplaceForUpdates = BindingOptions.DefaultUseReplaceForUpdates, ISortedObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        // if user has not specified different defaults, use system wide defaults instead.
+        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
+        var defaults = DynamicDataOptions.Binding;
+        var options = resetThreshold == BindingOptions.DefaultResetThreshold && useReplaceForUpdates == BindingOptions.DefaultUseReplaceForUpdates
+            ? defaults
+            : defaults with { ResetThreshold = resetThreshold, UseReplaceForUpdates = useReplaceForUpdates };
+
+        adaptor ??= new SortedObservableCollectionAdaptor<TObject, TKey>(options);
+
+        var target = new ObservableCollectionExtended<TObject>();
+        readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
+        return source.Bind(target, adaptor);
+    }
+
+#if SUPPORTS_BINDINGLIST
+
+    /// <summary>
+    /// Binds a clone of the observable change set to the target observable collection.
+    /// </summary>
+    /// <typeparam name="TObject">The object type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="bindingList">The <see cref="BindingList{TObject}"/> that will receive the changes.</param>
+    /// <param name="resetThreshold">The reset threshold.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// targetCollection.
+    /// </exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, BindingList<TObject> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
+
+        return source.Adapt(new BindingListAdaptor<TObject, TKey>(bindingList, resetThreshold));
+    }
+
+    /// <summary>
+    /// Binds a clone of the observable change set to the target observable collection.
+    /// </summary>
+    /// <typeparam name="TObject">The object type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
+    /// <param name="bindingList">The <see cref="BindingList{TObject}"/> that will receive the changes.</param>
+    /// <param name="resetThreshold">The reset threshold.</param>
+    /// <returns>An observable which will emit change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// targetCollection.
+    /// </exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, BindingList<TObject> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
+
+        return source.Adapt(new SortedBindingListAdaptor<TObject, TKey>(bindingList, resetThreshold));
+    }
+
+#endif
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.BufferInitial.cs b/src/DynamicData/Cache/ObservableCacheEx.BufferInitial.cs
new file mode 100644
index 000000000..c8d709c85
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.BufferInitial.cs
@@ -0,0 +1,56 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Buffers the initial burst of changesets for the specified duration, merges them into a single
+    /// changeset, then passes all subsequent changesets through without buffering.
+    /// </summary>
+    /// <typeparam name="TObject">The object type.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to buffer during the initial loading period.</param>
+    /// <param name="initialBuffer">The <see cref="TimeSpan"/> time window to buffer, measured from when the first changeset arrives.</param>
+    /// <param name="scheduler">The scheduler for timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>An observable that emits one merged changeset for the initial burst, then passthrough for the rest.</returns>
+    /// <remarks>
+    /// <para>
+    /// Useful for aggregating the initial snapshot (which may arrive as many small changesets) into a
+    /// single changeset for efficient downstream processing, while leaving subsequent live updates untouched.
+    /// </para>
+    /// <para>Internally uses <see cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>, Rx <c>Buffer</c>, and <see cref="FlattenBufferResult{TObject, TKey}"/>.</para>
+    /// </remarks>
+    /// <seealso cref="Batch{TObject, TKey}"/>
+    /// <seealso cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> BufferInitial<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan initialBuffer, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull => source.DeferUntilLoaded().Publish(
+            shared =>
+            {
+                var initial = shared.Buffer(initialBuffer, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult().Take(1);
+
+                return initial.Concat(shared);
+            });
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Cast.cs b/src/DynamicData/Cache/ObservableCacheEx.Cast.cs
new file mode 100644
index 000000000..90aa68b00
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Cast.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Casts each item in the changeset to a new type using the provided converter function.
+    /// Equivalent to <see cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/>
+    /// but named for discoverability when a simple type cast or conversion is needed.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to cast.</param>
+    /// <param name="converter">The <see cref="Func{TSource, TDestination}"/> conversion function applied to each item.</param>
+    /// <returns>An observable changeset of converted items.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Calls <paramref name="converter"/> and emits an <b>Add</b> with the converted item.</description></item>
+    /// <item><term>Update</term><description>Calls <paramref name="converter"/> on the new value and emits an <b>Update</b>.</description></item>
+    /// <item><term>Remove</term><description>Emits a <b>Remove</b>. The converter is not called.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b>. The converter is not called.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="OfType{TObject, TKey, TDestination}"/>
+    public static IObservable<IChangeSet<TDestination, TKey>> Cast<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> converter)
+        where TSource : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new Cast<TSource, TKey, TDestination>(source, converter).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ChangeKey.cs b/src/DynamicData/Cache/ObservableCacheEx.ChangeKey.cs
new file mode 100644
index 000000000..53dc96e5d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ChangeKey.cs
@@ -0,0 +1,84 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Re-keys each item in the changeset by applying <paramref name="keySelector"/> to the current item.
+    /// The original change reason is preserved; only the key is remapped.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TSourceKey">The type of the source key.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the destination key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TSourceKey}}"/> to re-key.</param>
+    /// <param name="keySelector">The <see cref="Func{TObject, TDestinationKey}"/> that computes the destination key from the item, e.g. <c>(item) =&gt; item.NewId</c>.</param>
+    /// <returns>An observable changeset with items re-keyed using <paramref name="keySelector"/>.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description><paramref name="keySelector"/> is called on the item. An <b>Add</b> is emitted with the destination key.</description></item>
+    /// <item><term>Update</term><description><paramref name="keySelector"/> is called on the current item. An <b>Update</b> is emitted with the destination key. If the key selector produces a different destination key for the updated value than it did for the original value, downstream consumers will see an <b>Update</b> for a key that may not match the original <b>Add</b>.</description></item>
+    /// <item><term>Remove</term><description><paramref name="keySelector"/> is called on the item. A <b>Remove</b> is emitted with the destination key.</description></item>
+    /// <item><term>Refresh</term><description><paramref name="keySelector"/> is called on the item. A <b>Refresh</b> is emitted with the destination key.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/>
+    public static IObservable<IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this IObservable<IChangeSet<TObject, TSourceKey>> source, Func<TObject, TDestinationKey> keySelector)
+        where TObject : notnull
+        where TSourceKey : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return source.Select(
+            updates =>
+            {
+                var changed = updates.Select(u => new Change<TObject, TDestinationKey>(u.Reason, keySelector(u.Current), u.Current, u.Previous));
+                return new ChangeSet<TObject, TDestinationKey>(changed);
+            });
+    }
+
+    /// <inheritdoc cref="ChangeKey{TObject, TSourceKey, TDestinationKey}(IObservable{IChangeSet{TObject, TSourceKey}}, Func{TObject, TDestinationKey})"/>
+    /// <remarks>
+    /// This overload also provides the source key to <paramref name="keySelector"/>,
+    /// allowing the destination key to be derived from both the item and its original key.
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this IObservable<IChangeSet<TObject, TSourceKey>> source, Func<TSourceKey, TObject, TDestinationKey> keySelector)
+        where TObject : notnull
+        where TSourceKey : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return source.Select(
+            updates =>
+            {
+                var changed = updates.Select(u => new Change<TObject, TDestinationKey>(u.Reason, keySelector(u.Key, u.Current), u.Current, u.Previous));
+                return new ChangeSet<TObject, TDestinationKey>(changed);
+            });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Clear.cs b/src/DynamicData/Cache/ObservableCacheEx.Clear.cs
new file mode 100644
index 000000000..d29301dc8
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Clear.cs
@@ -0,0 +1,71 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Removes all items from the cache, producing a changeset with a <b>Remove</b> for every item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to clear.</param>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Not produced by this operation.</description></item>
+    /// <item><term>Update</term><description>Not produced by this operation.</description></item>
+    /// <item><term>Remove</term><description>A <b>Remove</b> is emitted for every item currently in the cache.</description></item>
+    /// <item><term>Refresh</term><description>Not produced by this operation.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Clear<TObject, TKey>(this ISourceCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Clear());
+    }
+
+    /// <inheritdoc cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
+    public static void Clear<TObject, TKey>(this IIntermediateCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Clear());
+    }
+
+    /// <inheritdoc cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
+    public static void Clear<TObject, TKey>(this LockFreeObservableCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        source.Edit(updater => updater.Clear());
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Clone.cs b/src/DynamicData/Cache/ObservableCacheEx.Clone.cs
new file mode 100644
index 000000000..1f635fc58
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Clone.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Applies each change from the source changeset to the specified <paramref name="target"/> collection as a side effect.
+    /// The changeset is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to clone.</param>
+    /// <param name="target">The <see cref="ICollection{TObject}"/> target collection to which changes are applied.</param>
+    /// <returns>An observable that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The item is added to <paramref name="target"/>. Forwarded as <b>Add</b>.</description></item>
+    /// <item><term>Update</term><description>The previous item is removed from <paramref name="target"/> and the current item is added. Forwarded as <b>Update</b>.</description></item>
+    /// <item><term>Remove</term><description>The item is removed from <paramref name="target"/>. Forwarded as <b>Remove</b>.</description></item>
+    /// <item><term>Refresh</term><description>Ignored (<see cref="ICollection{T}"/> has no concept of refresh). Forwarded as <b>Refresh</b>.</description></item>
+    /// </list>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Clone<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ICollection<TObject> target)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        target.ThrowArgumentNullExceptionIfNull(nameof(target));
+
+        return source.Do(
+            changes =>
+            {
+                foreach (var item in changes.ToConcreteType())
+                {
+                    switch (item.Reason)
+                    {
+                        case ChangeReason.Add:
+                            {
+                                target.Add(item.Current);
+                            }
+
+                            break;
+
+                        case ChangeReason.Update:
+                            {
+                                target.Remove(item.Previous.Value);
+                                target.Add(item.Current);
+                            }
+
+                            break;
+
+                        case ChangeReason.Remove:
+                            target.Remove(item.Current);
+                            break;
+                    }
+                }
+            });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Combine.cs b/src/DynamicData/Cache/ObservableCacheEx.Combine.cs
new file mode 100644
index 000000000..eb46b86b3
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Combine.cs
@@ -0,0 +1,144 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> source, CombineOperator type)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return Observable.Create<IChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                var connections = source.Connect().Transform(x => x.Connect()).AsObservableList();
+                var subscriber = connections.Combine(type).SubscribeSafe(observer);
+                return new CompositeDisposable(connections, subscriber);
+            });
+    }
+
+    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> source, CombineOperator type)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return Observable.Create<IChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                var connections = source.Connect().Transform(x => x.Connect()).AsObservableList();
+                var subscriber = connections.Combine(type).SubscribeSafe(observer);
+                return new CompositeDisposable(connections, subscriber);
+            });
+    }
+
+    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, CombineOperator type)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DynamicCombiner<TObject, TKey>(source, type).Run();
+    }
+
+    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources, CombineOperator type)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return Observable.Create<IChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                void UpdateAction(IChangeSet<TObject, TKey> updates)
+                {
+                    try
+                    {
+                        observer.OnNext(updates);
+                    }
+                    catch (Exception ex)
+                    {
+                        observer.OnError(ex);
+                    }
+                }
+
+                var subscriber = Disposable.Empty;
+                try
+                {
+                    var combiner = new Combiner<TObject, TKey>(type, UpdateAction);
+                    subscriber = combiner.Subscribe([.. sources]);
+                }
+                catch (Exception ex)
+                {
+                    observer.OnError(ex);
+                    observer.OnCompleted();
+                }
+
+                return subscriber;
+            });
+    }
+
+    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, CombineOperator type, params IObservable<IChangeSet<TObject, TKey>>[] combineTarget)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        combineTarget.ThrowArgumentNullExceptionIfNull(nameof(combineTarget));
+
+        return Observable.Create<IChangeSet<TObject, TKey>>(
+            observer =>
+            {
+                void UpdateAction(IChangeSet<TObject, TKey> updates)
+                {
+                    try
+                    {
+                        observer.OnNext(updates);
+                    }
+                    catch (Exception ex)
+                    {
+                        observer.OnError(ex);
+                        observer.OnCompleted();
+                    }
+                }
+
+                var subscriber = Disposable.Empty;
+                try
+                {
+                    var list = combineTarget.ToList();
+                    list.Insert(0, source);
+
+                    var combiner = new Combiner<TObject, TKey>(type, UpdateAction);
+                    subscriber = combiner.Subscribe([.. list]);
+                }
+                catch (Exception ex)
+                {
+                    observer.OnError(ex);
+                    observer.OnCompleted();
+                }
+
+                return subscriber;
+            });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Convert.cs b/src/DynamicData/Cache/ObservableCacheEx.Convert.cs
new file mode 100644
index 000000000..bf6d26c18
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Convert.cs
@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Obsolete: use <see cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/> instead.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to convert.</param>
+    /// <param name="conversionFactory">The <see cref="Func{TObject, TDestination}"/> conversion factory.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    [Obsolete("This was an experiment that did not work. Use Transform instead")]
+    public static IObservable<IChangeSet<TDestination, TKey>> Convert<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TDestination> conversionFactory)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
+
+        return source.Select(
+            changes =>
+            {
+                var transformed = changes.Select(change => new Change<TDestination, TKey>(change.Reason, change.Key, conversionFactory(change.Current), change.Previous.Convert(conversionFactory), change.CurrentIndex, change.PreviousIndex));
+                return new ChangeSet<TDestination, TKey>(transformed);
+            });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.CreateChangeSetTransformer.cs b/src/DynamicData/Cache/ObservableCacheEx.CreateChangeSetTransformer.cs
new file mode 100644
index 000000000..47d11d3ca
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.CreateChangeSetTransformer.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey>(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).AsObservableChangeSet(keySelector);
+
+    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).ToObservableChangeSet<TCollection, TDestination>().AddKey(keySelector);
+
+    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey>(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).Connect();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.DeferUntilLoaded.cs b/src/DynamicData/Cache/ObservableCacheEx.DeferUntilLoaded.cs
new file mode 100644
index 000000000..89cebf0da
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.DeferUntilLoaded.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Suppresses all emissions until the first non-empty changeset arrives, then replays that changeset and all subsequent ones.
+    /// If the source never produces a non-empty changeset, the stream waits indefinitely.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to defer until the first changeset arrives.</param>
+    /// <returns>An observable that begins emitting changesets once the first non-empty changeset is received.</returns>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> Blocks indefinitely if the cache or stream never receives any data. Ensure the source will eventually emit at least one changeset.</para>
+    /// </remarks>
+    /// <seealso cref="SkipInitial{TObject, TKey}"/>
+    public static IObservable<IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DeferUntilLoaded<TObject, TKey>(source).Run();
+    }
+
+    /// <inheritdoc cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this IObservableCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DeferUntilLoaded<TObject, TKey>(source).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.DisposeMany.cs b/src/DynamicData/Cache/ObservableCacheEx.DisposeMany.cs
new file mode 100644
index 000000000..52ad51274
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.DisposeMany.cs
@@ -0,0 +1,71 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// <para>
+    /// Disposes items implementing <see cref="IDisposable"/> when they are removed or replaced,
+    /// and disposes all tracked items when the stream completes, errors, or the subscription is disposed.
+    /// </para>
+    /// <para>
+    /// Individual items are disposed <b>after</b> the changeset has been forwarded downstream, so downstream operators
+    /// see the removal before disposal occurs. Items that do not implement <see cref="IDisposable"/> are ignored.
+    /// </para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to track for disposal on removal.</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Tracks the item. No disposal.</description></item>
+    ///   <item><term>Update</term><description>Disposes the <b>previous</b> value (if it differs by reference from the current). Tracks the new value.</description></item>
+    ///   <item><term>Remove</term><description>Disposes the removed item.</description></item>
+    ///   <item><term>Refresh</term><description>Passed through. No disposal.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// On stream completion, error, or subscription disposal, all remaining tracked items are disposed.
+    /// All disposal is synchronous via <see cref="IDisposable.Dispose()"/>.
+    /// For items that implement <see cref="IAsyncDisposable"/>, use <see cref="AsyncDisposeMany{TObject,TKey}"/> instead.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AsyncDisposeMany{TObject,TKey}"/>
+    /// <seealso cref="SubscribeMany{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
+    /// <seealso cref="ObservableListEx.DisposeMany"/>
+    public static IObservable<IChangeSet<TObject, TKey>> DisposeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DisposeMany<TObject, TKey>(source).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.DistinctValues.cs b/src/DynamicData/Cache/ObservableCacheEx.DistinctValues.cs
new file mode 100644
index 000000000..6007f055c
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.DistinctValues.cs
@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    ///     Selects distinct values from the source.
+    /// </summary>
+    /// <typeparam name="TObject">The type object from which the distinct values are selected.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to extract distinct values.</param>
+    /// <param name="valueSelector">The <see cref="Func{TObject, TValue}"/> value selector.</param>
+    /// <returns>An observable which will emit distinct change sets.</returns>
+    /// <remarks>
+    /// Due to it's nature only adds or removes can be returned.
+    /// <para><b>Worth noting:</b> Reference counting assumes value equality is transitive. Mutable value objects with inconsistent <c>Equals</c> implementations can corrupt ref counts.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    /// <seealso cref="ObservableListEx.DistinctValues"/>
+    public static IObservable<IDistinctChangeSet<TValue>> DistinctValues<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TValue> valueSelector)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        valueSelector.ThrowArgumentNullExceptionIfNull(nameof(valueSelector));
+
+        return Observable.Create<IDistinctChangeSet<TValue>>(observer => new DistinctCalculator<TObject, TKey, TValue>(source, valueSelector).Run().SubscribeSafe(observer));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.EditDiff.cs b/src/DynamicData/Cache/ObservableCacheEx.EditDiff.cs
new file mode 100644
index 000000000..86a68c29a
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.EditDiff.cs
@@ -0,0 +1,139 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="EditDiff{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject}, Func{TObject, TObject, bool})"/>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to diff and update.</param>
+    /// <param name="allItems">The <see cref="IEnumerable{TObject}"/> representing the complete desired state to diff against the cache.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item.</param>
+    /// <remarks>
+    /// This overload uses an <see cref="IEqualityComparer{T}"/> instead of a <see cref="Func{T, T, TResult}"/> delegate
+    /// to determine item equality.
+    /// </remarks>
+    public static void EditDiff<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> allItems, IEqualityComparer<TObject> equalityComparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        allItems.ThrowArgumentNullExceptionIfNull(nameof(allItems));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+
+        source.EditDiff(allItems, equalityComparer.Equals);
+    }
+
+    /// <summary>
+    /// Diffs a complete snapshot of items against the current cache contents, producing the minimal set of
+    /// Add, Update, and Remove changes needed to bring the cache in sync with the snapshot.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to diff and update.</param>
+    /// <param name="allItems">The <see cref="IEnumerable{TObject}"/> representing the complete desired state.</param>
+    /// <param name="areItemsEqual">The <see cref="Func{TObject, TObject, bool}"/> that returns <see langword="true"/> when the current and previous items are considered equal, e.g. <c>(current, previous) =&gt; current.Version == previous.Version</c>.</param>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Items in <paramref name="allItems"/> whose key is not in the cache produce an <b>Add</b>.</description></item>
+    /// <item><term>Update</term><description>Items present in both <paramref name="allItems"/> and the cache that differ (per <paramref name="areItemsEqual"/>) produce an <b>Update</b>.</description></item>
+    /// <item><term>Remove</term><description>Items in the cache whose key is not in <paramref name="allItems"/> produce a <b>Remove</b>.</description></item>
+    /// <item><term>Refresh</term><description>Not produced by this operation.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="allItems"/>, or <paramref name="areItemsEqual"/> is <see langword="null"/>.</exception>
+    public static void EditDiff<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> allItems, Func<TObject, TObject, bool> areItemsEqual)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        allItems.ThrowArgumentNullExceptionIfNull(nameof(allItems));
+        areItemsEqual.ThrowArgumentNullExceptionIfNull(nameof(areItemsEqual));
+
+        var editDiff = new EditDiff<TObject, TKey>(source, areItemsEqual);
+        editDiff.Edit(allItems);
+    }
+
+    /// <summary>
+    /// Converts an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> into a changeset stream by diffing each
+    /// emission against the previous one. Each emission replaces the entire dataset.
+    /// Counterpart to <see cref="ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{TObject}}"/> to convert into a keyed changeset stream.</param>
+    /// <param name="keySelector">The <see cref="Func{TObject, TKey}"/> that extracts the unique key from each item.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> for comparing items. Uses default equality if <see langword="null"/>.</param>
+    /// <returns>An observable changeset representing the incremental differences between successive snapshots.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Items in the new snapshot whose key was not in the previous snapshot produce an <b>Add</b>.</description></item>
+    /// <item><term>Update</term><description>Items present in both snapshots that differ (per <paramref name="equalityComparer"/>) produce an <b>Update</b>.</description></item>
+    /// <item><term>Remove</term><description>Items in the previous snapshot whose key is absent from the new snapshot produce a <b>Remove</b>.</description></item>
+    /// <item><term>Refresh</term><description>Not produced by this operator.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this IObservable<IEnumerable<TObject>> source, Func<TObject, TKey> keySelector, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return new EditDiffChangeSet<TObject, TKey>(source, keySelector, equalityComparer).Run();
+    }
+
+    /// <summary>
+    /// Converts an <see cref="IObservable{T}"/> of <see cref="Optional{T}"/> into a changeset stream that tracks
+    /// a single item: <c>Some</c> produces an <b>Add</b> or <b>Update</b>, and <c>None</c> produces a <b>Remove</b>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{Optional{TObject}}"/> to convert into a keyed changeset stream.</param>
+    /// <param name="keySelector">The <see cref="Func{TObject, TKey}"/> that extracts the unique key from each item.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> for comparing items. Uses default equality if <see langword="null"/>.</param>
+    /// <returns>An observable changeset tracking the single optional item.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Emitted when the source produces <c>Some(value)</c> and no item was previously tracked.</description></item>
+    /// <item><term>Update</term><description>Emitted when the source produces <c>Some(value)</c> and an item was already tracked with a different value (per <paramref name="equalityComparer"/>).</description></item>
+    /// <item><term>Remove</term><description>Emitted when the source produces <c>None</c> and an item was previously tracked.</description></item>
+    /// <item><term>Refresh</term><description>Not produced by this operator.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this IObservable<Optional<TObject>> source, Func<TObject, TKey> keySelector, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return new EditDiffChangeSetOptional<TObject, TKey>(source, keySelector, equalityComparer).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.EnsureUniqueKeys.cs b/src/DynamicData/Cache/ObservableCacheEx.EnsureUniqueKeys.cs
new file mode 100644
index 000000000..f3ec6e103
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.EnsureUniqueKeys.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Validates that each changeset contains no duplicate keys.
+    /// If duplicates are detected, an <see cref="InvalidOperationException"/> is emitted via <c>OnError</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to validate for unique keys.</param>
+    /// <returns>A changeset stream guaranteed to contain unique keys per changeset.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Forwarded as <b>Add</b> if the key is unique within the changeset.</description></item>
+    /// <item><term>Update</term><description>Forwarded as <b>Update</b> if the key is unique within the changeset.</description></item>
+    /// <item><term>Remove</term><description>Forwarded as <b>Remove</b> if the key is unique within the changeset.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the key is unique within the changeset.</description></item>
+    /// <item><term>OnError</term><description>Also emitted with <see cref="InvalidOperationException"/> if duplicate keys are detected in a changeset.</description></item>
+    /// </list>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> EnsureUniqueKeys<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new UniquenessEnforcer<TObject, TKey>(source).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Except.cs b/src/DynamicData/Cache/ObservableCacheEx.Except.cs
new file mode 100644
index 000000000..19699c8d2
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Except.cs
@@ -0,0 +1,129 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Dynamically apply a logical Except operator between the collections
+    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// others.
+    /// </exception>
+    /// <seealso cref="ObservableListEx.Except"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (others is null || others.Length == 0)
+        {
+            throw new ArgumentNullException(nameof(others));
+        }
+
+        return source.Combine(CombineOperator.Except, others);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Except operator between the collections
+    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// others.
+    /// </exception>
+    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Except);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Except operator between the collections
+    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Except);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Except operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Except);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Except operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Except);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ExpireAfter.cs b/src/DynamicData/Cache/ObservableCacheEx.ExpireAfter.cs
new file mode 100644
index 000000000..168d8903e
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ExpireAfter.cs
@@ -0,0 +1,141 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Schedules automatic removal of items after the timeout returned by <paramref name="timeSelector"/>.
+    /// If <paramref name="timeSelector"/> returns <see langword="null"/>, the item never expires.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
+    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
+    /// <returns>An observable changeset that includes timer-driven <b>Remove</b> changes for expired items.</returns>
+    /// <remarks>
+    /// <para>When a timer fires, a <b>Remove</b> is emitted for the expired item.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Schedules a removal timer based on <paramref name="timeSelector"/>. Forwarded as <b>Add</b>.</description></item>
+    /// <item><term>Update</term><description>Resets the removal timer for the item. Forwarded as <b>Update</b>.</description></item>
+    /// <item><term>Remove</term><description>Cancels the removal timer. Forwarded as <b>Remove</b>.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b>. No timer change.</description></item>
+    /// <item><term>OnError</term><description>All pending timers are cancelled.</description></item>
+    /// <item><term>OnCompleted</term><description>All pending timers are cancelled.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> A <see langword="null"/> return from <paramref name="timeSelector"/> means "never expire". <b>Update</b> changes reset the expiration timer.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="timeSelector"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Func<TObject, TimeSpan?> timeSelector)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
+            source: source,
+            timeSelector: timeSelector);
+
+    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
+    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used to schedule expiration timers.</param>
+    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Func<TObject, TimeSpan?> timeSelector,
+                IScheduler scheduler)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
+            source: source,
+            timeSelector: timeSelector,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
+    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
+    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> polling interval. If specified, items are expired on a polling interval rather than per-item timers. Less accurate but more efficient when many items share similar expiration times.</param>
+    /// <remarks>
+    /// This overload uses periodic polling instead of per-item timers. Expired items are removed on the next
+    /// poll after their timeout elapses, which trades accuracy for reduced timer overhead.
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Func<TObject, TimeSpan?> timeSelector,
+                TimeSpan? pollingInterval)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
+            source: source,
+            timeSelector: timeSelector,
+            pollingInterval: pollingInterval);
+
+    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?}, TimeSpan?)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
+    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
+    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> if specified, items are expired on a polling interval rather than per-item timers.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used to schedule polling and expiration timers.</param>
+    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Func<TObject, TimeSpan?> timeSelector,
+                TimeSpan? pollingInterval,
+                IScheduler scheduler)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
+            source: source,
+            timeSelector: timeSelector,
+            pollingInterval: pollingInterval,
+            scheduler: scheduler);
+
+    /// <summary>
+    /// Automatically removes items from the <see cref="ISourceCache{TObject, TKey}"/> after the timeout returned
+    /// by <paramref name="timeSelector"/>. Returns an observable of the removed key-value pairs (not a changeset stream).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
+    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
+    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> if specified, items are expired on a polling interval rather than per-item timers.</param>
+    /// <param name="scheduler">The scheduler used to schedule expiration timers. Defaults to <see cref="GlobalConfig.DefaultScheduler"/> if <see langword="null"/>.</param>
+    /// <returns>An observable that emits the key-value pairs of items removed from the cache by expiration.</returns>
+    /// <remarks>
+    /// Unlike the stream-based overloads, this operates directly on the <see cref="ISourceCache{TObject, TKey}"/>
+    /// and returns the removed items as <see cref="KeyValuePair{TKey, TObject}"/> collections,
+    /// not as a changeset stream.
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="timeSelector"/> is <see langword="null"/>.</exception>
+    public static IObservable<IEnumerable<KeyValuePair<TKey, TObject>>> ExpireAfter<TObject, TKey>(
+                this ISourceCache<TObject, TKey> source,
+                Func<TObject, TimeSpan?> timeSelector,
+                TimeSpan? pollingInterval = null,
+                IScheduler? scheduler = null)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.ExpireAfter.ForSource<TObject, TKey>.Create(
+            source: source,
+            timeSelector: timeSelector,
+            pollingInterval: pollingInterval,
+            scheduler: scheduler);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Filter.cs b/src/DynamicData/Cache/ObservableCacheEx.Filter.cs
new file mode 100644
index 000000000..7b43d0173
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Filter.cs
@@ -0,0 +1,145 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters items from the source changeset stream using a static predicate.
+    /// Only items that satisfy <paramref name="filter"/> are included downstream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
+    /// <param name="filter">The <see cref="Func{TObject, bool}"/> predicate used to determine whether each item is included.</param>
+    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance. Set to <see langword="false"/> to emit empty changesets, which can be useful for monitoring loading status.</param>
+    /// <returns>An observable changeset containing only items that satisfy <paramref name="filter"/>.</returns>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The predicate is evaluated. If it passes, an <b>Add</b> is emitted. Otherwise the item is dropped.</description></item>
+    /// <item><term>Update</term><description>Four outcomes: if both old and new values pass, an <b>Update</b> is emitted. If only the new value passes, an <b>Add</b> is emitted. If only the old value passed, a <b>Remove</b> is emitted. If neither passes, the change is dropped.</description></item>
+    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>Refresh</term><description>The predicate is re-evaluated. If the item now passes but previously did not, an <b>Add</b> is emitted. If it still passes, a <b>Refresh</b> is forwarded. If it no longer passes, a <b>Remove</b> is emitted. If it still fails, the change is dropped.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> <b>Refresh</b> events trigger re-evaluation, which can promote or demote items. Pair with <see cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/> for property-change-driven filtering.</para>
+    /// </remarks>
+    /// <seealso cref="FilterImmutable{TObject, TKey}"/>
+    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableListEx.Filter"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                Func<TObject, bool> filter,
+                bool suppressEmptyChangeSets = true)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.Filter.Static<TObject, TKey>.Create(
+            source: source,
+            filter: filter,
+            suppressEmptyChangeSets: suppressEmptyChangeSets);
+
+    /// <inheritdoc cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{Func{TObject, bool}}, IObservable{Unit}, bool)"/>
+    /// <remarks>
+    /// This overload does not accept a <c>reapplyFilter</c> signal. It is equivalent to calling the
+    /// full dynamic overload with <see cref="Observable.Empty{TResult}()"/> as the reapply observable.
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                IObservable<Func<TObject, bool>> predicateChanged,
+                bool suppressEmptyChangeSets = true)
+            where TObject : notnull
+            where TKey : notnull
+        => source.Filter(
+            predicateChanged: predicateChanged,
+            reapplyFilter: Observable.Empty<Unit>(),
+            suppressEmptyChangeSets: suppressEmptyChangeSets);
+
+    /// <summary>
+    /// Creates a dynamically filtered stream where the filter predicate depends on external state.
+    /// Each emission from <paramref name="predicateState"/> triggers a full re-filtering of all items.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TState">The type of state value required by <paramref name="predicate"/>.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
+    /// <param name="predicateState">The <see cref="IObservable{TState}"/> stream of state values to be passed to <paramref name="predicate"/>.</param>
+    /// <param name="predicate">The <see cref="Func{TState, TObject, bool}"/> predicate that receives the current state and an item, returning <see langword="true"/> to include or <see langword="false"/> to exclude.</param>
+    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance. Set to <see langword="false"/> to emit empty changesets.</param>
+    /// <returns>An observable changeset containing only items satisfying <paramref name="predicate"/> for the latest state.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="predicateState"/>, or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// <paramref name="predicateState"/> should emit an initial value immediately upon subscription.
+    /// Until the first state value arrives, no items pass the filter (all items are excluded).
+    /// Each subsequent state emission triggers a full re-evaluation of every item in the collection.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Evaluated against the current state. If it passes, an <b>Add</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>Update</term><description>Re-evaluated. Four outcomes as with the static <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> overload.</description></item>
+    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>Refresh</term><description>Re-evaluated against the current state. May produce <b>Add</b>, <b>Refresh</b>, <b>Remove</b>, or be dropped.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> <paramref name="predicateState"/> should emit an initial value immediately. Each emission triggers a full re-evaluation of all items, which can be expensive for large collections.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey, TState>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                IObservable<TState> predicateState,
+                Func<TState, TObject, bool> predicate,
+                bool suppressEmptyChangeSets = true)
+            where TObject : notnull
+            where TKey : notnull
+        => Cache.Internal.Filter.Dynamic<TObject, TKey, TState>.Create(
+            source: source,
+            predicateState: predicateState,
+            predicate: predicate,
+            reapplyFilter: Observable.Empty<Unit>(),
+            suppressEmptyChangeSets: suppressEmptyChangeSets);
+
+    /// <inheritdoc cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
+    /// <param name="predicateChanged">The <see cref="IObservable{Func{TObject, bool}}"/> that emits new predicates. Each emission replaces the current predicate and triggers a full re-evaluation of all items.</param>
+    /// <param name="reapplyFilter">The <see cref="IObservable{Unit}"/> that, when it emits, triggers a full re-evaluation of all items against the current predicate. Useful when filtering on mutable item properties.</param>
+    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance.</param>
+    /// <remarks>
+    /// In addition to the per-item behavior described in the static <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> overload,
+    /// emissions from <paramref name="predicateChanged"/> replace the predicate and trigger full re-filtering,
+    /// while emissions from <paramref name="reapplyFilter"/> re-evaluate all items against the current predicate.
+    /// <para><b>Worth noting:</b> No items are included until the predicate observable emits its first value.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
+                this IObservable<IChangeSet<TObject, TKey>> source,
+                IObservable<Func<TObject, bool>> predicateChanged,
+                IObservable<Unit> reapplyFilter,
+                bool suppressEmptyChangeSets = true)
+            where TObject : notnull
+            where TKey : notnull
+
+        => Cache.Internal.Filter.Dynamic<TObject, TKey, Func<TObject, bool>>.Create(
+            source: source,
+            predicateState: predicateChanged,
+            predicate: static (predicate, item) => predicate.Invoke(item),
+            reapplyFilter: reapplyFilter,
+            suppressEmptyChangeSets: suppressEmptyChangeSets);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FilterImmutable.cs b/src/DynamicData/Cache/ObservableCacheEx.FilterImmutable.cs
new file mode 100644
index 000000000..3c4d432a7
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FilterImmutable.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Creates a filtered stream, optimized for stateless/deterministic filtering of immutable items.
+    /// </summary>
+    /// <typeparam name="TObject">The type of collection items to be filtered.</typeparam>
+    /// <typeparam name="TKey">The type of the key values of each collection item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter (items assumed immutable).</param>
+    /// <param name="predicate">The <see cref="Func{TObject, bool}"/> filtering predicate to be applied to each item.</param>
+    /// <param name="suppressEmptyChangeSets">A flag indicating whether the created stream should emit empty changesets. Empty changesets are suppressed by default, for performance. Set to ensure that a downstream changeset occurs for every upstream changeset.</param>
+    /// <returns>A stream of collection changesets where upstream collection items are filtered by the given predicate.</returns>
+    /// <remarks>
+    /// <para>The goal of this operator is to optimize a common use-case of reactive programming, where data values flowing through a stream are immutable, and state changes are distributed by publishing new immutable items as replacements, instead of mutating the items directly.</para>
+    /// <para>In addition to assuming that all collection items are immutable, this operator also assumes that the given filter predicate is deterministic, such that the result it returns will always be the same each time a specific input is passed to it. In other words, the predicate itself also contains no mutable state.</para>
+    /// <para>Under these assumptions, this operator can bypass the need to keep track of every collection item that passes through it, which the normal <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> operator must do, in order to re-evaluate the filtering status of items, during a refresh operation.</para>
+    /// <para>Consider using this operator when the following are true:</para>
+    /// <list type="bullet">
+    /// <item><description>Your collection items are immutable, and changes are published by replacing entire items</description></item>
+    /// <item><description>Your filtering logic does not change over the lifetime of the stream, only the items do</description></item>
+    /// <item><description>Your filtering predicate runs quickly, and does not heavily allocate memory</description></item>
+    /// </list>
+    /// <para>Note that, because filtering is purely deterministic, Refresh operations are transparently ignored by this operator.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The predicate is evaluated. If it passes, an <b>Add</b> is emitted. Otherwise the item is dropped.</description></item>
+    /// <item><term>Update</term><description>Four outcomes: if both old and new values pass, an <b>Update</b> is emitted. If only the new value passes, an <b>Add</b> is emitted. If only the old value passed, a <b>Remove</b> is emitted. If neither passes, the change is dropped.</description></item>
+    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>Refresh</term><description><b>Dropped.</b> Because items are assumed immutable, there is nothing to re-evaluate.</description></item>
+    /// </list>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> FilterImmutable<TObject, TKey>(
+            this IObservable<IChangeSet<TObject, TKey>> source,
+            Func<TObject, bool> predicate,
+            bool suppressEmptyChangeSets = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
+
+        return new FilterImmutable<TObject, TKey>(
+                predicate: predicate,
+                source: source,
+                suppressEmptyChangeSets: suppressEmptyChangeSets)
+            .Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FilterOnObservable.cs b/src/DynamicData/Cache/ObservableCacheEx.FilterOnObservable.cs
new file mode 100644
index 000000000..82733f25a
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FilterOnObservable.cs
@@ -0,0 +1,95 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters items using a per-item <see cref="IObservable{Boolean}"/> that controls inclusion.
+    /// Each item's observable is created by <paramref name="filterFactory"/> and toggles the item in or out of the downstream stream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter using per-item observables.</param>
+    /// <param name="filterFactory">A factory that creates an <see cref="IObservable{Boolean}"/> for each item and its key. When the observable emits <see langword="true"/>, the item is included; when <see langword="false"/>, it is excluded.</param>
+    /// <param name="buffer">A <see cref="TimeSpan"/> that optional time window to buffer inclusion changes from per-item observables before re-evaluating.</param>
+    /// <param name="scheduler">An <see cref="IScheduler"/> that optional scheduler used for buffering.</param>
+    /// <returns>An observable changeset containing only items whose per-item observable most recently emitted <see langword="true"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Source changeset handling (parent events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Subscribes to the per-item observable. The item is <b>not included downstream until the observable emits its first <see langword="true"/></b>.</description></item>
+    /// <item><term>Update</term><description>Disposes the old item's observable subscription and subscribes to the new item's observable. Inclusion state is reset; the new observable must emit before the item reappears.</description></item>
+    /// <item><term>Remove</term><description>Disposes the item's observable subscription. If the item was included downstream, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently included downstream. Otherwise dropped.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Per-item observable handling (filter observable events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
+    /// <item><term>First <see langword="true"/></term><description>The item is included: an <b>Add</b> is emitted downstream.</description></item>
+    /// <item><term><see langword="false"/> (was included)</term><description>The item is excluded: a <b>Remove</b> is emitted downstream.</description></item>
+    /// <item><term><see langword="true"/> (was excluded)</term><description>The item is re-included: an <b>Add</b> is emitted downstream.</description></item>
+    /// <item><term><see langword="true"/> (was included)</term><description>No effect (already included).</description></item>
+    /// <item><term><see langword="false"/> (was excluded)</term><description>No effect (already excluded).</description></item>
+    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
+    /// <item><term>Completed</term><description>The item remains in its current inclusion state. No further toggling is possible for this item.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> Items are invisible downstream until their per-item observable emits at least one <see langword="true"/>.
+    /// If an item's observable never emits, the item never appears. The <paramref name="buffer"/> parameter batches
+    /// rapid inclusion changes from per-item observables into a single re-evaluation, reducing changeset chatter.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="filterFactory"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
+    /// <seealso cref="ObservableListEx.FilterOnObservable"/>
+    public static IObservable<IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<bool>> filterFactory, TimeSpan? buffer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        filterFactory.ThrowArgumentNullExceptionIfNull(nameof(filterFactory));
+
+        return new FilterOnObservable<TObject, TKey>(source, filterFactory, buffer, scheduler).Run();
+    }
+
+    /// <inheritdoc cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    /// <remarks>
+    /// This overload does not provide the key to <paramref name="filterFactory"/>; only the item is passed.
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<bool>> filterFactory, TimeSpan? buffer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        filterFactory.ThrowArgumentNullExceptionIfNull(nameof(filterFactory));
+
+        return source.FilterOnObservable((obj, _) => filterFactory(obj), buffer, scheduler);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FinallySafe.cs b/src/DynamicData/Cache/ObservableCacheEx.FinallySafe.cs
new file mode 100644
index 000000000..b50111d6b
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FinallySafe.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Obsolete: do not use. This can cause unhandled exception issues. Use the standard Rx <c>Finally</c> operator instead.
+    /// </summary>
+    /// <typeparam name="T">The type contained within the observables.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to attach a finally action to.</param>
+    /// <param name="finallyAction">The <see cref="Action"/> to invoke when the subscription terminates.</param>
+    /// <returns>An observable which has always a finally action applied.</returns>
+    [Obsolete("This can cause unhandled exception issues so do not use")]
+    public static IObservable<T> FinallySafe<T>(this IObservable<T> source, Action finallyAction)
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        finallyAction.ThrowArgumentNullExceptionIfNull(nameof(finallyAction));
+
+        return new FinallySafe<T>(source, finallyAction).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Flatten.cs b/src/DynamicData/Cache/ObservableCacheEx.Flatten.cs
new file mode 100644
index 000000000..23052c9e5
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Flatten.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Unwraps each <see cref="IChangeSet{TObject, TKey}"/> into individual <see cref="Change{TObject, TKey}"/>
+    /// values via <see cref="Observable.SelectMany{TSource, TResult}(IObservable{TSource}, Func{TSource, IEnumerable{TResult}})"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to flatten into individual changes.</param>
+    /// <returns>An observable of individual <see cref="Change{TObject, TKey}"/> values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="ForEachChange{TObject, TKey}"/>
+    public static IObservable<Change<TObject, TKey>> Flatten<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.SelectMany(changes => changes);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FlattenBufferResult.cs b/src/DynamicData/Cache/ObservableCacheEx.FlattenBufferResult.cs
new file mode 100644
index 000000000..357b859ac
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FlattenBufferResult.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Merges a list of changesets (typically from an Rx <c>Buffer</c> operation) into a single changeset
+    /// by concatenating all changes. Empty buffers are filtered out.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to flatten.</param>
+    /// <returns>An observable changeset combining all changes from each buffer into a single emission.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> FlattenBufferResult<TObject, TKey>(this IObservable<IList<IChangeSet<TObject, TKey>>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Where(x => x.Count != 0).Select(updates => new ChangeSet<TObject, TKey>(updates.SelectMany(u => u)));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ForEachChange.cs b/src/DynamicData/Cache/ObservableCacheEx.ForEachChange.cs
new file mode 100644
index 000000000..fb23c04b6
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ForEachChange.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Invokes <paramref name="action"/> for every individual <see cref="Change{TObject,TKey}"/> in each changeset,
+    /// regardless of change reason. The changeset is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe each individual change in.</param>
+    /// <param name="action">The action to invoke for each change. Receives the full <see cref="Change{TObject,TKey}"/> struct, including <see cref="Change{TObject,TKey}.Reason"/>, <see cref="Change{TObject,TKey}.Key"/>, <see cref="Change{TObject,TKey}.Current"/>, and <see cref="Change{TObject,TKey}.Previous"/>.</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// All change reasons (Add, Update, Remove, Refresh) trigger the callback.
+    /// Use <see cref="OnItemAdded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>,
+    /// <see cref="OnItemUpdated{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TObject,TKey})"/>,
+    /// <see cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>, or
+    /// <see cref="OnItemRefreshed{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>
+    /// to target a specific reason.
+    /// </para>
+    /// <para>
+    /// Implemented via Rx's <c>Do</c> operator on the changeset stream.
+    /// Exceptions thrown in <paramref name="action"/> propagate as <c>OnError</c> to the subscriber. No try-catch is applied.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="ObservableListEx.ForEachChange"/>
+    public static IObservable<IChangeSet<TObject, TKey>> ForEachChange<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<Change<TObject, TKey>> action)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        action.ThrowArgumentNullExceptionIfNull(nameof(action));
+
+        return source.Do(changes => changes.ForEach(action));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ForForced.cs b/src/DynamicData/Cache/ObservableCacheEx.ForForced.cs
new file mode 100644
index 000000000..02103498f
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ForForced.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    private static IObservable<Func<TSource, TKey, bool>>? ForForced<TSource, TKey>(this IObservable<Unit>? source)
+        where TKey : notnull => source?.Select(
+            _ =>
+            {
+                static bool Transformer(TSource item, TKey key) => true;
+                return (Func<TSource, TKey, bool>)Transformer;
+            });
+
+    private static IObservable<Func<TSource, TKey, bool>>? ForForced<TSource, TKey>(this IObservable<Func<TSource, bool>>? source)
+        where TKey : notnull => source?.Select(
+            condition =>
+            {
+                bool Transformer(TSource item, TKey key) => condition(item);
+                return (Func<TSource, TKey, bool>)Transformer;
+            });
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FullJoin.cs b/src/DynamicData/Cache/ObservableCacheEx.FullJoin.cs
new file mode 100644
index 000000000..9328527e2
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FullJoin.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left and right values into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, Optional<TRight>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.FullJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Joins two changeset streams, producing a result for every key that appears on either side (or both).
+    /// Both sides are <see cref="Optional{T}"/> because a given key may only exist on one side at any point.
+    /// Equivalent to SQL FULL OUTER JOIN.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left, and optional right into a destination object. Example: <c>(key, left, right) =&gt; new Result(key, left, right)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Emits with the left value and the matching right (or <see cref="Optional.None{T}"/> if no right exists).</description></item>
+    ///   <item><term>Update</term><description>Re-invokes <paramref name="resultSelector"/> with the new left value and current right (if any).</description></item>
+    ///   <item><term>Remove</term><description>If a right match still exists, re-invokes the selector with left as <see cref="Optional.None{T}"/>. If neither side remains, removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Emits with the matching left (or <see cref="Optional.None{T}"/>) and the right value.</description></item>
+    ///   <item><term>Update</term><description>Re-invokes selector with current left (if any) and the new right value.</description></item>
+    ///   <item><term>Remove</term><description>If a left match still exists, re-invokes the selector with right as <see cref="Optional.None{T}"/>. If neither side remains, removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
+    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
+    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, Optional<TRight>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.FullJoinMany.cs b/src/DynamicData/Cache/ObservableCacheEx.FullJoinMany.cs
new file mode 100644
index 000000000..c2e5894bc
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.FullJoinMany.cs
@@ -0,0 +1,107 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left value and the right group into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.FullJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Groups right-side items by their mapped key, then full-joins each group to the left source.
+    /// A result is produced for every key that appears on either side (or both). The left value is
+    /// <see cref="Optional{T}"/> because only the right side may have entries for a given key.
+    /// Equivalent to SQL FULL OUTER JOIN with the right side grouped.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left value, and the right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Emits with the left value and the current right group for that key (may be empty).</description></item>
+    ///   <item><term>Update</term><description>Re-invokes <paramref name="resultSelector"/> with the new left value and current right group.</description></item>
+    ///   <item><term>Remove</term><description>If the right group is non-empty, re-invokes with left as <see cref="Optional.None{T}"/>. If both sides are empty, removes the result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Updates the right group, then re-invokes selector with the current left (if any) and the updated group.</description></item>
+    ///   <item><term>Update</term><description>Updates the right group and re-invokes selector.</description></item>
+    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty and no left exists, removes the result. Otherwise re-invokes selector.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Group.cs b/src/DynamicData/Cache/ObservableCacheEx.Group.cs
new file mode 100644
index 000000000..b803146d8
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Group.cs
@@ -0,0 +1,166 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Groups items from the source changeset, producing groups only for group keys present in <paramref name="resultGroupSource"/>.
+    /// Useful for parent-child relationships where parents and children come from different streams.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
+    /// <param name="groupSelector">The <see cref="Func{TObject, TGroupKey}"/> group selector factory.</param>
+    /// <param name="resultGroupSource">An <see cref="IObservable{IDistinctChangeSet{TGroupKey}}"/> of <see cref="IDistinctChangeSet{TGroupKey}"/> used to determine which groups appear in the result.</param>
+    /// <remarks>
+    /// Useful for parent-child collection when the parent and child are soured from different streams.
+    /// </remarks>
+    /// <returns>An observable which will emit group change sets.</returns>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelector, IObservable<IDistinctChangeSet<TGroupKey>> resultGroupSource)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupSelector.ThrowArgumentNullExceptionIfNull(nameof(groupSelector));
+        resultGroupSource.ThrowArgumentNullExceptionIfNull(nameof(resultGroupSource));
+
+        return new SpecifiedGrouper<TObject, TKey, TGroupKey>(source, groupSelector, resultGroupSource).Run();
+    }
+
+    /// <summary>
+    /// Groups items from the source changeset by a key extracted via <paramref name="groupSelectorKey"/>.
+    /// Each group is an observable sub-cache that receives changes for its members.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
+    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
+    /// <returns>An observable that emits group changesets. Each group exposes a sub-cache of its members.</returns>
+    /// <remarks>
+    /// <para>
+    /// Items are assigned to groups based on the value returned by <paramref name="groupSelectorKey"/>.
+    /// Groups are created on demand when the first item is assigned, and removed when their last member is removed.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The group key is evaluated. The item is added to the corresponding group (creating the group if new). An <b>Add</b> is emitted to the group's sub-cache.</description></item>
+    /// <item><term>Update</term><description>The group key is re-evaluated. If unchanged, an <b>Update</b> is emitted within the same group. If the key changed, the item is removed from the old group (emitting <b>Remove</b>) and added to the new group (emitting <b>Add</b>). An empty old group is removed.</description></item>
+    /// <item><term>Remove</term><description>The item is removed from its group. If the group becomes empty, the group itself is removed from the output.</description></item>
+    /// <item><term>Refresh</term><description>The group key is re-evaluated. If unchanged, a <b>Refresh</b> is forwarded within the group. If the key changed, the item moves between groups (Remove from old, Add to new).</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> Each group is a live sub-cache that can be subscribed to independently. Subscribers
+    /// to a group receive only changes for items in that group. When a group is removed (becomes empty),
+    /// its sub-cache completes.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="GroupWithImmutableState{TObject, TKey, TGroupKey}"/>
+    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="GroupOnProperty{TObject, TKey, TGroupKey}"/>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
+
+        return new GroupOn<TObject, TKey, TGroupKey>(source, groupSelectorKey, null).Run();
+    }
+
+    /// <inheritdoc cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
+    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
+    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that, when it emits, all items are re-evaluated against the group selector, potentially moving items between groups.</param>
+    /// <returns>An observable that emits group changesets.</returns>
+    /// <remarks>This overload adds a <paramref name="regrouper"/> signal. When it fires, every item in the cache is re-grouped using the current selector, which is useful when the grouping depends on mutable item state.</remarks>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit> regrouper)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
+        regrouper.ThrowArgumentNullExceptionIfNull(nameof(regrouper));
+
+        return new GroupOn<TObject, TKey, TGroupKey>(source, groupSelectorKey, regrouper).Run();
+    }
+
+    /// <summary>
+    /// Groups items using a dynamically changing group selector function.
+    /// Each time <paramref name="groupSelectorKeyObservable"/> emits a new selector, all items are re-grouped.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
+    /// <param name="groupSelectorKeyObservable">The <see cref="IObservable{Func{TObject, TKey, TGroupKey}}"/> that emits group selector functions. Each emission triggers a full re-grouping of all items.</param>
+    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that optional signal to force re-evaluation of all items against the current selector.</param>
+    /// <returns>An observable that emits group changesets.</returns>
+    /// <remarks>
+    /// <para>
+    /// Unlike the static-selector overload, this accepts an observable of selector functions. When a new selector
+    /// arrives, every item is re-evaluated and may move between groups. The optional <paramref name="regrouper"/>
+    /// signal triggers re-evaluation without changing the selector (useful when item properties that affect grouping change).
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The current selector determines the group. Item is added to the group (group created if new).</description></item>
+    /// <item><term>Update</term><description>Group key re-evaluated. Item may move between groups if the key changed.</description></item>
+    /// <item><term>Remove</term><description>Item removed from its group. Empty groups are removed.</description></item>
+    /// <item><term>Refresh</term><description>Group key re-evaluated. Item may move between groups.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
+    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}}, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<Func<TObject, TKey, TGroupKey>> groupSelectorKeyObservable, IObservable<Unit>? regrouper = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupSelectorKeyObservable.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKeyObservable));
+
+        return new GroupOnDynamic<TObject, TKey, TGroupKey>(source, groupSelectorKeyObservable, regrouper).Run();
+    }
+
+    /// <inheritdoc cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{Func{TObject, TKey, TGroupKey}}, IObservable{Unit}?)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
+    /// <param name="groupSelectorKeyObservable">The <see cref="IObservable{Func{TObject, TGroupKey}}"/> of selector functions that take only the item (not the key).</param>
+    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> signal to force re-evaluation.</param>
+    /// <remarks>This overload accepts a selector that does not receive the key. Delegates to the overload accepting <c>Func&lt;TObject, TKey, TGroupKey&gt;</c>.</remarks>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<Func<TObject, TGroupKey>> groupSelectorKeyObservable, IObservable<Unit>? regrouper = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        groupSelectorKeyObservable.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKeyObservable));
+
+        return source.Group(groupSelectorKeyObservable.Select(AdaptSelector<TObject, TKey, TGroupKey>), regrouper);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.GroupOnObservable.cs b/src/DynamicData/Cache/ObservableCacheEx.GroupOnObservable.cs
new file mode 100644
index 000000000..31115d013
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.GroupOnObservable.cs
@@ -0,0 +1,104 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Groups items where each item's group key is determined by a per-item observable.
+    /// The observable is created by <paramref name="groupObservableSelector"/> for each item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group using per-item observables.</param>
+    /// <param name="groupObservableSelector">A <see cref="Func{T, TResult}"/> factory that creates a group key observable for each item and its key.</param>
+    /// <returns>An observable that emits group changesets. Each group is a live sub-cache of its members.</returns>
+    /// <remarks>
+    /// <para>
+    /// Unlike <see cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/> which evaluates
+    /// the group key synchronously, this operator defers group assignment until the per-item observable emits.
+    /// </para>
+    /// <para>
+    /// <b>Source changeset handling (parent events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Subscribes to the per-item group key observable. The item is <b>not placed in any group until the observable emits its first group key</b>.</description></item>
+    /// <item><term>Update</term><description>Disposes the old item's group key subscription and subscribes to the new item's observable. The item is removed from its current group until the new observable emits.</description></item>
+    /// <item><term>Remove</term><description>Disposes the item's group key subscription. The item is removed from its current group. Empty groups are removed.</description></item>
+    /// <item><term>Refresh</term><description>No effect on subscriptions. The item remains in its current group.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Per-item observable handling (group key observable events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
+    /// <item><term>First value</term><description>The item is placed into the group matching the emitted key. An <b>Add</b> appears in that group's sub-cache. If the group is new, the group itself is added to the output.</description></item>
+    /// <item><term>New value (different key)</term><description>The item moves: <b>Remove</b> from the old group, <b>Add</b> to the new group. If the old group becomes empty, it is removed from the output.</description></item>
+    /// <item><term>Same value (unchanged key)</term><description>No effect (filtered by <c>DistinctUntilChanged</c>).</description></item>
+    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
+    /// <item><term>Completed</term><description>The item remains in its current group. No further group key changes are possible for this item.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> Items are invisible (not in any group) until their per-item observable emits at least one
+    /// group key. If an item's observable never emits, the item never appears in any group. Per-item observable errors
+    /// terminate the entire stream. The output completes when the source completes and all per-item observables have
+    /// also completed.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
+    /// <seealso cref="GroupOnProperty{TObject, TKey, TGroupKey}"/>
+    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="TransformOnObservable{TSource, TKey, TDestination}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, IObservable{TDestination}})"/>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnObservable<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TGroupKey>> groupObservableSelector)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupObservableSelector.ThrowArgumentNullExceptionIfNull(nameof(groupObservableSelector));
+
+        return new GroupOnObservable<TObject, TKey, TGroupKey>(source, groupObservableSelector).Run();
+    }
+
+    /// <summary>
+    /// Groups the source by the latest value from their observable created by the given factory.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group using per-item observables.</param>
+    /// <param name="groupObservableSelector">The <see cref="Func{TObject, IObservable{TGroupKey}}"/> group selector key.</param>
+    /// <returns>An observable which will emit group change sets.</returns>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnObservable<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TGroupKey>> groupObservableSelector)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        groupObservableSelector.ThrowArgumentNullExceptionIfNull(nameof(groupObservableSelector));
+
+        return source.GroupOnObservable(AdaptSelector<TObject, TKey, IObservable<TGroupKey>>(groupObservableSelector));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.GroupOnProperty.cs b/src/DynamicData/Cache/ObservableCacheEx.GroupOnProperty.cs
new file mode 100644
index 000000000..5165d4091
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.GroupOnProperty.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// <para>Groups the source using the property specified by the property selector. Groups are re-applied when the property value changed.</para>
+    /// <para>When there are likely to be a large number of group property changes specify a throttle to improve performance.</para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group by a property value.</param>
+    /// <param name="propertySelector">The <see cref="Expression{Func{TObject, TGroupKey}}"/> property selector used to group the items.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> a time span that indicates the throttle to wait for property change events.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable which will emit immutable group change sets.</returns>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnProperty<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TGroupKey>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
+
+        return new GroupOnProperty<TObject, TKey, TGroupKey>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.GroupOnPropertyWithImmutableState.cs b/src/DynamicData/Cache/ObservableCacheEx.GroupOnPropertyWithImmutableState.cs
new file mode 100644
index 000000000..2be1f5ca0
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.GroupOnPropertyWithImmutableState.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// <para>Groups the source using the property specified by the property selector. Each update produces immutable grouping. Groups are re-applied when the property value changed.</para>
+    /// <para>When there are likely to be a large number of group property changes specify a throttle to improve performance.</para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group by a property value with immutable snapshots.</param>
+    /// <param name="propertySelector">The <see cref="Expression{Func{TObject, TGroupKey}}"/> property selector used to group the items.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> a time span that indicates the throttle to wait for property change events.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
+    /// <returns>An observable which will emit immutable group change sets.</returns>
+    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnPropertyWithImmutableState<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TGroupKey>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
+
+        return new GroupOnPropertyWithImmutableState<TObject, TKey, TGroupKey>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.GroupWithImmutableState.cs b/src/DynamicData/Cache/ObservableCacheEx.GroupWithImmutableState.cs
new file mode 100644
index 000000000..1284a4b4f
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.GroupWithImmutableState.cs
@@ -0,0 +1,66 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Groups items by <paramref name="groupSelectorKey"/>, emitting immutable group snapshots instead of mutable sub-caches.
+    /// Each group change contains a frozen copy of the group's state at that point in time.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group with immutable snapshots.</param>
+    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
+    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that optional signal to force re-evaluation of all items against the group selector.</param>
+    /// <returns>An observable that emits immutable group changesets.</returns>
+    /// <remarks>
+    /// <para>
+    /// Behaves identically to <see cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
+    /// in terms of how items are assigned to groups, but each group emission is an immutable snapshot.
+    /// This makes it safe for parallel processing and eliminates race conditions on group state.
+    /// The tradeoff is higher memory usage, since each change produces a new snapshot of the affected group.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Item added to its group. An immutable snapshot of the group is emitted.</description></item>
+    /// <item><term>Update</term><description>If group key unchanged, group snapshot re-emitted. If changed, item moves between groups; both affected groups emit new snapshots.</description></item>
+    /// <item><term>Remove</term><description>Item removed from group. Updated snapshot emitted. Empty groups are removed.</description></item>
+    /// <item><term>Refresh</term><description>Group key re-evaluated. If changed, item moves; affected group snapshots emitted.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
+    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TKey, TGroupKey}"/>
+    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupWithImmutableState<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit>? regrouper = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
+
+        return new GroupOnImmutable<TObject, TKey, TGroupKey>(source, groupSelectorKey, regrouper).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.IgnoreSameReferenceUpdate.cs b/src/DynamicData/Cache/ObservableCacheEx.IgnoreSameReferenceUpdate.cs
new file mode 100644
index 000000000..f5ff65ace
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.IgnoreSameReferenceUpdate.cs
@@ -0,0 +1,38 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Ignores updates when the update is the same reference.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to suppress same-reference updates in.</param>
+    /// <returns>An observable which emits change sets and ignores equal value changes.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> IgnoreSameReferenceUpdate<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.IgnoreUpdateWhen((c, p) => ReferenceEquals(c, p));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.IgnoreUpdateWhen.cs b/src/DynamicData/Cache/ObservableCacheEx.IgnoreUpdateWhen.cs
new file mode 100644
index 000000000..2b8f11a87
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.IgnoreUpdateWhen.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Ignores the update when the condition is met.
+    /// The first parameter in the ignore function is the current value and the second parameter is the previous value.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to selectively suppress updates in.</param>
+    /// <param name="ignoreFunction">The <see cref="Func{TObject, TObject, bool}"/> ignore function (current,previous)=>{ return true to ignore }.</param>
+    /// <returns>An observable which emits change sets and ignores updates equal to the lambda.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> IgnoreUpdateWhen<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TObject, bool> ignoreFunction)
+        where TObject : notnull
+        where TKey : notnull => source.Select(
+            updates =>
+            {
+                var result = updates.Where(
+                    u =>
+                    {
+                        if (u.Reason != ChangeReason.Update)
+                        {
+                            return true;
+                        }
+
+                        return !ignoreFunction(u.Current, u.Previous.Value);
+                    });
+                return new ChangeSet<TObject, TKey>(result);
+            }).NotEmpty();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.IncludeUpdateWhen.cs b/src/DynamicData/Cache/ObservableCacheEx.IncludeUpdateWhen.cs
new file mode 100644
index 000000000..2c1a2e020
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.IncludeUpdateWhen.cs
@@ -0,0 +1,51 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Only includes the update when the condition is met.
+    /// The first parameter in the ignore function is the current value and the second parameter is the previous value.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to selectively include updates in.</param>
+    /// <param name="includeFunction">The <see cref="Func{TObject, TObject, bool}"/> include function (current,previous)=>{ return true to include }.</param>
+    /// <returns>An observable which emits change sets and ignores updates equal to the lambda.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> IncludeUpdateWhen<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TObject, bool> includeFunction)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        includeFunction.ThrowArgumentNullExceptionIfNull(nameof(includeFunction));
+
+        return source.Select(
+            changes =>
+            {
+                var result = changes.Where(change => change.Reason != ChangeReason.Update || includeFunction(change.Current, change.Previous.Value));
+                return new ChangeSet<TObject, TKey>(result);
+            }).NotEmpty();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.InnerJoin.cs b/src/DynamicData/Cache/ObservableCacheEx.InnerJoin.cs
new file mode 100644
index 000000000..8a80e640d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.InnerJoin.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left and right values into a destination object. The composite key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the composite key from the result selector. Delegates to <see cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, (TLeftKey leftKey, TRightKey rightKey)>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, TRight, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.InnerJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Joins two changeset streams, producing a result only for keys that exist on both sides simultaneously.
+    /// When either side loses its value for a key, the joined result is removed. Equivalent to SQL INNER JOIN.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the composite key, left value, and right value into a destination object. Example: <c>((leftKey, rightKey), left, right) =&gt; new Result(leftKey, rightKey, left, right)</c>.</param>
+    /// <returns>An observable changeset keyed by a composite <c>(TLeftKey, TRightKey)</c> tuple.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If a matching right value exists, invokes <paramref name="resultSelector"/> and emits an Add. If no right match, no emission.</description></item>
+    ///   <item><term>Update</term><description>If a matching right exists, re-invokes the selector and emits an Update.</description></item>
+    ///   <item><term>Remove</term><description>Removes all joined results involving the removed left key.</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If a matching left value exists, invokes the selector and emits an Add.</description></item>
+    ///   <item><term>Update</term><description>If a matching left exists, re-invokes the selector and emits an Update.</description></item>
+    ///   <item><term>Remove</term><description>Removes the joined result for this right key (if it was downstream).</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>The output is keyed by a <c>(TLeftKey, TRightKey)</c> composite tuple, since a single left item may match multiple right items.</para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
+    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, (TLeftKey leftKey, TRightKey rightKey)>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<(TLeftKey leftKey, TRightKey rightKey), TLeft, TRight, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.InnerJoinMany.cs b/src/DynamicData/Cache/ObservableCacheEx.InnerJoinMany.cs
new file mode 100644
index 000000000..60bf2a343
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.InnerJoinMany.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the right group into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.InnerJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Groups right-side items by their mapped key, then inner-joins each group to the left source.
+    /// A result is produced only when a left item and at least one right item share the same key.
+    /// Equivalent to SQL INNER JOIN with the right side grouped.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If a non-empty right group exists for this key, invokes <paramref name="resultSelector"/> and emits an Add. Otherwise no emission.</description></item>
+    ///   <item><term>Update</term><description>If a right group exists, re-invokes the selector and emits an Update.</description></item>
+    ///   <item><term>Remove</term><description>Removes the joined result (if it was downstream).</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Updates the right group. If a matching left exists and the group was previously empty, emits an Add. If already joined, emits an Update.</description></item>
+    ///   <item><term>Update</term><description>Updates the right group and re-invokes the selector if a matching left exists.</description></item>
+    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty, removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
+    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.InvokeEvaluate.cs b/src/DynamicData/Cache/ObservableCacheEx.InvokeEvaluate.cs
new file mode 100644
index 000000000..f19fde951
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.InvokeEvaluate.cs
@@ -0,0 +1,48 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Calls <c>Evaluate()</c> on items that implement <see cref="IEvaluateAware"/> when a <b>Refresh</b> change arrives.
+    /// Other change reasons are forwarded without invoking Evaluate.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to trigger re-evaluation on.</param>
+    /// <returns>An observable that emits the same changesets as <paramref name="source"/>, unchanged.</returns>
+    /// <remarks>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term><b>Add</b></term><description>Forwarded unchanged.</description></item>
+    ///   <item><term><b>Update</b></term><description>Forwarded unchanged.</description></item>
+    ///   <item><term><b>Remove</b></term><description>Forwarded unchanged.</description></item>
+    ///   <item><term><b>Refresh</b></term><description>Calls <c>Evaluate()</c> on the item, then forwards the change.</description></item>
+    /// </list>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> InvokeEvaluate<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : IEvaluateAware
+        where TKey : notnull => source.Do(changes => changes.Where(u => u.Reason == ChangeReason.Refresh).ForEach(u => u.Current.Evaluate()));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.LeftJoin.cs b/src/DynamicData/Cache/ObservableCacheEx.LeftJoin.cs
new file mode 100644
index 000000000..5da9d2abe
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.LeftJoin.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the optional right into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, Optional<TRight>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.LeftJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Joins two changeset streams, producing a result for every left-side key. The right side is
+    /// <see cref="Optional{T}"/> because a matching right item may or may not exist. All left items
+    /// appear in the output regardless. Equivalent to SQL LEFT OUTER JOIN.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and optional right into a destination object. Example: <c>(key, left, right) =&gt; new Result(key, left, right)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the left value and matching right (or <see cref="Optional.None{T}"/>).</description></item>
+    ///   <item><term>Update</term><description>Re-invokes the selector with the new left value and current right (if any).</description></item>
+    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If a matching left exists, re-invokes the selector (right transitions from None to Some) and emits an Update.</description></item>
+    ///   <item><term>Update</term><description>If a matching left exists, re-invokes the selector with the new right value.</description></item>
+    ///   <item><term>Remove</term><description>If a matching left exists, re-invokes the selector (right transitions from Some to None) and emits an Update.</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
+    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
+    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, Optional<TRight>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.LeftJoinMany.cs b/src/DynamicData/Cache/ObservableCacheEx.LeftJoinMany.cs
new file mode 100644
index 000000000..726ec5f1f
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.LeftJoinMany.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the right group into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.LeftJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Groups right-side items by their mapped key, then left-joins each group to the left source.
+    /// A result is produced for every left-side key. The right group may be empty if no right items match.
+    /// Equivalent to SQL LEFT OUTER JOIN with the right side grouped.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the left value and the current right group (which may be empty).</description></item>
+    ///   <item><term>Update</term><description>Re-invokes the selector with the new left value and current right group.</description></item>
+    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Updates the right group. If a matching left exists, re-invokes the selector and emits an Update.</description></item>
+    ///   <item><term>Update</term><description>Updates the right group and re-invokes the selector if a matching left exists.</description></item>
+    ///   <item><term>Remove</term><description>Updates the right group. If a matching left exists, re-invokes the selector (group may now be empty).</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.LimitSizeTo.cs b/src/DynamicData/Cache/ObservableCacheEx.LimitSizeTo.cs
new file mode 100644
index 000000000..810f118d0
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.LimitSizeTo.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Applies a FIFO size limit to the changeset stream. When the number of items exceeds <paramref name="size"/>,
+    /// the oldest items are evicted and emitted as <b>Remove</b> changes.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply size limits to.</param>
+    /// <param name="size">The maximum number of items allowed. Must be greater than zero.</param>
+    /// <returns>An observable changeset stream with size-limited contents.</returns>
+    /// <remarks>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term><b>Add</b></term><description>Forwarded. If the cache exceeds the size limit, the oldest items are emitted as <b>Remove</b> changes.</description></item>
+    ///   <item><term><b>Update</b></term><description>Forwarded unchanged.</description></item>
+    ///   <item><term><b>Remove</b></term><description>Forwarded unchanged.</description></item>
+    ///   <item><term><b>Refresh</b></term><description>Forwarded unchanged.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentException"><paramref name="size"/> is zero or negative.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> LimitSizeTo<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, int size)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (size <= 0)
+        {
+            throw new ArgumentException("Size limit must be greater than zero");
+        }
+
+        return new SizeExpirer<TObject, TKey>(source, size).Run();
+    }
+
+    /// <summary>
+    /// Operates directly on a <see cref="ISourceCache{TObject, TKey}"/>, removing the oldest items when the cache
+    /// exceeds <paramref name="sizeLimit"/>. Returns an observable of the evicted key-value pairs (not a changeset stream).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
+    /// <param name="sizeLimit">The maximum number of items allowed. Must be greater than zero.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for observing changes. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>An observable that emits batches of evicted key-value pairs whenever the cache exceeds the size limit.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentException"><paramref name="sizeLimit"/> is zero or negative.</exception>
+    public static IObservable<IEnumerable<KeyValuePair<TKey, TObject>>> LimitSizeTo<TObject, TKey>(this ISourceCache<TObject, TKey> source, int sizeLimit, IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (sizeLimit <= 0)
+        {
+            throw new ArgumentException("Size limit must be greater than zero", nameof(sizeLimit));
+        }
+
+        return Observable.Create<IEnumerable<KeyValuePair<TKey, TObject>>>(
+            observer =>
+            {
+                long orderItemWasAdded = -1;
+                var sizeLimiter = new SizeLimiter<TObject, TKey>(sizeLimit);
+
+                return source.Connect().Finally(observer.OnCompleted).ObserveOn(scheduler ?? GlobalConfig.DefaultScheduler).Transform((t, v) => new ExpirableItem<TObject, TKey>(t, v, DateTime.Now, Interlocked.Increment(ref orderItemWasAdded))).Select(sizeLimiter.CloneAndReturnExpiredOnly).Where(expired => expired.Length != 0).Subscribe(
+                    toRemove =>
+                    {
+                        try
+                        {
+                            source.Remove(toRemove.Select(kv => kv.Key));
+                            observer.OnNext(toRemove);
+                        }
+                        catch (Exception ex)
+                        {
+                            observer.OnError(ex);
+                        }
+                    });
+            });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.MergeChangeSets.cs b/src/DynamicData/Cache/ObservableCacheEx.MergeChangeSets.cs
new file mode 100644
index 000000000..c29bd2a6b
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.MergeChangeSets.cs
@@ -0,0 +1,434 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Merges multiple changeset streams that arrive dynamically into a single unified changeset stream.
+    /// Each inner stream emitted by the outer observable is subscribed and its changes forwarded downstream.
+    /// When multiple sources provide the same key, the first source to add it retains priority unless a
+    /// comparer-based overload is used.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
+    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
+    /// <remarks>
+    /// <para>
+    /// Each inner changeset stream is independently tracked in its own cache. When multiple sources provide the same key,
+    /// this overload uses first-in-wins semantics: the value from whichever source added the key first is
+    /// the one published downstream. To control which value wins for duplicate keys, use an overload that
+    /// accepts an <see cref="IComparer{T}"/>, which selects the lowest-ordered value across all sources.
+    /// An <see cref="IEqualityComparer{T}"/> can be provided separately to suppress no-op updates when
+    /// the new value equals the currently published value for a key.
+    /// </para>
+    /// <para>
+    /// <b>Overload families:</b> MergeChangeSets has 16 overloads organized along three axes:
+    /// (1) <b>Source type</b>: dynamic (<c>IObservable&lt;IObservable&lt;IChangeSet&gt;&gt;</c>, sources arrive at runtime),
+    /// pair (<c>source + other</c>, exactly two streams), or static (<see cref="IEnumerable{T}"/>, all sources known up front).
+    /// (2) <b>Conflict resolution</b>: none (first-in-wins), <see cref="IComparer{T}"/> (lowest-ordered wins),
+    /// <see cref="IEqualityComparer{T}"/> (suppresses duplicate updates), or both.
+    /// (3) <b>Completion</b>: static overloads accept a <c>completable</c> flag; when <see langword="false"/>, the output never completes
+    /// even after all sources finish (useful for "live" merge scenarios).
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>If no source has previously provided this key, an <b>Add</b> is emitted downstream. If another source already holds this key, the new value is tracked internally but not emitted (first-in-wins). With a comparer, the lowest-ordered value across all sources is selected and published instead.</description></item>
+    /// <item><term>Update</term><description>If the updating source currently owns the downstream value for this key, an <b>Update</b> is emitted. If a comparer is provided and the update causes a different source's value to become the best candidate, an <b>Update</b> is emitted with that other source's value.</description></item>
+    /// <item><term>Remove</term><description>If the removed value was the one published downstream, the operator scans all remaining sources for the same key. If another source still holds that key, an <b>Update</b> is emitted with the replacement value (selected by comparer if provided, otherwise the next available). If no other source holds the key, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>If the refreshed item matches the currently published value, the <b>Refresh</b> is forwarded. With a comparer, all sources are re-evaluated first; if a different value now wins, an <b>Update</b> is emitted instead of the Refresh.</description></item>
+    /// <item><term>OnCompleted</term><description>For dynamic overloads, the output completes when the outer observable completes and all subscribed inner observables have also completed. For static overloads, completion depends on the <c>completable</c> parameter (default <see langword="true"/>).</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> When a source removes a key that was published downstream, the fallback to another
+    /// source's value is emitted as an <b>Update</b> (not an Add). This can be surprising if you expect
+    /// a Remove followed by an Add. Also, errors from any single inner source terminate the entire merged
+    /// stream, so consider error handling within individual sources if isolation is needed.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/>
+    /// <seealso cref="ObservableListEx.MergeChangeSets"/>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer: null).Run();
+    }
+
+    /// <summary>
+    /// Merges dynamic cache changeset streams into a single output, using a comparer to resolve key conflicts.
+    /// When multiple sources provide the same key, the item ordering lowest according to <paramref name="comparer"/>
+    /// is published downstream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
+    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer).Run();
+    }
+
+    /// <summary>
+    /// Merges dynamic cache changeset streams into a single output, using an equality comparer to suppress
+    /// redundant updates. When an incoming value for a key is equal (per <paramref name="equalityComparer"/>)
+    /// to the currently published value, the update is suppressed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
+    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="equalityComparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer: null).Run();
+    }
+
+    /// <summary>
+    /// Merges dynamic cache changeset streams into a single output, using both a comparer for key conflict resolution
+    /// and an equality comparer to suppress redundant updates.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
+    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer).Run();
+    }
+
+    /// <summary>
+    /// Convenience overload that merges exactly two cache changeset streams into a single output.
+    /// Uses first-in-wins semantics for key conflicts.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from both sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        other.ThrowArgumentNullExceptionIfNull(nameof(other));
+
+        return new[] { source, other }.MergeChangeSets(scheduler, completable);
+    }
+
+    /// <summary>
+    /// Convenience overload that merges exactly two cache changeset streams, using a comparer for key conflict resolution.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when both sources provide the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from both sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        other.ThrowArgumentNullExceptionIfNull(nameof(other));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new[] { source, other }.MergeChangeSets(comparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Convenience overload that merges exactly two cache changeset streams, using an equality comparer to suppress redundant updates.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from both sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, or <paramref name="equalityComparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        other.ThrowArgumentNullExceptionIfNull(nameof(other));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+
+        return new[] { source, other }.MergeChangeSets(equalityComparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Convenience overload that merges exactly two cache changeset streams, using both a comparer and an equality comparer.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when both sources provide the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from both sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        other.ThrowArgumentNullExceptionIfNull(nameof(other));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new[] { source, other }.MergeChangeSets(equalityComparer, comparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges <paramref name="source"/> with additional changeset streams into a single output.
+    /// Uses first-in-wins semantics for key conflicts.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.EnumerateOne().Concat(others).MergeChangeSets(scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges <paramref name="source"/> with additional changeset streams, using a comparer for key conflict resolution.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return source.EnumerateOne().Concat(others).MergeChangeSets(comparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges <paramref name="source"/> with additional changeset streams, using an equality comparer to suppress redundant updates.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, or <paramref name="equalityComparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+
+        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges <paramref name="source"/> with additional changeset streams, using both a comparer and an equality comparer.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, comparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges a fixed collection of cache changeset streams into a single unified output. All source streams are
+    /// subscribed when the output observable is subscribed to.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
+    /// <remarks>
+    /// <para>
+    /// When multiple sources provide items with the same key, this overload uses first-in-wins semantics:
+    /// the first source to provide a key retains priority. Removing that source's item allows the next
+    /// available value for that key (if any) to surface. To control which value wins, use an overload
+    /// that accepts an <see cref="IComparer{T}"/>.
+    /// </para>
+    /// <para>
+    /// An error from any source terminates the entire merged output.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer: null, completable, scheduler).Run();
+    }
+
+    /// <summary>
+    /// Merges a fixed collection of cache changeset streams into a single output, using a comparer for key conflict
+    /// resolution. When multiple sources provide the same key, the item ordering lowest according to
+    /// <paramref name="comparer"/> is published downstream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer, completable, scheduler).Run();
+    }
+
+    /// <summary>
+    /// Merges a fixed collection of cache changeset streams into a single output, using an equality comparer to
+    /// suppress redundant updates. When an incoming value for a key is equal (per <paramref name="equalityComparer"/>)
+    /// to the currently published value, the update is suppressed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="equalityComparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer: null, completable, scheduler).Run();
+    }
+
+    /// <summary>
+    /// Merges a fixed collection of cache changeset streams into a single output, using both a comparer for key
+    /// conflict resolution and an equality comparer to suppress redundant updates.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
+    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
+    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
+    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
+    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer, completable, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.MergeMany.cs b/src/DynamicData/Cache/ObservableCacheEx.MergeMany.cs
new file mode 100644
index 000000000..b3c290d34
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.MergeMany.cs
@@ -0,0 +1,83 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Subscribes to a child observable for each item in the source cache changeset stream and merges all child
+    /// emissions into a single <see cref="IObservable{T}"/>. When an item is added, <paramref name="observableSelector"/>
+    /// creates its child subscription. When updated, the previous child subscription is disposed and a new one is created.
+    /// When removed, its child subscription is disposed. Refresh changes have no effect on subscriptions.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of values emitted by child observables.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that produces a child observable for each source item.</param>
+    /// <returns>An observable that emits values from all active child observables, interleaved by arrival order.</returns>
+    /// <remarks>
+    /// <para>
+    /// This operator does not produce changesets. It produces a flat stream of <typeparamref name="TDestination"/>
+    /// values, similar to Rx <c>SelectMany</c> but lifecycle-aware: child subscriptions track items entering and
+    /// leaving the source cache.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Calls <paramref name="observableSelector"/> to create a child observable and subscribes to it. Emissions from the child flow into the merged output.</description></item>
+    /// <item><term>Update</term><description>Disposes the previous child subscription and creates a new one for the updated item.</description></item>
+    /// <item><term>Remove</term><description>Disposes the child subscription for the removed item.</description></item>
+    /// <item><term>Refresh</term><description>No effect on subscriptions. The child observable continues unchanged.</description></item>
+    /// <item><term>OnError</term><description>Errors from child observables are silently swallowed (the child is unsubscribed). Errors from the source changeset stream terminate the merged output.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> The output is a plain <see cref="IObservable{TDestination}"/>, not a changeset stream. If you need merged changesets, use <see cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/> instead.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    /// <seealso cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/>
+    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
+    /// <seealso cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IDisposable})"/>
+    /// <seealso cref="ObservableListEx.MergeMany"/>
+    public static IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TDestination>> observableSelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeMany<TObject, TKey, TDestination>(source, observableSelector).Run();
+    }
+
+    /// <inheritdoc cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives both the item and its key, and returns a child observable.</param>
+    public static IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TDestination>> observableSelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeMany<TObject, TKey, TDestination>(source, observableSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.MergeManyChangeSets.cs b/src/DynamicData/Cache/ObservableCacheEx.MergeManyChangeSets.cs
new file mode 100644
index 000000000..5fcbb9ed0
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.MergeManyChangeSets.cs
@@ -0,0 +1,437 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
+    /// into a single flattened output. This overload requires a comparer for resolving destination key conflicts.
+    /// The selector receives only the item, not its key.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
+    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observableSelector"/> or <paramref name="comparer"/> is null.</exception>
+    /// <seealso cref="ObservableListEx.MergeManyChangeSets"/>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), comparer);
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
+    /// into a single flattened output. This overload requires a comparer for resolving destination key conflicts.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
+    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="comparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return source.MergeManyChangeSets(observableSelector, equalityComparer: null, comparer: comparer);
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
+    /// into a single flattened output. The selector receives only the item, not its key.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value for a destination key.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
+    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), equalityComparer, comparer);
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child changeset stream and merges all child
+    /// changes into a single flattened output stream. Child subscriptions track the parent item lifecycle:
+    /// created on Add, replaced on Update, disposed on Remove.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source (parent) cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying parent items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a parent item and its key, and returns a child cache changeset stream. Called once per parent Add/Update.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress no-op child updates. When a child key's new value equals the current value per this comparer, the update is not emitted.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve child key conflicts when multiple parents contribute children with the same destination key. The lowest-ordered child value wins. Without a comparer, the first parent to provide a key retains priority.</param>
+    /// <returns>A merged changeset stream containing all child items from all active parent subscriptions.</returns>
+    /// <remarks>
+    /// <para>
+    /// This is the changeset-aware counterpart to <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>.
+    /// Where MergeMany produces a flat <c>IObservable&lt;T&gt;</c>, MergeManyChangeSets produces an <c>IObservable&lt;IChangeSet&gt;</c>
+    /// that tracks the full lifecycle of child items, including key conflict resolution across parents.
+    /// </para>
+    /// <para>
+    /// <b>Parent-side change handling (source changeset events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Calls <paramref name="observableSelector"/> with the new parent item to obtain a child changeset stream, then subscribes. As the child stream emits changesets, those child items are merged into the output. The downstream observer sees <b>Add</b> changes for each new child item.</description></item>
+    /// <item><term>Update</term><description>Disposes the previous parent's child subscription (removing all of its contributed child items from the output as <b>Remove</b> changes), then creates a new child subscription for the updated parent. The new child's items appear as <b>Add</b> changes.</description></item>
+    /// <item><term>Remove</term><description>Disposes the parent's child subscription. All child items contributed by that parent are emitted as <b>Remove</b> changes in the output. If another parent also provides a child with the same destination key, that parent's value is promoted as an <b>Update</b> (not an Add).</description></item>
+    /// <item><term>Refresh</term><description>No effect on the child subscription. The parent's child stream continues unchanged.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Child-side change handling (changes arriving from child changeset streams):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>If the destination key is new, an <b>Add</b> is emitted. If another parent already contributed a child with the same key, the conflict is resolved by <paramref name="comparer"/> (lowest wins) or first-in-wins if no comparer. The losing value is tracked internally but not emitted.</description></item>
+    /// <item><term>Update</term><description>If this parent currently owns the destination key downstream, an <b>Update</b> is emitted. With a comparer, all parents are re-evaluated for that key; a different parent's value may win, producing an <b>Update</b> to that value instead.</description></item>
+    /// <item><term>Remove</term><description>If this parent's value was the one published downstream for that destination key, the operator scans other parents for the same key. If found, an <b>Update</b> is emitted with the replacement. If not, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>If the child item is the one currently published downstream, the <b>Refresh</b> is forwarded. With a comparer, all parents are re-evaluated first; if a different value now wins, an <b>Update</b> is emitted instead.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Error and completion:</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>OnError</term><description>An error from the source (parent) stream or from any child changeset stream terminates the entire output. Unlike <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>, child errors are NOT swallowed.</description></item>
+    /// <item><term>OnCompleted</term><description>The output completes when the source (parent) stream completes <b>and</b> all active child changeset streams have also completed.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> When multiple parents contribute children with the same destination key, only one value is published
+    /// downstream at a time. The <paramref name="comparer"/> controls which value wins; without it, the first parent to add the key
+    /// retains priority. Removing a parent that owned a contested key causes the next-best value (per comparer or next available)
+    /// to surface as an <b>Update</b>, not an Add. The <paramref name="equalityComparer"/> independently controls whether a child
+    /// Update for an already-published key is suppressed when the new value equals the old.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
+    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
+    /// <seealso cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IObservable{IChangeSet{TDestination, TDestinationKey}}}, Func{TDestination, TDestinationKey})"/>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeManyCacheChangeSets<TObject, TKey, TDestination, TDestinationKey>(source, observableSelector, equalityComparer, comparer).Run();
+    }
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/>.
+    /// Uses <paramref name="sourceComparer"/> to resolve destination key conflicts by source priority.
+    /// The selector receives only the item, not its key.
+    /// Source priorities are always re-evaluated on Refresh (default behavior).
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IComparer<TDestination> childComparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, DefaultResortOnSourceRefresh, equalityComparer: null, childComparer);
+    }
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/>.
+    /// Uses <paramref name="sourceComparer"/> to resolve destination key conflicts by source priority.
+    /// Source priorities are always re-evaluated on Refresh (default behavior).
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IComparer<TDestination> childComparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, DefaultResortOnSourceRefresh, equalityComparer: null, childComparer);
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/> and
+    /// explicit <paramref name="resortOnSourceRefresh"/> control. The selector receives only the item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
+    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IComparer<TDestination> childComparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, resortOnSourceRefresh, equalityComparer: null, childComparer);
+    }
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/> and
+    /// explicit <paramref name="resortOnSourceRefresh"/> control.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
+    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IComparer<TDestination> childComparer)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, resortOnSourceRefresh, equalityComparer: null, childComparer);
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets. Uses <paramref name="sourceComparer"/> to resolve
+    /// destination key conflicts. The selector receives only the item, not its key.
+    /// Source priorities are always re-evaluated on Refresh (default behavior).
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, DefaultResortOnSourceRefresh, equalityComparer, childComparer);
+    }
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets. Uses <paramref name="sourceComparer"/> to resolve
+    /// destination key conflicts. Source priorities are always re-evaluated on Refresh (default behavior).
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, DefaultResortOnSourceRefresh, equalityComparer, childComparer);
+
+    /// <summary>
+    /// Source-priority variant of MergeManyChangeSets with full control over all conflict resolution parameters.
+    /// The selector receives only the item, not its key.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
+    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, resortOnSourceRefresh, equalityComparer, childComparer);
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child
+    /// changes into a single flattened output. When multiple source items produce children with the same destination key,
+    /// <paramref name="sourceComparer"/> determines which source has priority (the source ordering lower wins).
+    /// If sources compare equal, <paramref name="childComparer"/> (if provided) breaks the tie.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
+    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
+    /// <param name="resortOnSourceRefresh">If <see langword="true"/> (default), a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value for a destination key.</param>
+    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer to resolve destination key conflicts when source items compare equal.</param>
+    /// <returns>A merged changeset stream containing items from all active child streams, with conflicts resolved by source priority.</returns>
+    /// <remarks>
+    /// <para>
+    /// The <paramref name="sourceComparer"/> provides a layer of conflict resolution above the child values themselves.
+    /// This is useful when source items represent priority tiers (e.g., user settings overriding defaults).
+    /// </para>
+    /// <para>
+    /// Errors from child streams propagate to the output. An error from the source or any child terminates the merged output.
+    /// The output completes when the source completes and all active child streams have also completed.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="sourceComparer"/> is null.</exception>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+        sourceComparer.ThrowArgumentNullExceptionIfNull(nameof(sourceComparer));
+
+        return new MergeManyCacheChangeSetsSourceCompare<TObject, TKey, TDestination, TDestinationKey>(source, observableSelector, sourceComparer, equalityComparer, childComparer, resortOnSourceRefresh).Run();
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child list changeset stream produced by
+    /// <paramref name="observableSelector"/> and merges all child changes into a single flattened list changeset output.
+    /// Child subscriptions follow the source item lifecycle: created on Add, replaced on Update, disposed on Remove.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child list changeset streams.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child list changeset stream.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to detect duplicate items in the merged list output.</param>
+    /// <returns>A merged list changeset stream containing items from all active child streams.</returns>
+    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeManyListChangeSets<TObject, TKey, TDestination>(source, observableSelector, equalityComparer).Run();
+    }
+
+    /// <summary>
+    /// For each item in the source cache, subscribes to a child list changeset stream and merges all child changes
+    /// into a single flattened list changeset output. The selector receives only the item, not its key.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child list changeset streams.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child list changeset stream.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to detect duplicate items in the merged list output.</param>
+    /// <returns>A merged list changeset stream containing items from all active child streams.</returns>
+    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+        return source.MergeManyChangeSets((obj, _) => observableSelector(obj), equalityComparer);
+    }
+
+    private const bool DefaultResortOnSourceRefresh = true;
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.MergeManyItems.cs b/src/DynamicData/Cache/ObservableCacheEx.MergeManyItems.cs
new file mode 100644
index 000000000..b2581c6c8
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.MergeManyItems.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Like <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>,
+    /// but wraps each emitted value as an <see cref="ItemWithValue{TObject, TValue}"/>, pairing the source item
+    /// with the value it produced. This lets you identify which source item is responsible for each emission.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
+    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
+    /// <typeparam name="TDestination">The type of values emitted by child observables.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that produces a child observable for each source item.</param>
+    /// <returns>An observable of <see cref="ItemWithValue{TObject, TValue}"/> pairing each emission with its source item.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
+    public static IObservable<ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TDestination>> observableSelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeManyItems<TObject, TKey, TDestination>(source, observableSelector).Run();
+    }
+
+    /// <inheritdoc cref="MergeManyItems{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives both the item and its key, and returns a child observable.</param>
+    public static IObservable<ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TDestination>> observableSelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeManyItems<TObject, TKey, TDestination>(source, observableSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.MonitorStatus.cs b/src/DynamicData/Cache/ObservableCacheEx.MonitorStatus.cs
new file mode 100644
index 000000000..93abf0f92
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.MonitorStatus.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Monitors the source observable and emits <see cref="ConnectionStatus"/> values: <c>Pending</c> initially,
+    /// <c>Loaded</c> when the first value arrives, <c>Errored</c> on error, and <c>Completed</c> on completion.
+    /// This is not a changeset operator.
+    /// </summary>
+    /// <typeparam name="T">The type of the source observable.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to monitor for connection status.</param>
+    /// <returns>An observable that emits <see cref="ConnectionStatus"/> values reflecting the source's lifecycle.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<ConnectionStatus> MonitorStatus<T>(this IObservable<T> source) => new StatusMonitor<T>(source).Run();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.NotEmpty.cs b/src/DynamicData/Cache/ObservableCacheEx.NotEmpty.cs
new file mode 100644
index 000000000..a267d1511
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.NotEmpty.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters out empty changesets from the stream. A thin wrapper around <c>Where(changes =&gt; changes.Count != 0)</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to suppress empty changesets.</param>
+    /// <returns>An observable that emits only non-empty changesets.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="StartWithEmpty{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> NotEmpty<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Where(changes => changes.Count != 0);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OfType.cs b/src/DynamicData/Cache/ObservableCacheEx.OfType.cs
new file mode 100644
index 000000000..dd12ae230
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OfType.cs
@@ -0,0 +1,57 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters and casts items in the changeset to <typeparamref name="TDestination"/>. Items that are not of type
+    /// <typeparamref name="TDestination"/> are excluded. Combines filter and transform in one step without an intermediate cache.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the objects in the source changeset.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TDestination">The destination type to filter and cast to.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by type.</param>
+    /// <param name="suppressEmptyChangeSets">If <see langword="true"/>, changesets that become empty after filtering are suppressed.</param>
+    /// <returns>An observable changeset of <typeparamref name="TDestination"/> items.</returns>
+    /// <remarks>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term><b>Add</b></term><description>If the item is <typeparamref name="TDestination"/>, cast and emit as <b>Add</b>. Otherwise dropped.</description></item>
+    ///   <item><term><b>Update</b></term><description>Re-evaluated. If the new item is <typeparamref name="TDestination"/>, emit accordingly. If the old item was downstream but the new one is not, emit <b>Remove</b>.</description></item>
+    ///   <item><term><b>Remove</b></term><description>If the item was downstream, emit <b>Remove</b>.</description></item>
+    ///   <item><term><b>Refresh</b></term><description>If the item is downstream, forwarded as <b>Refresh</b>.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TDestination, TKey>> OfType<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, bool suppressEmptyChangeSets = true)
+        where TObject : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new OfType<TObject, TKey, TDestination>(source, suppressEmptyChangeSets).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OnChangeAction.cs b/src/DynamicData/Cache/ObservableCacheEx.OnChangeAction.cs
new file mode 100644
index 000000000..00b222a68
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OnChangeAction.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    private static IObservable<IChangeSet<TObject, TKey>> OnChangeAction<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Predicate<Change<TObject, TKey>> predicate, Action<Change<TObject, TKey>> changeAction)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        return source.Do(changes =>
+        {
+            foreach (var change in changes.ToConcreteType())
+            {
+                if (!predicate(change))
+                {
+                    continue;
+                }
+
+                changeAction(change);
+            }
+        });
+    }
+
+    private static IObservable<IChangeSet<TObject, TKey>> OnChangeAction<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ChangeReason reason, Action<TObject, TKey> action)
+        where TObject : notnull
+        where TKey : notnull
+        => source.OnChangeAction(change => change.Reason == reason, change => action(change.Current, change.Key));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OnItemAdded.cs b/src/DynamicData/Cache/ObservableCacheEx.OnItemAdded.cs
new file mode 100644
index 000000000..40e47a95b
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OnItemAdded.cs
@@ -0,0 +1,74 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Callback for each item as and when it is being added to the stream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item additions in.</param>
+    /// <param name="addAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each added item. Receives the new item and its key.</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Invokes <paramref name="addAction"/> with the item and key.</description></item>
+    ///   <item><term>Update</term><description>Ignored.</description></item>
+    ///   <item><term>Remove</term><description>Ignored.</description></item>
+    ///   <item><term>Refresh</term><description>Ignored.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// Exceptions thrown in <paramref name="addAction"/> propagate as <c>OnError</c>. No try-catch is applied.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="addAction"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="OnItemUpdated{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TObject,TKey})"/>
+    /// <seealso cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>
+    /// <seealso cref="ForEachChange{TObject,TKey}"/>
+    /// <seealso cref="ObservableListEx.OnItemAdded"/>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemAdded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> addAction)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        addAction.ThrowArgumentNullExceptionIfNull(nameof(addAction));
+
+        return source.OnChangeAction(ChangeReason.Add, addAction);
+    }
+
+    /// <inheritdoc cref="OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item additions in.</param>
+    /// <param name="addAction">The <see cref="Action{TObject}"/> callback invoked for each added item. Receives only the item (no key).</param>
+    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemAdded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> addAction)
+        where TObject : notnull
+        where TKey : notnull
+        => source.OnItemAdded((obj, _) => addAction(obj));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OnItemRefreshed.cs b/src/DynamicData/Cache/ObservableCacheEx.OnItemRefreshed.cs
new file mode 100644
index 000000000..13441fd02
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OnItemRefreshed.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Callback for each item as and when it is being refreshed in the stream.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item refresh events in.</param>
+    /// <param name="refreshAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each refreshed item. Receives the item and its key.</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Ignored.</description></item>
+    ///   <item><term>Update</term><description>Ignored.</description></item>
+    ///   <item><term>Remove</term><description>Ignored.</description></item>
+    ///   <item><term>Refresh</term><description>Invokes <paramref name="refreshAction"/> with the item and key.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// Exceptions thrown in <paramref name="refreshAction"/> propagate as <c>OnError</c>. No try-catch is applied.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="refreshAction"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AutoRefresh{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableListEx.OnItemRefreshed"/>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemRefreshed<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> refreshAction)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        refreshAction.ThrowArgumentNullExceptionIfNull(nameof(refreshAction));
+
+        return source.OnChangeAction(ChangeReason.Refresh, refreshAction);
+    }
+
+    /// <inheritdoc cref="OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item refresh events in.</param>
+    /// <param name="refreshAction">The <see cref="Action{TObject}"/> callback invoked for each refreshed item. Receives only the item (no key).</param>
+    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemRefreshed<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> refreshAction)
+        where TObject : notnull
+        where TKey : notnull
+        => source.OnItemRefreshed((obj, _) => refreshAction(obj));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OnItemRemoved.cs b/src/DynamicData/Cache/ObservableCacheEx.OnItemRemoved.cs
new file mode 100644
index 000000000..6935103fe
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OnItemRemoved.cs
@@ -0,0 +1,92 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Invokes <paramref name="removeAction"/> for each item with <see cref="ChangeReason.Remove"/> in the changeset stream.
+    /// The changeset is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item removals in.</param>
+    /// <param name="removeAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each removed item. Receives the removed item and its key.</param>
+    /// <param name="invokeOnUnsubscribe">
+    /// When <see langword="true"/> (the default), the callback is also invoked for <b>every item still in the cache</b>
+    /// when the subscription is disposed. When <see langword="false"/>, only inline Remove changes trigger the callback.
+    /// </param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Ignored (but tracked internally when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>).</description></item>
+    ///   <item><term>Update</term><description>Ignored (cache updated internally when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>).</description></item>
+    ///   <item><term>Remove</term><description>Invokes <paramref name="removeAction"/> with the item and key.</description></item>
+    ///   <item><term>Refresh</term><description>Ignored.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Unsubscribe behavior:</b> when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, the operator
+    /// maintains an internal cache mirroring the stream. On disposal, it iterates all remaining items and
+    /// invokes <paramref name="removeAction"/> for each. This is useful for cleanup logic (e.g. event unsubscription)
+    /// that must run for items that were never explicitly removed.
+    /// </para>
+    /// <para>
+    /// Exceptions thrown in <paramref name="removeAction"/> propagate as <c>OnError</c> during inline removes.
+    /// During unsubscribe disposal, exceptions are not caught.
+    /// </para>
+    /// <para><b>Worth noting:</b> The action also fires for ALL remaining items when the subscription is disposed (unless <c>invokeOnUnsubscribe</c> is <see langword="false"/>). The action runs under a lock; avoid calling into other caches from within it.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="removeAction"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="DisposeMany{TObject,TKey}"/>
+    /// <seealso cref="SubscribeMany{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IDisposable})"/>
+    /// <seealso cref="ObservableListEx.OnItemRemoved"/>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemRemoved<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> removeAction, bool invokeOnUnsubscribe = true)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        removeAction.ThrowArgumentNullExceptionIfNull(nameof(removeAction));
+
+        if (invokeOnUnsubscribe)
+        {
+            return new OnBeingRemoved<TObject, TKey>(source, removeAction).Run();
+        }
+
+        return source.OnChangeAction(ChangeReason.Remove, removeAction);
+    }
+
+    /// <inheritdoc cref="OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey}, bool)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item removals in.</param>
+    /// <param name="removeAction">The <see cref="Action{TObject}"/> callback invoked for each removed item. Receives only the item (no key).</param>
+    /// <param name="invokeOnUnsubscribe">When <see langword="true"/> (the default), also invoked for all remaining items on disposal.</param>
+    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey}, bool)"/>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemRemoved<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> removeAction, bool invokeOnUnsubscribe = true)
+        where TObject : notnull
+        where TKey : notnull
+        => source.OnItemRemoved((obj, _) => removeAction(obj), invokeOnUnsubscribe);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.OnItemUpdated.cs b/src/DynamicData/Cache/ObservableCacheEx.OnItemUpdated.cs
new file mode 100644
index 000000000..464bbf29b
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.OnItemUpdated.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Invokes <paramref name="updateAction"/> for each item with <see cref="ChangeReason.Update"/> in the changeset stream.
+    /// The changeset is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item updates in.</param>
+    /// <param name="updateAction">The <see cref="Action{TObject, TObject, TKey}"/> callback invoked for each updated item. Receives the current value, previous value, and key.</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Ignored.</description></item>
+    ///   <item><term>Update</term><description>Invokes <paramref name="updateAction"/> with (current, previous, key). The previous value is always available for Update changes.</description></item>
+    ///   <item><term>Remove</term><description>Ignored.</description></item>
+    ///   <item><term>Refresh</term><description>Ignored.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// Exceptions thrown in <paramref name="updateAction"/> propagate as <c>OnError</c>. No try-catch is applied.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="updateAction"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="OnItemAdded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>
+    /// <seealso cref="ForEachChange{TObject,TKey}"/>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemUpdated<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TObject, TKey> updateAction)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
+
+        return source.OnChangeAction(static change => change.Reason == ChangeReason.Update, change => updateAction(change.Current, change.Previous.Value, change.Key));
+    }
+
+    /// <inheritdoc cref="OnItemUpdated{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item updates in.</param>
+    /// <param name="updateAction">The <see cref="Action{TObject, TObject}"/> callback invoked for each updated item. Receives only the current and previous values (no key).</param>
+    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemUpdated{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TObject, TKey})"/>.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> OnItemUpdated<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TObject> updateAction)
+        where TObject : notnull
+        where TKey : notnull
+        => source.OnItemUpdated((cur, prev, _) => updateAction(cur, prev));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Or.cs b/src/DynamicData/Cache/ObservableCacheEx.Or.cs
new file mode 100644
index 000000000..a0de6f338
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Or.cs
@@ -0,0 +1,131 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Combines multiple changeset streams using logical OR (union). An item appears downstream if it exists in any source.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
+    /// <returns>A changeset stream containing items present in any of the sources.</returns>
+    /// <remarks>
+    /// <para>
+    /// Items are tracked via reference counting across all sources. An item appears downstream as long as
+    /// at least one source contains it. When the last source holding a key removes it, the item is removed downstream.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>If this is the first source to provide the key, an <b>Add</b> is emitted. If other sources already have the key, the reference count is incremented but no emission occurs.</description></item>
+    /// <item><term>Update</term><description>If the item is currently downstream, an <b>Update</b> is emitted.</description></item>
+    /// <item><term>Remove</term><description>Reference count decremented. If the count reaches zero (no source holds the key), a <b>Remove</b> is emitted. Otherwise no emission.</description></item>
+    /// <item><term>Refresh</term><description>If the item is downstream, a <b>Refresh</b> is forwarded.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
+    /// <seealso cref="ObservableListEx.Or"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (others is null || others.Length == 0)
+        {
+            throw new ArgumentNullException(nameof(others));
+        }
+
+        return source.Combine(CombineOperator.Or, others);
+    }
+
+    /// <inheritdoc cref="Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
+    /// <remarks>This overload accepts a pre-built collection of sources instead of a params array.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Or);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Or operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Or);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Or operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Or);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Or operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Or);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.PopulateFrom.cs b/src/DynamicData/Cache/ObservableCacheEx.PopulateFrom.cs
new file mode 100644
index 000000000..24d4d407e
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.PopulateFrom.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Subscribes to the observable and calls <c>AddOrUpdate</c> on the source cache for each emitted batch of items.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
+    /// <param name="observable">The <see cref="IObservable{IEnumerable{TObject}}"/> that emits batches of items.</param>
+    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from <paramref name="observable"/>.</returns>
+    /// <remarks>
+    /// <para>Each emission from <paramref name="observable"/> is passed to <see cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject})"/>, producing one changeset per emission containing <b>Add</b> or <b>Update</b> events for each item. Errors from <paramref name="observable"/> propagate and terminate the subscription. Completion ends the subscription; the cache retains all items.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observable"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
+    /// <seealso cref="ToObservableChangeSet{TObject, TKey}(IObservable{IEnumerable{TObject}}, Func{TObject, TKey}, Func{TObject, TimeSpan?}, int, IScheduler?)"/>
+    public static IDisposable PopulateFrom<TObject, TKey>(this ISourceCache<TObject, TKey> source, IObservable<IEnumerable<TObject>> observable)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return observable.Subscribe(source.AddOrUpdate);
+    }
+
+    /// <summary>
+    /// Subscribes to the observable and calls <c>AddOrUpdate</c> on the source cache for each emitted item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
+    /// <param name="observable">The <see cref="IObservable{TObject}"/> that emits individual items.</param>
+    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from <paramref name="observable"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observable"/> is <see langword="null"/>.</exception>
+    public static IDisposable PopulateFrom<TObject, TKey>(this ISourceCache<TObject, TKey> source, IObservable<TObject> observable)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return observable.Subscribe(source.AddOrUpdate);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.PopulateInto.cs b/src/DynamicData/Cache/ObservableCacheEx.PopulateInto.cs
new file mode 100644
index 000000000..d5ce99d73
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.PopulateInto.cs
@@ -0,0 +1,91 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Subscribes to the changeset stream and clones each changeset into the destination cache.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
+    /// <param name="destination">The <see cref="ISourceCache{TObject, TKey}"/> that will receive the changes.</param>
+    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from the source.</returns>
+    /// <remarks>
+    /// <para>
+    /// Each changeset from the source is applied to the destination cache inside an Edit call.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The item is added to the destination cache via AddOrUpdate.</description></item>
+    /// <item><term>Update</term><description>The item is updated in the destination cache via AddOrUpdate.</description></item>
+    /// <item><term>Remove</term><description>The item is removed from the destination cache.</description></item>
+    /// <item><term>Refresh</term><description>A Refresh is issued on the destination cache for the item.</description></item>
+    /// <item><term>OnError</term><description>The subscription is terminated. The destination cache is not rolled back.</description></item>
+    /// <item><term>OnCompleted</term><description>The subscription ends. The destination cache retains all items.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="destination"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="PopulateFrom{TObject, TKey}(ISourceCache{TObject, TKey}, IObservable{IEnumerable{TObject}})"/>
+    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
+    /// <seealso cref="ObservableListEx.PopulateInto{T}(IObservable{IChangeSet{T}}, ISourceList{T})"/>
+    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ISourceCache<TObject, TKey> destination)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
+    }
+
+    /// <inheritdoc cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
+    /// <param name="destination">The <see cref="IIntermediateCache{TObject, TKey}"/> that will receive the changes.</param>
+    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
+    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IIntermediateCache<TObject, TKey> destination)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
+    }
+
+    /// <inheritdoc cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
+    /// <param name="destination">The <see cref="LockFreeObservableCache{TObject, TKey}"/> that will receive the changes.</param>
+    /// <remarks>Overload that targets a <see cref="LockFreeObservableCache{TObject, TKey}"/>.</remarks>
+    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, LockFreeObservableCache<TObject, TKey> destination)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.QueryWhenChanged.cs b/src/DynamicData/Cache/ObservableCacheEx.QueryWhenChanged.cs
new file mode 100644
index 000000000..f294f119c
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.QueryWhenChanged.cs
@@ -0,0 +1,91 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Projects the current cache state through <paramref name="resultSelector"/> after each modification.
+    /// Emits a new value of <typeparamref name="TDestination"/> on every changeset.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
+    /// <param name="resultSelector">A function that projects the current <see cref="IQuery{TObject, TKey}"/> snapshot to a result value.</param>
+    /// <returns>An observable that emits a projected value after each changeset.</returns>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> The selector is called on every changeset, which can be chatty. The <see cref="IQuery{TObject, TKey}"/> exposes the full cache state for LINQ-style queries.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="ToCollection{TObject, TKey}"/>
+    /// <seealso cref="ToSortedCollection{TObject, TKey, TSortKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TSortKey}, SortDirection)"/>
+    /// <seealso cref="ObservableListEx.QueryWhenChanged"/>
+    public static IObservable<TDestination> QueryWhenChanged<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<IQuery<TObject, TKey>, TDestination> resultSelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return source.QueryWhenChanged().Select(resultSelector);
+    }
+
+    /// <summary>
+    /// The latest copy of the cache is exposed for querying i)  after each modification to the underlying data ii) upon subscription.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
+    /// <returns>An observable which emits the query.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new QueryWhenChanged<TObject, TKey, Unit>(source).Run();
+    }
+
+    /// <summary>
+    /// The latest copy of the cache is exposed for querying i)  after each modification to the underlying data ii) on subscription.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
+    /// <param name="itemChangedTrigger">A <see cref="Func{T, TResult}"/> that should the query be triggered for observables on individual items.</param>
+    /// <returns>An observable that emits the query.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> itemChangedTrigger)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        itemChangedTrigger.ThrowArgumentNullExceptionIfNull(nameof(itemChangedTrigger));
+
+        return new QueryWhenChanged<TObject, TKey, TValue>(source, itemChangedTrigger).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.RefCount.cs b/src/DynamicData/Cache/ObservableCacheEx.RefCount.cs
new file mode 100644
index 000000000..66c8315b5
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.RefCount.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Cache-aware equivalent of <c>Publish().RefCount()</c>. An internal cache is created on the first subscriber
+    /// and disposed when the last subscriber unsubscribes. All subscribers share the same upstream subscription.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to share via reference counting.</param>
+    /// <returns>A ref-counted observable changeset stream.</returns>
+    /// <seealso cref="AsObservableCache{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
+    public static IObservable<IChangeSet<TObject, TKey>> RefCount<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new RefCount<TObject, TKey>(source).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Refresh.cs b/src/DynamicData/Cache/ObservableCacheEx.Refresh.cs
new file mode 100644
index 000000000..4e9947f28
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Refresh.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Signals downstream operators to re-evaluate the specified item. Produces a changeset with a single <b>Refresh</b> change.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to refresh.</param>
+    /// <remarks>
+    /// <para>Convenience method that wraps a Refresh inside <see cref="ISourceCache{TObject,TKey}.Edit"/>. A Refresh does not change data in the cache; it signals downstream operators (such as <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> or <see cref="Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>) to re-evaluate the item.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="SuppressRefresh{TObject, TKey}"/>
+    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Refresh(item));
+    }
+
+    /// <summary>
+    /// Signals downstream operators to re-evaluate the specified items. Produces one changeset with a <b>Refresh</b> for each item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
+    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to refresh.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Refresh(items));
+    }
+
+    /// <summary>
+    /// Signals downstream operators to re-evaluate all items in the cache. Produces one changeset with a <b>Refresh</b> for every item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Refresh());
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Remove.cs b/src/DynamicData/Cache/ObservableCacheEx.Remove.cs
new file mode 100644
index 000000000..d835ff00b
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Remove.cs
@@ -0,0 +1,129 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Removes the specified item from the cache. Produces a <b>Remove</b> changeset if the item exists, nothing otherwise.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to remove.</param>
+    /// <remarks>
+    /// <para>Convenience method that wraps a single-item removal inside <see cref="ISourceCache{TObject,TKey}.Edit"/>. The key is extracted from the item using the cache's key selector.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
+    /// <seealso cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
+    /// <seealso cref="RemoveKeys{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TKey})"/>
+    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(item));
+    }
+
+    /// <summary>
+    /// Removes the item with the specified key from the cache. Produces a <b>Remove</b> changeset if the key exists, nothing otherwise.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key of the item to remove.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(key));
+    }
+
+    /// <summary>
+    /// Removes the specified items from the cache. Any items not present in the cache are ignored.
+    /// Produces a <b>Remove</b> changeset for each item that existed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to remove.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(items));
+    }
+
+    /// <summary>
+    /// Removes the items with the specified keys from the cache. Any keys not present are ignored.
+    /// Produces a <b>Remove</b> changeset for each key that existed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TKey> keys)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(keys));
+    }
+
+    /// <inheritdoc cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, TKey)"/>
+    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key of the item to remove.</param>
+    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
+    public static void Remove<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(key));
+    }
+
+    /// <inheritdoc cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TKey})"/>
+    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> from which to remove items.</param>
+    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
+    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
+    public static void Remove<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, IEnumerable<TKey> keys)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.Remove(keys));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.RemoveKey.cs b/src/DynamicData/Cache/ObservableCacheEx.RemoveKey.cs
new file mode 100644
index 000000000..6e9f3ecd6
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.RemoveKey.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Strips the key from a cache changeset, converting <see cref="IChangeSet{TObject, TKey}"/> to
+    /// <see cref="IChangeSet{TObject}"/> (list changeset). All indexed changes are dropped (sorting is not supported).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to strip keys from, producing an unkeyed list changeset.</param>
+    /// <returns>A list changeset stream without key information.</returns>
+    /// <seealso cref="ObservableListEx.AddKey{TObject, TKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TKey})"/>
+    /// <seealso cref="ChangeKey{TObject, TSourceKey, TDestinationKey}(IObservable{IChangeSet{TObject, TSourceKey}}, Func{TObject, TDestinationKey})"/>
+    public static IObservable<IChangeSet<TObject>> RemoveKey<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Select(
+            changes =>
+            {
+                var enumerator = new RemoveKeyEnumerator<TObject, TKey>(changes);
+                return new ChangeSet<TObject>(enumerator);
+            });
+    }
+
+    /// <summary>
+    /// Removes a specific key from the cache. Equivalent to <c>source.Edit(u =&gt; u.RemoveKey(key))</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove a key.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to remove.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void RemoveKey<TObject, TKey>(this ISourceCache<TObject, TKey> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.RemoveKey(key));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.RemoveKeys.cs b/src/DynamicData/Cache/ObservableCacheEx.RemoveKeys.cs
new file mode 100644
index 000000000..837bf45f3
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.RemoveKeys.cs
@@ -0,0 +1,44 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Removes multiple keys from the cache in a single <c>Edit</c> call. Keys not present in the cache are ignored.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove keys.</param>
+    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static void RemoveKeys<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TKey> keys)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        source.Edit(updater => updater.RemoveKeys(keys));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.RightJoin.cs b/src/DynamicData/Cache/ObservableCacheEx.RightJoin.cs
new file mode 100644
index 000000000..7bd66b375
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.RightJoin.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left and right values into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, TRight, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.RightJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Joins two changeset streams, producing a result for every right-side key. The left side is
+    /// <see cref="Optional{T}"/> because a matching left item may or may not exist. All right items
+    /// appear in the output regardless. Equivalent to SQL RIGHT OUTER JOIN.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the right key, optional left, and right value into a destination object. Example: <c>(rightKey, left, right) =&gt; new Result(rightKey, left, right)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TRightKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the matching left (or <see cref="Optional.None{T}"/>) and the right value.</description></item>
+    ///   <item><term>Update</term><description>Re-invokes the selector with current left (if any) and the new right value.</description></item>
+    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If matching right items exist, re-invokes the selector (left transitions from None to Some) and emits Updates.</description></item>
+    ///   <item><term>Update</term><description>If matching right items exist, re-invokes the selector with the new left value.</description></item>
+    ///   <item><term>Remove</term><description>If matching right items exist, re-invokes the selector (left transitions from Some to None) and emits Updates.</description></item>
+    ///   <item><term>Refresh</term><description>If joined results exist, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
+    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
+    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TRightKey, Optional<TLeft>, TRight, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.RightJoinMany.cs b/src/DynamicData/Cache/ObservableCacheEx.RightJoinMany.cs
new file mode 100644
index 000000000..cb6a5a924
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.RightJoinMany.cs
@@ -0,0 +1,107 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left value and the right group into a destination object. The key is not provided in this overload.</param>
+    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return left.RightJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
+    }
+
+    /// <summary>
+    /// Groups right-side items by their mapped key, then right-joins each group to the left source.
+    /// A result is produced for every key that has at least one right item. The left value is
+    /// <see cref="Optional{T}"/> because a matching left item may or may not exist.
+    /// Equivalent to SQL RIGHT OUTER JOIN with the right side grouped.
+    /// </summary>
+    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
+    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
+    /// <typeparam name="TRight">The item type of the right source.</typeparam>
+    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
+    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
+    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
+    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
+    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
+    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Right-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Updates the right group. If the group was previously empty, emits an Add with the current left (if any). Otherwise emits an Update.</description></item>
+    ///   <item><term>Update</term><description>Updates the right group and re-invokes <paramref name="resultSelector"/>.</description></item>
+    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty, removes the joined result.</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// <b>Left-side change handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>If a non-empty right group exists, re-invokes the selector (left transitions from None to Some) and emits an Update.</description></item>
+    ///   <item><term>Update</term><description>If a non-empty right group exists, re-invokes the selector with the new left value.</description></item>
+    ///   <item><term>Remove</term><description>If a non-empty right group exists, re-invokes the selector (left transitions from Some to None) and emits an Update.</description></item>
+    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
+    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
+    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
+    public static IObservable<IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+        where TLeft : notnull
+        where TLeftKey : notnull
+        where TRight : notnull
+        where TRightKey : notnull
+        where TDestination : notnull
+    {
+        left.ThrowArgumentNullExceptionIfNull(nameof(left));
+        right.ThrowArgumentNullExceptionIfNull(nameof(right));
+        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return new RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.SkipInitial.cs b/src/DynamicData/Cache/ObservableCacheEx.SkipInitial.cs
new file mode 100644
index 000000000..6a2ed2db4
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.SkipInitial.cs
@@ -0,0 +1,47 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Skips the initial snapshot changeset that <c>Connect()</c> typically emits, then forwards all subsequent changesets.
+    /// Internally uses <c>DeferUntilLoaded().Skip(1)</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to skip the initial changeset.</param>
+    /// <returns>An observable that skips the first changeset and forwards all others.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="DeferUntilLoaded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
+    /// <seealso cref="StartWithEmpty{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> SkipInitial<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.DeferUntilLoaded().Skip(1);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Sort.cs b/src/DynamicData/Cache/ObservableCacheEx.Sort.cs
new file mode 100644
index 000000000..87bccebe5
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Sort.cs
@@ -0,0 +1,119 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Obsolete: use SortAndBind instead. Sorts using the specified comparer.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
+    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used to determine sort order.</param>
+    /// <param name="sortOptimisations">A <see cref="SortOptimisations"/> that sort optimisation flags. Specify one or more sort optimisations.</param>
+    /// <param name="resetThreshold">The number of updates before the entire list is resorted (rather than inline sort).</param>
+    /// <returns>An observable which emits change sets.</returns>
+    /// <exception cref="ArgumentNullException">
+    /// source
+    /// or
+    /// comparer.
+    /// </exception>
+    /// <seealso cref="ObservableListEx.Sort"/>
+    [Obsolete(Constants.SortIsObsolete)]
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new Sort<TObject, TKey>(source, comparer, sortOptimisations, resetThreshold: resetThreshold).Run();
+    }
+
+    /// <summary>
+    /// Obsolete: use SortAndBind instead. Sorts using a dynamic comparer observable.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
+    /// <param name="comparerObservable">The <see cref="IObservable{IComparer{TObject}}"/> comparer observable.</param>
+    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
+    /// <param name="resetThreshold">The reset threshold.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    [Obsolete(Constants.SortIsObsolete)]
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IComparer<TObject>> comparerObservable, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparerObservable.ThrowArgumentNullExceptionIfNull(nameof(comparerObservable));
+
+        return new Sort<TObject, TKey>(source, null, sortOptimisations, comparerObservable, resetThreshold: resetThreshold).Run();
+    }
+
+    /// <summary>
+    /// Obsolete: use SortAndBind instead. Sorts using a dynamic comparer observable with a manual re-sort signal.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
+    /// <param name="comparerObservable">The <see cref="IObservable{IComparer{TObject}}"/> comparer observable.</param>
+    /// <param name="resorter">An <see cref="IObservable{Unit}"/> that signals the algorithm to re-sort the entire data set.</param>
+    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
+    /// <param name="resetThreshold">The reset threshold.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    [Obsolete(Constants.SortIsObsolete)]
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IComparer<TObject>> comparerObservable, IObservable<Unit> resorter, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparerObservable.ThrowArgumentNullExceptionIfNull(nameof(comparerObservable));
+
+        return new Sort<TObject, TKey>(source, null, sortOptimisations, comparerObservable, resorter, resetThreshold).Run();
+    }
+
+    /// <summary>
+    /// Obsolete: use SortAndBind instead. Sorts using a static comparer with a manual re-sort signal.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
+    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used to determine sort order.</param>
+    /// <param name="resorter">An <see cref="IObservable{Unit}"/> that signals the algorithm to re-sort the entire data set.</param>
+    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
+    /// <param name="resetThreshold">The reset threshold.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    [Obsolete(Constants.SortIsObsolete)]
+    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer, IObservable<Unit> resorter, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        resorter.ThrowArgumentNullExceptionIfNull(nameof(resorter));
+
+        return new Sort<TObject, TKey>(source, comparer, sortOptimisations, null, resorter, resetThreshold).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.SortAndBind.cs b/src/DynamicData/Cache/ObservableCacheEx.SortAndBind.cs
index 9ce7130f2..9f5e1444c 100644
--- a/src/DynamicData/Cache/ObservableCacheEx.SortAndBind.cs
+++ b/src/DynamicData/Cache/ObservableCacheEx.SortAndBind.cs
@@ -9,7 +9,7 @@
 namespace DynamicData;
 
 /// <summary>
-/// ObservableCache extensions for SortAndBind.
+/// Extensions for dynamic data.
 /// </summary>
 public static partial class ObservableCacheEx
 {
diff --git a/src/DynamicData/Cache/ObservableCacheEx.SortBy.cs b/src/DynamicData/Cache/ObservableCacheEx.SortBy.cs
new file mode 100644
index 000000000..2834f6084
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.SortBy.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Sorts the changeset stream by the value returned from <paramref name="expression"/>. Creates a comparer internally
+    /// and delegates to <see cref="Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>.
+    /// Since Sort is obsolete, prefer SortAndBind for new code.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
+    /// <param name="expression">A <see cref="Func{T, TResult}"/> that expression that selects a comparable value from each item.</param>
+    /// <param name="sortOrder">The <see cref="SortDirection"/> sort direction. Defaults to ascending.</param>
+    /// <param name="sortOptimisations">A <see cref="SortOptimisations"/> that sort optimization flags.</param>
+    /// <param name="resetThreshold">The number of updates before the entire list is re-sorted (rather than inline sort).</param>
+    /// <returns>An observable that emits sorted changesets.</returns>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> SortBy<TObject, TKey>(
+        this IObservable<IChangeSet<TObject, TKey>> source,
+        Func<TObject, IComparable> expression,
+        SortDirection sortOrder = SortDirection.Ascending,
+        SortOptimisations sortOptimisations = SortOptimisations.None,
+        int resetThreshold = DefaultSortResetThreshold)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source = source ?? throw new ArgumentNullException(nameof(source));
+        expression = expression ?? throw new ArgumentNullException(nameof(expression));
+
+        return source.Sort(
+            sortOrder switch
+            {
+                SortDirection.Descending => SortExpressionComparer<TObject>.Descending(expression),
+                _ => SortExpressionComparer<TObject>.Ascending(expression),
+            },
+            sortOptimisations,
+            resetThreshold);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.StartWithEmpty.cs b/src/DynamicData/Cache/ObservableCacheEx.StartWithEmpty.cs
new file mode 100644
index 000000000..8960f03aa
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.StartWithEmpty.cs
@@ -0,0 +1,95 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Prepends an empty changeset to the source stream, ensuring subscribers always receive an immediate
+    /// (empty) notification on subscription. Uses Rx's <c>StartWith</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty changeset first, then all source changesets.</returns>
+    /// <seealso cref="ObservableListEx.StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.StartWith(ChangeSet<TObject, TKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty sorted changeset first, then all source changesets.</returns>
+    /// <remarks>Overload for <see cref="ISortedChangeSet{TObject, TKey}"/>.</remarks>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.StartWith(SortedChangeSet<TObject, TKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <param name="source">The source <see cref="IObservable{IVirtualChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty virtual changeset first, then all source changesets.</returns>
+    /// <remarks>Overload for <see cref="IVirtualChangeSet{TObject, TKey}"/>.</remarks>
+    public static IObservable<IVirtualChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IVirtualChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.StartWith(VirtualChangeSet<TObject, TKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <param name="source">The source <see cref="IObservable{IPagedChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty paged changeset first, then all source changesets.</returns>
+    /// <remarks>Overload for <see cref="IPagedChangeSet{TObject, TKey}"/>.</remarks>
+    public static IObservable<IPagedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IPagedChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.StartWith(PagedChangeSet<TObject, TKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The grouping key type.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IGroupChangeSet{TObject, TKey, TGroupKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty group changeset first, then all source changesets.</returns>
+    /// <remarks>Overload for <see cref="IGroupChangeSet{TObject, TKey, TGroupKey}"/>.</remarks>
+    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull => source.StartWith(GroupChangeSet<TObject, TKey, TGroupKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TGroupKey">The grouping key type.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IImmutableGroupChangeSet{TObject, TKey, TGroupKey}}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty immutable group changeset first, then all source changesets.</returns>
+    /// <remarks>Overload for <see cref="IImmutableGroupChangeSet{TObject, TKey, TGroupKey}"/>.</remarks>
+    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+        where TGroupKey : notnull => source.StartWith(ImmutableGroupChangeSet<TObject, TKey, TGroupKey>.Empty);
+
+    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{T}"/> of <see cref="IReadOnlyCollection{T}"/> to prepend an empty changeset to.</param>
+    /// <returns>An observable that emits an empty collection first, then all source collections.</returns>
+    /// <remarks>Overload for <see cref="IReadOnlyCollection{T}"/>.</remarks>
+    public static IObservable<IReadOnlyCollection<T>> StartWithEmpty<T>(this IObservable<IReadOnlyCollection<T>> source) => source.StartWith(ReadOnlyCollectionLight<T>.Empty);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.StartWithItem.cs b/src/DynamicData/Cache/ObservableCacheEx.StartWithItem.cs
new file mode 100644
index 000000000..560f53723
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.StartWithItem.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="StartWithItem{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TObject, TKey)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an initial item to.</param>
+    /// <param name="item">The item to prepend. The key is extracted from <see cref="IKey{TKey}.Key"/>.</param>
+    /// <remarks>Overload for items that implement <see cref="IKey{TKey}"/>. Delegates to the explicit key overload.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TObject item)
+        where TObject : IKey<TKey>
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.StartWithItem(item, item.Key);
+    }
+
+    /// <summary>
+    /// Prepends a changeset containing a single <b>Add</b> for the given item and key to the source stream.
+    /// The Rx equivalent of <c>StartWith</c>, but wrapped as a DynamicData changeset.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an initial item to.</param>
+    /// <param name="item">The <typeparamref name="TObject"/> item to prepend.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key for the item.</param>
+    /// <returns>An observable that emits a single-item Add changeset first, then all source changesets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TObject item, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        var change = new Change<TObject, TKey>(ChangeReason.Add, key, item);
+        return source.StartWith(new ChangeSet<TObject, TKey> { change });
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.SubscribeMany.cs b/src/DynamicData/Cache/ObservableCacheEx.SubscribeMany.cs
new file mode 100644
index 000000000..4149907ba
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.SubscribeMany.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Creates an <see cref="IDisposable"/> subscription per item via <paramref name="subscriptionFactory"/>.
+    /// Subscriptions are created on Add/Update and disposed on Update/Remove. All active subscriptions
+    /// are disposed when the stream completes, errors, or the subscription is disposed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to create a subscription for each item in.</param>
+    /// <param name="subscriptionFactory">A factory that creates an <see cref="IDisposable"/> for each item. Called on Add and Update (for the new value).</param>
+    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Change reason handling:</b>
+    /// <list type="table">
+    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
+    ///   <item><term>Add</term><description>Calls <paramref name="subscriptionFactory"/>, stores the returned <see cref="IDisposable"/>.</description></item>
+    ///   <item><term>Update</term><description>Disposes the previous subscription, then calls <paramref name="subscriptionFactory"/> for the new value.</description></item>
+    ///   <item><term>Remove</term><description>Disposes the subscription for the removed item.</description></item>
+    ///   <item><term>Refresh</term><description>Passed through. No subscription change.</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// Internally implemented using <see cref="Transform{TDestination,TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Func{TObject,TKey,TDestination}, bool)"/>
+    /// and <see cref="DisposeMany{TObject,TKey}"/>, so disposal semantics match <see cref="DisposeMany{TObject,TKey}"/>.
+    /// </para>
+    /// <para>
+    /// Use this to tie per-item side effects (event subscriptions, polling timers, child observable subscriptions)
+    /// to the lifecycle of items in the cache.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="subscriptionFactory"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="DisposeMany{TObject,TKey}"/>
+    /// <seealso cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>
+    /// <seealso cref="ObservableListEx.SubscribeMany"/>
+    public static IObservable<IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IDisposable> subscriptionFactory)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
+
+        return new SubscribeMany<TObject, TKey>(source, subscriptionFactory).Run();
+    }
+
+    /// <inheritdoc cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to create a subscription for each item in.</param>
+    /// <param name="subscriptionFactory">A factory that creates an <see cref="IDisposable"/> for each item. Receives the item and its key.</param>
+    /// <remarks>Overload whose factory receives both the item and the key. See <see cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/> for full details.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IDisposable> subscriptionFactory)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
+
+        return new SubscribeMany<TObject, TKey>(source, subscriptionFactory).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.SuppressRefresh.cs b/src/DynamicData/Cache/ObservableCacheEx.SuppressRefresh.cs
new file mode 100644
index 000000000..452c4ea0d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.SuppressRefresh.cs
@@ -0,0 +1,38 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Suppress refresh notifications.
+    /// </summary>
+    /// <typeparam name="TObject">The object of the change set.</typeparam>
+    /// <typeparam name="TKey">The key of the change set.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to strip refresh events.</param>
+    /// <returns>An observable which emits change sets.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> SuppressRefresh<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.WhereReasonsAreNot(ChangeReason.Refresh);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Switch.cs b/src/DynamicData/Cache/ObservableCacheEx.Switch.cs
new file mode 100644
index 000000000..c300179c1
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Switch.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="Switch{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
+    /// <param name="sources">An observable that emits <see cref="IObservableCache{TObject, TKey}"/> instances.</param>
+    /// <remarks>Overload that accepts observable caches. Internally calls <c>Connect()</c> on each cache and delegates to the changeset overload.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this IObservable<IObservableCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Select(cache => cache.Connect()).Switch();
+    }
+
+    /// <summary>
+    /// Subscribes to the latest inner changeset stream, unsubscribing from the previous one on each switch.
+    /// When switching, the old source's items are removed and the new source's items are added.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">An <see cref="IObservable{T}"/> of <see cref="IObservable{T}"/> changeset streams. The operator subscribes to the latest inner stream.</param>
+    /// <returns>A changeset stream reflecting the items from the most recently emitted inner source.</returns>
+    /// <remarks>
+    /// <para>On switch: <b>Remove</b> is emitted for all items from the previous source, then <b>Add</b> for all items from the new source.</para>
+    /// <para><b>Worth noting:</b> Each switch clears the entire downstream cache before populating from the new source. Subscribers see a full remove-then-add reset on every switch.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return new Switch<TObject, TKey>(sources).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ToCollection.cs b/src/DynamicData/Cache/ObservableCacheEx.ToCollection.cs
new file mode 100644
index 000000000..1871e4337
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ToCollection.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Converts the change set into a fully formed collection. Each change in the source results in a new collection.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a collection on each change.</param>
+    /// <returns>An observable which emits the read only collection.</returns>
+    /// <seealso cref="ObservableListEx.ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
+    public static IObservable<IReadOnlyCollection<TObject>> ToCollection<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull => source.QueryWhenChanged(query => new ReadOnlyCollectionLight<TObject>(query.Items));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ToObservableChangeSet.cs b/src/DynamicData/Cache/ObservableCacheEx.ToObservableChangeSet.cs
new file mode 100644
index 000000000..f04d2c998
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ToObservableChangeSet.cs
@@ -0,0 +1,95 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Bridges a standard Rx observable of individual items into a DynamicData changeset stream.
+    /// Each emission becomes an <b>Add</b> (or <b>Update</b> if the key already exists).
+    /// Supports optional per-item expiration and size limiting.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{TObject}"/> to convert into a keyed changeset stream.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that selects the unique key for each item.</param>
+    /// <param name="expireAfter">An optional <see cref="Func{T, TResult}"/> that specifies per-item expiration time. Return <see langword="null"/> for no expiration.</param>
+    /// <param name="limitSizeTo">The maximum cache size. Oldest items are removed when exceeded. Use -1 for no limit.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiration timing.</param>
+    /// <returns>An observable changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(
+            this IObservable<TObject> source,
+            Func<TObject, TKey> keySelector,
+            Func<TObject, TimeSpan?>? expireAfter = null,
+            int limitSizeTo = -1,
+            IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return Cache.Internal.ToObservableChangeSet<TObject, TKey>.Create(
+            source: source,
+            keySelector: keySelector,
+            expireAfter: expireAfter,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+    }
+
+    /// <summary>
+    /// Bridges a standard Rx observable of item batches into a DynamicData changeset stream.
+    /// Each batch is processed with <c>AddOrUpdate</c>, producing <b>Add</b> or <b>Update</b> changes per item.
+    /// Supports optional per-item expiration and size limiting.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{TObject}}"/> to convert into a keyed changeset stream.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that selects the unique key for each item.</param>
+    /// <param name="expireAfter">An optional <see cref="Func{T, TResult}"/> that specifies per-item expiration time. Return <see langword="null"/> for no expiration.</param>
+    /// <param name="limitSizeTo">The maximum cache size. Oldest items are removed when exceeded. Use -1 for no limit.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiration timing.</param>
+    /// <returns>An observable changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(
+            this IObservable<IEnumerable<TObject>> source,
+            Func<TObject, TKey> keySelector,
+            Func<TObject, TimeSpan?>? expireAfter = null,
+            int limitSizeTo = -1,
+            IScheduler? scheduler = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return Cache.Internal.ToObservableChangeSet<TObject, TKey>.Create(
+            source: source,
+            keySelector: keySelector,
+            expireAfter: expireAfter,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ToObservableOptional.cs b/src/DynamicData/Cache/ObservableCacheEx.ToObservableOptional.cs
new file mode 100644
index 000000000..43d2c39eb
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ToObservableOptional.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Watches a single key in the source changeset stream, emitting <c>Optional.Some(value)</c> when the key
+    /// is present and <see cref="Optional.None{T}"/> when it is removed. Duplicate values are suppressed via <paramref name="equalityComparer"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to watch.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that optional comparer to suppress duplicate emissions. Uses default equality if <see langword="null"/>.</param>
+    /// <returns>An observable of <see cref="Optional{TObject}"/> that reflects the presence or absence of the specified key.</returns>
+    /// <remarks>
+    /// <para>
+    /// Unlike <see cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>, this emits <c>None</c> on removal
+    /// (rather than the removed value), making it possible to distinguish "key is absent" from "key has a value".
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Emits <c>Optional.Some(value)</c> if the key was not previously tracked.</description></item>
+    /// <item><term>Update</term><description>Emits <c>Optional.Some(newValue)</c> if the new value differs from the previous per <paramref name="equalityComparer"/>. Otherwise suppressed.</description></item>
+    /// <item><term>Remove</term><description>Emits <see cref="Optional.None{T}"/>.</description></item>
+    /// <item><term>Refresh</term><description>Emits <c>Optional.Some(value)</c> if the value differs from the last emission per <paramref name="equalityComparer"/>. Otherwise suppressed.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> No emission occurs if the key is not present at subscription time. To get an initial <c>None</c> when the key is absent, use the overload with <c>initialOptionalWhenMissing: true</c>.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Watch{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
+    /// <seealso cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
+    public static IObservable<Optional<TObject>> ToObservableOptional<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new ToObservableOptional<TObject, TKey>(source, key, equalityComparer).Run();
+    }
+
+    /// <summary>
+    /// Converts an observable cache into an observable optional that emits the value for the given key.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key value.</param>
+    /// <param name="initialOptionalWhenMissing">When <see langword="true"/>, emits an initial <see cref="Optional{TObject}"/> with no value if the key is not present in the cache.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> instance used to determine if an object value has changed.</param>
+    /// <returns>An observable optional.</returns>
+    /// <exception cref="ArgumentNullException">source is null.</exception>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> Uses lock-based coordination. If the key exists synchronously on <c>Connect()</c>, the initial <c>None</c> may or may not be emitted depending on timing.</para>
+    /// </remarks>
+    public static IObservable<Optional<TObject>> ToObservableOptional<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key, bool initialOptionalWhenMissing, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        if (initialOptionalWhenMissing)
+        {
+            return Observable.Defer(() =>
+            {
+                var seenValue = false;
+                return source.ToObservableOptional(key, equalityComparer)
+                    .Do(_ => seenValue = true)
+                    .Merge(Observable.Defer(() => seenValue
+                        ? Observable.Empty<Optional<TObject>>()
+                        : Observable.Return(Optional.None<TObject>())));
+            });
+        }
+
+        return source.ToObservableOptional(key, equalityComparer);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.ToSortedCollection.cs b/src/DynamicData/Cache/ObservableCacheEx.ToSortedCollection.cs
new file mode 100644
index 000000000..81770d625
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.ToSortedCollection.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Converts the change set into a fully formed sorted collection. Each change in the source results in a new sorted collection.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TSortKey">The sort key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a sorted collection on each change.</param>
+    /// <param name="sort">The <see cref="Func{TObject, TSortKey}"/> sort function.</param>
+    /// <param name="sortOrder">The <see cref="SortDirection"/> sort order. Defaults to ascending.</param>
+    /// <returns>An observable which emits the read only collection.</returns>
+    /// <seealso cref="ObservableListEx.ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
+    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey, TSortKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TSortKey> sort, SortDirection sortOrder = SortDirection.Ascending)
+        where TObject : notnull
+        where TKey : notnull
+        where TSortKey : notnull => source.QueryWhenChanged(query => sortOrder == SortDirection.Ascending ? new ReadOnlyCollectionLight<TObject>(query.Items.OrderBy(sort)) : new ReadOnlyCollectionLight<TObject>(query.Items.OrderByDescending(sort)));
+
+    /// <summary>
+    /// Converts the change set into a fully formed sorted collection. Each change in the source results in a new sorted collection.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a sorted collection on each change.</param>
+    /// <param name="comparer">The <see cref="IComparer{TObject}"/> sort comparer.</param>
+    /// <returns>An observable which emits the read only collection.</returns>
+    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer)
+        where TObject : notnull
+        where TKey : notnull => source.QueryWhenChanged(
+            query =>
+            {
+                var items = query.Items.AsList();
+                items.Sort(comparer);
+                return new ReadOnlyCollectionLight<TObject>(items);
+            });
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Transform.cs b/src/DynamicData/Cache/ObservableCacheEx.Transform.cs
new file mode 100644
index 000000000..8319591d0
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Transform.cs
@@ -0,0 +1,181 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update). The factory receives only the current item.</remarks>
+    /// <seealso cref="ObservableListEx.Transform"/>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, bool transformOnRefresh)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform((current, _, _) => transformFactory(current), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update). The factory receives the current item and key.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, bool transformOnRefresh)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform((current, _, key) => transformFactory(current, key), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update).</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, bool transformOnRefresh)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new Transform<TDestination, TSource, TKey>(source, transformFactory, transformOnRefresh: transformOnRefresh).Run();
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts an optional <c>forceTransform</c> predicate filtering by source item only (without the key). The factory receives only the current item.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, IObservable<Func<TSource, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform((current, _, _) => transformFactory(current), forceTransform?.ForForced<TSource, TKey>());
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts an optional <c>forceTransform</c> predicate filtering by source item and key. The factory receives the current item and key.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform((current, _, key) => transformFactory(current, key), forceTransform);
+    }
+
+    /// <summary>
+    /// Projects each item in the changeset to a new form using a synchronous transform factory.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform.</param>
+    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, TDestination}"/> that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
+    /// <param name="forceTransform">An observable that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. Re-transformed items are emitted as <see cref="ChangeReason.Update"/> changes. If <see langword="null"/>, no forced re-transforms occur.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Transform maintains a 1:1 mapping between source and destination items, keyed identically. The factory
+    /// is called once per Add and once per Update. Removes are forwarded without calling the factory.
+    /// </para>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Calls factory, emits Add.</description></item>
+    ///   <item><term>Update</term><description>Calls factory (receives current item, previous item, key), emits Update with Previous preserved.</description></item>
+    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh without re-transforming. To re-transform on Refresh, use the <paramref name="forceTransform"/> parameter or the <c>transformOnRefresh</c> overloads.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> By default, <b>Refresh</b> does NOT re-invoke the transform factory (it is just forwarded). Set <c>transformOnRefresh: true</c> to re-transform on <b>Refresh</b>.</para>
+    /// <para>
+    /// When <paramref name="forceTransform"/> emits a predicate, every cached item is tested against it.
+    /// Matching items are re-transformed and emitted as Updates.
+    /// </para>
+    /// <para>
+    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>, terminating the stream.
+    /// Use <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// to catch factory errors without killing the stream.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <seealso cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <seealso cref="TransformImmutable{TDestination, TSource, TKey}"/>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        if (forceTransform is not null)
+        {
+            return new TransformWithForcedTransform<TDestination, TSource, TKey>(source, transformFactory, forceTransform).Run();
+        }
+
+        return new Transform<TDestination, TSource, TKey>(source, transformFactory).Run();
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits. The factory receives only the current item.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull => source.Transform((cur, _, _) => transformFactory(cur), forceTransform.ForForced<TSource, TKey>());
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits. The factory receives the current item and key.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
+
+        return source.Transform((cur, _, key) => transformFactory(cur, key), forceTransform.ForForced<TSource, TKey>());
+    }
+
+    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
+
+        return source.Transform(transformFactory, forceTransform.ForForced<TSource, TKey>());
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformAsync.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformAsync.cs
new file mode 100644
index 000000000..5e76e6cb8
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformAsync.cs
@@ -0,0 +1,171 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload takes a simpler factory that receives only the current item.</remarks>
+    /// <seealso cref="ObservableListEx.TransformAsync"/>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync((current, _, _) => transformFactory(current), forceTransform);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload takes a factory that receives the current item and key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync((current, _, key) => transformFactory(current, key), forceTransform);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload takes a factory that receives the current item the previous item and key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync((current, previous, key, _) => transformFactory(current, previous, key), forceTransform);
+    }
+
+    /// <summary>
+    /// Async version of <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>.
+    /// Projects each item using an async factory that returns <see cref="Task{TResult}"/>.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform asynchronously.</param>
+    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, Task{TDestination}}"/> async function that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
+    /// <param name="forceTransform">An observable that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. Re-transformed items are emitted as <see cref="ChangeReason.Update"/> changes. If <see langword="null"/>, no forced re-transforms occur.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Transforms within a single changeset batch execute concurrently. The entire batch must complete
+    /// before the resulting changeset is emitted. Use the <see cref="TransformAsyncOptions"/> overloads
+    /// to control maximum concurrency and Refresh handling.
+    /// </para>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Awaits factory, emits Add.</description></item>
+    ///   <item><term>Update</term><description>Awaits factory (receives current, previous, key), emits Update.</description></item>
+    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
+    ///   <item><term>Refresh</term><description>Forwarded as Refresh by default. Use <see cref="TransformAsyncOptions.TransformOnRefresh"/> to re-transform.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Transforms are batched per changeset (all tasks must complete before the next changeset is processed). Completion waits for in-flight transforms. <b>Remove</b> does NOT cancel in-flight transforms for the removed key.</para>
+    /// <para>
+    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>. Use
+    /// <see cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// to catch factory errors without terminating the stream.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, null, forceTransform).Run();
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives only the current item.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync((current, _, _) => transformFactory(current), options);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives the current item and key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return TransformAsync(source, (current, _, key, _) => transformFactory(current, key), options);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return TransformAsync(source, (current, previous, key, _) => transformFactory(current, previous, key), options);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, CancellationToken, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>> transformFactory, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, null, null, options.MaximumConcurrency, options.TransformOnRefresh).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformImmutable.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformImmutable.cs
new file mode 100644
index 000000000..940746e7a
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformImmutable.cs
@@ -0,0 +1,69 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Optimized transform for immutable items with deterministic (pure) transform functions.
+    /// Refresh changes are dropped entirely since immutable items cannot change in place.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform (items assumed immutable).</param>
+    /// <param name="transformFactory">The <see cref="Func{TSource, TDestination}"/> pure function that maps a source item to a destination item. Must be deterministic: same input always produces equivalent output.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Because the transform is assumed to be stateless and deterministic, this operator does not track
+    /// previously transformed items. This reduces memory overhead compared to <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>.
+    /// </para>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Calls factory, emits Add.</description></item>
+    ///   <item><term>Update</term><description>Calls factory, emits Update.</description></item>
+    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
+    ///   <item><term>Refresh</term><description>DROPPED. Immutable items do not change, so Refresh is meaningless.</description></item>
+    /// </list>
+    /// <para>Use this when items are immutable, the factory is pure, and the factory is cheap. If any of these conditions are false, use <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/> instead.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformImmutable<TDestination, TSource, TKey>(
+            this IObservable<IChangeSet<TSource, TKey>> source,
+            Func<TSource, TDestination> transformFactory)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformImmutable<TDestination, TSource, TKey>(
+                source: source,
+                transformFactory: transformFactory)
+            .Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformMany.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformMany.cs
new file mode 100644
index 000000000..682f5592d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformMany.cs
@@ -0,0 +1,84 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Flattens each source item into zero or more destination items (1:N), producing a single flat changeset.
+    /// Each child item must have a globally unique key across all parents.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the child items.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
+    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
+    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children.</param>
+    /// <param name="manySelector">A function that expands a parent item into its children. For <see cref="ObservableCollection{T}"/> or <see cref="IObservableCache{TObject, TKey}"/> overloads, subsequent changes to the child collection are automatically tracked.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item. Keys must be unique across ALL parents, not just within one parent.</param>
+    /// <returns>An observable changeset of flattened child items.</returns>
+    /// <remarks>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Calls <paramref name="manySelector"/>, emits Add for each child.</description></item>
+    ///   <item><term>Update</term><description>Diffs old children vs new children: emits Remove for removed children, Add for new children, Update for children with matching keys.</description></item>
+    ///   <item><term>Remove</term><description>Emits Remove for all children of the removed parent.</description></item>
+    ///   <item><term>Refresh</term><description>Propagated as Refresh to all children (no re-expansion).</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> If two source items produce children with the same key, last-in-wins. <b>Refresh</b> does NOT re-expand children (only <b>Update</b> does).</para>
+    /// <para>If two parents produce children with the same key, last-in-wins. Use the async variant with a <see cref="IComparer{T}"/> to control conflict resolution.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="manySelector"/>, or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <seealso cref="ObservableListEx.TransformMany"/>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, IEnumerable<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
+
+    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
+    /// <remarks>This overload accepts an <see cref="ObservableCollection{T}"/> selector. Changes to the child collection (adds, removes, replacements) are automatically observed and reflected downstream.</remarks>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, ObservableCollection<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
+
+    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
+    /// <remarks>This overload accepts a <see cref="ReadOnlyObservableCollection{T}"/> selector. Changes to the child collection are automatically observed and reflected downstream.</remarks>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, ReadOnlyObservableCollection<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
+
+    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
+    /// <remarks>This overload accepts an <see cref="IObservableCache{TObject, TKey}"/> selector. The child cache is live: subsequent changes to it are automatically propagated downstream.</remarks>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, IObservableCache<TDestination, TDestinationKey>> manySelector, Func<TDestination, TDestinationKey> keySelector)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformManyAsync.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformManyAsync.cs
new file mode 100644
index 000000000..4a6ac6005
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformManyAsync.cs
@@ -0,0 +1,128 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Async version of <see cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>.
+    /// Flattens each source item into zero or more destination items using an async factory.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the child items.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
+    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
+    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children asynchronously.</param>
+    /// <param name="manySelector">An async function that expands a parent item (and its key) into an <see cref="IEnumerable{T}"/> of children.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional comparer to determine if two child items with the same key are equal. Used to suppress no-op updates.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key collisions when the same destination key is produced by multiple parents. The winning item is determined by this comparer.</param>
+    /// <returns>An observable changeset of flattened child items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Because each parent's expansion is async, child collections may arrive via separate changesets
+    /// (unlike the synchronous <c>TransformMany</c> which batches all children into one changeset).
+    /// </para>
+    /// <para>
+    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>. Use
+    /// <see cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// to catch errors without killing the stream.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="manySelector"/> is <see langword="null"/>.</exception>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer).Run();
+    }
+
+    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => source.TransformManyAsync((val, _) => manySelector(val), keySelector, equalityComparer, comparer);
+
+    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives the source item and its key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination>
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer).Run();
+    }
+
+    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives only the source item.</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => source.TransformManyAsync((val, _) => manySelector(val), keySelector, equalityComparer, comparer);
+
+    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live: its changes propagate downstream. No <c>keySelector</c> is needed since the cache already has keys. The factory receives the source item and its key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector), equalityComparer, comparer).Run();
+    }
+
+    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives only the source item.</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => source.TransformManyAsync((val, _) => manySelector(val), equalityComparer, comparer);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformManySafeAsync.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformManySafeAsync.cs
new file mode 100644
index 000000000..5e9d2c062
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformManySafeAsync.cs
@@ -0,0 +1,123 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Async version of <see cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
+    /// with error handling. Factory exceptions are caught and routed to <paramref name="errorHandler"/> instead of
+    /// terminating the stream.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the child items.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
+    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
+    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children asynchronously with error handling.</param>
+    /// <param name="manySelector">An async function that expands a parent item (and its key) into an <see cref="IEnumerable{T}"/> of children.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item.</param>
+    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="manySelector"/> throws. The faulting item is skipped and the stream continues.</param>
+    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional comparer to determine if two child items with the same key are equal.</param>
+    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key collisions when the same destination key is produced by multiple parents.</param>
+    /// <returns>An observable changeset of flattened child items.</returns>
+    /// <remarks>Because the transformations are asynchronous, each sub-collection may be emitted via a separate changeset.</remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="manySelector"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer, errorHandler).Run();
+    }
+
+    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => source.TransformManySafeAsync((val, _) => manySelector(val), keySelector, errorHandler, equalityComparer, comparer);
+
+    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives the source item and its key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination>
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer, errorHandler).Run();
+    }
+
+    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives only the source item.</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => source.TransformManySafeAsync((val, _) => manySelector(val), keySelector, errorHandler, equalityComparer, comparer);
+
+    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives the source item and its key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector), equalityComparer, comparer, errorHandler).Run();
+    }
+
+    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives only the source item.</remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TDestination : notnull
+        where TDestinationKey : notnull
+        where TSource : notnull
+        where TSourceKey : notnull => source.TransformManySafeAsync((val, _) => manySelector(val), errorHandler, equalityComparer, comparer);
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformOnObservable.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformOnObservable.cs
new file mode 100644
index 000000000..24d9e5e04
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformOnObservable.cs
@@ -0,0 +1,93 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Projects each item into a per-item observable. The latest value emitted by each item's observable
+    /// becomes the transformed value in the output changeset.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform using per-item observables.</param>
+    /// <param name="transformFactory">A function that, given a source item and its key, returns an <see cref="IObservable{TDestination}"/> whose emissions become the transformed values.</param>
+    /// <returns>An observable changeset where each key's value is the latest emission from its per-item observable.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Source changeset handling (parent events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Calls <paramref name="transformFactory"/> and subscribes to the returned observable. The item is <b>not visible downstream until the observable emits its first value</b>.</description></item>
+    /// <item><term>Update</term><description>Disposes the old item's observable subscription and subscribes to the new item's observable. The item disappears from downstream until the new observable emits.</description></item>
+    /// <item><term>Remove</term><description>Disposes the item's observable subscription. If the item was visible downstream, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently visible downstream. Otherwise dropped.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Per-item observable handling (transform observable events):</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
+    /// <item><term>First value</term><description>The transformed item appears downstream as an <b>Add</b>.</description></item>
+    /// <item><term>Subsequent values</term><description>Each new value replaces the previous one: an <b>Update</b> is emitted downstream.</description></item>
+    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
+    /// <item><term>Completed</term><description>The item remains at its last emitted value. No further updates are possible for this item.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Worth noting:</b> Items are invisible downstream until their per-item observable emits at least one value.
+    /// If an item's observable never emits, that item never appears in the output. The transform factory's selector
+    /// runs under an internal lock, so it must not synchronously access other DynamicData caches (deadlock risk in
+    /// cross-cache pipelines). The output completes when the source completes and all per-item observables have
+    /// also completed.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, TDestination}, bool)"/>
+    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}})"/>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformOnObservable<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, IObservable<TDestination>> transformFactory)
+        where TSource : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformOnObservable<TSource, TKey, TDestination>(source, transformFactory).Run();
+    }
+
+    /// <inheritdoc cref="TransformOnObservable{TSource, TKey, TDestination}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, IObservable{TDestination}})"/>
+    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformOnObservable<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, IObservable<TDestination>> transformFactory)
+        where TSource : notnull
+        where TKey : notnull
+        where TDestination : notnull
+    {
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformOnObservable((obj, _) => transformFactory(obj));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformSafe.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformSafe.cs
new file mode 100644
index 000000000..f8e68385d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformSafe.cs
@@ -0,0 +1,127 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts a simpler factory that receives only the current item, and a forceTransform predicate filtering by source item only.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafe((current, _, _) => transformFactory(current), errorHandler, forceTransform.ForForced<TSource, TKey>());
+    }
+
+    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts a factory that receives the current item and key.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafe((current, _, key) => transformFactory(current, key), errorHandler, forceTransform);
+    }
+
+    /// <summary>
+    /// Projects each item using a synchronous factory, catching factory exceptions via a mandatory error handler
+    /// instead of terminating the stream.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform with error handling.</param>
+    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, TDestination}"/> that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
+    /// <param name="errorHandler">A callback invoked when <paramref name="transformFactory"/> throws. Receives an <see cref="Error{TSource, TKey}"/> containing the exception and the faulting item. The item is skipped and the stream continues.</param>
+    /// <param name="forceTransform">An optional <see cref="IObservable{T}"/> that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. If <see langword="null"/>, no forced re-transforms occur.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Behaves identically to <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// except that factory exceptions are routed to <paramref name="errorHandler"/> instead of propagating as <see cref="IObserver{T}.OnError"/>.
+    /// Source-level errors (i.e. the source observable itself erroring) still propagate normally.
+    /// </para>
+    /// <para><b>Worth noting:</b> Factory exceptions are caught per-item; the faulting item is skipped and reported to the error handler while the stream continues. Source-level errors still terminate the stream.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+        if (forceTransform is not null)
+        {
+            return new TransformWithForcedTransform<TDestination, TSource, TKey>(source, transformFactory, forceTransform, errorHandler).Run();
+        }
+
+        return new Transform<TDestination, TSource, TKey>(source, transformFactory, errorHandler).Run();
+    }
+
+    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items. The factory receives only the current item.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull => source.TransformSafe((cur, _, _) => transformFactory(cur), errorHandler, forceTransform.ForForced<TSource, TKey>());
+
+    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items. The factory receives the current item and key.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
+
+        return source.TransformSafe((cur, _, key) => transformFactory(cur, key), errorHandler, forceTransform.ForForced<TSource, TKey>());
+    }
+
+    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
+
+        return source.TransformSafe(transformFactory, errorHandler, forceTransform.ForForced<TSource, TKey>());
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformSafeAsync.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformSafeAsync.cs
new file mode 100644
index 000000000..70477e563
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformSafeAsync.cs
@@ -0,0 +1,154 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload takes a factory that receives only the current item.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafeAsync((current, _, _) => transformFactory(current), errorHandler, forceTransform);
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload takes a factory that receives the current item and key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafeAsync((current, _, key) => transformFactory(current, key), errorHandler, forceTransform);
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, CancellationToken, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafeAsync((s, p, k, t) => transformFactory(s, p, k), errorHandler, forceTransform);
+    }
+
+    /// <summary>
+    /// Async version of <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>.
+    /// Projects each item using an async factory, catching factory exceptions via a mandatory error handler.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform asynchronously with error handling.</param>
+    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, CancellationToken, Task{TDestination}}"/> async function that produces a <typeparamref name="TDestination"/>.</param>
+    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="transformFactory"/> throws or faults. The item is skipped and the stream continues.</param>
+    /// <param name="forceTransform">An optional <see cref="IObservable{T}"/> that forces re-transformation of matching items.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>Combines the async execution model of <see cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/> with the error-safe behavior of <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>.</remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, errorHandler, forceTransform).Run();
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives only the current item.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafeAsync((current, _, _) => transformFactory(current), errorHandler, options);
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives the current item and key.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformSafeAsync((current, _, key) => transformFactory(current, key), errorHandler, options);
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, CancellationToken, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        return source.TransformSafeAsync((current, previous, key, cancel) => transformFactory(current, previous, key), errorHandler, options);
+    }
+
+    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, CancellationToken, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
+    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
+    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
+        where TDestination : notnull
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, errorHandler, null, options.MaximumConcurrency, options.TransformOnRefresh).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformToTree.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformToTree.cs
new file mode 100644
index 000000000..e0020280d
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformToTree.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Builds a hierarchical tree from a flat changeset using a parent key selector.
+    /// Each item becomes a <see cref="Node{TObject, TKey}"/> with Parent, Children, Depth, and IsRoot properties.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the source items. Must be a reference type.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to transform into a hierarchical tree.</param>
+    /// <param name="pivotOn">The <see cref="Func{TObject, TKey}"/> that returns the key of an item's parent. Return the item's own key (or a non-existent key) for root items.</param>
+    /// <param name="predicateChanged">An optional <see cref="IObservable{T}"/> that emits a filter predicate for nodes. When the predicate changes, nodes are re-evaluated and filtered.</param>
+    /// <returns>An observable changeset of <see cref="Node{TObject, TKey}"/> items representing the tree.</returns>
+    /// <remarks>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Creates node, attaches to parent (or root if parent not found), emits Add.</description></item>
+    ///   <item><term>Update</term><description>Updates node. If <paramref name="pivotOn"/> returns a different parent key, the node is re-parented.</description></item>
+    ///   <item><term>Remove</term><description>Removes node. Orphaned children become root nodes.</description></item>
+    ///   <item><term>Refresh</term><description>Re-evaluates parent key. May re-parent the node if the parent changed.</description></item>
+    /// </list>
+    /// <para>Circular references are NOT detected. If item A is the parent of B and B is the parent of A, behavior is undefined.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pivotOn"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<Node<TObject, TKey>, TKey>> TransformToTree<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey> pivotOn, IObservable<Func<Node<TObject, TKey>, bool>>? predicateChanged = null)
+        where TObject : class
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        pivotOn.ThrowArgumentNullExceptionIfNull(nameof(pivotOn));
+
+        return new TreeBuilder<TObject, TKey>(source, pivotOn, predicateChanged).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TransformWithInlineUpdate.cs b/src/DynamicData/Cache/ObservableCacheEx.TransformWithInlineUpdate.cs
new file mode 100644
index 000000000..99004fa73
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TransformWithInlineUpdate.cs
@@ -0,0 +1,111 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
+    /// <remarks>This overload defaults to <c>transformOnRefresh: false</c> and does not provide an error handler (factory exceptions propagate as OnError).</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction)
+        where TDestination : class
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
+
+        return source.TransformWithInlineUpdate(transformFactory, updateAction, false);
+    }
+
+    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
+    /// <remarks>This overload does not provide an error handler (factory exceptions propagate as OnError). The <c>transformOnRefresh</c> parameter controls Refresh behavior.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, bool transformOnRefresh)
+        where TDestination : class
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
+
+        return new TransformWithInlineUpdate<TDestination, TSource, TKey>(source, transformFactory, updateAction, transformOnRefresh: transformOnRefresh).Run();
+    }
+
+    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
+    /// <remarks>This overload defaults to <c>transformOnRefresh: false</c> but includes an error handler for factory/update action exceptions.</remarks>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, Action<Error<TSource, TKey>> errorHandler)
+        where TDestination : class
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return source.TransformWithInlineUpdate(transformFactory, updateAction, errorHandler, false);
+    }
+
+    /// <summary>
+    /// Projects each item using a transform factory for Add, and mutates the existing transformed
+    /// item in place (via an update action) for Update, preserving the original object reference.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the transformed items. Must be a reference type since items are mutated in place.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform with in-place mutation on updates.</param>
+    /// <param name="transformFactory">A <see cref="Func{T, TResult}"/> that called on Add (and optionally Refresh) to create a new <typeparamref name="TDestination"/>.</param>
+    /// <param name="updateAction">A <see cref="Action{T}"/> that called on Update. Receives <c>(existingTransformed, newSource)</c>. Mutate the existing transformed item to reflect the new source value. Example: <c>(vm, model) =&gt; vm.Value = model.Value</c>.</param>
+    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="transformFactory"/> or <paramref name="updateAction"/> throws. The faulting item is skipped.</param>
+    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh changes call <paramref name="updateAction"/> on the existing item.</param>
+    /// <returns>An observable changeset of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// This is useful when the destination type is a ViewModel that should maintain its identity across updates.
+    /// Instead of replacing the entire ViewModel, the update action patches the existing instance.
+    /// </para>
+    /// <para><b>Change reason handling:</b></para>
+    /// <list type="table">
+    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
+    ///   <item><term>Add</term><description>Calls <paramref name="transformFactory"/>, emits Add.</description></item>
+    ///   <item><term>Update</term><description>Calls <paramref name="updateAction"/> on the EXISTING transformed item (same reference), emits Update.</description></item>
+    ///   <item><term>Remove</term><description>Emits Remove.</description></item>
+    ///   <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is true, calls <paramref name="updateAction"/>. Otherwise forwarded as Refresh.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, <paramref name="updateAction"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
+    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, Action<Error<TSource, TKey>> errorHandler, bool transformOnRefresh)
+        where TDestination : class
+        where TSource : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
+        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
+
+        return new TransformWithInlineUpdate<TDestination, TSource, TKey>(source, transformFactory, updateAction, errorHandler, transformOnRefresh).Run();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TreatMovesAsRemoveAdd.cs b/src/DynamicData/Cache/ObservableCacheEx.TreatMovesAsRemoveAdd.cs
new file mode 100644
index 000000000..965001488
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TreatMovesAsRemoveAdd.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Converts moves changes to remove + add.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to convert move events into remove/add pairs.</param>
+    /// <returns>the same SortedChangeSets, except all moves are replaced with remove + add.</returns>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> TreatMovesAsRemoveAdd<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        static IEnumerable<Change<TObject, TKey>> ReplaceMoves(IChangeSet<TObject, TKey> items)
+        {
+            foreach (var change in items.ToConcreteType())
+            {
+                if (change.Reason == ChangeReason.Moved)
+                {
+                    yield return new Change<TObject, TKey>(ChangeReason.Remove, change.Key, change.Current, change.PreviousIndex);
+
+                    yield return new Change<TObject, TKey>(ChangeReason.Add, change.Key, change.Current, change.CurrentIndex);
+                }
+                else
+                {
+                    yield return change;
+                }
+            }
+        }
+
+        return source.Select(changes => new SortedChangeSet<TObject, TKey>(changes.SortedItems, ReplaceMoves(changes)));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TrueFor.cs b/src/DynamicData/Cache/ObservableCacheEx.TrueFor.cs
new file mode 100644
index 000000000..a49b33f24
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TrueFor.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    private static IObservable<bool> TrueFor<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<IEnumerable<ObservableWithValue<TObject, TValue>>, bool> collectionMatcher)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull => new TrueFor<TObject, TKey, TValue>(source, observableSelector, collectionMatcher).Run();
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TrueForAll.cs b/src/DynamicData/Cache/ObservableCacheEx.TrueForAll.cs
new file mode 100644
index 000000000..e09acbedb
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TrueForAll.cs
@@ -0,0 +1,78 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Emits <see langword="true"/> when all items in the cache satisfy a condition based on their per-item observable,
+    /// and <see langword="false"/> otherwise. Re-evaluates whenever the cache changes or any per-item observable emits.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value emitted by each per-item observable.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across all items in.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
+    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each per-item observable's latest value.</param>
+    /// <returns>An observable of <c>bool</c> that emits whenever the all-items condition changes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="equalityCondition"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>A new per-item subscription is created. The aggregate condition is recalculated.</description></item>
+    /// <item><term>Update</term><description>The item is replaced in the collection snapshot. Condition recalculated.</description></item>
+    /// <item><term>Remove</term><description>Per-item subscription disposed. Condition recalculated over remaining items.</description></item>
+    /// <item><term>Refresh</term><description>No effect on per-item subscriptions. Condition not recalculated unless the per-item observable emits.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Items whose per-item observable has not yet emitted are treated as not satisfying the condition. An empty cache is vacuously <see langword="true"/>. The result uses <c>DistinctUntilChanged</c>, so duplicate <c>bool</c> values are suppressed.</para>
+    /// </remarks>
+    /// <seealso cref="TrueForAny{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TValue, bool})"/>
+    public static IObservable<bool> TrueForAll<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TValue, bool> equalityCondition)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull => source.TrueFor(observableSelector, items => items.All(o => o.LatestValue.HasValue && equalityCondition(o.LatestValue.Value)));
+
+    /// <summary>
+    /// <para>
+    /// Produces a boolean observable indicating whether the latest resulting value from all of the specified observables matches
+    /// the equality condition. The observable is re-evaluated whenever.
+    /// </para>
+    /// <para>
+    /// i) The cache changes
+    /// or ii) The inner observable changes.
+    /// </para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across all items in.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> that selector which returns the target observable.</param>
+    /// <param name="equalityCondition">The <see cref="Func{TObject, TValue, bool}"/> equality condition.</param>
+    /// <returns>An observable which boolean values indicating if true.</returns>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    public static IObservable<bool> TrueForAll<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TObject, TValue, bool> equalityCondition)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull => source.TrueFor(observableSelector, items => items.All(o => o.LatestValue.HasValue && equalityCondition(o.Item, o.LatestValue.Value)));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.TrueForAny.cs b/src/DynamicData/Cache/ObservableCacheEx.TrueForAny.cs
new file mode 100644
index 000000000..f98e5270a
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.TrueForAny.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Emits <see langword="true"/> when any item in the cache satisfies a condition based on its per-item observable,
+    /// and <see langword="false"/> when none do. Re-evaluates whenever the cache changes or any per-item observable emits.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value emitted by each per-item observable.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across any item in.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
+    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each item and its per-item observable's latest value.</param>
+    /// <returns>An observable of <c>bool</c> that emits whenever the any-item condition changes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="equalityCondition"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>A new per-item subscription is created. The aggregate condition is recalculated.</description></item>
+    /// <item><term>Update</term><description>The item is replaced in the collection snapshot. Condition recalculated.</description></item>
+    /// <item><term>Remove</term><description>Per-item subscription disposed. Condition recalculated over remaining items.</description></item>
+    /// <item><term>Refresh</term><description>No effect on per-item subscriptions. Condition not recalculated unless the per-item observable emits.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Items whose per-item observable has not yet emitted are treated as not satisfying the condition. An empty cache yields <see langword="false"/>. The result uses <c>DistinctUntilChanged</c>, so duplicate <c>bool</c> values are suppressed.</para>
+    /// </remarks>
+    /// <seealso cref="TrueForAll{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TValue, bool})"/>
+    public static IObservable<bool> TrueForAny<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TObject, TValue, bool> equalityCondition)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull => source.TrueFor(observableSelector, items => items.Any(o => o.LatestValue.HasValue && equalityCondition(o.Item, o.LatestValue.Value)));
+
+    /// <inheritdoc cref="TrueForAny{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TObject, TValue, bool})"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across any item in.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
+    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each per-item observable's latest value (without the item).</param>
+    /// <remarks>This overload accepts a predicate that takes only the value, not the item. Useful when the condition depends only on the observed value.</remarks>
+    public static IObservable<bool> TrueForAny<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TValue, bool> equalityCondition)
+        where TObject : notnull
+        where TKey : notnull
+        where TValue : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+        equalityCondition.ThrowArgumentNullExceptionIfNull(nameof(equalityCondition));
+
+        return source.TrueFor(observableSelector, items => items.Any(o => o.LatestValue.HasValue && equalityCondition(o.LatestValue.Value)));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.UpdateIndex.cs b/src/DynamicData/Cache/ObservableCacheEx.UpdateIndex.cs
new file mode 100644
index 000000000..933529ea0
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.UpdateIndex.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Sets the <c>Index</c> property on each item (which must implement <see cref="IIndexAware"/>)
+    /// to reflect its position in the sorted output. Operates on <see cref="ISortedChangeSet{TObject, TKey}"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to update index positions in.</param>
+    /// <returns>An observable that emits the sorted changesets after updating item indices.</returns>
+    public static IObservable<ISortedChangeSet<TObject, TKey>> UpdateIndex<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
+        where TObject : IIndexAware
+        where TKey : notnull => source.Do(changes => changes.SortedItems.Select((update, index) => new { update, index }).ForEach(u => u.update.Value.Index = u.index));
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.VirtualiseAndPage.cs b/src/DynamicData/Cache/ObservableCacheEx.VirtualiseAndPage.cs
index d5a4bd979..2dbeaf1e6 100644
--- a/src/DynamicData/Cache/ObservableCacheEx.VirtualiseAndPage.cs
+++ b/src/DynamicData/Cache/ObservableCacheEx.VirtualiseAndPage.cs
@@ -8,7 +8,7 @@
 namespace DynamicData;
 
 /// <summary>
-/// ObservableCache extensions for the virtualised group of operators.
+/// Extensions for dynamic data.
 /// </summary>
 public static partial class ObservableCacheEx
 {
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Watch.cs b/src/DynamicData/Cache/ObservableCacheEx.Watch.cs
new file mode 100644
index 000000000..8cccf6088
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Watch.cs
@@ -0,0 +1,55 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters the source changeset stream to a single key, emitting each <see cref="Change{TObject, TKey}"/> for that key.
+    /// Changes for all other keys are ignored.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
+    /// <returns>An observable of <see cref="Change{TObject, TKey}"/> for the specified key only.</returns>
+    /// <remarks>
+    /// <para>
+    /// Emits Add, Update, Remove, and Refresh changes as they occur for the target key.
+    /// No initial emission occurs if the key is not yet present in the cache. This operator does not
+    /// produce changesets; it produces individual change notifications. For Optional-based watching,
+    /// use <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
+    /// <seealso cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>
+    public static IObservable<Change<TObject, TKey>> Watch<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.SelectMany(updates => updates).Where(update => update.Key.Equals(key));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WatchValue.cs b/src/DynamicData/Cache/ObservableCacheEx.WatchValue.cs
new file mode 100644
index 000000000..50929fb3a
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WatchValue.cs
@@ -0,0 +1,75 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Filters the source changeset stream to a single key, emitting the current value each time it changes.
+    /// Even emits the value on removal (the removed item's value).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservableCache{TObject, TKey}"/> to watch a single key in.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
+    /// <returns>An observable of the item's value whenever it changes for the specified key.</returns>
+    /// <remarks>
+    /// <para>
+    /// Unlike <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>,
+    /// this does not emit <see cref="Optional.None{T}"/> on removal. It emits the removed item's value instead.
+    /// If you need to distinguish presence from absence, use ToObservableOptional.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Emits the added item's value.</description></item>
+    /// <item><term>Update</term><description>Emits the new value.</description></item>
+    /// <item><term>Remove</term><description>Emits the removed item's value (not <c>None</c>; use <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/> if you need removal detection).</description></item>
+    /// <item><term>Refresh</term><description>Emits the current value.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> No emission occurs if the key is not present at subscription time. Changes to other keys are ignored entirely.</para>
+    /// </remarks>
+    /// <seealso cref="Watch{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
+    /// <seealso cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>
+    public static IObservable<TObject> WatchValue<TObject, TKey>(this IObservableCache<TObject, TKey> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Watch(key).Select(u => u.Current);
+    }
+
+    /// <inheritdoc cref="WatchValue{TObject, TKey}(IObservableCache{TObject, TKey}, TKey)"/>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
+    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
+    /// <remarks>This overload extends <see cref="IObservable{T}">IObservable</see>&lt;<see cref="IChangeSet{TObject, TKey}"/>&gt; instead of <see cref="IObservableCache{TObject, TKey}"/>.</remarks>
+    public static IObservable<TObject> WatchValue<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Watch(key).Select(u => u.Current);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WhenAnyPropertyChanged.cs b/src/DynamicData/Cache/ObservableCacheEx.WhenAnyPropertyChanged.cs
new file mode 100644
index 000000000..15c3196dc
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WhenAnyPropertyChanged.cs
@@ -0,0 +1,65 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Emits an item whenever any of its properties change via <see cref="INotifyPropertyChanged"/>.
+    /// Subscribes to PropertyChanged on each cache item using MergeMany.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe property changes on items in.</param>
+    /// <param name="propertiesToMonitor">The specific property names to monitor.  If empty, all property changes trigger emissions.</param>
+    /// <returns>An observable that emits the item itself each time a monitored property changes.</returns>
+    /// <remarks>
+    /// <para>
+    /// Subscriptions are managed per item: created on Add, replaced on Update, disposed on Remove.
+    /// Errors from individual property subscriptions are silently ignored. The output is not a changeset
+    /// stream; it is a plain <c>IObservable&lt;TObject?&gt;</c>. If the same item changes multiple properties
+    /// rapidly, each change emits the item separately (no deduplication).
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Subscribes to PropertyChanged on the new item.</description></item>
+    /// <item><term>Update</term><description>Disposes the old item's subscription and subscribes to the new item.</description></item>
+    /// <item><term>Remove</term><description>Disposes the item's PropertyChanged subscription.</description></item>
+    /// <item><term>Refresh</term><description>No effect on subscriptions.</description></item>
+    /// <item><term>OnError</term><description>Errors from individual property subscriptions are silently ignored. Source errors terminate the stream.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="WhenPropertyChanged{TObject, TKey, TValue}"/>
+    /// <seealso cref="WhenValueChanged{TObject, TKey, TValue}"/>
+    /// <seealso cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableListEx.WhenAnyPropertyChanged"/>
+    public static IObservable<TObject?> WhenAnyPropertyChanged<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params string[] propertiesToMonitor)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.MergeMany(t => t.WhenAnyPropertyChanged(propertiesToMonitor));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WhenPropertyChanged.cs b/src/DynamicData/Cache/ObservableCacheEx.WhenPropertyChanged.cs
new file mode 100644
index 000000000..9efbb2791
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WhenPropertyChanged.cs
@@ -0,0 +1,64 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Emits a <see cref="PropertyValue{TObject, TValue}"/> (item + property value) whenever the specified property
+    /// changes on any item in the cache. Subscribes via <see cref="INotifyPropertyChanged"/> using MergeMany.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the monitored property.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe a specific property on items in.</param>
+    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that expression selecting the property to monitor.</param>
+    /// <param name="notifyOnInitialValue">When <see langword="true"/> (the default), the current property value is emitted immediately for each item upon subscription.</param>
+    /// <returns>An observable of <see cref="PropertyValue{TObject, TValue}"/> containing both the item and its property value.</returns>
+    /// <remarks>
+    /// <para>
+    /// Per-item subscriptions are created on Add, replaced on Update, disposed on Remove. Errors from individual
+    /// property subscriptions are silently ignored. The output is not a changeset stream. If you only need
+    /// the value (not the owning item), use <see cref="WhenValueChanged{TObject, TKey, TValue}"/> instead.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Subscribes to the specified property on the new item. If <c>notifyOnInitialValue</c> is true, the current value is emitted immediately.</description></item>
+    /// <item><term>Update</term><description>Disposes the old item's property subscription and subscribes to the new item.</description></item>
+    /// <item><term>Remove</term><description>Disposes the item's property subscription. No further emissions for this item.</description></item>
+    /// <item><term>Refresh</term><description>No effect on subscriptions. The existing property subscription continues.</description></item>
+    /// <item><term>OnError</term><description>Per-item property subscription errors are silently ignored. Source errors terminate the stream.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="ObservableListEx.WhenPropertyChanged"/>
+    public static IObservable<PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
+
+        return source.MergeMany(t => t.WhenPropertyChanged(propertyAccessor, notifyOnInitialValue));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WhenValueChanged.cs b/src/DynamicData/Cache/ObservableCacheEx.WhenValueChanged.cs
new file mode 100644
index 000000000..b27e31c4f
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WhenValueChanged.cs
@@ -0,0 +1,67 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Emits the property value whenever the specified property changes on any item in the cache.
+    /// Like <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> but emits only the value, discarding the owning item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the monitored property.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe a specific property value on items in.</param>
+    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that expression selecting the property to monitor.</param>
+    /// <param name="notifyOnInitialValue">When <see langword="true"/> (the default), the current property value is emitted immediately for each item upon subscription.</param>
+    /// <returns>An observable of property values. The owning item is not included; use <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> if you need it.</returns>
+    /// <remarks>
+    /// <para>
+    /// Per-item subscriptions are created on Add, replaced on Update, disposed on Remove. Errors from individual
+    /// property subscriptions are silently ignored. If you need to correlate a value back to its source item,
+    /// use <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> which returns a <see cref="PropertyValue{TObject, TValue}"/> pair.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Subscribes to the specified property. If <c>notifyOnInitialValue</c> is true, the current value is emitted immediately.</description></item>
+    /// <item><term>Update</term><description>Disposes the old subscription, subscribes to the new item's property.</description></item>
+    /// <item><term>Remove</term><description>Disposes the property subscription.</description></item>
+    /// <item><term>Refresh</term><description>No effect on subscriptions.</description></item>
+    /// <item><term>OnError</term><description>Per-item errors silently ignored. Source errors terminate the stream.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="WhenPropertyChanged{TObject, TKey, TValue}"/>
+    /// <seealso cref="WhenAnyPropertyChanged{TObject, TKey}"/>
+    /// <seealso cref="AutoRefresh{TObject, TKey, TProperty}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableListEx.WhenValueChanged"/>
+    public static IObservable<TValue?> WhenValueChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+        where TObject : INotifyPropertyChanged
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
+
+        return source.MergeMany(t => t.WhenChanged(propertyAccessor, notifyOnInitialValue));
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAre.cs b/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAre.cs
new file mode 100644
index 000000000..095e1ec11
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAre.cs
@@ -0,0 +1,57 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Includes changes for the specified reasons only.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by change reason.</param>
+    /// <param name="reasons">The <see cref="ChangeReason"/> values to filter by.</param>
+    /// <returns>An observable which emits a change set with items matching the reasons.</returns>
+    /// <exception cref="ArgumentNullException">reasons.</exception>
+    /// <exception cref="ArgumentException">Must select at least on reason.</exception>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes will cause memory leaks in downstream caches, since items are never cleaned up.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> WhereReasonsAre<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params ChangeReason[] reasons)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
+
+        if (reasons.Length == 0)
+        {
+            throw new ArgumentException("Must select at least one reason");
+        }
+
+        var hashed = new HashSet<ChangeReason>(reasons);
+
+        return source.Select(updates => new ChangeSet<TObject, TKey>(updates.Where(u => hashed.Contains(u.Reason)))).NotEmpty();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAreNot.cs b/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAreNot.cs
new file mode 100644
index 000000000..7f9bf5bb6
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.WhereReasonsAreNot.cs
@@ -0,0 +1,56 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Excludes updates for the specified reasons.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by excluding change reasons.</param>
+    /// <param name="reasons">The <see cref="ChangeReason"/> values to filter by.</param>
+    /// <returns>An observable which emits a change set with items not matching the reasons.</returns>
+    /// <exception cref="ArgumentNullException">reasons.</exception>
+    /// <exception cref="ArgumentException">Must select at least on reason.</exception>
+    /// <remarks>
+    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes will cause memory leaks in downstream caches, since items are never cleaned up.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> WhereReasonsAreNot<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params ChangeReason[] reasons)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
+
+        if (reasons.Length == 0)
+        {
+            throw new ArgumentException("Must select at least one reason");
+        }
+
+        var hashed = new HashSet<ChangeReason>(reasons);
+
+        return source.Select(updates => new ChangeSet<TObject, TKey>(updates.Where(u => !hashed.Contains(u.Reason)))).NotEmpty();
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.Xor.cs b/src/DynamicData/Cache/ObservableCacheEx.Xor.cs
new file mode 100644
index 000000000..8b82b1943
--- /dev/null
+++ b/src/DynamicData/Cache/ObservableCacheEx.Xor.cs
@@ -0,0 +1,132 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
+using DynamicData.Binding;
+using DynamicData.Cache;
+using DynamicData.Cache.Internal;
+
+// ReSharper disable once CheckNamespace
+
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for dynamic data.
+/// </summary>
+public static partial class ObservableCacheEx
+{
+    /// <summary>
+    /// Combines multiple changeset streams using logical XOR (symmetric difference).
+    /// An item appears downstream only if it exists in exactly one source.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
+    /// <returns>A changeset stream containing items present in exactly one source.</returns>
+    /// <remarks>
+    /// <para>
+    /// Items are tracked via reference counting. An item appears downstream only when exactly one
+    /// source holds it. Adding the same key from a second source removes it from the result;
+    /// removing from that second source restores it.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>If the key is now held by exactly one source, an <b>Add</b> is emitted. If adding causes the count to reach 2+, a <b>Remove</b> is emitted (the item is no longer exclusive).</description></item>
+    /// <item><term>Update</term><description>If the item is currently downstream (count is 1), an <b>Update</b> is emitted.</description></item>
+    /// <item><term>Remove</term><description>Reference count decremented. If the count drops to exactly 1, an <b>Add</b> is emitted (the item is now exclusive to one source). If it drops to 0, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>If the item is downstream, a <b>Refresh</b> is forwarded.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <seealso cref="ObservableListEx.Xor"/>
+    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (others is null || others.Length == 0)
+        {
+            throw new ArgumentNullException(nameof(others));
+        }
+
+        return source.Combine(CombineOperator.Xor, others);
+    }
+
+    /// <inheritdoc cref="Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
+    /// <remarks>This overload accepts a pre-built collection of sources instead of a params array.</remarks>
+    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Xor);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
+    /// Items which are only in one of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
+    /// <returns>An observable which emits a change set.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Xor);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits a change set.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Xor);
+    }
+
+    /// <summary>
+    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
+    /// Items which are in any of the sources are included in the result.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
+    /// <returns>An observable which emits a change set.</returns>
+    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Combine(CombineOperator.Xor);
+    }
+}
diff --git a/src/DynamicData/Cache/ObservableCacheEx.cs b/src/DynamicData/Cache/ObservableCacheEx.cs
index 2f91f6a87..76a0cb1f8 100644
--- a/src/DynamicData/Cache/ObservableCacheEx.cs
+++ b/src/DynamicData/Cache/ObservableCacheEx.cs
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
 // Roland Pheasant licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
@@ -17,6 +17,7 @@
 using DynamicData.Cache.Internal;
 
 // ReSharper disable once CheckNamespace
+
 namespace DynamicData;
 
 /// <summary>
@@ -25,6809 +26,4 @@ namespace DynamicData;
 public static partial class ObservableCacheEx
 {
     private const int DefaultSortResetThreshold = 100;
-    private const bool DefaultResortOnSourceRefresh = true;
-
-    /// <summary>
-    /// Injects a side effect into the changeset stream by calling <paramref name="adaptor"/>.<see cref="IChangeSetAdaptor{TObject, TKey}.Adapt(IChangeSet{TObject, TKey})"/>
-    /// for every changeset, then forwarding it downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe and adapt.</param>
-    /// <param name="adaptor">The <see cref="IChangeSetAdaptor{TObject, TKey}"/> whose Adapt method is called for each changeset.</param>
-    /// <returns>An observable that emits the same changesets as <paramref name="source"/>, after the adaptor has processed each one.</returns>
-    /// <remarks>
-    /// <para>
-    /// This is a thin wrapper around Rx's <c>Do</c> operator. The adaptor receives each changeset
-    /// as a side effect; the changeset itself is forwarded downstream unmodified.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="adaptor"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Adapt{TObject, TKey}(IObservable{ISortedChangeSet{TObject, TKey}}, ISortedChangeSetAdaptor{TObject, TKey})"/>
-    /// <seealso cref="Bind{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservableCollection{TObject}, IObservableCollectionAdaptor{TObject, TKey})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IChangeSetAdaptor<TObject, TKey> adaptor)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
-
-        return source.Do(adaptor.Adapt);
-    }
-
-    /// <inheritdoc cref="Adapt{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IChangeSetAdaptor{TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to observe and adapt.</param>
-    /// <param name="adaptor">The <see cref="ISortedChangeSetAdaptor{TObject, TKey}"/> whose Adapt method is called for each changeset.</param>
-    /// <remarks>This overload operates on <see cref="ISortedChangeSet{TObject, TKey}"/>. Delegates to Rx's <c>Do</c> operator.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, ISortedChangeSetAdaptor<TObject, TKey> adaptor)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
-
-        return source.Do(adaptor.Adapt);
-    }
-
-    /// <summary>
-    /// Adds or updates the cache with the specified item, producing a changeset with a single <b>Add</b>
-    /// (if the key is new) or <b>Update</b> (if the key already exists).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
-    /// <remarks>
-    /// <para>Convenience method that wraps a single-item mutation inside <see cref="ISourceCache{TObject,TKey}.Edit"/>.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Produced when the key does not already exist in the cache.</description></item>
-    /// <item><term>Update</term><description>Produced when the key already exists. The previous value is included in the changeset.</description></item>
-    /// <item><term>Remove</term><description>Not produced by this method.</description></item>
-    /// <item><term>Refresh</term><description>Not produced by this method.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="EditDiff{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject}, IEqualityComparer{TObject})"/>
-    /// <seealso cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.AddOrUpdate(item));
-    }
-
-    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
-    /// <param name="equalityComparer">The <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item. When equal, the update is skipped.</param>
-    /// <remarks>This overload uses <paramref name="equalityComparer"/> to suppress no-op updates when the new value equals the existing one.</remarks>
-    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item, IEqualityComparer<TObject> equalityComparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.AddOrUpdate(item, equalityComparer));
-    }
-
-    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
-    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to add or update.</param>
-    /// <remarks>Batch overload. All items are added/updated inside a single <see cref="ISourceCache{TObject,TKey}.Edit"/> call, producing one changeset.</remarks>
-    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.AddOrUpdate(items));
-    }
-
-    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to add or update items in.</param>
-    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to add or update.</param>
-    /// <param name="equalityComparer">The <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item. When equal, the update is skipped.</param>
-    /// <remarks>Batch overload with equality comparison. All items are added/updated inside a single <see cref="ISourceCache{TObject,TKey}.Edit"/> call.</remarks>
-    public static void AddOrUpdate<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items, IEqualityComparer<TObject> equalityComparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.AddOrUpdate(items, equalityComparer));
-    }
-
-    /// <inheritdoc cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> to add or update items in.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to add or update.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to associate with the item.</param>
-    /// <remarks>This overload operates on <see cref="IIntermediateCache{TObject, TKey}"/>, which requires an explicit key parameter.</remarks>
-    public static void AddOrUpdate<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, TObject item, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        item.ThrowArgumentNullExceptionIfNull(nameof(item));
-
-        source.Edit(updater => updater.AddOrUpdate(item, key));
-    }
-
-    /// <summary>
-    /// Applied a logical And operator between the collections i.e items which are in all of the
-    /// sources are included.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    /// <exception cref="ArgumentNullException">source or others.</exception>
-    /// <seealso cref="ObservableListEx.And"/>
-    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return others is null || others.Length == 0
-            ? throw new ArgumentNullException(nameof(others))
-            : source.Combine(CombineOperator.And, others);
-    }
-
-    /// <summary>
-    /// Applied a logical And operator between the collections i.e items which are in all of the sources are included.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// others.
-    /// </exception>
-    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.And);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical And operator between the items in the outer observable list.
-    /// Items which are in all of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.And);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical And operator between the items in the outer observable list.
-    /// Items which are in all of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.And);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical And operator between the items in the outer observable list.
-    /// Items which are in all of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> And<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.And);
-    }
-
-    /// <summary>
-    /// Wraps an <see cref="IObservableCache{TObject, TKey}"/> in a read-only facade, hiding the mutable API.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="IObservableCache{TObject, TKey}"/> to operate on.</param>
-    /// <returns>A read-only <see cref="IObservableCache{TObject, TKey}"/>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
-    public static IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this IObservableCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new AnonymousObservableCache<TObject, TKey>(source);
-    }
-
-    /// <summary>
-    /// Materializes a changeset stream into a queryable, read-only <see cref="IObservableCache{TObject, TKey}"/>.
-    /// The cache subscribes to the source on first access and maintains a live snapshot of all items.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a read-only cache.</param>
-    /// <param name="applyLocking">If <see langword="true"/> (default), all cache operations are synchronized. Set to <see langword="false"/> when the caller guarantees single-threaded access.</param>
-    /// <returns>A read-only observable cache that reflects the current state of the pipeline.</returns>
-    /// <remarks>
-    /// <para>
-    /// Disposing the returned cache unsubscribes from the source stream. The cache's <c>Connect()</c>
-    /// method provides a changeset stream of its own, which re-emits the current state on each new subscriber.
-    /// </para>
-    /// <para>When <paramref name="applyLocking"/> is <see langword="false"/>, a <see cref="LockFreeObservableCache{TObject, TKey}"/> is used internally.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservableCache{TObject, TKey})"/>
-    /// <seealso cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
-    public static IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, bool applyLocking = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (applyLocking)
-        {
-            return new AnonymousObservableCache<TObject, TKey>(source);
-        }
-
-        return new LockFreeObservableCache<TObject, TKey>(source);
-    }
-
-    #if SUPPORTS_ASYNC_DISPOSABLE
-    /// <summary>
-    /// <para>
-    /// Disposes items implementing <see cref="IDisposable"/> or <see cref="IAsyncDisposable"/> when they are removed or replaced,
-    /// and disposes all tracked items when the stream completes, errors, or the subscription is disposed.
-    /// </para>
-    /// <para>
-    /// Individual items are disposed <b>after</b> the changeset has been forwarded downstream, so downstream operators
-    /// see the removal before disposal occurs. Items implementing neither disposal interface are ignored.
-    /// </para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to track for async disposal on removal.</param>
-    /// <param name="disposalsCompletedAccessor">
-    /// <para>
-    /// Invoked once per subscription, providing an <see cref="IObservable{Unit}"/> that signals when all
-    /// <see cref="IAsyncDisposable.DisposeAsync()"/> calls have finished. The signal emits a single value
-    /// and then completes.
-    /// </para>
-    /// <para>
-    /// This is delivered on a separate channel from the main changeset stream so it can be observed even
-    /// if the source stream errors.
-    /// </para>
-    /// </param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Tracks the item. No disposal.</description></item>
-    ///   <item><term>Update</term><description>Disposes the <b>previous</b> value (if it differs by reference from the current). Tracks the new value.</description></item>
-    ///   <item><term>Remove</term><description>Disposes the removed item.</description></item>
-    ///   <item><term>Refresh</term><description>Passed through. No disposal.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// On stream completion, error, or subscription disposal, all items still in the cache are disposed.
-    /// <see cref="IDisposable"/> items are disposed synchronously; <see cref="IAsyncDisposable"/> items
-    /// are dispatched via the <paramref name="disposalsCompletedAccessor"/> signal.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="disposalsCompletedAccessor"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="DisposeMany{TObject,TKey}"/>
-    public static IObservable<IChangeSet<TObject, TKey>> AsyncDisposeMany<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Action<IObservable<Unit>> disposalsCompletedAccessor)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.AsyncDisposeMany<TObject, TKey>.Create(
-            source: source,
-            disposalsCompletedAccessor: disposalsCompletedAccessor);
-    #endif
-
-    /// <summary>
-    /// Automatically refresh downstream operators when any properties change.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for property-driven refresh signals.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements have successive property changes.</param>
-    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications, preventing excessive refresh invocations.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable change set with additional refresh changes.</returns>
-    /// <seealso cref="ObservableListEx.AutoRefresh"/>
-    public static IObservable<IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.AutoRefreshOnObservable(
-            (t, _) =>
-            {
-                if (propertyChangeThrottle is null)
-                {
-                    return t.WhenAnyPropertyChanged();
-                }
-
-                return t.WhenAnyPropertyChanged().Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
-            },
-            changeSetBuffer,
-            scheduler);
-    }
-
-    /// <summary>
-    /// Automatically refresh downstream operators when properties change.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <typeparam name="TProperty">The type of the property.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for property-driven refresh signals.</param>
-    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that specify a property to observe changes. When it changes a Refresh is invoked.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements have successive property changes.</param>
-    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications, preventing excessive refresh invocations.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable change set with additional refresh changes.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey, TProperty>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TProperty>> propertyAccessor, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.AutoRefreshOnObservable(
-            (t, _) =>
-            {
-                if (propertyChangeThrottle is null)
-                {
-                    return t.WhenPropertyChanged(propertyAccessor, false);
-                }
-
-                return t.WhenPropertyChanged(propertyAccessor, false).Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
-            },
-            changeSetBuffer,
-            scheduler);
-    }
-
-    /// <summary>
-    /// Automatically refresh downstream operator. The refresh is triggered when the observable receives a notification.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <typeparam name="TAny">The type of evaluation.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for observable-driven refresh signals.</param>
-    /// <param name="reevaluator">The <see cref="Func{TObject, IObservable{TAny}}"/> observable which acts on items within the collection and produces a value when the item should be refreshed.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements require a refresh.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable change set with additional refresh changes.</returns>
-    /// <seealso cref="ObservableListEx.AutoRefreshOnObservable"/>
-    public static IObservable<IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => source.AutoRefreshOnObservable((t, _) => reevaluator(t), changeSetBuffer, scheduler);
-
-    /// <summary>
-    /// Automatically refresh downstream operator. The refresh is triggered when the observable receives a notification.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <typeparam name="TAny">The type of evaluation.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to monitor for observable-driven refresh signals.</param>
-    /// <param name="reevaluator">The <see cref="Func{TObject, TKey, IObservable{TAny}}"/> observable which acts on items within the collection and produces a value when the item should be refreshed.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration. Batches multiple refresh signals into a single changeset, improving performance when many elements change in quick succession. This greatly increases performance when many elements require a refresh.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable change set with additional refresh changes.</returns>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> Per-item observable errors are silently ignored (not forwarded to the downstream observer). Only source stream errors propagate.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        reevaluator.ThrowArgumentNullExceptionIfNull(nameof(reevaluator));
-
-        return new AutoRefresh<TObject, TKey, TAny>(source, reevaluator, changeSetBuffer, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Collects changesets emitted within a time window and merges them into a single changeset.
-    /// Uses Rx's <c>Buffer</c> operator followed by <see cref="FlattenBufferResult{TObject, TKey}"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to batch.</param>
-    /// <param name="timeSpan">The <see cref="TimeSpan"/> time window for batching.</param>
-    /// <param name="scheduler">The scheduler for timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>An observable that emits merged changesets, one per time window.</returns>
-    /// <remarks>
-    /// <para>
-    /// All changesets received during the time window are concatenated into a single changeset.
-    /// This is useful for reducing UI update frequency when the source emits many rapid changes.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Buffered and included in the merged changeset at the end of the time window.</description></item>
-    /// <item><term>Update</term><description>Buffered and included in the merged changeset.</description></item>
-    /// <item><term>Remove</term><description>Buffered and included in the merged changeset.</description></item>
-    /// <item><term>Refresh</term><description>Buffered and included in the merged changeset.</description></item>
-    /// <item><term>OnCompleted</term><description>Any remaining buffered changes are flushed, then completion is forwarded.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> The merged changeset may contain contradictory changes (e.g., Add then Remove for the same key). Downstream operators handle this correctly, but raw inspection of the changeset may be surprising.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="BufferInitial{TObject, TKey}"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Batch<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan timeSpan, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Buffer(timeSpan, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult();
-    }
-
-    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>This overload delegates to the primary overload with <c>initialPauseState: false</c>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => BatchIf(source, pauseIfTrueSelector, false, scheduler);
-
-    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>This overload delegates to the primary overload with default <c>initialPauseState: false</c>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, null, initialPauseState, scheduler: scheduler).Run();
-
-    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>This overload omits <c>initialPauseState</c> (defaults to <see langword="false"/>) but accepts a timeout.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, TimeSpan? timeOut = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => BatchIf(source, pauseIfTrueSelector, false, timeOut, scheduler);
-
-    /// <summary>
-    /// Conditionally buffers changesets while a pause signal is active, then flushes all buffered
-    /// changes as a single merged changeset when the signal resumes.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to conditionally buffer.</param>
-    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> that when <see langword="true"/>, buffering begins. When <see langword="false"/>, the buffer is flushed.</param>
-    /// <param name="initialPauseState">If <see langword="true"/>, starts in a paused (buffering) state.</param>
-    /// <param name="timeOut">A <see cref="TimeSpan"/> that maximum time the buffer stays open. When elapsed, the buffer is flushed regardless of pause state.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> for timeout timing.</param>
-    /// <returns>An observable that emits changesets, buffered or passthrough depending on pause state.</returns>
-    /// <remarks>
-    /// <para>
-    /// While paused, incoming changesets are accumulated. On resume (or timeout), all buffered changesets
-    /// are merged into a single changeset and emitted. While not paused, changesets pass through immediately.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Buffered while paused; forwarded immediately while active.</description></item>
-    /// <item><term>Update</term><description>Buffered while paused; forwarded immediately while active.</description></item>
-    /// <item><term>Remove</term><description>Buffered while paused; forwarded immediately while active.</description></item>
-    /// <item><term>Refresh</term><description>Buffered while paused; forwarded immediately while active.</description></item>
-    /// <item><term>OnError</term><description>Buffered data is lost.</description></item>
-    /// <item><term>OnCompleted</term><description>Any remaining buffered data is flushed before completion.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> If the source completes while paused, buffered data IS flushed before OnCompleted. However, if the source errors while paused, buffered data is lost.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pauseIfTrueSelector"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Batch{TObject, TKey}"/>
-    /// <seealso cref="BufferInitial{TObject, TKey}"/>
-    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, TimeSpan? timeOut = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
-
-        return new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, timeOut, initialPauseState, scheduler: scheduler).Run();
-    }
-
-    /// <inheritdoc cref="BatchIf{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to conditionally buffer.</param>
-    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> that controls buffering: <see langword="true"/> begins buffering, <see langword="false"/> flushes the buffer.</param>
-    /// <param name="initialPauseState">If <see langword="true"/>, starts in a paused (buffering) state.</param>
-    /// <param name="timer">An optional <see cref="IObservable{Unit}"/> timer. The buffer is flushed each time the timer produces a value, and buffering ceases when it completes.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <remarks>This overload accepts an explicit timer observable instead of a <see cref="TimeSpan"/> timeout.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, IObservable<Unit>? timer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => new BatchIf<TObject, TKey>(source, pauseIfTrueSelector, null, initialPauseState, timer, scheduler).Run();
-
-    /// <summary>
-    ///  Binds the results to the specified observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <param name="refreshThreshold">The number of changes before a reset notification is triggered.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    /// <seealso cref="ObservableListEx.Bind"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, int refreshThreshold = BindingOptions.DefaultResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        // if user has not specified different defaults, use system wide defaults instead.
-        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
-        var defaults = DynamicDataOptions.Binding;
-
-        var options = refreshThreshold == BindingOptions.DefaultResetThreshold
-            ? defaults
-            : defaults with { ResetThreshold = refreshThreshold };
-
-        return source?.Bind(destination, new ObservableCollectionAdaptor<TObject, TKey>(options)) ?? throw new ArgumentNullException(nameof(source));
-    }
-
-    /// <summary>
-    ///  Binds the results to the specified observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, BindingOptions options)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source?.Bind(destination, new ObservableCollectionAdaptor<TObject, TKey>(options)) ?? throw new ArgumentNullException(nameof(source));
-    }
-
-    /// <summary>
-    /// Binds the results to the specified binding collection using the specified update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <param name="updater">The <see cref="IObservableCollectionAdaptor{TObject, TKey}"/> that applies changes to the bound collection.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, IObservableCollectionAdaptor<TObject, TKey> updater)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-        updater.ThrowArgumentNullExceptionIfNull(nameof(updater));
-
-        return Observable.Create<IChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                var locker = InternalEx.NewLock();
-                return source.Synchronize(locker).Select(
-                    changes =>
-                    {
-                        updater.Adapt(changes, destination);
-                        return changes;
-                    }).SubscribeSafe(observer);
-            });
-    }
-
-    /// <summary>
-    /// Binds the results to the specified readonly observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
-    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, BindingOptions options)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        var target = new ObservableCollectionExtended<TObject>();
-        readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
-        return source.Bind(target, new ObservableCollectionAdaptor<TObject, TKey>(options));
-    }
-
-    /// <summary>
-    /// Binds the results to the specified readonly observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
-    /// <param name="resetThreshold">The number of changes before a reset notification is triggered.</param>
-    /// <param name="useReplaceForUpdates">When <see langword="true"/>, uses Replace instead of Remove/Add for updates in the bound collection. Not all platforms support replace notifications.</param>
-    /// <param name="adaptor">An optional <see cref="IObservableCollectionAdaptor{TObject, TKey}"/> that controls how the target collection is updated.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold, bool useReplaceForUpdates = BindingOptions.DefaultUseReplaceForUpdates, IObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (adaptor is not null)
-        {
-            var target = new ObservableCollectionExtended<TObject>();
-            readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
-            return source.Bind(target, adaptor);
-        }
-
-        // if user has not specified different defaults, use system wide defaults instead.
-        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
-        var defaults = DynamicDataOptions.Binding;
-
-        var options = resetThreshold == BindingOptions.DefaultResetThreshold && useReplaceForUpdates == BindingOptions.DefaultUseReplaceForUpdates
-            ? defaults
-            : defaults with { ResetThreshold = resetThreshold, UseReplaceForUpdates = useReplaceForUpdates };
-
-        return source.Bind(out readOnlyObservableCollection, options);
-    }
-
-    /// <summary>
-    ///  Binds the results to the specified observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source.Bind(destination, DynamicDataOptions.Binding);
-    }
-
-    /// <summary>
-    ///  Binds the results to the specified observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, BindingOptions options)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        var updater = new SortedObservableCollectionAdaptor<TObject, TKey>(options);
-        return source.Bind(destination, updater);
-    }
-
-    /// <summary>
-    /// Binds the results to the specified binding collection using the specified update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="destination">The <see cref="IObservableCollection{TObject}"/> that will receive the changes.</param>
-    /// <param name="updater">The <see cref="ISortedObservableCollectionAdaptor{TObject, TKey}"/> that applies changes to the bound collection.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, IObservableCollection<TObject> destination, ISortedObservableCollectionAdaptor<TObject, TKey> updater)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-        updater.ThrowArgumentNullExceptionIfNull(nameof(updater));
-
-        return Observable.Create<ISortedChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                var locker = InternalEx.NewLock();
-                return source.Synchronize(locker).Select(
-                    changes =>
-                    {
-                        updater.Adapt(changes, destination);
-                        return changes;
-                    }).SubscribeSafe(observer);
-            });
-    }
-
-    /// <summary>
-    /// Binds the results to the specified readonly observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
-    /// <param name="options">The <see cref="BindingOptions"/> that controls binding behavior.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, BindingOptions options)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        var target = new ObservableCollectionExtended<TObject>();
-        var result = new ReadOnlyObservableCollection<TObject>(target);
-        var updater = new SortedObservableCollectionAdaptor<TObject, TKey>(options);
-        readOnlyObservableCollection = result;
-        return source.Bind(target, updater);
-    }
-
-    /// <summary>
-    /// Binds the results to the specified readonly observable collection using the default update algorithm.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="readOnlyObservableCollection">The output <see cref="ReadOnlyObservableCollection{TObject}"/> that will be populated with the results.</param>
-    /// <param name="resetThreshold">The number of changes before a reset event is called on the observable collection.</param>
-    /// <param name="useReplaceForUpdates">When <see langword="true"/>, uses Replace instead of Remove/Add for updates in the bound collection. Not all platforms support replace notifications.</param>
-    /// <param name="adaptor">An <see cref="IChangeSetAdaptor{TObject, TKey}"/> that specify an adaptor to change the algorithm to update the target collection.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, out ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold, bool useReplaceForUpdates = BindingOptions.DefaultUseReplaceForUpdates, ISortedObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        // if user has not specified different defaults, use system wide defaults instead.
-        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
-        var defaults = DynamicDataOptions.Binding;
-        var options = resetThreshold == BindingOptions.DefaultResetThreshold && useReplaceForUpdates == BindingOptions.DefaultUseReplaceForUpdates
-            ? defaults
-            : defaults with { ResetThreshold = resetThreshold, UseReplaceForUpdates = useReplaceForUpdates };
-
-        adaptor ??= new SortedObservableCollectionAdaptor<TObject, TKey>(options);
-
-        var target = new ObservableCollectionExtended<TObject>();
-        readOnlyObservableCollection = new ReadOnlyObservableCollection<TObject>(target);
-        return source.Bind(target, adaptor);
-    }
-
-#if SUPPORTS_BINDINGLIST
-
-    /// <summary>
-    /// Binds a clone of the observable change set to the target observable collection.
-    /// </summary>
-    /// <typeparam name="TObject">The object type.</typeparam>
-    /// <typeparam name="TKey">The key type.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="bindingList">The <see cref="BindingList{TObject}"/> that will receive the changes.</param>
-    /// <param name="resetThreshold">The reset threshold.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// targetCollection.
-    /// </exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, BindingList<TObject> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
-
-        return source.Adapt(new BindingListAdaptor<TObject, TKey>(bindingList, resetThreshold));
-    }
-
-    /// <summary>
-    /// Binds a clone of the observable change set to the target observable collection.
-    /// </summary>
-    /// <typeparam name="TObject">The object type.</typeparam>
-    /// <typeparam name="TKey">The key type.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to bind to a collection.</param>
-    /// <param name="bindingList">The <see cref="BindingList{TObject}"/> that will receive the changes.</param>
-    /// <param name="resetThreshold">The reset threshold.</param>
-    /// <returns>An observable which will emit change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// targetCollection.
-    /// </exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source, BindingList<TObject> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
-
-        return source.Adapt(new SortedBindingListAdaptor<TObject, TKey>(bindingList, resetThreshold));
-    }
-
-#endif
-
-    /// <summary>
-    /// Buffers the initial burst of changesets for the specified duration, merges them into a single
-    /// changeset, then passes all subsequent changesets through without buffering.
-    /// </summary>
-    /// <typeparam name="TObject">The object type.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to buffer during the initial loading period.</param>
-    /// <param name="initialBuffer">The <see cref="TimeSpan"/> time window to buffer, measured from when the first changeset arrives.</param>
-    /// <param name="scheduler">The scheduler for timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>An observable that emits one merged changeset for the initial burst, then passthrough for the rest.</returns>
-    /// <remarks>
-    /// <para>
-    /// Useful for aggregating the initial snapshot (which may arrive as many small changesets) into a
-    /// single changeset for efficient downstream processing, while leaving subsequent live updates untouched.
-    /// </para>
-    /// <para>Internally uses <see cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>, Rx <c>Buffer</c>, and <see cref="FlattenBufferResult{TObject, TKey}"/>.</para>
-    /// </remarks>
-    /// <seealso cref="Batch{TObject, TKey}"/>
-    /// <seealso cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> BufferInitial<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TimeSpan initialBuffer, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull => source.DeferUntilLoaded().Publish(
-            shared =>
-            {
-                var initial = shared.Buffer(initialBuffer, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult().Take(1);
-
-                return initial.Concat(shared);
-            });
-
-    /// <summary>
-    /// Casts each item in the changeset to a new type using the provided converter function.
-    /// Equivalent to <see cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/>
-    /// but named for discoverability when a simple type cast or conversion is needed.
-    /// </summary>
-    /// <typeparam name="TSource">The type of the source object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to cast.</param>
-    /// <param name="converter">The <see cref="Func{TSource, TDestination}"/> conversion function applied to each item.</param>
-    /// <returns>An observable changeset of converted items.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Calls <paramref name="converter"/> and emits an <b>Add</b> with the converted item.</description></item>
-    /// <item><term>Update</term><description>Calls <paramref name="converter"/> on the new value and emits an <b>Update</b>.</description></item>
-    /// <item><term>Remove</term><description>Emits a <b>Remove</b>. The converter is not called.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b>. The converter is not called.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="OfType{TObject, TKey, TDestination}"/>
-    public static IObservable<IChangeSet<TDestination, TKey>> Cast<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> converter)
-        where TSource : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new Cast<TSource, TKey, TDestination>(source, converter).Run();
-    }
-
-    /// <summary>
-    /// Re-keys each item in the changeset by applying <paramref name="keySelector"/> to the current item.
-    /// The original change reason is preserved; only the key is remapped.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TSourceKey">The type of the source key.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the destination key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TSourceKey}}"/> to re-key.</param>
-    /// <param name="keySelector">The <see cref="Func{TObject, TDestinationKey}"/> that computes the destination key from the item, e.g. <c>(item) =&gt; item.NewId</c>.</param>
-    /// <returns>An observable changeset with items re-keyed using <paramref name="keySelector"/>.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description><paramref name="keySelector"/> is called on the item. An <b>Add</b> is emitted with the destination key.</description></item>
-    /// <item><term>Update</term><description><paramref name="keySelector"/> is called on the current item. An <b>Update</b> is emitted with the destination key. If the key selector produces a different destination key for the updated value than it did for the original value, downstream consumers will see an <b>Update</b> for a key that may not match the original <b>Add</b>.</description></item>
-    /// <item><term>Remove</term><description><paramref name="keySelector"/> is called on the item. A <b>Remove</b> is emitted with the destination key.</description></item>
-    /// <item><term>Refresh</term><description><paramref name="keySelector"/> is called on the item. A <b>Refresh</b> is emitted with the destination key.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/>
-    public static IObservable<IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this IObservable<IChangeSet<TObject, TSourceKey>> source, Func<TObject, TDestinationKey> keySelector)
-        where TObject : notnull
-        where TSourceKey : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return source.Select(
-            updates =>
-            {
-                var changed = updates.Select(u => new Change<TObject, TDestinationKey>(u.Reason, keySelector(u.Current), u.Current, u.Previous));
-                return new ChangeSet<TObject, TDestinationKey>(changed);
-            });
-    }
-
-    /// <inheritdoc cref="ChangeKey{TObject, TSourceKey, TDestinationKey}(IObservable{IChangeSet{TObject, TSourceKey}}, Func{TObject, TDestinationKey})"/>
-    /// <remarks>
-    /// This overload also provides the source key to <paramref name="keySelector"/>,
-    /// allowing the destination key to be derived from both the item and its original key.
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this IObservable<IChangeSet<TObject, TSourceKey>> source, Func<TSourceKey, TObject, TDestinationKey> keySelector)
-        where TObject : notnull
-        where TSourceKey : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return source.Select(
-            updates =>
-            {
-                var changed = updates.Select(u => new Change<TObject, TDestinationKey>(u.Reason, keySelector(u.Key, u.Current), u.Current, u.Previous));
-                return new ChangeSet<TObject, TDestinationKey>(changed);
-            });
-    }
-
-    /// <summary>
-    /// Removes all items from the cache, producing a changeset with a <b>Remove</b> for every item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to clear.</param>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Not produced by this operation.</description></item>
-    /// <item><term>Update</term><description>Not produced by this operation.</description></item>
-    /// <item><term>Remove</term><description>A <b>Remove</b> is emitted for every item currently in the cache.</description></item>
-    /// <item><term>Refresh</term><description>Not produced by this operation.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Clear<TObject, TKey>(this ISourceCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Clear());
-    }
-
-    /// <inheritdoc cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
-    public static void Clear<TObject, TKey>(this IIntermediateCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Clear());
-    }
-
-    /// <inheritdoc cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
-    public static void Clear<TObject, TKey>(this LockFreeObservableCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        source.Edit(updater => updater.Clear());
-    }
-
-    /// <summary>
-    /// Applies each change from the source changeset to the specified <paramref name="target"/> collection as a side effect.
-    /// The changeset is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to clone.</param>
-    /// <param name="target">The <see cref="ICollection{TObject}"/> target collection to which changes are applied.</param>
-    /// <returns>An observable that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The item is added to <paramref name="target"/>. Forwarded as <b>Add</b>.</description></item>
-    /// <item><term>Update</term><description>The previous item is removed from <paramref name="target"/> and the current item is added. Forwarded as <b>Update</b>.</description></item>
-    /// <item><term>Remove</term><description>The item is removed from <paramref name="target"/>. Forwarded as <b>Remove</b>.</description></item>
-    /// <item><term>Refresh</term><description>Ignored (<see cref="ICollection{T}"/> has no concept of refresh). Forwarded as <b>Refresh</b>.</description></item>
-    /// </list>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Clone<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ICollection<TObject> target)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        target.ThrowArgumentNullExceptionIfNull(nameof(target));
-
-        return source.Do(
-            changes =>
-            {
-                foreach (var item in changes.ToConcreteType())
-                {
-                    switch (item.Reason)
-                    {
-                        case ChangeReason.Add:
-                            {
-                                target.Add(item.Current);
-                            }
-
-                            break;
-
-                        case ChangeReason.Update:
-                            {
-                                target.Remove(item.Previous.Value);
-                                target.Add(item.Current);
-                            }
-
-                            break;
-
-                        case ChangeReason.Remove:
-                            target.Remove(item.Current);
-                            break;
-                    }
-                }
-            });
-    }
-
-    /// <summary>
-    /// Obsolete: use <see cref="Transform{TDestination, TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TDestination}, bool)"/> instead.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to convert.</param>
-    /// <param name="conversionFactory">The <see cref="Func{TObject, TDestination}"/> conversion factory.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    [Obsolete("This was an experiment that did not work. Use Transform instead")]
-    public static IObservable<IChangeSet<TDestination, TKey>> Convert<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TDestination> conversionFactory)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
-
-        return source.Select(
-            changes =>
-            {
-                var transformed = changes.Select(change => new Change<TDestination, TKey>(change.Reason, change.Key, conversionFactory(change.Current), change.Previous.Convert(conversionFactory), change.CurrentIndex, change.PreviousIndex));
-                return new ChangeSet<TDestination, TKey>(transformed);
-            });
-    }
-
-    /// <summary>
-    /// Suppresses all emissions until the first non-empty changeset arrives, then replays that changeset and all subsequent ones.
-    /// If the source never produces a non-empty changeset, the stream waits indefinitely.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to defer until the first changeset arrives.</param>
-    /// <returns>An observable that begins emitting changesets once the first non-empty changeset is received.</returns>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> Blocks indefinitely if the cache or stream never receives any data. Ensure the source will eventually emit at least one changeset.</para>
-    /// </remarks>
-    /// <seealso cref="SkipInitial{TObject, TKey}"/>
-    public static IObservable<IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DeferUntilLoaded<TObject, TKey>(source).Run();
-    }
-
-    /// <inheritdoc cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this IObservableCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DeferUntilLoaded<TObject, TKey>(source).Run();
-    }
-
-    /// <summary>
-    /// <para>
-    /// Disposes items implementing <see cref="IDisposable"/> when they are removed or replaced,
-    /// and disposes all tracked items when the stream completes, errors, or the subscription is disposed.
-    /// </para>
-    /// <para>
-    /// Individual items are disposed <b>after</b> the changeset has been forwarded downstream, so downstream operators
-    /// see the removal before disposal occurs. Items that do not implement <see cref="IDisposable"/> are ignored.
-    /// </para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to track for disposal on removal.</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Tracks the item. No disposal.</description></item>
-    ///   <item><term>Update</term><description>Disposes the <b>previous</b> value (if it differs by reference from the current). Tracks the new value.</description></item>
-    ///   <item><term>Remove</term><description>Disposes the removed item.</description></item>
-    ///   <item><term>Refresh</term><description>Passed through. No disposal.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// On stream completion, error, or subscription disposal, all remaining tracked items are disposed.
-    /// All disposal is synchronous via <see cref="IDisposable.Dispose()"/>.
-    /// For items that implement <see cref="IAsyncDisposable"/>, use <see cref="AsyncDisposeMany{TObject,TKey}"/> instead.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AsyncDisposeMany{TObject,TKey}"/>
-    /// <seealso cref="SubscribeMany{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
-    /// <seealso cref="ObservableListEx.DisposeMany"/>
-    public static IObservable<IChangeSet<TObject, TKey>> DisposeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DisposeMany<TObject, TKey>(source).Run();
-    }
-
-    /// <summary>
-    ///     Selects distinct values from the source.
-    /// </summary>
-    /// <typeparam name="TObject">The type object from which the distinct values are selected.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the value.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to extract distinct values.</param>
-    /// <param name="valueSelector">The <see cref="Func{TObject, TValue}"/> value selector.</param>
-    /// <returns>An observable which will emit distinct change sets.</returns>
-    /// <remarks>
-    /// Due to it's nature only adds or removes can be returned.
-    /// <para><b>Worth noting:</b> Reference counting assumes value equality is transitive. Mutable value objects with inconsistent <c>Equals</c> implementations can corrupt ref counts.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    /// <seealso cref="ObservableListEx.DistinctValues"/>
-    public static IObservable<IDistinctChangeSet<TValue>> DistinctValues<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TValue> valueSelector)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        valueSelector.ThrowArgumentNullExceptionIfNull(nameof(valueSelector));
-
-        return Observable.Create<IDistinctChangeSet<TValue>>(observer => new DistinctCalculator<TObject, TKey, TValue>(source, valueSelector).Run().SubscribeSafe(observer));
-    }
-
-    /// <inheritdoc cref="EditDiff{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject}, Func{TObject, TObject, bool})"/>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to diff and update.</param>
-    /// <param name="allItems">The <see cref="IEnumerable{TObject}"/> representing the complete desired state to diff against the cache.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> used to determine whether a new item is the same as an existing cached item.</param>
-    /// <remarks>
-    /// This overload uses an <see cref="IEqualityComparer{T}"/> instead of a <see cref="Func{T, T, TResult}"/> delegate
-    /// to determine item equality.
-    /// </remarks>
-    public static void EditDiff<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> allItems, IEqualityComparer<TObject> equalityComparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        allItems.ThrowArgumentNullExceptionIfNull(nameof(allItems));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-
-        source.EditDiff(allItems, equalityComparer.Equals);
-    }
-
-    /// <summary>
-    /// Diffs a complete snapshot of items against the current cache contents, producing the minimal set of
-    /// Add, Update, and Remove changes needed to bring the cache in sync with the snapshot.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to diff and update.</param>
-    /// <param name="allItems">The <see cref="IEnumerable{TObject}"/> representing the complete desired state.</param>
-    /// <param name="areItemsEqual">The <see cref="Func{TObject, TObject, bool}"/> that returns <see langword="true"/> when the current and previous items are considered equal, e.g. <c>(current, previous) =&gt; current.Version == previous.Version</c>.</param>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Items in <paramref name="allItems"/> whose key is not in the cache produce an <b>Add</b>.</description></item>
-    /// <item><term>Update</term><description>Items present in both <paramref name="allItems"/> and the cache that differ (per <paramref name="areItemsEqual"/>) produce an <b>Update</b>.</description></item>
-    /// <item><term>Remove</term><description>Items in the cache whose key is not in <paramref name="allItems"/> produce a <b>Remove</b>.</description></item>
-    /// <item><term>Refresh</term><description>Not produced by this operation.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="allItems"/>, or <paramref name="areItemsEqual"/> is <see langword="null"/>.</exception>
-    public static void EditDiff<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> allItems, Func<TObject, TObject, bool> areItemsEqual)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        allItems.ThrowArgumentNullExceptionIfNull(nameof(allItems));
-        areItemsEqual.ThrowArgumentNullExceptionIfNull(nameof(areItemsEqual));
-
-        var editDiff = new EditDiff<TObject, TKey>(source, areItemsEqual);
-        editDiff.Edit(allItems);
-    }
-
-    /// <summary>
-    /// Converts an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> into a changeset stream by diffing each
-    /// emission against the previous one. Each emission replaces the entire dataset.
-    /// Counterpart to <see cref="ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{TObject}}"/> to convert into a keyed changeset stream.</param>
-    /// <param name="keySelector">The <see cref="Func{TObject, TKey}"/> that extracts the unique key from each item.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> for comparing items. Uses default equality if <see langword="null"/>.</param>
-    /// <returns>An observable changeset representing the incremental differences between successive snapshots.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Items in the new snapshot whose key was not in the previous snapshot produce an <b>Add</b>.</description></item>
-    /// <item><term>Update</term><description>Items present in both snapshots that differ (per <paramref name="equalityComparer"/>) produce an <b>Update</b>.</description></item>
-    /// <item><term>Remove</term><description>Items in the previous snapshot whose key is absent from the new snapshot produce a <b>Remove</b>.</description></item>
-    /// <item><term>Refresh</term><description>Not produced by this operator.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this IObservable<IEnumerable<TObject>> source, Func<TObject, TKey> keySelector, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return new EditDiffChangeSet<TObject, TKey>(source, keySelector, equalityComparer).Run();
-    }
-
-    /// <summary>
-    /// Converts an <see cref="IObservable{T}"/> of <see cref="Optional{T}"/> into a changeset stream that tracks
-    /// a single item: <c>Some</c> produces an <b>Add</b> or <b>Update</b>, and <c>None</c> produces a <b>Remove</b>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{Optional{TObject}}"/> to convert into a keyed changeset stream.</param>
-    /// <param name="keySelector">The <see cref="Func{TObject, TKey}"/> that extracts the unique key from each item.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> for comparing items. Uses default equality if <see langword="null"/>.</param>
-    /// <returns>An observable changeset tracking the single optional item.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Emitted when the source produces <c>Some(value)</c> and no item was previously tracked.</description></item>
-    /// <item><term>Update</term><description>Emitted when the source produces <c>Some(value)</c> and an item was already tracked with a different value (per <paramref name="equalityComparer"/>).</description></item>
-    /// <item><term>Remove</term><description>Emitted when the source produces <c>None</c> and an item was previously tracked.</description></item>
-    /// <item><term>Refresh</term><description>Not produced by this operator.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this IObservable<Optional<TObject>> source, Func<TObject, TKey> keySelector, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return new EditDiffChangeSetOptional<TObject, TKey>(source, keySelector, equalityComparer).Run();
-    }
-
-    /// <summary>
-    /// Validates that each changeset contains no duplicate keys.
-    /// If duplicates are detected, an <see cref="InvalidOperationException"/> is emitted via <c>OnError</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to validate for unique keys.</param>
-    /// <returns>A changeset stream guaranteed to contain unique keys per changeset.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Forwarded as <b>Add</b> if the key is unique within the changeset.</description></item>
-    /// <item><term>Update</term><description>Forwarded as <b>Update</b> if the key is unique within the changeset.</description></item>
-    /// <item><term>Remove</term><description>Forwarded as <b>Remove</b> if the key is unique within the changeset.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the key is unique within the changeset.</description></item>
-    /// <item><term>OnError</term><description>Also emitted with <see cref="InvalidOperationException"/> if duplicate keys are detected in a changeset.</description></item>
-    /// </list>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> EnsureUniqueKeys<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new UniquenessEnforcer<TObject, TKey>(source).Run();
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Except operator between the collections
-    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// others.
-    /// </exception>
-    /// <seealso cref="ObservableListEx.Except"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (others is null || others.Length == 0)
-        {
-            throw new ArgumentNullException(nameof(others));
-        }
-
-        return source.Combine(CombineOperator.Except, others);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Except operator between the collections
-    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// others.
-    /// </exception>
-    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Except);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Except operator between the collections
-    /// Items from the first collection in the outer list are included unless contained in any of the other lists.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Except);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Except operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Except);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Except operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Except<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Except);
-    }
-
-    /// <summary>
-    /// Schedules automatic removal of items after the timeout returned by <paramref name="timeSelector"/>.
-    /// If <paramref name="timeSelector"/> returns <see langword="null"/>, the item never expires.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
-    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
-    /// <returns>An observable changeset that includes timer-driven <b>Remove</b> changes for expired items.</returns>
-    /// <remarks>
-    /// <para>When a timer fires, a <b>Remove</b> is emitted for the expired item.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Schedules a removal timer based on <paramref name="timeSelector"/>. Forwarded as <b>Add</b>.</description></item>
-    /// <item><term>Update</term><description>Resets the removal timer for the item. Forwarded as <b>Update</b>.</description></item>
-    /// <item><term>Remove</term><description>Cancels the removal timer. Forwarded as <b>Remove</b>.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b>. No timer change.</description></item>
-    /// <item><term>OnError</term><description>All pending timers are cancelled.</description></item>
-    /// <item><term>OnCompleted</term><description>All pending timers are cancelled.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> A <see langword="null"/> return from <paramref name="timeSelector"/> means "never expire". <b>Update</b> changes reset the expiration timer.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="timeSelector"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Func<TObject, TimeSpan?> timeSelector)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
-            source: source,
-            timeSelector: timeSelector);
-
-    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
-    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used to schedule expiration timers.</param>
-    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Func<TObject, TimeSpan?> timeSelector,
-                IScheduler scheduler)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
-            source: source,
-            timeSelector: timeSelector,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
-    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
-    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> polling interval. If specified, items are expired on a polling interval rather than per-item timers. Less accurate but more efficient when many items share similar expiration times.</param>
-    /// <remarks>
-    /// This overload uses periodic polling instead of per-item timers. Expired items are removed on the next
-    /// poll after their timeout elapses, which trades accuracy for reduced timer overhead.
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Func<TObject, TimeSpan?> timeSelector,
-                TimeSpan? pollingInterval)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
-            source: source,
-            timeSelector: timeSelector,
-            pollingInterval: pollingInterval);
-
-    /// <inheritdoc cref="ExpireAfter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TimeSpan?}, TimeSpan?)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply time-based expiration to.</param>
-    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
-    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> if specified, items are expired on a polling interval rather than per-item timers.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used to schedule polling and expiration timers.</param>
-    public static IObservable<IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Func<TObject, TimeSpan?> timeSelector,
-                TimeSpan? pollingInterval,
-                IScheduler scheduler)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.ExpireAfter.ForStream<TObject, TKey>.Create(
-            source: source,
-            timeSelector: timeSelector,
-            pollingInterval: pollingInterval,
-            scheduler: scheduler);
-
-    /// <summary>
-    /// Automatically removes items from the <see cref="ISourceCache{TObject, TKey}"/> after the timeout returned
-    /// by <paramref name="timeSelector"/>. Returns an observable of the removed key-value pairs (not a changeset stream).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
-    /// <param name="timeSelector">An optional <see cref="Func{T, TResult}"/> that returns the expiration timeout for each item, or <see langword="null"/> for no expiration.</param>
-    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> if specified, items are expired on a polling interval rather than per-item timers.</param>
-    /// <param name="scheduler">The scheduler used to schedule expiration timers. Defaults to <see cref="GlobalConfig.DefaultScheduler"/> if <see langword="null"/>.</param>
-    /// <returns>An observable that emits the key-value pairs of items removed from the cache by expiration.</returns>
-    /// <remarks>
-    /// Unlike the stream-based overloads, this operates directly on the <see cref="ISourceCache{TObject, TKey}"/>
-    /// and returns the removed items as <see cref="KeyValuePair{TKey, TObject}"/> collections,
-    /// not as a changeset stream.
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="timeSelector"/> is <see langword="null"/>.</exception>
-    public static IObservable<IEnumerable<KeyValuePair<TKey, TObject>>> ExpireAfter<TObject, TKey>(
-                this ISourceCache<TObject, TKey> source,
-                Func<TObject, TimeSpan?> timeSelector,
-                TimeSpan? pollingInterval = null,
-                IScheduler? scheduler = null)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.ExpireAfter.ForSource<TObject, TKey>.Create(
-            source: source,
-            timeSelector: timeSelector,
-            pollingInterval: pollingInterval,
-            scheduler: scheduler);
-
-    /// <summary>
-    /// Filters items from the source changeset stream using a static predicate.
-    /// Only items that satisfy <paramref name="filter"/> are included downstream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
-    /// <param name="filter">The <see cref="Func{TObject, bool}"/> predicate used to determine whether each item is included.</param>
-    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance. Set to <see langword="false"/> to emit empty changesets, which can be useful for monitoring loading status.</param>
-    /// <returns>An observable changeset containing only items that satisfy <paramref name="filter"/>.</returns>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The predicate is evaluated. If it passes, an <b>Add</b> is emitted. Otherwise the item is dropped.</description></item>
-    /// <item><term>Update</term><description>Four outcomes: if both old and new values pass, an <b>Update</b> is emitted. If only the new value passes, an <b>Add</b> is emitted. If only the old value passed, a <b>Remove</b> is emitted. If neither passes, the change is dropped.</description></item>
-    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>Refresh</term><description>The predicate is re-evaluated. If the item now passes but previously did not, an <b>Add</b> is emitted. If it still passes, a <b>Refresh</b> is forwarded. If it no longer passes, a <b>Remove</b> is emitted. If it still fails, the change is dropped.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> <b>Refresh</b> events trigger re-evaluation, which can promote or demote items. Pair with <see cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/> for property-change-driven filtering.</para>
-    /// </remarks>
-    /// <seealso cref="FilterImmutable{TObject, TKey}"/>
-    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableListEx.Filter"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                Func<TObject, bool> filter,
-                bool suppressEmptyChangeSets = true)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.Filter.Static<TObject, TKey>.Create(
-            source: source,
-            filter: filter,
-            suppressEmptyChangeSets: suppressEmptyChangeSets);
-
-    /// <inheritdoc cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{Func{TObject, bool}}, IObservable{Unit}, bool)"/>
-    /// <remarks>
-    /// This overload does not accept a <c>reapplyFilter</c> signal. It is equivalent to calling the
-    /// full dynamic overload with <see cref="Observable.Empty{TResult}()"/> as the reapply observable.
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                IObservable<Func<TObject, bool>> predicateChanged,
-                bool suppressEmptyChangeSets = true)
-            where TObject : notnull
-            where TKey : notnull
-        => source.Filter(
-            predicateChanged: predicateChanged,
-            reapplyFilter: Observable.Empty<Unit>(),
-            suppressEmptyChangeSets: suppressEmptyChangeSets);
-
-    /// <summary>
-    /// Creates a dynamically filtered stream where the filter predicate depends on external state.
-    /// Each emission from <paramref name="predicateState"/> triggers a full re-filtering of all items.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TState">The type of state value required by <paramref name="predicate"/>.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
-    /// <param name="predicateState">The <see cref="IObservable{TState}"/> stream of state values to be passed to <paramref name="predicate"/>.</param>
-    /// <param name="predicate">The <see cref="Func{TState, TObject, bool}"/> predicate that receives the current state and an item, returning <see langword="true"/> to include or <see langword="false"/> to exclude.</param>
-    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance. Set to <see langword="false"/> to emit empty changesets.</param>
-    /// <returns>An observable changeset containing only items satisfying <paramref name="predicate"/> for the latest state.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="predicateState"/>, or <paramref name="predicate"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// <paramref name="predicateState"/> should emit an initial value immediately upon subscription.
-    /// Until the first state value arrives, no items pass the filter (all items are excluded).
-    /// Each subsequent state emission triggers a full re-evaluation of every item in the collection.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Evaluated against the current state. If it passes, an <b>Add</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>Update</term><description>Re-evaluated. Four outcomes as with the static <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> overload.</description></item>
-    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>Refresh</term><description>Re-evaluated against the current state. May produce <b>Add</b>, <b>Refresh</b>, <b>Remove</b>, or be dropped.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> <paramref name="predicateState"/> should emit an initial value immediately. Each emission triggers a full re-evaluation of all items, which can be expensive for large collections.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey, TState>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                IObservable<TState> predicateState,
-                Func<TState, TObject, bool> predicate,
-                bool suppressEmptyChangeSets = true)
-            where TObject : notnull
-            where TKey : notnull
-        => Cache.Internal.Filter.Dynamic<TObject, TKey, TState>.Create(
-            source: source,
-            predicateState: predicateState,
-            predicate: predicate,
-            reapplyFilter: Observable.Empty<Unit>(),
-            suppressEmptyChangeSets: suppressEmptyChangeSets);
-
-    /// <inheritdoc cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter.</param>
-    /// <param name="predicateChanged">The <see cref="IObservable{Func{TObject, bool}}"/> that emits new predicates. Each emission replaces the current predicate and triggers a full re-evaluation of all items.</param>
-    /// <param name="reapplyFilter">The <see cref="IObservable{Unit}"/> that, when it emits, triggers a full re-evaluation of all items against the current predicate. Useful when filtering on mutable item properties.</param>
-    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed for performance.</param>
-    /// <remarks>
-    /// In addition to the per-item behavior described in the static <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> overload,
-    /// emissions from <paramref name="predicateChanged"/> replace the predicate and trigger full re-filtering,
-    /// while emissions from <paramref name="reapplyFilter"/> re-evaluate all items against the current predicate.
-    /// <para><b>Worth noting:</b> No items are included until the predicate observable emits its first value.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Filter<TObject, TKey>(
-                this IObservable<IChangeSet<TObject, TKey>> source,
-                IObservable<Func<TObject, bool>> predicateChanged,
-                IObservable<Unit> reapplyFilter,
-                bool suppressEmptyChangeSets = true)
-            where TObject : notnull
-            where TKey : notnull
-
-        => Cache.Internal.Filter.Dynamic<TObject, TKey, Func<TObject, bool>>.Create(
-            source: source,
-            predicateState: predicateChanged,
-            predicate: static (predicate, item) => predicate.Invoke(item),
-            reapplyFilter: reapplyFilter,
-            suppressEmptyChangeSets: suppressEmptyChangeSets);
-
-    /// <summary>
-    /// Creates a filtered stream, optimized for stateless/deterministic filtering of immutable items.
-    /// </summary>
-    /// <typeparam name="TObject">The type of collection items to be filtered.</typeparam>
-    /// <typeparam name="TKey">The type of the key values of each collection item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter (items assumed immutable).</param>
-    /// <param name="predicate">The <see cref="Func{TObject, bool}"/> filtering predicate to be applied to each item.</param>
-    /// <param name="suppressEmptyChangeSets">A flag indicating whether the created stream should emit empty changesets. Empty changesets are suppressed by default, for performance. Set to ensure that a downstream changeset occurs for every upstream changeset.</param>
-    /// <returns>A stream of collection changesets where upstream collection items are filtered by the given predicate.</returns>
-    /// <remarks>
-    /// <para>The goal of this operator is to optimize a common use-case of reactive programming, where data values flowing through a stream are immutable, and state changes are distributed by publishing new immutable items as replacements, instead of mutating the items directly.</para>
-    /// <para>In addition to assuming that all collection items are immutable, this operator also assumes that the given filter predicate is deterministic, such that the result it returns will always be the same each time a specific input is passed to it. In other words, the predicate itself also contains no mutable state.</para>
-    /// <para>Under these assumptions, this operator can bypass the need to keep track of every collection item that passes through it, which the normal <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> operator must do, in order to re-evaluate the filtering status of items, during a refresh operation.</para>
-    /// <para>Consider using this operator when the following are true:</para>
-    /// <list type="bullet">
-    /// <item><description>Your collection items are immutable, and changes are published by replacing entire items</description></item>
-    /// <item><description>Your filtering logic does not change over the lifetime of the stream, only the items do</description></item>
-    /// <item><description>Your filtering predicate runs quickly, and does not heavily allocate memory</description></item>
-    /// </list>
-    /// <para>Note that, because filtering is purely deterministic, Refresh operations are transparently ignored by this operator.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The predicate is evaluated. If it passes, an <b>Add</b> is emitted. Otherwise the item is dropped.</description></item>
-    /// <item><term>Update</term><description>Four outcomes: if both old and new values pass, an <b>Update</b> is emitted. If only the new value passes, an <b>Add</b> is emitted. If only the old value passed, a <b>Remove</b> is emitted. If neither passes, the change is dropped.</description></item>
-    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>Refresh</term><description><b>Dropped.</b> Because items are assumed immutable, there is nothing to re-evaluate.</description></item>
-    /// </list>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> FilterImmutable<TObject, TKey>(
-            this IObservable<IChangeSet<TObject, TKey>> source,
-            Func<TObject, bool> predicate,
-            bool suppressEmptyChangeSets = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
-
-        return new FilterImmutable<TObject, TKey>(
-                predicate: predicate,
-                source: source,
-                suppressEmptyChangeSets: suppressEmptyChangeSets)
-            .Run();
-    }
-
-    /// <summary>
-    /// Filters items using a per-item <see cref="IObservable{Boolean}"/> that controls inclusion.
-    /// Each item's observable is created by <paramref name="filterFactory"/> and toggles the item in or out of the downstream stream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter using per-item observables.</param>
-    /// <param name="filterFactory">A factory that creates an <see cref="IObservable{Boolean}"/> for each item and its key. When the observable emits <see langword="true"/>, the item is included; when <see langword="false"/>, it is excluded.</param>
-    /// <param name="buffer">A <see cref="TimeSpan"/> that optional time window to buffer inclusion changes from per-item observables before re-evaluating.</param>
-    /// <param name="scheduler">An <see cref="IScheduler"/> that optional scheduler used for buffering.</param>
-    /// <returns>An observable changeset containing only items whose per-item observable most recently emitted <see langword="true"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Source changeset handling (parent events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Subscribes to the per-item observable. The item is <b>not included downstream until the observable emits its first <see langword="true"/></b>.</description></item>
-    /// <item><term>Update</term><description>Disposes the old item's observable subscription and subscribes to the new item's observable. Inclusion state is reset; the new observable must emit before the item reappears.</description></item>
-    /// <item><term>Remove</term><description>Disposes the item's observable subscription. If the item was included downstream, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently included downstream. Otherwise dropped.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Per-item observable handling (filter observable events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
-    /// <item><term>First <see langword="true"/></term><description>The item is included: an <b>Add</b> is emitted downstream.</description></item>
-    /// <item><term><see langword="false"/> (was included)</term><description>The item is excluded: a <b>Remove</b> is emitted downstream.</description></item>
-    /// <item><term><see langword="true"/> (was excluded)</term><description>The item is re-included: an <b>Add</b> is emitted downstream.</description></item>
-    /// <item><term><see langword="true"/> (was included)</term><description>No effect (already included).</description></item>
-    /// <item><term><see langword="false"/> (was excluded)</term><description>No effect (already excluded).</description></item>
-    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
-    /// <item><term>Completed</term><description>The item remains in its current inclusion state. No further toggling is possible for this item.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> Items are invisible downstream until their per-item observable emits at least one <see langword="true"/>.
-    /// If an item's observable never emits, the item never appears. The <paramref name="buffer"/> parameter batches
-    /// rapid inclusion changes from per-item observables into a single re-evaluation, reducing changeset chatter.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="filterFactory"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
-    /// <seealso cref="ObservableListEx.FilterOnObservable"/>
-    public static IObservable<IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<bool>> filterFactory, TimeSpan? buffer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        filterFactory.ThrowArgumentNullExceptionIfNull(nameof(filterFactory));
-
-        return new FilterOnObservable<TObject, TKey>(source, filterFactory, buffer, scheduler).Run();
-    }
-
-    /// <inheritdoc cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    /// <remarks>
-    /// This overload does not provide the key to <paramref name="filterFactory"/>; only the item is passed.
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<bool>> filterFactory, TimeSpan? buffer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        filterFactory.ThrowArgumentNullExceptionIfNull(nameof(filterFactory));
-
-        return source.FilterOnObservable((obj, _) => filterFactory(obj), buffer, scheduler);
-    }
-
-    /// <summary>
-    /// Obsolete: do not use. This can cause unhandled exception issues. Use the standard Rx <c>Finally</c> operator instead.
-    /// </summary>
-    /// <typeparam name="T">The type contained within the observables.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to attach a finally action to.</param>
-    /// <param name="finallyAction">The <see cref="Action"/> to invoke when the subscription terminates.</param>
-    /// <returns>An observable which has always a finally action applied.</returns>
-    [Obsolete("This can cause unhandled exception issues so do not use")]
-    public static IObservable<T> FinallySafe<T>(this IObservable<T> source, Action finallyAction)
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        finallyAction.ThrowArgumentNullExceptionIfNull(nameof(finallyAction));
-
-        return new FinallySafe<T>(source, finallyAction).Run();
-    }
-
-    /// <summary>
-    /// Unwraps each <see cref="IChangeSet{TObject, TKey}"/> into individual <see cref="Change{TObject, TKey}"/>
-    /// values via <see cref="Observable.SelectMany{TSource, TResult}(IObservable{TSource}, Func{TSource, IEnumerable{TResult}})"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to flatten into individual changes.</param>
-    /// <returns>An observable of individual <see cref="Change{TObject, TKey}"/> values.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="ForEachChange{TObject, TKey}"/>
-    public static IObservable<Change<TObject, TKey>> Flatten<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.SelectMany(changes => changes);
-    }
-
-    /// <summary>
-    /// Merges a list of changesets (typically from an Rx <c>Buffer</c> operation) into a single changeset
-    /// by concatenating all changes. Empty buffers are filtered out.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to flatten.</param>
-    /// <returns>An observable changeset combining all changes from each buffer into a single emission.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> FlattenBufferResult<TObject, TKey>(this IObservable<IList<IChangeSet<TObject, TKey>>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Where(x => x.Count != 0).Select(updates => new ChangeSet<TObject, TKey>(updates.SelectMany(u => u)));
-    }
-
-    /// <summary>
-    /// Invokes <paramref name="action"/> for every individual <see cref="Change{TObject,TKey}"/> in each changeset,
-    /// regardless of change reason. The changeset is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe each individual change in.</param>
-    /// <param name="action">The action to invoke for each change. Receives the full <see cref="Change{TObject,TKey}"/> struct, including <see cref="Change{TObject,TKey}.Reason"/>, <see cref="Change{TObject,TKey}.Key"/>, <see cref="Change{TObject,TKey}.Current"/>, and <see cref="Change{TObject,TKey}.Previous"/>.</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// All change reasons (Add, Update, Remove, Refresh) trigger the callback.
-    /// Use <see cref="OnItemAdded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>,
-    /// <see cref="OnItemUpdated{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TObject,TKey})"/>,
-    /// <see cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>, or
-    /// <see cref="OnItemRefreshed{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>
-    /// to target a specific reason.
-    /// </para>
-    /// <para>
-    /// Implemented via Rx's <c>Do</c> operator on the changeset stream.
-    /// Exceptions thrown in <paramref name="action"/> propagate as <c>OnError</c> to the subscriber. No try-catch is applied.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="ObservableListEx.ForEachChange"/>
-    public static IObservable<IChangeSet<TObject, TKey>> ForEachChange<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<Change<TObject, TKey>> action)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        action.ThrowArgumentNullExceptionIfNull(nameof(action));
-
-        return source.Do(changes => changes.ForEach(action));
-    }
-
-    /// <inheritdoc cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left and right values into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, Optional<TRight>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.FullJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Joins two changeset streams, producing a result for every key that appears on either side (or both).
-    /// Both sides are <see cref="Optional{T}"/> because a given key may only exist on one side at any point.
-    /// Equivalent to SQL FULL OUTER JOIN.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left, and optional right into a destination object. Example: <c>(key, left, right) =&gt; new Result(key, left, right)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Emits with the left value and the matching right (or <see cref="Optional.None{T}"/> if no right exists).</description></item>
-    ///   <item><term>Update</term><description>Re-invokes <paramref name="resultSelector"/> with the new left value and current right (if any).</description></item>
-    ///   <item><term>Remove</term><description>If a right match still exists, re-invokes the selector with left as <see cref="Optional.None{T}"/>. If neither side remains, removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Emits with the matching left (or <see cref="Optional.None{T}"/>) and the right value.</description></item>
-    ///   <item><term>Update</term><description>Re-invokes selector with current left (if any) and the new right value.</description></item>
-    ///   <item><term>Remove</term><description>If a left match still exists, re-invokes the selector with right as <see cref="Optional.None{T}"/>. If neither side remains, removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
-    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
-    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, Optional<TRight>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <inheritdoc cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left value and the right group into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.FullJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Groups right-side items by their mapped key, then full-joins each group to the left source.
-    /// A result is produced for every key that appears on either side (or both). The left value is
-    /// <see cref="Optional{T}"/> because only the right side may have entries for a given key.
-    /// Equivalent to SQL FULL OUTER JOIN with the right side grouped.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left value, and the right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Emits with the left value and the current right group for that key (may be empty).</description></item>
-    ///   <item><term>Update</term><description>Re-invokes <paramref name="resultSelector"/> with the new left value and current right group.</description></item>
-    ///   <item><term>Remove</term><description>If the right group is non-empty, re-invokes with left as <see cref="Optional.None{T}"/>. If both sides are empty, removes the result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Updates the right group, then re-invokes selector with the current left (if any) and the updated group.</description></item>
-    ///   <item><term>Update</term><description>Updates the right group and re-invokes selector.</description></item>
-    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty and no left exists, removes the result. Otherwise re-invokes selector.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <summary>
-    /// Groups items from the source changeset, producing groups only for group keys present in <paramref name="resultGroupSource"/>.
-    /// Useful for parent-child relationships where parents and children come from different streams.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
-    /// <param name="groupSelector">The <see cref="Func{TObject, TGroupKey}"/> group selector factory.</param>
-    /// <param name="resultGroupSource">An <see cref="IObservable{IDistinctChangeSet{TGroupKey}}"/> of <see cref="IDistinctChangeSet{TGroupKey}"/> used to determine which groups appear in the result.</param>
-    /// <remarks>
-    /// Useful for parent-child collection when the parent and child are soured from different streams.
-    /// </remarks>
-    /// <returns>An observable which will emit group change sets.</returns>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelector, IObservable<IDistinctChangeSet<TGroupKey>> resultGroupSource)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupSelector.ThrowArgumentNullExceptionIfNull(nameof(groupSelector));
-        resultGroupSource.ThrowArgumentNullExceptionIfNull(nameof(resultGroupSource));
-
-        return new SpecifiedGrouper<TObject, TKey, TGroupKey>(source, groupSelector, resultGroupSource).Run();
-    }
-
-    /// <summary>
-    /// Groups items from the source changeset by a key extracted via <paramref name="groupSelectorKey"/>.
-    /// Each group is an observable sub-cache that receives changes for its members.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
-    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
-    /// <returns>An observable that emits group changesets. Each group exposes a sub-cache of its members.</returns>
-    /// <remarks>
-    /// <para>
-    /// Items are assigned to groups based on the value returned by <paramref name="groupSelectorKey"/>.
-    /// Groups are created on demand when the first item is assigned, and removed when their last member is removed.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The group key is evaluated. The item is added to the corresponding group (creating the group if new). An <b>Add</b> is emitted to the group's sub-cache.</description></item>
-    /// <item><term>Update</term><description>The group key is re-evaluated. If unchanged, an <b>Update</b> is emitted within the same group. If the key changed, the item is removed from the old group (emitting <b>Remove</b>) and added to the new group (emitting <b>Add</b>). An empty old group is removed.</description></item>
-    /// <item><term>Remove</term><description>The item is removed from its group. If the group becomes empty, the group itself is removed from the output.</description></item>
-    /// <item><term>Refresh</term><description>The group key is re-evaluated. If unchanged, a <b>Refresh</b> is forwarded within the group. If the key changed, the item moves between groups (Remove from old, Add to new).</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> Each group is a live sub-cache that can be subscribed to independently. Subscribers
-    /// to a group receive only changes for items in that group. When a group is removed (becomes empty),
-    /// its sub-cache completes.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="GroupWithImmutableState{TObject, TKey, TGroupKey}"/>
-    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="GroupOnProperty{TObject, TKey, TGroupKey}"/>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
-
-        return new GroupOn<TObject, TKey, TGroupKey>(source, groupSelectorKey, null).Run();
-    }
-
-    /// <inheritdoc cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
-    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
-    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that, when it emits, all items are re-evaluated against the group selector, potentially moving items between groups.</param>
-    /// <returns>An observable that emits group changesets.</returns>
-    /// <remarks>This overload adds a <paramref name="regrouper"/> signal. When it fires, every item in the cache is re-grouped using the current selector, which is useful when the grouping depends on mutable item state.</remarks>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit> regrouper)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
-        regrouper.ThrowArgumentNullExceptionIfNull(nameof(regrouper));
-
-        return new GroupOn<TObject, TKey, TGroupKey>(source, groupSelectorKey, regrouper).Run();
-    }
-
-    /// <summary>
-    /// Groups items using a dynamically changing group selector function.
-    /// Each time <paramref name="groupSelectorKeyObservable"/> emits a new selector, all items are re-grouped.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
-    /// <param name="groupSelectorKeyObservable">The <see cref="IObservable{Func{TObject, TKey, TGroupKey}}"/> that emits group selector functions. Each emission triggers a full re-grouping of all items.</param>
-    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that optional signal to force re-evaluation of all items against the current selector.</param>
-    /// <returns>An observable that emits group changesets.</returns>
-    /// <remarks>
-    /// <para>
-    /// Unlike the static-selector overload, this accepts an observable of selector functions. When a new selector
-    /// arrives, every item is re-evaluated and may move between groups. The optional <paramref name="regrouper"/>
-    /// signal triggers re-evaluation without changing the selector (useful when item properties that affect grouping change).
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The current selector determines the group. Item is added to the group (group created if new).</description></item>
-    /// <item><term>Update</term><description>Group key re-evaluated. Item may move between groups if the key changed.</description></item>
-    /// <item><term>Remove</term><description>Item removed from its group. Empty groups are removed.</description></item>
-    /// <item><term>Refresh</term><description>Group key re-evaluated. Item may move between groups.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
-    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}}, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<Func<TObject, TKey, TGroupKey>> groupSelectorKeyObservable, IObservable<Unit>? regrouper = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupSelectorKeyObservable.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKeyObservable));
-
-        return new GroupOnDynamic<TObject, TKey, TGroupKey>(source, groupSelectorKeyObservable, regrouper).Run();
-    }
-
-    /// <inheritdoc cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{Func{TObject, TKey, TGroupKey}}, IObservable{Unit}?)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group.</param>
-    /// <param name="groupSelectorKeyObservable">The <see cref="IObservable{Func{TObject, TGroupKey}}"/> of selector functions that take only the item (not the key).</param>
-    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> signal to force re-evaluation.</param>
-    /// <remarks>This overload accepts a selector that does not receive the key. Delegates to the overload accepting <c>Func&lt;TObject, TKey, TGroupKey&gt;</c>.</remarks>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<Func<TObject, TGroupKey>> groupSelectorKeyObservable, IObservable<Unit>? regrouper = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        groupSelectorKeyObservable.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKeyObservable));
-
-        return source.Group(groupSelectorKeyObservable.Select(AdaptSelector<TObject, TKey, TGroupKey>), regrouper);
-    }
-
-    /// <summary>
-    /// Groups items where each item's group key is determined by a per-item observable.
-    /// The observable is created by <paramref name="groupObservableSelector"/> for each item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group using per-item observables.</param>
-    /// <param name="groupObservableSelector">A <see cref="Func{T, TResult}"/> factory that creates a group key observable for each item and its key.</param>
-    /// <returns>An observable that emits group changesets. Each group is a live sub-cache of its members.</returns>
-    /// <remarks>
-    /// <para>
-    /// Unlike <see cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/> which evaluates
-    /// the group key synchronously, this operator defers group assignment until the per-item observable emits.
-    /// </para>
-    /// <para>
-    /// <b>Source changeset handling (parent events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Subscribes to the per-item group key observable. The item is <b>not placed in any group until the observable emits its first group key</b>.</description></item>
-    /// <item><term>Update</term><description>Disposes the old item's group key subscription and subscribes to the new item's observable. The item is removed from its current group until the new observable emits.</description></item>
-    /// <item><term>Remove</term><description>Disposes the item's group key subscription. The item is removed from its current group. Empty groups are removed.</description></item>
-    /// <item><term>Refresh</term><description>No effect on subscriptions. The item remains in its current group.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Per-item observable handling (group key observable events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
-    /// <item><term>First value</term><description>The item is placed into the group matching the emitted key. An <b>Add</b> appears in that group's sub-cache. If the group is new, the group itself is added to the output.</description></item>
-    /// <item><term>New value (different key)</term><description>The item moves: <b>Remove</b> from the old group, <b>Add</b> to the new group. If the old group becomes empty, it is removed from the output.</description></item>
-    /// <item><term>Same value (unchanged key)</term><description>No effect (filtered by <c>DistinctUntilChanged</c>).</description></item>
-    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
-    /// <item><term>Completed</term><description>The item remains in its current group. No further group key changes are possible for this item.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> Items are invisible (not in any group) until their per-item observable emits at least one
-    /// group key. If an item's observable never emits, the item never appears in any group. Per-item observable errors
-    /// terminate the entire stream. The output completes when the source completes and all per-item observables have
-    /// also completed.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
-    /// <seealso cref="GroupOnProperty{TObject, TKey, TGroupKey}"/>
-    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="TransformOnObservable{TSource, TKey, TDestination}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, IObservable{TDestination}})"/>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnObservable<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TGroupKey>> groupObservableSelector)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupObservableSelector.ThrowArgumentNullExceptionIfNull(nameof(groupObservableSelector));
-
-        return new GroupOnObservable<TObject, TKey, TGroupKey>(source, groupObservableSelector).Run();
-    }
-
-    /// <summary>
-    /// Groups the source by the latest value from their observable created by the given factory.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group using per-item observables.</param>
-    /// <param name="groupObservableSelector">The <see cref="Func{TObject, IObservable{TGroupKey}}"/> group selector key.</param>
-    /// <returns>An observable which will emit group change sets.</returns>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnObservable<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TGroupKey>> groupObservableSelector)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        groupObservableSelector.ThrowArgumentNullExceptionIfNull(nameof(groupObservableSelector));
-
-        return source.GroupOnObservable(AdaptSelector<TObject, TKey, IObservable<TGroupKey>>(groupObservableSelector));
-    }
-
-    /// <summary>
-    /// <para>Groups the source using the property specified by the property selector. Groups are re-applied when the property value changed.</para>
-    /// <para>When there are likely to be a large number of group property changes specify a throttle to improve performance.</para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group by a property value.</param>
-    /// <param name="propertySelector">The <see cref="Expression{Func{TObject, TGroupKey}}"/> property selector used to group the items.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> a time span that indicates the throttle to wait for property change events.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable which will emit immutable group change sets.</returns>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnProperty<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TGroupKey>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
-
-        return new GroupOnProperty<TObject, TKey, TGroupKey>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// <para>Groups the source using the property specified by the property selector. Each update produces immutable grouping. Groups are re-applied when the property value changed.</para>
-    /// <para>When there are likely to be a large number of group property changes specify a throttle to improve performance.</para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group by a property value with immutable snapshots.</param>
-    /// <param name="propertySelector">The <see cref="Expression{Func{TObject, TGroupKey}}"/> property selector used to group the items.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> a time span that indicates the throttle to wait for property change events.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling work.</param>
-    /// <returns>An observable which will emit immutable group change sets.</returns>
-    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnPropertyWithImmutableState<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TGroupKey>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
-
-        return new GroupOnPropertyWithImmutableState<TObject, TKey, TGroupKey>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Groups items by <paramref name="groupSelectorKey"/>, emitting immutable group snapshots instead of mutable sub-caches.
-    /// Each group change contains a frozen copy of the group's state at that point in time.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to group with immutable snapshots.</param>
-    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> that extracts the group key from each item.</param>
-    /// <param name="regrouper">An <see cref="IObservable{Unit}"/> that optional signal to force re-evaluation of all items against the group selector.</param>
-    /// <returns>An observable that emits immutable group changesets.</returns>
-    /// <remarks>
-    /// <para>
-    /// Behaves identically to <see cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
-    /// in terms of how items are assigned to groups, but each group emission is an immutable snapshot.
-    /// This makes it safe for parallel processing and eliminates race conditions on group state.
-    /// The tradeoff is higher memory usage, since each change produces a new snapshot of the affected group.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Item added to its group. An immutable snapshot of the group is emitted.</description></item>
-    /// <item><term>Update</term><description>If group key unchanged, group snapshot re-emitted. If changed, item moves between groups; both affected groups emit new snapshots.</description></item>
-    /// <item><term>Remove</term><description>Item removed from group. Updated snapshot emitted. Empty groups are removed.</description></item>
-    /// <item><term>Refresh</term><description>Group key re-evaluated. If changed, item moves; affected group snapshots emitted.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Group{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TGroupKey})"/>
-    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TKey, TGroupKey}"/>
-    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupWithImmutableState<TObject, TKey, TGroupKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit>? regrouper = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
-
-        return new GroupOnImmutable<TObject, TKey, TGroupKey>(source, groupSelectorKey, regrouper).Run();
-    }
-
-    /// <summary>
-    /// Ignores updates when the update is the same reference.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to suppress same-reference updates in.</param>
-    /// <returns>An observable which emits change sets and ignores equal value changes.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> IgnoreSameReferenceUpdate<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.IgnoreUpdateWhen((c, p) => ReferenceEquals(c, p));
-
-    /// <summary>
-    /// Ignores the update when the condition is met.
-    /// The first parameter in the ignore function is the current value and the second parameter is the previous value.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to selectively suppress updates in.</param>
-    /// <param name="ignoreFunction">The <see cref="Func{TObject, TObject, bool}"/> ignore function (current,previous)=>{ return true to ignore }.</param>
-    /// <returns>An observable which emits change sets and ignores updates equal to the lambda.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> IgnoreUpdateWhen<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TObject, bool> ignoreFunction)
-        where TObject : notnull
-        where TKey : notnull => source.Select(
-            updates =>
-            {
-                var result = updates.Where(
-                    u =>
-                    {
-                        if (u.Reason != ChangeReason.Update)
-                        {
-                            return true;
-                        }
-
-                        return !ignoreFunction(u.Current, u.Previous.Value);
-                    });
-                return new ChangeSet<TObject, TKey>(result);
-            }).NotEmpty();
-
-    /// <summary>
-    /// Only includes the update when the condition is met.
-    /// The first parameter in the ignore function is the current value and the second parameter is the previous value.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to selectively include updates in.</param>
-    /// <param name="includeFunction">The <see cref="Func{TObject, TObject, bool}"/> include function (current,previous)=>{ return true to include }.</param>
-    /// <returns>An observable which emits change sets and ignores updates equal to the lambda.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> IncludeUpdateWhen<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TObject, bool> includeFunction)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        includeFunction.ThrowArgumentNullExceptionIfNull(nameof(includeFunction));
-
-        return source.Select(
-            changes =>
-            {
-                var result = changes.Where(change => change.Reason != ChangeReason.Update || includeFunction(change.Current, change.Previous.Value));
-                return new ChangeSet<TObject, TKey>(result);
-            }).NotEmpty();
-    }
-
-    /// <inheritdoc cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left and right values into a destination object. The composite key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the composite key from the result selector. Delegates to <see cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, (TLeftKey leftKey, TRightKey rightKey)>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, TRight, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.InnerJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Joins two changeset streams, producing a result only for keys that exist on both sides simultaneously.
-    /// When either side loses its value for a key, the joined result is removed. Equivalent to SQL INNER JOIN.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the composite key, left value, and right value into a destination object. Example: <c>((leftKey, rightKey), left, right) =&gt; new Result(leftKey, rightKey, left, right)</c>.</param>
-    /// <returns>An observable changeset keyed by a composite <c>(TLeftKey, TRightKey)</c> tuple.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If a matching right value exists, invokes <paramref name="resultSelector"/> and emits an Add. If no right match, no emission.</description></item>
-    ///   <item><term>Update</term><description>If a matching right exists, re-invokes the selector and emits an Update.</description></item>
-    ///   <item><term>Remove</term><description>Removes all joined results involving the removed left key.</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If a matching left value exists, invokes the selector and emits an Add.</description></item>
-    ///   <item><term>Update</term><description>If a matching left exists, re-invokes the selector and emits an Update.</description></item>
-    ///   <item><term>Remove</term><description>Removes the joined result for this right key (if it was downstream).</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>The output is keyed by a <c>(TLeftKey, TRightKey)</c> composite tuple, since a single left item may match multiple right items.</para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
-    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, (TLeftKey leftKey, TRightKey rightKey)>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<(TLeftKey leftKey, TRightKey rightKey), TLeft, TRight, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <inheritdoc cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the right group into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.InnerJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Groups right-side items by their mapped key, then inner-joins each group to the left source.
-    /// A result is produced only when a left item and at least one right item share the same key.
-    /// Equivalent to SQL INNER JOIN with the right side grouped.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If a non-empty right group exists for this key, invokes <paramref name="resultSelector"/> and emits an Add. Otherwise no emission.</description></item>
-    ///   <item><term>Update</term><description>If a right group exists, re-invokes the selector and emits an Update.</description></item>
-    ///   <item><term>Remove</term><description>Removes the joined result (if it was downstream).</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Updates the right group. If a matching left exists and the group was previously empty, emits an Add. If already joined, emits an Update.</description></item>
-    ///   <item><term>Update</term><description>Updates the right group and re-invokes the selector if a matching left exists.</description></item>
-    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty, removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
-    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <summary>
-    /// Calls <c>Evaluate()</c> on items that implement <see cref="IEvaluateAware"/> when a <b>Refresh</b> change arrives.
-    /// Other change reasons are forwarded without invoking Evaluate.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to trigger re-evaluation on.</param>
-    /// <returns>An observable that emits the same changesets as <paramref name="source"/>, unchanged.</returns>
-    /// <remarks>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term><b>Add</b></term><description>Forwarded unchanged.</description></item>
-    ///   <item><term><b>Update</b></term><description>Forwarded unchanged.</description></item>
-    ///   <item><term><b>Remove</b></term><description>Forwarded unchanged.</description></item>
-    ///   <item><term><b>Refresh</b></term><description>Calls <c>Evaluate()</c> on the item, then forwards the change.</description></item>
-    /// </list>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> InvokeEvaluate<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : IEvaluateAware
-        where TKey : notnull => source.Do(changes => changes.Where(u => u.Reason == ChangeReason.Refresh).ForEach(u => u.Current.Evaluate()));
-
-    /// <inheritdoc cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the optional right into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, Optional<TRight>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.LeftJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Joins two changeset streams, producing a result for every left-side key. The right side is
-    /// <see cref="Optional{T}"/> because a matching right item may or may not exist. All left items
-    /// appear in the output regardless. Equivalent to SQL LEFT OUTER JOIN.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and optional right into a destination object. Example: <c>(key, left, right) =&gt; new Result(key, left, right)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the left value and matching right (or <see cref="Optional.None{T}"/>).</description></item>
-    ///   <item><term>Update</term><description>Re-invokes the selector with the new left value and current right (if any).</description></item>
-    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If a matching left exists, re-invokes the selector (right transitions from None to Some) and emits an Update.</description></item>
-    ///   <item><term>Update</term><description>If a matching left exists, re-invokes the selector with the new right value.</description></item>
-    ///   <item><term>Remove</term><description>If a matching left exists, re-invokes the selector (right transitions from Some to None) and emits an Update.</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
-    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
-    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, Optional<TRight>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <inheritdoc cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the left value and the right group into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.LeftJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Groups right-side items by their mapped key, then left-joins each group to the left source.
-    /// A result is produced for every left-side key. The right group may be empty if no right items match.
-    /// Equivalent to SQL LEFT OUTER JOIN with the right side grouped.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the left value and the current right group (which may be empty).</description></item>
-    ///   <item><term>Update</term><description>Re-invokes the selector with the new left value and current right group.</description></item>
-    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Updates the right group. If a matching left exists, re-invokes the selector and emits an Update.</description></item>
-    ///   <item><term>Update</term><description>Updates the right group and re-invokes the selector if a matching left exists.</description></item>
-    ///   <item><term>Remove</term><description>Updates the right group. If a matching left exists, re-invokes the selector (group may now be empty).</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <summary>
-    /// Applies a FIFO size limit to the changeset stream. When the number of items exceeds <paramref name="size"/>,
-    /// the oldest items are evicted and emitted as <b>Remove</b> changes.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to apply size limits to.</param>
-    /// <param name="size">The maximum number of items allowed. Must be greater than zero.</param>
-    /// <returns>An observable changeset stream with size-limited contents.</returns>
-    /// <remarks>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term><b>Add</b></term><description>Forwarded. If the cache exceeds the size limit, the oldest items are emitted as <b>Remove</b> changes.</description></item>
-    ///   <item><term><b>Update</b></term><description>Forwarded unchanged.</description></item>
-    ///   <item><term><b>Remove</b></term><description>Forwarded unchanged.</description></item>
-    ///   <item><term><b>Refresh</b></term><description>Forwarded unchanged.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="size"/> is zero or negative.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> LimitSizeTo<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, int size)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (size <= 0)
-        {
-            throw new ArgumentException("Size limit must be greater than zero");
-        }
-
-        return new SizeExpirer<TObject, TKey>(source, size).Run();
-    }
-
-    /// <summary>
-    /// Operates directly on a <see cref="ISourceCache{TObject, TKey}"/>, removing the oldest items when the cache
-    /// exceeds <paramref name="sizeLimit"/>. Returns an observable of the evicted key-value pairs (not a changeset stream).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
-    /// <param name="sizeLimit">The maximum number of items allowed. Must be greater than zero.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for observing changes. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>An observable that emits batches of evicted key-value pairs whenever the cache exceeds the size limit.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="sizeLimit"/> is zero or negative.</exception>
-    public static IObservable<IEnumerable<KeyValuePair<TKey, TObject>>> LimitSizeTo<TObject, TKey>(this ISourceCache<TObject, TKey> source, int sizeLimit, IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (sizeLimit <= 0)
-        {
-            throw new ArgumentException("Size limit must be greater than zero", nameof(sizeLimit));
-        }
-
-        return Observable.Create<IEnumerable<KeyValuePair<TKey, TObject>>>(
-            observer =>
-            {
-                long orderItemWasAdded = -1;
-                var sizeLimiter = new SizeLimiter<TObject, TKey>(sizeLimit);
-
-                return source.Connect().Finally(observer.OnCompleted).ObserveOn(scheduler ?? GlobalConfig.DefaultScheduler).Transform((t, v) => new ExpirableItem<TObject, TKey>(t, v, DateTime.Now, Interlocked.Increment(ref orderItemWasAdded))).Select(sizeLimiter.CloneAndReturnExpiredOnly).Where(expired => expired.Length != 0).Subscribe(
-                    toRemove =>
-                    {
-                        try
-                        {
-                            source.Remove(toRemove.Select(kv => kv.Key));
-                            observer.OnNext(toRemove);
-                        }
-                        catch (Exception ex)
-                        {
-                            observer.OnError(ex);
-                        }
-                    });
-            });
-    }
-
-    /// <summary>
-    /// Subscribes to a child observable for each item in the source cache changeset stream and merges all child
-    /// emissions into a single <see cref="IObservable{T}"/>. When an item is added, <paramref name="observableSelector"/>
-    /// creates its child subscription. When updated, the previous child subscription is disposed and a new one is created.
-    /// When removed, its child subscription is disposed. Refresh changes have no effect on subscriptions.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of values emitted by child observables.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that produces a child observable for each source item.</param>
-    /// <returns>An observable that emits values from all active child observables, interleaved by arrival order.</returns>
-    /// <remarks>
-    /// <para>
-    /// This operator does not produce changesets. It produces a flat stream of <typeparamref name="TDestination"/>
-    /// values, similar to Rx <c>SelectMany</c> but lifecycle-aware: child subscriptions track items entering and
-    /// leaving the source cache.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Calls <paramref name="observableSelector"/> to create a child observable and subscribes to it. Emissions from the child flow into the merged output.</description></item>
-    /// <item><term>Update</term><description>Disposes the previous child subscription and creates a new one for the updated item.</description></item>
-    /// <item><term>Remove</term><description>Disposes the child subscription for the removed item.</description></item>
-    /// <item><term>Refresh</term><description>No effect on subscriptions. The child observable continues unchanged.</description></item>
-    /// <item><term>OnError</term><description>Errors from child observables are silently swallowed (the child is unsubscribed). Errors from the source changeset stream terminate the merged output.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> The output is a plain <see cref="IObservable{TDestination}"/>, not a changeset stream. If you need merged changesets, use <see cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/> instead.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    /// <seealso cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/>
-    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
-    /// <seealso cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IDisposable})"/>
-    /// <seealso cref="ObservableListEx.MergeMany"/>
-    public static IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TDestination>> observableSelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeMany<TObject, TKey, TDestination>(source, observableSelector).Run();
-    }
-
-    /// <inheritdoc cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives both the item and its key, and returns a child observable.</param>
-    public static IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TDestination>> observableSelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeMany<TObject, TKey, TDestination>(source, observableSelector).Run();
-    }
-
-    /// <summary>
-    /// Merges multiple changeset streams that arrive dynamically into a single unified changeset stream.
-    /// Each inner stream emitted by the outer observable is subscribed and its changes forwarded downstream.
-    /// When multiple sources provide the same key, the first source to add it retains priority unless a
-    /// comparer-based overload is used.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
-    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
-    /// <remarks>
-    /// <para>
-    /// Each inner changeset stream is independently tracked in its own cache. When multiple sources provide the same key,
-    /// this overload uses first-in-wins semantics: the value from whichever source added the key first is
-    /// the one published downstream. To control which value wins for duplicate keys, use an overload that
-    /// accepts an <see cref="IComparer{T}"/>, which selects the lowest-ordered value across all sources.
-    /// An <see cref="IEqualityComparer{T}"/> can be provided separately to suppress no-op updates when
-    /// the new value equals the currently published value for a key.
-    /// </para>
-    /// <para>
-    /// <b>Overload families:</b> MergeChangeSets has 16 overloads organized along three axes:
-    /// (1) <b>Source type</b>: dynamic (<c>IObservable&lt;IObservable&lt;IChangeSet&gt;&gt;</c>, sources arrive at runtime),
-    /// pair (<c>source + other</c>, exactly two streams), or static (<see cref="IEnumerable{T}"/>, all sources known up front).
-    /// (2) <b>Conflict resolution</b>: none (first-in-wins), <see cref="IComparer{T}"/> (lowest-ordered wins),
-    /// <see cref="IEqualityComparer{T}"/> (suppresses duplicate updates), or both.
-    /// (3) <b>Completion</b>: static overloads accept a <c>completable</c> flag; when <see langword="false"/>, the output never completes
-    /// even after all sources finish (useful for "live" merge scenarios).
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>If no source has previously provided this key, an <b>Add</b> is emitted downstream. If another source already holds this key, the new value is tracked internally but not emitted (first-in-wins). With a comparer, the lowest-ordered value across all sources is selected and published instead.</description></item>
-    /// <item><term>Update</term><description>If the updating source currently owns the downstream value for this key, an <b>Update</b> is emitted. If a comparer is provided and the update causes a different source's value to become the best candidate, an <b>Update</b> is emitted with that other source's value.</description></item>
-    /// <item><term>Remove</term><description>If the removed value was the one published downstream, the operator scans all remaining sources for the same key. If another source still holds that key, an <b>Update</b> is emitted with the replacement value (selected by comparer if provided, otherwise the next available). If no other source holds the key, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>If the refreshed item matches the currently published value, the <b>Refresh</b> is forwarded. With a comparer, all sources are re-evaluated first; if a different value now wins, an <b>Update</b> is emitted instead of the Refresh.</description></item>
-    /// <item><term>OnCompleted</term><description>For dynamic overloads, the output completes when the outer observable completes and all subscribed inner observables have also completed. For static overloads, completion depends on the <c>completable</c> parameter (default <see langword="true"/>).</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> When a source removes a key that was published downstream, the fallback to another
-    /// source's value is emitted as an <b>Update</b> (not an Add). This can be surprising if you expect
-    /// a Remove followed by an Add. Also, errors from any single inner source terminate the entire merged
-    /// stream, so consider error handling within individual sources if isolation is needed.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IComparer{TDestination}, IEqualityComparer{TDestination})"/>
-    /// <seealso cref="ObservableListEx.MergeChangeSets"/>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer: null).Run();
-    }
-
-    /// <summary>
-    /// Merges dynamic cache changeset streams into a single output, using a comparer to resolve key conflicts.
-    /// When multiple sources provide the same key, the item ordering lowest according to <paramref name="comparer"/>
-    /// is published downstream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
-    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer).Run();
-    }
-
-    /// <summary>
-    /// Merges dynamic cache changeset streams into a single output, using an equality comparer to suppress
-    /// redundant updates. When an incoming value for a key is equal (per <paramref name="equalityComparer"/>)
-    /// to the currently published value, the update is suppressed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
-    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="equalityComparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer: null).Run();
-    }
-
-    /// <summary>
-    /// Merges dynamic cache changeset streams into a single output, using both a comparer for key conflict resolution
-    /// and an equality comparer to suppress redundant updates.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">An <see cref="IObservable{T}"/> that emits changeset streams. Each inner stream is subscribed as it appears.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
-    /// <returns>A unified changeset stream containing changes from all active source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer).Run();
-    }
-
-    /// <summary>
-    /// Convenience overload that merges exactly two cache changeset streams into a single output.
-    /// Uses first-in-wins semantics for key conflicts.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from both sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        other.ThrowArgumentNullExceptionIfNull(nameof(other));
-
-        return new[] { source, other }.MergeChangeSets(scheduler, completable);
-    }
-
-    /// <summary>
-    /// Convenience overload that merges exactly two cache changeset streams, using a comparer for key conflict resolution.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when both sources provide the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from both sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        other.ThrowArgumentNullExceptionIfNull(nameof(other));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new[] { source, other }.MergeChangeSets(comparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Convenience overload that merges exactly two cache changeset streams, using an equality comparer to suppress redundant updates.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from both sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, or <paramref name="equalityComparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        other.ThrowArgumentNullExceptionIfNull(nameof(other));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-
-        return new[] { source, other }.MergeChangeSets(equalityComparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Convenience overload that merges exactly two cache changeset streams, using both a comparer and an equality comparer.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge with <paramref name="source"/>.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when both sources provide the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when both streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from both sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="other"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IChangeSet<TObject, TKey>> other, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        other.ThrowArgumentNullExceptionIfNull(nameof(other));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new[] { source, other }.MergeChangeSets(equalityComparer, comparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges <paramref name="source"/> with additional changeset streams into a single output.
-    /// Uses first-in-wins semantics for key conflicts.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.EnumerateOne().Concat(others).MergeChangeSets(scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges <paramref name="source"/> with additional changeset streams, using a comparer for key conflict resolution.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return source.EnumerateOne().Concat(others).MergeChangeSets(comparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges <paramref name="source"/> with additional changeset streams, using an equality comparer to suppress redundant updates.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, or <paramref name="equalityComparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-
-        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges <paramref name="source"/> with additional changeset streams, using both a comparer and an equality comparer.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to merge.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to merge with <paramref name="source"/>.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all streams complete. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="others"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IEnumerable<IObservable<IChangeSet<TObject, TKey>>> others, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, comparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges a fixed collection of cache changeset streams into a single unified output. All source streams are
-    /// subscribed when the output observable is subscribed to.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
-    /// <remarks>
-    /// <para>
-    /// When multiple sources provide items with the same key, this overload uses first-in-wins semantics:
-    /// the first source to provide a key retains priority. Removing that source's item allows the next
-    /// available value for that key (if any) to surface. To control which value wins, use an overload
-    /// that accepts an <see cref="IComparer{T}"/>.
-    /// </para>
-    /// <para>
-    /// An error from any source terminates the entire merged output.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer: null, completable, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Merges a fixed collection of cache changeset streams into a single output, using a comparer for key conflict
-    /// resolution. When multiple sources provide the same key, the item ordering lowest according to
-    /// <paramref name="comparer"/> is published downstream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer: null, comparer, completable, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Merges a fixed collection of cache changeset streams into a single output, using an equality comparer to
-    /// suppress redundant updates. When an incoming value for a key is equal (per <paramref name="equalityComparer"/>)
-    /// to the currently published value, the update is suppressed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="equalityComparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer: null, completable, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Merges a fixed collection of cache changeset streams into a single output, using both a comparer for key
-    /// conflict resolution and an equality comparer to suppress redundant updates.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the changesets.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying items.</typeparam>
-    /// <param name="source">The source <see cref="IEnumerable{T}"/> to merge.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that equality comparer to detect duplicate values for the same key, suppressing no-op updates.</param>
-    /// <param name="comparer">An <see cref="IComparer{TObject}"/> that comparer to determine which value wins when multiple sources provide the same key. The lowest-ordered value is published.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> used when subscribing to the source streams.</param>
-    /// <param name="completable">If <see langword="true"/> (default), the output completes when all source streams have completed. If <see langword="false"/>, the output never completes.</param>
-    /// <returns>A unified changeset stream containing changes from all source streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="equalityComparer"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject> equalityComparer, IComparer<TObject> comparer, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        equalityComparer.ThrowArgumentNullExceptionIfNull(nameof(equalityComparer));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new MergeChangeSets<TObject, TKey>(source, equalityComparer, comparer, completable, scheduler).Run();
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
-    /// into a single flattened output. This overload requires a comparer for resolving destination key conflicts.
-    /// The selector receives only the item, not its key.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
-    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="observableSelector"/> or <paramref name="comparer"/> is null.</exception>
-    /// <seealso cref="ObservableListEx.MergeManyChangeSets"/>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), comparer);
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
-    /// into a single flattened output. This overload requires a comparer for resolving destination key conflicts.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
-    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="comparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return source.MergeManyChangeSets(observableSelector, equalityComparer: null, comparer: comparer);
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child changes
-    /// into a single flattened output. The selector receives only the item, not its key.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value for a destination key.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key conflicts when multiple child streams provide items with the same destination key. The lowest-ordered item wins.</param>
-    /// <returns>A merged changeset stream containing items from all active child streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), equalityComparer, comparer);
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child changeset stream and merges all child
-    /// changes into a single flattened output stream. Child subscriptions track the parent item lifecycle:
-    /// created on Add, replaced on Update, disposed on Remove.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source (parent) cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying parent items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a parent item and its key, and returns a child cache changeset stream. Called once per parent Add/Update.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress no-op child updates. When a child key's new value equals the current value per this comparer, the update is not emitted.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve child key conflicts when multiple parents contribute children with the same destination key. The lowest-ordered child value wins. Without a comparer, the first parent to provide a key retains priority.</param>
-    /// <returns>A merged changeset stream containing all child items from all active parent subscriptions.</returns>
-    /// <remarks>
-    /// <para>
-    /// This is the changeset-aware counterpart to <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>.
-    /// Where MergeMany produces a flat <c>IObservable&lt;T&gt;</c>, MergeManyChangeSets produces an <c>IObservable&lt;IChangeSet&gt;</c>
-    /// that tracks the full lifecycle of child items, including key conflict resolution across parents.
-    /// </para>
-    /// <para>
-    /// <b>Parent-side change handling (source changeset events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Calls <paramref name="observableSelector"/> with the new parent item to obtain a child changeset stream, then subscribes. As the child stream emits changesets, those child items are merged into the output. The downstream observer sees <b>Add</b> changes for each new child item.</description></item>
-    /// <item><term>Update</term><description>Disposes the previous parent's child subscription (removing all of its contributed child items from the output as <b>Remove</b> changes), then creates a new child subscription for the updated parent. The new child's items appear as <b>Add</b> changes.</description></item>
-    /// <item><term>Remove</term><description>Disposes the parent's child subscription. All child items contributed by that parent are emitted as <b>Remove</b> changes in the output. If another parent also provides a child with the same destination key, that parent's value is promoted as an <b>Update</b> (not an Add).</description></item>
-    /// <item><term>Refresh</term><description>No effect on the child subscription. The parent's child stream continues unchanged.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Child-side change handling (changes arriving from child changeset streams):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>If the destination key is new, an <b>Add</b> is emitted. If another parent already contributed a child with the same key, the conflict is resolved by <paramref name="comparer"/> (lowest wins) or first-in-wins if no comparer. The losing value is tracked internally but not emitted.</description></item>
-    /// <item><term>Update</term><description>If this parent currently owns the destination key downstream, an <b>Update</b> is emitted. With a comparer, all parents are re-evaluated for that key; a different parent's value may win, producing an <b>Update</b> to that value instead.</description></item>
-    /// <item><term>Remove</term><description>If this parent's value was the one published downstream for that destination key, the operator scans other parents for the same key. If found, an <b>Update</b> is emitted with the replacement. If not, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>If the child item is the one currently published downstream, the <b>Refresh</b> is forwarded. With a comparer, all parents are re-evaluated first; if a different value now wins, an <b>Update</b> is emitted instead.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Error and completion:</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>OnError</term><description>An error from the source (parent) stream or from any child changeset stream terminates the entire output. Unlike <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>, child errors are NOT swallowed.</description></item>
-    /// <item><term>OnCompleted</term><description>The output completes when the source (parent) stream completes <b>and</b> all active child changeset streams have also completed.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> When multiple parents contribute children with the same destination key, only one value is published
-    /// downstream at a time. The <paramref name="comparer"/> controls which value wins; without it, the first parent to add the key
-    /// retains priority. Removing a parent that owned a contested key causes the next-best value (per comparer or next available)
-    /// to surface as an <b>Update</b>, not an Add. The <paramref name="equalityComparer"/> independently controls whether a child
-    /// Update for an already-published key is suppressed when the new value equals the old.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
-    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
-    /// <seealso cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IObservable{IChangeSet{TDestination, TDestinationKey}}}, Func{TDestination, TDestinationKey})"/>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeManyCacheChangeSets<TObject, TKey, TDestination, TDestinationKey>(source, observableSelector, equalityComparer, comparer).Run();
-    }
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/>.
-    /// Uses <paramref name="sourceComparer"/> to resolve destination key conflicts by source priority.
-    /// The selector receives only the item, not its key.
-    /// Source priorities are always re-evaluated on Refresh (default behavior).
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IComparer<TDestination> childComparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, DefaultResortOnSourceRefresh, equalityComparer: null, childComparer);
-    }
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/>.
-    /// Uses <paramref name="sourceComparer"/> to resolve destination key conflicts by source priority.
-    /// Source priorities are always re-evaluated on Refresh (default behavior).
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IComparer<TDestination> childComparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, DefaultResortOnSourceRefresh, equalityComparer: null, childComparer);
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/> and
-    /// explicit <paramref name="resortOnSourceRefresh"/> control. The selector receives only the item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
-    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IComparer<TDestination> childComparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, resortOnSourceRefresh, equalityComparer: null, childComparer);
-    }
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets with a required <paramref name="childComparer"/> and
-    /// explicit <paramref name="resortOnSourceRefresh"/> control.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
-    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that fallback comparer to resolve destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IComparer<TDestination> childComparer)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, resortOnSourceRefresh, equalityComparer: null, childComparer);
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets. Uses <paramref name="sourceComparer"/> to resolve
-    /// destination key conflicts. The selector receives only the item, not its key.
-    /// Source priorities are always re-evaluated on Refresh (default behavior).
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, DefaultResortOnSourceRefresh, equalityComparer, childComparer);
-    }
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets. Uses <paramref name="sourceComparer"/> to resolve
-    /// destination key conflicts. Source priorities are always re-evaluated on Refresh (default behavior).
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull => source.MergeManyChangeSets(observableSelector, sourceComparer, DefaultResortOnSourceRefresh, equalityComparer, childComparer);
-
-    /// <summary>
-    /// Source-priority variant of MergeManyChangeSets with full control over all conflict resolution parameters.
-    /// The selector receives only the item, not its key.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key.</param>
-    /// <param name="resortOnSourceRefresh">If <see langword="true"/>, a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer for destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream with conflicts resolved by source priority.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return source.MergeManyChangeSets((t, _) => observableSelector(t), sourceComparer, resortOnSourceRefresh, equalityComparer, childComparer);
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child cache changeset stream and merges all child
-    /// changes into a single flattened output. When multiple source items produce children with the same destination key,
-    /// <paramref name="sourceComparer"/> determines which source has priority (the source ordering lower wins).
-    /// If sources compare equal, <paramref name="childComparer"/> (if provided) breaks the tie.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key identifying child items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child cache changeset stream.</param>
-    /// <param name="sourceComparer">An <see cref="IComparer{TObject}"/> that comparer to prioritize between source items when their children produce the same destination key. Lower-ordered source wins.</param>
-    /// <param name="resortOnSourceRefresh">If <see langword="true"/> (default), a Refresh in the source stream re-evaluates source priorities. If <see langword="false"/>, Refresh events are ignored for priority recalculation.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to suppress updates when the incoming child value equals the current value for a destination key.</param>
-    /// <param name="childComparer">An <see cref="IComparer{TDestination}"/> that optional fallback comparer to resolve destination key conflicts when source items compare equal.</param>
-    /// <returns>A merged changeset stream containing items from all active child streams, with conflicts resolved by source priority.</returns>
-    /// <remarks>
-    /// <para>
-    /// The <paramref name="sourceComparer"/> provides a layer of conflict resolution above the child values themselves.
-    /// This is useful when source items represent priority tiers (e.g., user settings overriding defaults).
-    /// </para>
-    /// <para>
-    /// Errors from child streams propagate to the output. An error from the source or any child terminates the merged output.
-    /// The output completes when the source completes and all active child streams have also completed.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="sourceComparer"/> is null.</exception>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? childComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-        sourceComparer.ThrowArgumentNullExceptionIfNull(nameof(sourceComparer));
-
-        return new MergeManyCacheChangeSetsSourceCompare<TObject, TKey, TDestination, TDestinationKey>(source, observableSelector, sourceComparer, equalityComparer, childComparer, resortOnSourceRefresh).Run();
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child list changeset stream produced by
-    /// <paramref name="observableSelector"/> and merges all child changes into a single flattened list changeset output.
-    /// Child subscriptions follow the source item lifecycle: created on Add, replaced on Update, disposed on Remove.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child list changeset streams.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and its key, and returns a child list changeset stream.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to detect duplicate items in the merged list output.</param>
-    /// <returns>A merged list changeset stream containing items from all active child streams.</returns>
-    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeManyListChangeSets<TObject, TKey, TDestination>(source, observableSelector, equalityComparer).Run();
-    }
-
-    /// <summary>
-    /// For each item in the source cache, subscribes to a child list changeset stream and merges all child changes
-    /// into a single flattened list changeset output. The selector receives only the item, not its key.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child list changeset streams.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives a source item and returns a child list changeset stream.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional equality comparer to detect duplicate items in the merged list output.</param>
-    /// <returns>A merged list changeset stream containing items from all active child streams.</returns>
-    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-        return source.MergeManyChangeSets((obj, _) => observableSelector(obj), equalityComparer);
-    }
-
-    /// <summary>
-    /// Like <see cref="MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>,
-    /// but wraps each emitted value as an <see cref="ItemWithValue{TObject, TValue}"/>, pairing the source item
-    /// with the value it produced. This lets you identify which source item is responsible for each emission.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source cache.</typeparam>
-    /// <typeparam name="TKey">The type of the key identifying source cache items.</typeparam>
-    /// <typeparam name="TDestination">The type of values emitted by child observables.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that produces a child observable for each source item.</param>
-    /// <returns>An observable of <see cref="ItemWithValue{TObject, TValue}"/> pairing each emission with its source item.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is null.</exception>
-    public static IObservable<ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TDestination>> observableSelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeManyItems<TObject, TKey, TDestination>(source, observableSelector).Run();
-    }
-
-    /// <inheritdoc cref="MergeManyItems{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> whose items each produce an observable.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory function that receives both the item and its key, and returns a child observable.</param>
-    public static IObservable<ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IObservable<TDestination>> observableSelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeManyItems<TObject, TKey, TDestination>(source, observableSelector).Run();
-    }
-
-    /// <summary>
-    /// Monitors the source observable and emits <see cref="ConnectionStatus"/> values: <c>Pending</c> initially,
-    /// <c>Loaded</c> when the first value arrives, <c>Errored</c> on error, and <c>Completed</c> on completion.
-    /// This is not a changeset operator.
-    /// </summary>
-    /// <typeparam name="T">The type of the source observable.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to monitor for connection status.</param>
-    /// <returns>An observable that emits <see cref="ConnectionStatus"/> values reflecting the source's lifecycle.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="DeferUntilLoaded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<ConnectionStatus> MonitorStatus<T>(this IObservable<T> source) => new StatusMonitor<T>(source).Run();
-
-    /// <summary>
-    /// Filters out empty changesets from the stream. A thin wrapper around <c>Where(changes =&gt; changes.Count != 0)</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to suppress empty changesets.</param>
-    /// <returns>An observable that emits only non-empty changesets.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="StartWithEmpty{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> NotEmpty<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Where(changes => changes.Count != 0);
-    }
-
-    /// <summary>
-    /// Filters and casts items in the changeset to <typeparamref name="TDestination"/>. Items that are not of type
-    /// <typeparamref name="TDestination"/> are excluded. Combines filter and transform in one step without an intermediate cache.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the objects in the source changeset.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TDestination">The destination type to filter and cast to.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by type.</param>
-    /// <param name="suppressEmptyChangeSets">If <see langword="true"/>, changesets that become empty after filtering are suppressed.</param>
-    /// <returns>An observable changeset of <typeparamref name="TDestination"/> items.</returns>
-    /// <remarks>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term><b>Add</b></term><description>If the item is <typeparamref name="TDestination"/>, cast and emit as <b>Add</b>. Otherwise dropped.</description></item>
-    ///   <item><term><b>Update</b></term><description>Re-evaluated. If the new item is <typeparamref name="TDestination"/>, emit accordingly. If the old item was downstream but the new one is not, emit <b>Remove</b>.</description></item>
-    ///   <item><term><b>Remove</b></term><description>If the item was downstream, emit <b>Remove</b>.</description></item>
-    ///   <item><term><b>Refresh</b></term><description>If the item is downstream, forwarded as <b>Refresh</b>.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TDestination, TKey>> OfType<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, bool suppressEmptyChangeSets = true)
-        where TObject : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new OfType<TObject, TKey, TDestination>(source, suppressEmptyChangeSets).Run();
-    }
-
-    /// <summary>
-    /// Callback for each item as and when it is being added to the stream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item additions in.</param>
-    /// <param name="addAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each added item. Receives the new item and its key.</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Invokes <paramref name="addAction"/> with the item and key.</description></item>
-    ///   <item><term>Update</term><description>Ignored.</description></item>
-    ///   <item><term>Remove</term><description>Ignored.</description></item>
-    ///   <item><term>Refresh</term><description>Ignored.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// Exceptions thrown in <paramref name="addAction"/> propagate as <c>OnError</c>. No try-catch is applied.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="addAction"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="OnItemUpdated{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TObject,TKey})"/>
-    /// <seealso cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>
-    /// <seealso cref="ForEachChange{TObject,TKey}"/>
-    /// <seealso cref="ObservableListEx.OnItemAdded"/>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemAdded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> addAction)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        addAction.ThrowArgumentNullExceptionIfNull(nameof(addAction));
-
-        return source.OnChangeAction(ChangeReason.Add, addAction);
-    }
-
-    /// <inheritdoc cref="OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item additions in.</param>
-    /// <param name="addAction">The <see cref="Action{TObject}"/> callback invoked for each added item. Receives only the item (no key).</param>
-    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemAdded<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> addAction)
-        where TObject : notnull
-        where TKey : notnull
-        => source.OnItemAdded((obj, _) => addAction(obj));
-
-    /// <summary>
-    /// Callback for each item as and when it is being refreshed in the stream.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item refresh events in.</param>
-    /// <param name="refreshAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each refreshed item. Receives the item and its key.</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Ignored.</description></item>
-    ///   <item><term>Update</term><description>Ignored.</description></item>
-    ///   <item><term>Remove</term><description>Ignored.</description></item>
-    ///   <item><term>Refresh</term><description>Invokes <paramref name="refreshAction"/> with the item and key.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// Exceptions thrown in <paramref name="refreshAction"/> propagate as <c>OnError</c>. No try-catch is applied.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="refreshAction"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AutoRefresh{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableListEx.OnItemRefreshed"/>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemRefreshed<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> refreshAction)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        refreshAction.ThrowArgumentNullExceptionIfNull(nameof(refreshAction));
-
-        return source.OnChangeAction(ChangeReason.Refresh, refreshAction);
-    }
-
-    /// <inheritdoc cref="OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item refresh events in.</param>
-    /// <param name="refreshAction">The <see cref="Action{TObject}"/> callback invoked for each refreshed item. Receives only the item (no key).</param>
-    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey})"/>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemRefreshed<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> refreshAction)
-        where TObject : notnull
-        where TKey : notnull
-        => source.OnItemRefreshed((obj, _) => refreshAction(obj));
-
-    /// <summary>
-    /// Invokes <paramref name="removeAction"/> for each item with <see cref="ChangeReason.Remove"/> in the changeset stream.
-    /// The changeset is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item removals in.</param>
-    /// <param name="removeAction">The <see cref="Action{TObject, TKey}"/> callback invoked for each removed item. Receives the removed item and its key.</param>
-    /// <param name="invokeOnUnsubscribe">
-    /// When <see langword="true"/> (the default), the callback is also invoked for <b>every item still in the cache</b>
-    /// when the subscription is disposed. When <see langword="false"/>, only inline Remove changes trigger the callback.
-    /// </param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Ignored (but tracked internally when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>).</description></item>
-    ///   <item><term>Update</term><description>Ignored (cache updated internally when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>).</description></item>
-    ///   <item><term>Remove</term><description>Invokes <paramref name="removeAction"/> with the item and key.</description></item>
-    ///   <item><term>Refresh</term><description>Ignored.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Unsubscribe behavior:</b> when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, the operator
-    /// maintains an internal cache mirroring the stream. On disposal, it iterates all remaining items and
-    /// invokes <paramref name="removeAction"/> for each. This is useful for cleanup logic (e.g. event unsubscription)
-    /// that must run for items that were never explicitly removed.
-    /// </para>
-    /// <para>
-    /// Exceptions thrown in <paramref name="removeAction"/> propagate as <c>OnError</c> during inline removes.
-    /// During unsubscribe disposal, exceptions are not caught.
-    /// </para>
-    /// <para><b>Worth noting:</b> The action also fires for ALL remaining items when the subscription is disposed (unless <c>invokeOnUnsubscribe</c> is <see langword="false"/>). The action runs under a lock; avoid calling into other caches from within it.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="removeAction"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="DisposeMany{TObject,TKey}"/>
-    /// <seealso cref="SubscribeMany{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IDisposable})"/>
-    /// <seealso cref="ObservableListEx.OnItemRemoved"/>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemRemoved<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TKey> removeAction, bool invokeOnUnsubscribe = true)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        removeAction.ThrowArgumentNullExceptionIfNull(nameof(removeAction));
-
-        if (invokeOnUnsubscribe)
-        {
-            return new OnBeingRemoved<TObject, TKey>(source, removeAction).Run();
-        }
-
-        return source.OnChangeAction(ChangeReason.Remove, removeAction);
-    }
-
-    /// <inheritdoc cref="OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey}, bool)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item removals in.</param>
-    /// <param name="removeAction">The <see cref="Action{TObject}"/> callback invoked for each removed item. Receives only the item (no key).</param>
-    /// <param name="invokeOnUnsubscribe">When <see langword="true"/> (the default), also invoked for all remaining items on disposal.</param>
-    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TKey}, bool)"/>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemRemoved<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject> removeAction, bool invokeOnUnsubscribe = true)
-        where TObject : notnull
-        where TKey : notnull
-        => source.OnItemRemoved((obj, _) => removeAction(obj), invokeOnUnsubscribe);
-
-    /// <summary>
-    /// Invokes <paramref name="updateAction"/> for each item with <see cref="ChangeReason.Update"/> in the changeset stream.
-    /// The changeset is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item updates in.</param>
-    /// <param name="updateAction">The <see cref="Action{TObject, TObject, TKey}"/> callback invoked for each updated item. Receives the current value, previous value, and key.</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Ignored.</description></item>
-    ///   <item><term>Update</term><description>Invokes <paramref name="updateAction"/> with (current, previous, key). The previous value is always available for Update changes.</description></item>
-    ///   <item><term>Remove</term><description>Ignored.</description></item>
-    ///   <item><term>Refresh</term><description>Ignored.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// Exceptions thrown in <paramref name="updateAction"/> propagate as <c>OnError</c>. No try-catch is applied.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="updateAction"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="OnItemAdded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey})"/>
-    /// <seealso cref="ForEachChange{TObject,TKey}"/>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemUpdated<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TObject, TKey> updateAction)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
-
-        return source.OnChangeAction(static change => change.Reason == ChangeReason.Update, change => updateAction(change.Current, change.Previous.Value, change.Key));
-    }
-
-    /// <inheritdoc cref="OnItemUpdated{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe item updates in.</param>
-    /// <param name="updateAction">The <see cref="Action{TObject, TObject}"/> callback invoked for each updated item. Receives only the current and previous values (no key).</param>
-    /// <remarks>Overload that omits the key from the callback. Delegates to <see cref="OnItemUpdated{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject, TObject, TKey})"/>.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> OnItemUpdated<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Action<TObject, TObject> updateAction)
-        where TObject : notnull
-        where TKey : notnull
-        => source.OnItemUpdated((cur, prev, _) => updateAction(cur, prev));
-
-    /// <summary>
-    /// Combines multiple changeset streams using logical OR (union). An item appears downstream if it exists in any source.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
-    /// <returns>A changeset stream containing items present in any of the sources.</returns>
-    /// <remarks>
-    /// <para>
-    /// Items are tracked via reference counting across all sources. An item appears downstream as long as
-    /// at least one source contains it. When the last source holding a key removes it, the item is removed downstream.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>If this is the first source to provide the key, an <b>Add</b> is emitted. If other sources already have the key, the reference count is incremented but no emission occurs.</description></item>
-    /// <item><term>Update</term><description>If the item is currently downstream, an <b>Update</b> is emitted.</description></item>
-    /// <item><term>Remove</term><description>Reference count decremented. If the count reaches zero (no source holds the key), a <b>Remove</b> is emitted. Otherwise no emission.</description></item>
-    /// <item><term>Refresh</term><description>If the item is downstream, a <b>Refresh</b> is forwarded.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
-    /// <seealso cref="ObservableListEx.Or"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (others is null || others.Length == 0)
-        {
-            throw new ArgumentNullException(nameof(others));
-        }
-
-        return source.Combine(CombineOperator.Or, others);
-    }
-
-    /// <inheritdoc cref="Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
-    /// <remarks>This overload accepts a pre-built collection of sources instead of a params array.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Or);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Or operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Or);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Or operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Or);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Or operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Or<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Or);
-    }
-
-    /// <summary>
-    /// Subscribes to the observable and calls <c>AddOrUpdate</c> on the source cache for each emitted batch of items.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
-    /// <param name="observable">The <see cref="IObservable{IEnumerable{TObject}}"/> that emits batches of items.</param>
-    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from <paramref name="observable"/>.</returns>
-    /// <remarks>
-    /// <para>Each emission from <paramref name="observable"/> is passed to <see cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TObject})"/>, producing one changeset per emission containing <b>Add</b> or <b>Update</b> events for each item. Errors from <paramref name="observable"/> propagate and terminate the subscription. Completion ends the subscription; the cache retains all items.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observable"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
-    /// <seealso cref="ToObservableChangeSet{TObject, TKey}(IObservable{IEnumerable{TObject}}, Func{TObject, TKey}, Func{TObject, TimeSpan?}, int, IScheduler?)"/>
-    public static IDisposable PopulateFrom<TObject, TKey>(this ISourceCache<TObject, TKey> source, IObservable<IEnumerable<TObject>> observable)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return observable.Subscribe(source.AddOrUpdate);
-    }
-
-    /// <summary>
-    /// Subscribes to the observable and calls <c>AddOrUpdate</c> on the source cache for each emitted item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to operate on.</param>
-    /// <param name="observable">The <see cref="IObservable{TObject}"/> that emits individual items.</param>
-    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from <paramref name="observable"/>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observable"/> is <see langword="null"/>.</exception>
-    public static IDisposable PopulateFrom<TObject, TKey>(this ISourceCache<TObject, TKey> source, IObservable<TObject> observable)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return observable.Subscribe(source.AddOrUpdate);
-    }
-
-    /// <summary>
-    /// Subscribes to the changeset stream and clones each changeset into the destination cache.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
-    /// <param name="destination">The <see cref="ISourceCache{TObject, TKey}"/> that will receive the changes.</param>
-    /// <returns>An <see cref="IDisposable"/> that, when disposed, unsubscribes from the source.</returns>
-    /// <remarks>
-    /// <para>
-    /// Each changeset from the source is applied to the destination cache inside an Edit call.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The item is added to the destination cache via AddOrUpdate.</description></item>
-    /// <item><term>Update</term><description>The item is updated in the destination cache via AddOrUpdate.</description></item>
-    /// <item><term>Remove</term><description>The item is removed from the destination cache.</description></item>
-    /// <item><term>Refresh</term><description>A Refresh is issued on the destination cache for the item.</description></item>
-    /// <item><term>OnError</term><description>The subscription is terminated. The destination cache is not rolled back.</description></item>
-    /// <item><term>OnCompleted</term><description>The subscription ends. The destination cache retains all items.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="destination"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="PopulateFrom{TObject, TKey}(ISourceCache{TObject, TKey}, IObservable{IEnumerable{TObject}})"/>
-    /// <seealso cref="AsObservableCache{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
-    /// <seealso cref="ObservableListEx.PopulateInto{T}(IObservable{IChangeSet{T}}, ISourceList{T})"/>
-    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ISourceCache<TObject, TKey> destination)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
-    }
-
-    /// <inheritdoc cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
-    /// <param name="destination">The <see cref="IIntermediateCache{TObject, TKey}"/> that will receive the changes.</param>
-    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
-    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IIntermediateCache<TObject, TKey> destination)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
-    }
-
-    /// <inheritdoc cref="PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to pipe into a target cache.</param>
-    /// <param name="destination">The <see cref="LockFreeObservableCache{TObject, TKey}"/> that will receive the changes.</param>
-    /// <remarks>Overload that targets a <see cref="LockFreeObservableCache{TObject, TKey}"/>.</remarks>
-    public static IDisposable PopulateInto<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, LockFreeObservableCache<TObject, TKey> destination)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
-    }
-
-    /// <summary>
-    /// Projects the current cache state through <paramref name="resultSelector"/> after each modification.
-    /// Emits a new value of <typeparamref name="TDestination"/> on every changeset.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
-    /// <param name="resultSelector">A function that projects the current <see cref="IQuery{TObject, TKey}"/> snapshot to a result value.</param>
-    /// <returns>An observable that emits a projected value after each changeset.</returns>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> The selector is called on every changeset, which can be chatty. The <see cref="IQuery{TObject, TKey}"/> exposes the full cache state for LINQ-style queries.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="ToCollection{TObject, TKey}"/>
-    /// <seealso cref="ToSortedCollection{TObject, TKey, TSortKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TSortKey}, SortDirection)"/>
-    /// <seealso cref="ObservableListEx.QueryWhenChanged"/>
-    public static IObservable<TDestination> QueryWhenChanged<TObject, TKey, TDestination>(this IObservable<IChangeSet<TObject, TKey>> source, Func<IQuery<TObject, TKey>, TDestination> resultSelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return source.QueryWhenChanged().Select(resultSelector);
-    }
-
-    /// <summary>
-    /// The latest copy of the cache is exposed for querying i)  after each modification to the underlying data ii) upon subscription.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
-    /// <returns>An observable which emits the query.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new QueryWhenChanged<TObject, TKey, Unit>(source).Run();
-    }
-
-    /// <summary>
-    /// The latest copy of the cache is exposed for querying i)  after each modification to the underlying data ii) on subscription.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the value.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to project on each change.</param>
-    /// <param name="itemChangedTrigger">A <see cref="Func{T, TResult}"/> that should the query be triggered for observables on individual items.</param>
-    /// <returns>An observable that emits the query.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> itemChangedTrigger)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        itemChangedTrigger.ThrowArgumentNullExceptionIfNull(nameof(itemChangedTrigger));
-
-        return new QueryWhenChanged<TObject, TKey, TValue>(source, itemChangedTrigger).Run();
-    }
-
-    /// <summary>
-    /// Cache-aware equivalent of <c>Publish().RefCount()</c>. An internal cache is created on the first subscriber
-    /// and disposed when the last subscriber unsubscribes. All subscribers share the same upstream subscription.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to share via reference counting.</param>
-    /// <returns>A ref-counted observable changeset stream.</returns>
-    /// <seealso cref="AsObservableCache{TObject,TKey}(IObservable{IChangeSet{TObject, TKey}}, bool)"/>
-    public static IObservable<IChangeSet<TObject, TKey>> RefCount<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new RefCount<TObject, TKey>(source).Run();
-    }
-
-    /// <summary>
-    /// Signals downstream operators to re-evaluate the specified item. Produces a changeset with a single <b>Refresh</b> change.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to refresh.</param>
-    /// <remarks>
-    /// <para>Convenience method that wraps a Refresh inside <see cref="ISourceCache{TObject,TKey}.Edit"/>. A Refresh does not change data in the cache; it signals downstream operators (such as <see cref="Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/> or <see cref="Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>) to re-evaluate the item.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="SuppressRefresh{TObject, TKey}"/>
-    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Refresh(item));
-    }
-
-    /// <summary>
-    /// Signals downstream operators to re-evaluate the specified items. Produces one changeset with a <b>Refresh</b> for each item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
-    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to refresh.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Refresh(items));
-    }
-
-    /// <summary>
-    /// Signals downstream operators to re-evaluate all items in the cache. Produces one changeset with a <b>Refresh</b> for every item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> to signal re-evaluation on.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Refresh<TObject, TKey>(this ISourceCache<TObject, TKey> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Refresh());
-    }
-
-    /// <summary>
-    /// Removes the specified item from the cache. Produces a <b>Remove</b> changeset if the item exists, nothing otherwise.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to remove.</param>
-    /// <remarks>
-    /// <para>Convenience method that wraps a single-item removal inside <see cref="ISourceCache{TObject,TKey}.Edit"/>. The key is extracted from the item using the cache's key selector.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="AddOrUpdate{TObject, TKey}(ISourceCache{TObject, TKey}, TObject)"/>
-    /// <seealso cref="Clear{TObject, TKey}(ISourceCache{TObject, TKey})"/>
-    /// <seealso cref="RemoveKeys{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TKey})"/>
-    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, TObject item)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(item));
-    }
-
-    /// <summary>
-    /// Removes the item with the specified key from the cache. Produces a <b>Remove</b> changeset if the key exists, nothing otherwise.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key of the item to remove.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(key));
-    }
-
-    /// <summary>
-    /// Removes the specified items from the cache. Any items not present in the cache are ignored.
-    /// Produces a <b>Remove</b> changeset for each item that existed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="items">The <see cref="IEnumerable{TObject}"/> of items to remove.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TObject> items)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(items));
-    }
-
-    /// <summary>
-    /// Removes the items with the specified keys from the cache. Any keys not present are ignored.
-    /// Produces a <b>Remove</b> changeset for each key that existed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void Remove<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TKey> keys)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(keys));
-    }
-
-    /// <inheritdoc cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, TKey)"/>
-    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key of the item to remove.</param>
-    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
-    public static void Remove<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(key));
-    }
-
-    /// <inheritdoc cref="Remove{TObject, TKey}(ISourceCache{TObject, TKey}, IEnumerable{TKey})"/>
-    /// <param name="source">The <see cref="IIntermediateCache{TObject, TKey}"/> from which to remove items.</param>
-    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
-    /// <remarks>Overload that targets an <see cref="IIntermediateCache{TObject, TKey}"/>.</remarks>
-    public static void Remove<TObject, TKey>(this IIntermediateCache<TObject, TKey> source, IEnumerable<TKey> keys)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.Remove(keys));
-    }
-
-    /// <summary>
-    /// Strips the key from a cache changeset, converting <see cref="IChangeSet{TObject, TKey}"/> to
-    /// <see cref="IChangeSet{TObject}"/> (list changeset). All indexed changes are dropped (sorting is not supported).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to strip keys from, producing an unkeyed list changeset.</param>
-    /// <returns>A list changeset stream without key information.</returns>
-    /// <seealso cref="ObservableListEx.AddKey{TObject, TKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TKey})"/>
-    /// <seealso cref="ChangeKey{TObject, TSourceKey, TDestinationKey}(IObservable{IChangeSet{TObject, TSourceKey}}, Func{TObject, TDestinationKey})"/>
-    public static IObservable<IChangeSet<TObject>> RemoveKey<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Select(
-            changes =>
-            {
-                var enumerator = new RemoveKeyEnumerator<TObject, TKey>(changes);
-                return new ChangeSet<TObject>(enumerator);
-            });
-    }
-
-    /// <summary>
-    /// Removes a specific key from the cache. Equivalent to <c>source.Edit(u =&gt; u.RemoveKey(key))</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove a key.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to remove.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void RemoveKey<TObject, TKey>(this ISourceCache<TObject, TKey> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.RemoveKey(key));
-    }
-
-    /// <summary>
-    /// Removes multiple keys from the cache in a single <c>Edit</c> call. Keys not present in the cache are ignored.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The <see cref="ISourceCache{TObject, TKey}"/> from which to remove keys.</param>
-    /// <param name="keys">The <see cref="IEnumerable{TKey}"/> keys to remove.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static void RemoveKeys<TObject, TKey>(this ISourceCache<TObject, TKey> source, IEnumerable<TKey> keys)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        source.Edit(updater => updater.RemoveKeys(keys));
-    }
-
-    /// <inheritdoc cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left and right values into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, TRight, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.RightJoin(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Joins two changeset streams, producing a result for every right-side key. The left side is
-    /// <see cref="Optional{T}"/> because a matching left item may or may not exist. All right items
-    /// appear in the output regardless. Equivalent to SQL RIGHT OUTER JOIN.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the right key, optional left, and right value into a destination object. Example: <c>(rightKey, left, right) =&gt; new Result(rightKey, left, right)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TRightKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Always emits. Invokes <paramref name="resultSelector"/> with the matching left (or <see cref="Optional.None{T}"/>) and the right value.</description></item>
-    ///   <item><term>Update</term><description>Re-invokes the selector with current left (if any) and the new right value.</description></item>
-    ///   <item><term>Remove</term><description>Removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh on the joined result.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If matching right items exist, re-invokes the selector (left transitions from None to Some) and emits Updates.</description></item>
-    ///   <item><term>Update</term><description>If matching right items exist, re-invokes the selector with the new left value.</description></item>
-    ///   <item><term>Remove</term><description>If matching right items exist, re-invokes the selector (left transitions from Some to None) and emits Updates.</description></item>
-    ///   <item><term>Refresh</term><description>If joined results exist, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="InnerJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{ValueTuple{TLeftKey, TRightKey}, TLeft, TRight, TDestination})"/>
-    /// <seealso cref="LeftJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="FullJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, Optional{TRight}, TDestination})"/>
-    /// <seealso cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TRightKey, Optional<TLeft>, TRight, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <inheritdoc cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the optional left value and the right group into a destination object. The key is not provided in this overload.</param>
-    /// <remarks>Overload that omits the key from the result selector. Delegates to <see cref="RightJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>.</remarks>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return left.RightJoinMany(right, rightKeySelector, (_, leftValue, rightValue) => resultSelector(leftValue, rightValue));
-    }
-
-    /// <summary>
-    /// Groups right-side items by their mapped key, then right-joins each group to the left source.
-    /// A result is produced for every key that has at least one right item. The left value is
-    /// <see cref="Optional{T}"/> because a matching left item may or may not exist.
-    /// Equivalent to SQL RIGHT OUTER JOIN with the right side grouped.
-    /// </summary>
-    /// <typeparam name="TLeft">The item type of the left source.</typeparam>
-    /// <typeparam name="TLeftKey">The key type of the left source.</typeparam>
-    /// <typeparam name="TRight">The item type of the right source.</typeparam>
-    /// <typeparam name="TRightKey">The key type of the right source.</typeparam>
-    /// <typeparam name="TDestination">The type produced by <paramref name="resultSelector"/>.</typeparam>
-    /// <param name="left">The left <see cref="IObservable{IChangeSet{TLeft, TLeftKey}}"/> to join.</param>
-    /// <param name="right">The right <see cref="IObservable{IChangeSet{TRight, TRightKey}}"/> to join.</param>
-    /// <param name="rightKeySelector">A <see cref="Func{T, TResult}"/> that maps each right item to the left key it should join on.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> that combines the key, optional left value, and right group into a destination object. Example: <c>(key, left, group) =&gt; new Result(key, left, group)</c>.</param>
-    /// <returns>An observable changeset keyed by <typeparamref name="TLeftKey"/>.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Right-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Updates the right group. If the group was previously empty, emits an Add with the current left (if any). Otherwise emits an Update.</description></item>
-    ///   <item><term>Update</term><description>Updates the right group and re-invokes <paramref name="resultSelector"/>.</description></item>
-    ///   <item><term>Remove</term><description>Updates the right group. If the group becomes empty, removes the joined result.</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// <b>Left-side change handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>If a non-empty right group exists, re-invokes the selector (left transitions from None to Some) and emits an Update.</description></item>
-    ///   <item><term>Update</term><description>If a non-empty right group exists, re-invokes the selector with the new left value.</description></item>
-    ///   <item><term>Remove</term><description>If a non-empty right group exists, re-invokes the selector (left transitions from Some to None) and emits an Update.</description></item>
-    ///   <item><term>Refresh</term><description>If a joined result exists, forwarded as Refresh.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>Both sources are serialized through a shared lock held during downstream delivery. Avoid blocking operations in subscribers.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Any argument is <see langword="null"/>.</exception>
-    /// <seealso cref="RightJoin{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TRightKey, Optional{TLeft}, TRight, TDestination})"/>
-    /// <seealso cref="InnerJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="LeftJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, TLeft, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    /// <seealso cref="FullJoinMany{TLeft, TLeftKey, TRight, TRightKey, TDestination}(IObservable{IChangeSet{TLeft, TLeftKey}}, IObservable{IChangeSet{TRight, TRightKey}}, Func{TRight, TLeftKey}, Func{TLeftKey, Optional{TLeft}, IGrouping{TRight, TRightKey, TLeftKey}, TDestination})"/>
-    public static IObservable<IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this IObservable<IChangeSet<TLeft, TLeftKey>> left, IObservable<IChangeSet<TRight, TRightKey>> right, Func<TRight, TLeftKey> rightKeySelector, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
-        where TLeft : notnull
-        where TLeftKey : notnull
-        where TRight : notnull
-        where TRightKey : notnull
-        where TDestination : notnull
-    {
-        left.ThrowArgumentNullExceptionIfNull(nameof(left));
-        right.ThrowArgumentNullExceptionIfNull(nameof(right));
-        rightKeySelector.ThrowArgumentNullExceptionIfNull(nameof(rightKeySelector));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return new RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(left, right, rightKeySelector, resultSelector).Run();
-    }
-
-    /// <summary>
-    /// Skips the initial snapshot changeset that <c>Connect()</c> typically emits, then forwards all subsequent changesets.
-    /// Internally uses <c>DeferUntilLoaded().Skip(1)</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to skip the initial changeset.</param>
-    /// <returns>An observable that skips the first changeset and forwards all others.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="DeferUntilLoaded{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
-    /// <seealso cref="StartWithEmpty{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> SkipInitial<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.DeferUntilLoaded().Skip(1);
-    }
-
-    /// <summary>
-    /// Obsolete: use SortAndBind instead. Sorts using the specified comparer.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
-    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used to determine sort order.</param>
-    /// <param name="sortOptimisations">A <see cref="SortOptimisations"/> that sort optimisation flags. Specify one or more sort optimisations.</param>
-    /// <param name="resetThreshold">The number of updates before the entire list is resorted (rather than inline sort).</param>
-    /// <returns>An observable which emits change sets.</returns>
-    /// <exception cref="ArgumentNullException">
-    /// source
-    /// or
-    /// comparer.
-    /// </exception>
-    /// <seealso cref="ObservableListEx.Sort"/>
-    [Obsolete(Constants.SortIsObsolete)]
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new Sort<TObject, TKey>(source, comparer, sortOptimisations, resetThreshold: resetThreshold).Run();
-    }
-
-    /// <summary>
-    /// Obsolete: use SortAndBind instead. Sorts using a dynamic comparer observable.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
-    /// <param name="comparerObservable">The <see cref="IObservable{IComparer{TObject}}"/> comparer observable.</param>
-    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
-    /// <param name="resetThreshold">The reset threshold.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    [Obsolete(Constants.SortIsObsolete)]
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IComparer<TObject>> comparerObservable, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparerObservable.ThrowArgumentNullExceptionIfNull(nameof(comparerObservable));
-
-        return new Sort<TObject, TKey>(source, null, sortOptimisations, comparerObservable, resetThreshold: resetThreshold).Run();
-    }
-
-    /// <summary>
-    /// Obsolete: use SortAndBind instead. Sorts using a dynamic comparer observable with a manual re-sort signal.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
-    /// <param name="comparerObservable">The <see cref="IObservable{IComparer{TObject}}"/> comparer observable.</param>
-    /// <param name="resorter">An <see cref="IObservable{Unit}"/> that signals the algorithm to re-sort the entire data set.</param>
-    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
-    /// <param name="resetThreshold">The reset threshold.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    [Obsolete(Constants.SortIsObsolete)]
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IObservable<IComparer<TObject>> comparerObservable, IObservable<Unit> resorter, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparerObservable.ThrowArgumentNullExceptionIfNull(nameof(comparerObservable));
-
-        return new Sort<TObject, TKey>(source, null, sortOptimisations, comparerObservable, resorter, resetThreshold).Run();
-    }
-
-    /// <summary>
-    /// Obsolete: use SortAndBind instead. Sorts using a static comparer with a manual re-sort signal.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
-    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used to determine sort order.</param>
-    /// <param name="resorter">An <see cref="IObservable{Unit}"/> that signals the algorithm to re-sort the entire data set.</param>
-    /// <param name="sortOptimisations">The <see cref="SortOptimisations"/> sort optimisations.</param>
-    /// <param name="resetThreshold">The reset threshold.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    [Obsolete(Constants.SortIsObsolete)]
-    public static IObservable<ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer, IObservable<Unit> resorter, SortOptimisations sortOptimisations = SortOptimisations.None, int resetThreshold = DefaultSortResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        resorter.ThrowArgumentNullExceptionIfNull(nameof(resorter));
-
-        return new Sort<TObject, TKey>(source, comparer, sortOptimisations, null, resorter, resetThreshold).Run();
-    }
-
-    /// <summary>
-    /// Sorts the changeset stream by the value returned from <paramref name="expression"/>. Creates a comparer internally
-    /// and delegates to <see cref="Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>.
-    /// Since Sort is obsolete, prefer SortAndBind for new code.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to sort.</param>
-    /// <param name="expression">A <see cref="Func{T, TResult}"/> that expression that selects a comparable value from each item.</param>
-    /// <param name="sortOrder">The <see cref="SortDirection"/> sort direction. Defaults to ascending.</param>
-    /// <param name="sortOptimisations">A <see cref="SortOptimisations"/> that sort optimization flags.</param>
-    /// <param name="resetThreshold">The number of updates before the entire list is re-sorted (rather than inline sort).</param>
-    /// <returns>An observable that emits sorted changesets.</returns>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> SortBy<TObject, TKey>(
-        this IObservable<IChangeSet<TObject, TKey>> source,
-        Func<TObject, IComparable> expression,
-        SortDirection sortOrder = SortDirection.Ascending,
-        SortOptimisations sortOptimisations = SortOptimisations.None,
-        int resetThreshold = DefaultSortResetThreshold)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source = source ?? throw new ArgumentNullException(nameof(source));
-        expression = expression ?? throw new ArgumentNullException(nameof(expression));
-
-        return source.Sort(
-            sortOrder switch
-            {
-                SortDirection.Descending => SortExpressionComparer<TObject>.Descending(expression),
-                _ => SortExpressionComparer<TObject>.Ascending(expression),
-            },
-            sortOptimisations,
-            resetThreshold);
-    }
-
-    /// <summary>
-    /// Prepends an empty changeset to the source stream, ensuring subscribers always receive an immediate
-    /// (empty) notification on subscription. Uses Rx's <c>StartWith</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty changeset first, then all source changesets.</returns>
-    /// <seealso cref="ObservableListEx.StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.StartWith(ChangeSet<TObject, TKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty sorted changeset first, then all source changesets.</returns>
-    /// <remarks>Overload for <see cref="ISortedChangeSet{TObject, TKey}"/>.</remarks>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.StartWith(SortedChangeSet<TObject, TKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <param name="source">The source <see cref="IObservable{IVirtualChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty virtual changeset first, then all source changesets.</returns>
-    /// <remarks>Overload for <see cref="IVirtualChangeSet{TObject, TKey}"/>.</remarks>
-    public static IObservable<IVirtualChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IVirtualChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.StartWith(VirtualChangeSet<TObject, TKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <param name="source">The source <see cref="IObservable{IPagedChangeSet{TObject, TKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty paged changeset first, then all source changesets.</returns>
-    /// <remarks>Overload for <see cref="IPagedChangeSet{TObject, TKey}"/>.</remarks>
-    public static IObservable<IPagedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this IObservable<IPagedChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.StartWith(PagedChangeSet<TObject, TKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The grouping key type.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IGroupChangeSet{TObject, TKey, TGroupKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty group changeset first, then all source changesets.</returns>
-    /// <remarks>Overload for <see cref="IGroupChangeSet{TObject, TKey, TGroupKey}"/>.</remarks>
-    public static IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull => source.StartWith(GroupChangeSet<TObject, TKey, TGroupKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TGroupKey">The grouping key type.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IImmutableGroupChangeSet{TObject, TKey, TGroupKey}}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty immutable group changeset first, then all source changesets.</returns>
-    /// <remarks>Overload for <see cref="IImmutableGroupChangeSet{TObject, TKey, TGroupKey}"/>.</remarks>
-    public static IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-        where TGroupKey : notnull => source.StartWith(ImmutableGroupChangeSet<TObject, TKey, TGroupKey>.Empty);
-
-    /// <inheritdoc cref="StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{T}"/> of <see cref="IReadOnlyCollection{T}"/> to prepend an empty changeset to.</param>
-    /// <returns>An observable that emits an empty collection first, then all source collections.</returns>
-    /// <remarks>Overload for <see cref="IReadOnlyCollection{T}"/>.</remarks>
-    public static IObservable<IReadOnlyCollection<T>> StartWithEmpty<T>(this IObservable<IReadOnlyCollection<T>> source) => source.StartWith(ReadOnlyCollectionLight<T>.Empty);
-
-    /// <inheritdoc cref="StartWithItem{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TObject, TKey)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an initial item to.</param>
-    /// <param name="item">The item to prepend. The key is extracted from <see cref="IKey{TKey}.Key"/>.</param>
-    /// <remarks>Overload for items that implement <see cref="IKey{TKey}"/>. Delegates to the explicit key overload.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TObject item)
-        where TObject : IKey<TKey>
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.StartWithItem(item, item.Key);
-    }
-
-    /// <summary>
-    /// Prepends a changeset containing a single <b>Add</b> for the given item and key to the source stream.
-    /// The Rx equivalent of <c>StartWith</c>, but wrapped as a DynamicData changeset.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to prepend an initial item to.</param>
-    /// <param name="item">The <typeparamref name="TObject"/> item to prepend.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key for the item.</param>
-    /// <returns>An observable that emits a single-item Add changeset first, then all source changesets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TObject item, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        var change = new Change<TObject, TKey>(ChangeReason.Add, key, item);
-        return source.StartWith(new ChangeSet<TObject, TKey> { change });
-    }
-
-    /// <summary>
-    /// Creates an <see cref="IDisposable"/> subscription per item via <paramref name="subscriptionFactory"/>.
-    /// Subscriptions are created on Add/Update and disposed on Update/Remove. All active subscriptions
-    /// are disposed when the stream completes, errors, or the subscription is disposed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to create a subscription for each item in.</param>
-    /// <param name="subscriptionFactory">A factory that creates an <see cref="IDisposable"/> for each item. Called on Add and Update (for the new value).</param>
-    /// <returns>A stream that forwards all changesets from <paramref name="source"/> unchanged.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Change reason handling:</b>
-    /// <list type="table">
-    ///   <listheader><term>Event</term><description>Behavior</description></listheader>
-    ///   <item><term>Add</term><description>Calls <paramref name="subscriptionFactory"/>, stores the returned <see cref="IDisposable"/>.</description></item>
-    ///   <item><term>Update</term><description>Disposes the previous subscription, then calls <paramref name="subscriptionFactory"/> for the new value.</description></item>
-    ///   <item><term>Remove</term><description>Disposes the subscription for the removed item.</description></item>
-    ///   <item><term>Refresh</term><description>Passed through. No subscription change.</description></item>
-    /// </list>
-    /// </para>
-    /// <para>
-    /// Internally implemented using <see cref="Transform{TDestination,TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Func{TObject,TKey,TDestination}, bool)"/>
-    /// and <see cref="DisposeMany{TObject,TKey}"/>, so disposal semantics match <see cref="DisposeMany{TObject,TKey}"/>.
-    /// </para>
-    /// <para>
-    /// Use this to tie per-item side effects (event subscriptions, polling timers, child observable subscriptions)
-    /// to the lifecycle of items in the cache.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="subscriptionFactory"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="DisposeMany{TObject,TKey}"/>
-    /// <seealso cref="OnItemRemoved{TObject,TKey}(IObservable{IChangeSet{TObject,TKey}}, Action{TObject,TKey}, bool)"/>
-    /// <seealso cref="ObservableListEx.SubscribeMany"/>
-    public static IObservable<IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IDisposable> subscriptionFactory)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
-
-        return new SubscribeMany<TObject, TKey>(source, subscriptionFactory).Run();
-    }
-
-    /// <inheritdoc cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to create a subscription for each item in.</param>
-    /// <param name="subscriptionFactory">A factory that creates an <see cref="IDisposable"/> for each item. Receives the item and its key.</param>
-    /// <remarks>Overload whose factory receives both the item and the key. See <see cref="SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/> for full details.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey, IDisposable> subscriptionFactory)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
-
-        return new SubscribeMany<TObject, TKey>(source, subscriptionFactory).Run();
-    }
-
-    /// <summary>
-    /// Suppress refresh notifications.
-    /// </summary>
-    /// <typeparam name="TObject">The object of the change set.</typeparam>
-    /// <typeparam name="TKey">The key of the change set.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to strip refresh events.</param>
-    /// <returns>An observable which emits change sets.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> SuppressRefresh<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.WhereReasonsAreNot(ChangeReason.Refresh);
-
-    /// <inheritdoc cref="Switch{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}})"/>
-    /// <param name="sources">An observable that emits <see cref="IObservableCache{TObject, TKey}"/> instances.</param>
-    /// <remarks>Overload that accepts observable caches. Internally calls <c>Connect()</c> on each cache and delegates to the changeset overload.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this IObservable<IObservableCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Select(cache => cache.Connect()).Switch();
-    }
-
-    /// <summary>
-    /// Subscribes to the latest inner changeset stream, unsubscribing from the previous one on each switch.
-    /// When switching, the old source's items are removed and the new source's items are added.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">An <see cref="IObservable{T}"/> of <see cref="IObservable{T}"/> changeset streams. The operator subscribes to the latest inner stream.</param>
-    /// <returns>A changeset stream reflecting the items from the most recently emitted inner source.</returns>
-    /// <remarks>
-    /// <para>On switch: <b>Remove</b> is emitted for all items from the previous source, then <b>Add</b> for all items from the new source.</para>
-    /// <para><b>Worth noting:</b> Each switch clears the entire downstream cache before populating from the new source. Subscribers see a full remove-then-add reset on every switch.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this IObservable<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return new Switch<TObject, TKey>(sources).Run();
-    }
-
-    /// <summary>
-    /// Converts the change set into a fully formed collection. Each change in the source results in a new collection.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a collection on each change.</param>
-    /// <returns>An observable which emits the read only collection.</returns>
-    /// <seealso cref="ObservableListEx.ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
-    public static IObservable<IReadOnlyCollection<TObject>> ToCollection<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull => source.QueryWhenChanged(query => new ReadOnlyCollectionLight<TObject>(query.Items));
-
-    /// <summary>
-    /// Bridges a standard Rx observable of individual items into a DynamicData changeset stream.
-    /// Each emission becomes an <b>Add</b> (or <b>Update</b> if the key already exists).
-    /// Supports optional per-item expiration and size limiting.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{TObject}"/> to convert into a keyed changeset stream.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that selects the unique key for each item.</param>
-    /// <param name="expireAfter">An optional <see cref="Func{T, TResult}"/> that specifies per-item expiration time. Return <see langword="null"/> for no expiration.</param>
-    /// <param name="limitSizeTo">The maximum cache size. Oldest items are removed when exceeded. Use -1 for no limit.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiration timing.</param>
-    /// <returns>An observable changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(
-            this IObservable<TObject> source,
-            Func<TObject, TKey> keySelector,
-            Func<TObject, TimeSpan?>? expireAfter = null,
-            int limitSizeTo = -1,
-            IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return Cache.Internal.ToObservableChangeSet<TObject, TKey>.Create(
-            source: source,
-            keySelector: keySelector,
-            expireAfter: expireAfter,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-    }
-
-    /// <summary>
-    /// Bridges a standard Rx observable of item batches into a DynamicData changeset stream.
-    /// Each batch is processed with <c>AddOrUpdate</c>, producing <b>Add</b> or <b>Update</b> changes per item.
-    /// Supports optional per-item expiration and size limiting.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{TObject}}"/> to convert into a keyed changeset stream.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that selects the unique key for each item.</param>
-    /// <param name="expireAfter">An optional <see cref="Func{T, TResult}"/> that specifies per-item expiration time. Return <see langword="null"/> for no expiration.</param>
-    /// <param name="limitSizeTo">The maximum cache size. Oldest items are removed when exceeded. Use -1 for no limit.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiration timing.</param>
-    /// <returns>An observable changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(
-            this IObservable<IEnumerable<TObject>> source,
-            Func<TObject, TKey> keySelector,
-            Func<TObject, TimeSpan?>? expireAfter = null,
-            int limitSizeTo = -1,
-            IScheduler? scheduler = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return Cache.Internal.ToObservableChangeSet<TObject, TKey>.Create(
-            source: source,
-            keySelector: keySelector,
-            expireAfter: expireAfter,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-    }
-
-    /// <summary>
-    /// Watches a single key in the source changeset stream, emitting <c>Optional.Some(value)</c> when the key
-    /// is present and <see cref="Optional.None{T}"/> when it is removed. Duplicate values are suppressed via <paramref name="equalityComparer"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to watch.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TObject}"/> that optional comparer to suppress duplicate emissions. Uses default equality if <see langword="null"/>.</param>
-    /// <returns>An observable of <see cref="Optional{TObject}"/> that reflects the presence or absence of the specified key.</returns>
-    /// <remarks>
-    /// <para>
-    /// Unlike <see cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>, this emits <c>None</c> on removal
-    /// (rather than the removed value), making it possible to distinguish "key is absent" from "key has a value".
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Emits <c>Optional.Some(value)</c> if the key was not previously tracked.</description></item>
-    /// <item><term>Update</term><description>Emits <c>Optional.Some(newValue)</c> if the new value differs from the previous per <paramref name="equalityComparer"/>. Otherwise suppressed.</description></item>
-    /// <item><term>Remove</term><description>Emits <see cref="Optional.None{T}"/>.</description></item>
-    /// <item><term>Refresh</term><description>Emits <c>Optional.Some(value)</c> if the value differs from the last emission per <paramref name="equalityComparer"/>. Otherwise suppressed.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> No emission occurs if the key is not present at subscription time. To get an initial <c>None</c> when the key is absent, use the overload with <c>initialOptionalWhenMissing: true</c>.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Watch{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
-    /// <seealso cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
-    public static IObservable<Optional<TObject>> ToObservableOptional<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new ToObservableOptional<TObject, TKey>(source, key, equalityComparer).Run();
-    }
-
-    /// <summary>
-    /// Converts an observable cache into an observable optional that emits the value for the given key.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key value.</param>
-    /// <param name="initialOptionalWhenMissing">When <see langword="true"/>, emits an initial <see cref="Optional{TObject}"/> with no value if the key is not present in the cache.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> instance used to determine if an object value has changed.</param>
-    /// <returns>An observable optional.</returns>
-    /// <exception cref="ArgumentNullException">source is null.</exception>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> Uses lock-based coordination. If the key exists synchronously on <c>Connect()</c>, the initial <c>None</c> may or may not be emitted depending on timing.</para>
-    /// </remarks>
-    public static IObservable<Optional<TObject>> ToObservableOptional<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key, bool initialOptionalWhenMissing, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        if (initialOptionalWhenMissing)
-        {
-            var seenValue = false;
-            var locker = InternalEx.NewLock();
-
-            var optional = source.ToObservableOptional(key, equalityComparer).Synchronize(locker).Do(_ => seenValue = true);
-            var missing = Observable.Return(Optional.None<TObject>()).Synchronize(locker).Where(_ => !seenValue);
-
-            return optional.Merge(missing);
-        }
-
-        return source.ToObservableOptional(key, equalityComparer);
-    }
-
-    /// <summary>
-    /// Converts the change set into a fully formed sorted collection. Each change in the source results in a new sorted collection.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TSortKey">The sort key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a sorted collection on each change.</param>
-    /// <param name="sort">The <see cref="Func{TObject, TSortKey}"/> sort function.</param>
-    /// <param name="sortOrder">The <see cref="SortDirection"/> sort order. Defaults to ascending.</param>
-    /// <returns>An observable which emits the read only collection.</returns>
-    /// <seealso cref="ObservableListEx.ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
-    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey, TSortKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TSortKey> sort, SortDirection sortOrder = SortDirection.Ascending)
-        where TObject : notnull
-        where TKey : notnull
-        where TSortKey : notnull => source.QueryWhenChanged(query => sortOrder == SortDirection.Ascending ? new ReadOnlyCollectionLight<TObject>(query.Items.OrderBy(sort)) : new ReadOnlyCollectionLight<TObject>(query.Items.OrderByDescending(sort)));
-
-    /// <summary>
-    /// Converts the change set into a fully formed sorted collection. Each change in the source results in a new sorted collection.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to materialize into a sorted collection on each change.</param>
-    /// <param name="comparer">The <see cref="IComparer{TObject}"/> sort comparer.</param>
-    /// <returns>An observable which emits the read only collection.</returns>
-    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, IComparer<TObject> comparer)
-        where TObject : notnull
-        where TKey : notnull => source.QueryWhenChanged(
-            query =>
-            {
-                var items = query.Items.AsList();
-                items.Sort(comparer);
-                return new ReadOnlyCollectionLight<TObject>(items);
-            });
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update). The factory receives only the current item.</remarks>
-    /// <seealso cref="ObservableListEx.Transform"/>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, bool transformOnRefresh)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform((current, _, _) => transformFactory(current), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update). The factory receives the current item and key.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, bool transformOnRefresh)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform((current, _, key) => transformFactory(current, key), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts a <c>bool transformOnRefresh</c> flag. When <see langword="true"/>, Refresh changes cause re-transformation (emitted as Update).</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, bool transformOnRefresh)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new Transform<TDestination, TSource, TKey>(source, transformFactory, transformOnRefresh: transformOnRefresh).Run();
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts an optional <c>forceTransform</c> predicate filtering by source item only (without the key). The factory receives only the current item.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, IObservable<Func<TSource, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform((current, _, _) => transformFactory(current), forceTransform?.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts an optional <c>forceTransform</c> predicate filtering by source item and key. The factory receives the current item and key.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform((current, _, key) => transformFactory(current, key), forceTransform);
-    }
-
-    /// <summary>
-    /// Projects each item in the changeset to a new form using a synchronous transform factory.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform.</param>
-    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, TDestination}"/> that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
-    /// <param name="forceTransform">An observable that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. Re-transformed items are emitted as <see cref="ChangeReason.Update"/> changes. If <see langword="null"/>, no forced re-transforms occur.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Transform maintains a 1:1 mapping between source and destination items, keyed identically. The factory
-    /// is called once per Add and once per Update. Removes are forwarded without calling the factory.
-    /// </para>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Calls factory, emits Add.</description></item>
-    ///   <item><term>Update</term><description>Calls factory (receives current item, previous item, key), emits Update with Previous preserved.</description></item>
-    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh without re-transforming. To re-transform on Refresh, use the <paramref name="forceTransform"/> parameter or the <c>transformOnRefresh</c> overloads.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> By default, <b>Refresh</b> does NOT re-invoke the transform factory (it is just forwarded). Set <c>transformOnRefresh: true</c> to re-transform on <b>Refresh</b>.</para>
-    /// <para>
-    /// When <paramref name="forceTransform"/> emits a predicate, every cached item is tested against it.
-    /// Matching items are re-transformed and emitted as Updates.
-    /// </para>
-    /// <para>
-    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>, terminating the stream.
-    /// Use <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// to catch factory errors without killing the stream.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <seealso cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <seealso cref="TransformImmutable{TDestination, TSource, TKey}"/>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        if (forceTransform is not null)
-        {
-            return new TransformWithForcedTransform<TDestination, TSource, TKey>(source, transformFactory, forceTransform).Run();
-        }
-
-        return new Transform<TDestination, TSource, TKey>(source, transformFactory).Run();
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits. The factory receives only the current item.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull => source.Transform((cur, _, _) => transformFactory(cur), forceTransform.ForForced<TSource, TKey>());
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits. The factory receives the current item and key.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
-
-        return source.Transform((cur, _, key) => transformFactory(cur, key), forceTransform.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items when the observable emits.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
-
-        return source.Transform(transformFactory, forceTransform.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload takes a simpler factory that receives only the current item.</remarks>
-    /// <seealso cref="ObservableListEx.TransformAsync"/>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync((current, _, _) => transformFactory(current), forceTransform);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload takes a factory that receives the current item and key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync((current, _, key) => transformFactory(current, key), forceTransform);
-    }
-
-    /// <summary>
-    /// Async version of <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>.
-    /// Projects each item using an async factory that returns <see cref="Task{TResult}"/>.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform asynchronously.</param>
-    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, Task{TDestination}}"/> async function that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
-    /// <param name="forceTransform">An observable that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. Re-transformed items are emitted as <see cref="ChangeReason.Update"/> changes. If <see langword="null"/>, no forced re-transforms occur.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Transforms within a single changeset batch execute concurrently. The entire batch must complete
-    /// before the resulting changeset is emitted. Use the <see cref="TransformAsyncOptions"/> overloads
-    /// to control maximum concurrency and Refresh handling.
-    /// </para>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Awaits factory, emits Add.</description></item>
-    ///   <item><term>Update</term><description>Awaits factory (receives current, previous, key), emits Update.</description></item>
-    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
-    ///   <item><term>Refresh</term><description>Forwarded as Refresh by default. Use <see cref="TransformAsyncOptions.TransformOnRefresh"/> to re-transform.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Transforms are batched per changeset (all tasks must complete before the next changeset is processed). Completion waits for in-flight transforms. <b>Remove</b> does NOT cancel in-flight transforms for the removed key.</para>
-    /// <para>
-    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>. Use
-    /// <see cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// to catch factory errors without terminating the stream.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, null, forceTransform).Run();
-    }
-
-    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives only the current item.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync((current, _, _) => transformFactory(current), options);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives the current item and key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync((current, _, key) => transformFactory(current, key), options);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, null, null, options.MaximumConcurrency, options.TransformOnRefresh).Run();
-    }
-
-    /// <summary>
-    /// Optimized transform for immutable items with deterministic (pure) transform functions.
-    /// Refresh changes are dropped entirely since immutable items cannot change in place.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform (items assumed immutable).</param>
-    /// <param name="transformFactory">The <see cref="Func{TSource, TDestination}"/> pure function that maps a source item to a destination item. Must be deterministic: same input always produces equivalent output.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Because the transform is assumed to be stateless and deterministic, this operator does not track
-    /// previously transformed items. This reduces memory overhead compared to <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>.
-    /// </para>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Calls factory, emits Add.</description></item>
-    ///   <item><term>Update</term><description>Calls factory, emits Update.</description></item>
-    ///   <item><term>Remove</term><description>Emits Remove. Factory is NOT called.</description></item>
-    ///   <item><term>Refresh</term><description>DROPPED. Immutable items do not change, so Refresh is meaningless.</description></item>
-    /// </list>
-    /// <para>Use this when items are immutable, the factory is pure, and the factory is cheap. If any of these conditions are false, use <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/> instead.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformImmutable<TDestination, TSource, TKey>(
-            this IObservable<IChangeSet<TSource, TKey>> source,
-            Func<TSource, TDestination> transformFactory)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new TransformImmutable<TDestination, TSource, TKey>(
-                source: source,
-                transformFactory: transformFactory)
-            .Run();
-    }
-
-    /// <summary>
-    /// Flattens each source item into zero or more destination items (1:N), producing a single flat changeset.
-    /// Each child item must have a globally unique key across all parents.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the child items.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
-    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
-    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children.</param>
-    /// <param name="manySelector">A function that expands a parent item into its children. For <see cref="ObservableCollection{T}"/> or <see cref="IObservableCache{TObject, TKey}"/> overloads, subsequent changes to the child collection are automatically tracked.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item. Keys must be unique across ALL parents, not just within one parent.</param>
-    /// <returns>An observable changeset of flattened child items.</returns>
-    /// <remarks>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Calls <paramref name="manySelector"/>, emits Add for each child.</description></item>
-    ///   <item><term>Update</term><description>Diffs old children vs new children: emits Remove for removed children, Add for new children, Update for children with matching keys.</description></item>
-    ///   <item><term>Remove</term><description>Emits Remove for all children of the removed parent.</description></item>
-    ///   <item><term>Refresh</term><description>Propagated as Refresh to all children (no re-expansion).</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> If two source items produce children with the same key, last-in-wins. <b>Refresh</b> does NOT re-expand children (only <b>Update</b> does).</para>
-    /// <para>If two parents produce children with the same key, last-in-wins. Use the async variant with a <see cref="IComparer{T}"/> to control conflict resolution.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="manySelector"/>, or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <seealso cref="ObservableListEx.TransformMany"/>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, IEnumerable<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
-
-    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
-    /// <remarks>This overload accepts an <see cref="ObservableCollection{T}"/> selector. Changes to the child collection (adds, removes, replacements) are automatically observed and reflected downstream.</remarks>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, ObservableCollection<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
-
-    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
-    /// <remarks>This overload accepts a <see cref="ReadOnlyObservableCollection{T}"/> selector. Changes to the child collection are automatically observed and reflected downstream.</remarks>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, ReadOnlyObservableCollection<TDestination>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
-
-    /// <inheritdoc cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
-    /// <remarks>This overload accepts an <see cref="IObservableCache{TObject, TKey}"/> selector. The child cache is live: subsequent changes to it are automatically propagated downstream.</remarks>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, IObservableCache<TDestination, TDestinationKey>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => new TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(source, manySelector, keySelector).Run();
-
-    /// <summary>
-    /// Async version of <see cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>.
-    /// Flattens each source item into zero or more destination items using an async factory.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the child items.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
-    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
-    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children asynchronously.</param>
-    /// <param name="manySelector">An async function that expands a parent item (and its key) into an <see cref="IEnumerable{T}"/> of children.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional comparer to determine if two child items with the same key are equal. Used to suppress no-op updates.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key collisions when the same destination key is produced by multiple parents. The winning item is determined by this comparer.</param>
-    /// <returns>An observable changeset of flattened child items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Because each parent's expansion is async, child collections may arrive via separate changesets
-    /// (unlike the synchronous <c>TransformMany</c> which batches all children into one changeset).
-    /// </para>
-    /// <para>
-    /// Factory exceptions propagate as <see cref="IObserver{T}.OnError"/>. Use
-    /// <see cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// to catch errors without killing the stream.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="manySelector"/> is <see langword="null"/>.</exception>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer).Run();
-    }
-
-    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => source.TransformManyAsync((val, _) => manySelector(val), keySelector, equalityComparer, comparer);
-
-    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives the source item and its key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination>
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer).Run();
-    }
-
-    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives only the source item.</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => source.TransformManyAsync((val, _) => manySelector(val), keySelector, equalityComparer, comparer);
-
-    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live: its changes propagate downstream. No <c>keySelector</c> is needed since the cache already has keys. The factory receives the source item and its key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector), equalityComparer, comparer).Run();
-    }
-
-    /// <inheritdoc cref="TransformManyAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives only the source item.</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManyAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => source.TransformManyAsync((val, _) => manySelector(val), equalityComparer, comparer);
-
-    /// <summary>
-    /// Async version of <see cref="TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
-    /// with error handling. Factory exceptions are caught and routed to <paramref name="errorHandler"/> instead of
-    /// terminating the stream.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the child items.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the child item keys.</typeparam>
-    /// <typeparam name="TSource">The type of the source (parent) items.</typeparam>
-    /// <typeparam name="TSourceKey">The type of the source (parent) keys.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TSourceKey}}"/> to expand each item into multiple children asynchronously with error handling.</param>
-    /// <param name="manySelector">An async function that expands a parent item (and its key) into an <see cref="IEnumerable{T}"/> of children.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> that extracts a unique key from each child item.</param>
-    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="manySelector"/> throws. The faulting item is skipped and the stream continues.</param>
-    /// <param name="equalityComparer">An <see cref="IEqualityComparer{TDestination}"/> that optional comparer to determine if two child items with the same key are equal.</param>
-    /// <param name="comparer">An <see cref="IComparer{TDestination}"/> that optional comparer to resolve key collisions when the same destination key is produced by multiple parents.</param>
-    /// <returns>An observable changeset of flattened child items.</returns>
-    /// <remarks>Because the transformations are asynchronous, each sub-collection may be emitted via a separate changeset.</remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="manySelector"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer, errorHandler).Run();
-    }
-
-    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => source.TransformManySafeAsync((val, _) => manySelector(val), keySelector, errorHandler, equalityComparer, comparer);
-
-    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives the source item and its key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination>
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector, keySelector), equalityComparer, comparer, errorHandler).Run();
-    }
-
-    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an observable collection (of type <typeparamref name="TCollection"/> implementing both <see cref="INotifyCollectionChanged"/> and <see cref="IEnumerable{T}"/>) whose changes are tracked live. The factory receives only the source item.</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => source.TransformManySafeAsync((val, _) => manySelector(val), keySelector, errorHandler, equalityComparer, comparer);
-
-    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives the source item and its key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformManyAsync<TSource, TSourceKey, TDestination, TDestinationKey>(source, CreateChangeSetTransformer(manySelector), equalityComparer, comparer, errorHandler).Run();
-    }
-
-    /// <inheritdoc cref="TransformManySafeAsync{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, TSourceKey, Task{IEnumerable{TDestination}}}, Func{TDestination, TDestinationKey}, Action{Error{TSource, TSourceKey}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <remarks>This overload returns an <see cref="IObservableCache{TObject, TKey}"/> per parent. The child cache is live. The factory receives only the source item.</remarks>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> TransformManySafeAsync<TDestination, TDestinationKey, TSource, TSourceKey>(this IObservable<IChangeSet<TSource, TSourceKey>> source, Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector, Action<Error<TSource, TSourceKey>> errorHandler, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => source.TransformManySafeAsync((val, _) => manySelector(val), errorHandler, equalityComparer, comparer);
-
-    /// <summary>
-    /// Projects each item into a per-item observable. The latest value emitted by each item's observable
-    /// becomes the transformed value in the output changeset.
-    /// </summary>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform using per-item observables.</param>
-    /// <param name="transformFactory">A function that, given a source item and its key, returns an <see cref="IObservable{TDestination}"/> whose emissions become the transformed values.</param>
-    /// <returns>An observable changeset where each key's value is the latest emission from its per-item observable.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>Source changeset handling (parent events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Calls <paramref name="transformFactory"/> and subscribes to the returned observable. The item is <b>not visible downstream until the observable emits its first value</b>.</description></item>
-    /// <item><term>Update</term><description>Disposes the old item's observable subscription and subscribes to the new item's observable. The item disappears from downstream until the new observable emits.</description></item>
-    /// <item><term>Remove</term><description>Disposes the item's observable subscription. If the item was visible downstream, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently visible downstream. Otherwise dropped.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Per-item observable handling (transform observable events):</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Emission</term><description>Behavior</description></listheader>
-    /// <item><term>First value</term><description>The transformed item appears downstream as an <b>Add</b>.</description></item>
-    /// <item><term>Subsequent values</term><description>Each new value replaces the previous one: an <b>Update</b> is emitted downstream.</description></item>
-    /// <item><term>Error</term><description>Terminates the entire output stream.</description></item>
-    /// <item><term>Completed</term><description>The item remains at its last emitted value. No further updates are possible for this item.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Worth noting:</b> Items are invisible downstream until their per-item observable emits at least one value.
-    /// If an item's observable never emits, that item never appears in the output. The transform factory's selector
-    /// runs under an internal lock, so it must not synchronously access other DynamicData caches (deadlock risk in
-    /// cross-cache pipelines). The output completes when the source completes and all per-item observables have
-    /// also completed.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, TDestination}, bool)"/>
-    /// <seealso cref="FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="GroupOnObservable{TObject, TKey, TGroupKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TKey, IObservable{TGroupKey}})"/>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformOnObservable<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, IObservable<TDestination>> transformFactory)
-        where TSource : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new TransformOnObservable<TSource, TKey, TDestination>(source, transformFactory).Run();
-    }
-
-    /// <inheritdoc cref="TransformOnObservable{TSource, TKey, TDestination}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TKey, IObservable{TDestination}})"/>
-    /// <remarks>This overload takes a factory that receives only the source item (without the key).</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformOnObservable<TSource, TKey, TDestination>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, IObservable<TDestination>> transformFactory)
-        where TSource : notnull
-        where TKey : notnull
-        where TDestination : notnull
-    {
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformOnObservable((obj, _) => transformFactory(obj));
-    }
-
-    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts a simpler factory that receives only the current item, and a forceTransform predicate filtering by source item only.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafe((current, _, _) => transformFactory(current), errorHandler, forceTransform.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts a factory that receives the current item and key.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafe((current, _, key) => transformFactory(current, key), errorHandler, forceTransform);
-    }
-
-    /// <summary>
-    /// Projects each item using a synchronous factory, catching factory exceptions via a mandatory error handler
-    /// instead of terminating the stream.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform with error handling.</param>
-    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, TDestination}"/> that produces a <typeparamref name="TDestination"/> from the current source item, the previous source item (if any), and the key.</param>
-    /// <param name="errorHandler">A callback invoked when <paramref name="transformFactory"/> throws. Receives an <see cref="Error{TSource, TKey}"/> containing the exception and the faulting item. The item is skipped and the stream continues.</param>
-    /// <param name="forceTransform">An optional <see cref="IObservable{T}"/> that, when it emits a predicate, re-transforms all items for which the predicate returns <see langword="true"/>. If <see langword="null"/>, no forced re-transforms occur.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Behaves identically to <see cref="Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// except that factory exceptions are routed to <paramref name="errorHandler"/> instead of propagating as <see cref="IObserver{T}.OnError"/>.
-    /// Source-level errors (i.e. the source observable itself erroring) still propagate normally.
-    /// </para>
-    /// <para><b>Worth noting:</b> Factory exceptions are caught per-item; the faulting item is skipped and reported to the error handler while the stream continues. Source-level errors still terminate the stream.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-        if (forceTransform is not null)
-        {
-            return new TransformWithForcedTransform<TDestination, TSource, TKey>(source, transformFactory, forceTransform, errorHandler).Run();
-        }
-
-        return new Transform<TDestination, TSource, TKey>(source, transformFactory, errorHandler).Run();
-    }
-
-    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items. The factory receives only the current item.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull => source.TransformSafe((cur, _, _) => transformFactory(cur), errorHandler, forceTransform.ForForced<TSource, TKey>());
-
-    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items. The factory receives the current item and key.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
-
-        return source.TransformSafe((cur, _, key) => transformFactory(cur, key), errorHandler, forceTransform.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="IObservable{T}"/> of <see cref="Unit"/> to force re-transformation of ALL items.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, TDestination> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Unit> forceTransform)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        forceTransform.ThrowArgumentNullExceptionIfNull(nameof(forceTransform));
-
-        return source.TransformSafe(transformFactory, errorHandler, forceTransform.ForForced<TSource, TKey>());
-    }
-
-    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload takes a factory that receives only the current item.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafeAsync((current, _, _) => transformFactory(current), errorHandler, forceTransform);
-    }
-
-    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload takes a factory that receives the current item and key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafeAsync((current, _, key) => transformFactory(current, key), errorHandler, forceTransform);
-    }
-
-    /// <summary>
-    /// Async version of <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>.
-    /// Projects each item using an async factory, catching factory exceptions via a mandatory error handler.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform asynchronously with error handling.</param>
-    /// <param name="transformFactory">The <see cref="Func{TSource, Optional{TSource}, TKey, Task{TDestination}}"/> async function that produces a <typeparamref name="TDestination"/>.</param>
-    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="transformFactory"/> throws or faults. The item is skipped and the stream continues.</param>
-    /// <param name="forceTransform">An optional <see cref="IObservable{T}"/> that forces re-transformation of matching items.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>Combines the async execution model of <see cref="TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}}?)"/> with the error-safe behavior of <see cref="TransformSafe{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, TDestination}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>.</remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, errorHandler, forceTransform).Run();
-    }
-
-    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives only the current item.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafeAsync((current, _, _) => transformFactory(current), errorHandler, options);
-    }
-
-    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling. The factory receives the current item and key.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformSafeAsync((current, _, key) => transformFactory(current, key), errorHandler, options);
-    }
-
-    /// <inheritdoc cref="TransformSafeAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Optional{TSource}, TKey, Task{TDestination}}, Action{Error{TSource, TKey}}, IObservable{Func{TSource, TKey, bool}}?)"/>
-    /// <remarks>This overload accepts <see cref="TransformAsyncOptions"/> to control concurrency and Refresh handling.</remarks>
-    [SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, Optional<TSource>, TKey, Task<TDestination>> transformFactory, Action<Error<TSource, TKey>> errorHandler, TransformAsyncOptions options)
-        where TDestination : notnull
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformAsync<TDestination, TSource, TKey>(source, transformFactory, errorHandler, null, options.MaximumConcurrency, options.TransformOnRefresh).Run();
-    }
-
-    /// <summary>
-    /// Builds a hierarchical tree from a flat changeset using a parent key selector.
-    /// Each item becomes a <see cref="Node{TObject, TKey}"/> with Parent, Children, Depth, and IsRoot properties.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the source items. Must be a reference type.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to transform into a hierarchical tree.</param>
-    /// <param name="pivotOn">The <see cref="Func{TObject, TKey}"/> that returns the key of an item's parent. Return the item's own key (or a non-existent key) for root items.</param>
-    /// <param name="predicateChanged">An optional <see cref="IObservable{T}"/> that emits a filter predicate for nodes. When the predicate changes, nodes are re-evaluated and filtered.</param>
-    /// <returns>An observable changeset of <see cref="Node{TObject, TKey}"/> items representing the tree.</returns>
-    /// <remarks>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Creates node, attaches to parent (or root if parent not found), emits Add.</description></item>
-    ///   <item><term>Update</term><description>Updates node. If <paramref name="pivotOn"/> returns a different parent key, the node is re-parented.</description></item>
-    ///   <item><term>Remove</term><description>Removes node. Orphaned children become root nodes.</description></item>
-    ///   <item><term>Refresh</term><description>Re-evaluates parent key. May re-parent the node if the parent changed.</description></item>
-    /// </list>
-    /// <para>Circular references are NOT detected. If item A is the parent of B and B is the parent of A, behavior is undefined.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pivotOn"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<Node<TObject, TKey>, TKey>> TransformToTree<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, TKey> pivotOn, IObservable<Func<Node<TObject, TKey>, bool>>? predicateChanged = null)
-        where TObject : class
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        pivotOn.ThrowArgumentNullExceptionIfNull(nameof(pivotOn));
-
-        return new TreeBuilder<TObject, TKey>(source, pivotOn, predicateChanged).Run();
-    }
-
-    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
-    /// <remarks>This overload defaults to <c>transformOnRefresh: false</c> and does not provide an error handler (factory exceptions propagate as OnError).</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction)
-        where TDestination : class
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
-
-        return source.TransformWithInlineUpdate(transformFactory, updateAction, false);
-    }
-
-    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
-    /// <remarks>This overload does not provide an error handler (factory exceptions propagate as OnError). The <c>transformOnRefresh</c> parameter controls Refresh behavior.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, bool transformOnRefresh)
-        where TDestination : class
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
-
-        return new TransformWithInlineUpdate<TDestination, TSource, TKey>(source, transformFactory, updateAction, transformOnRefresh: transformOnRefresh).Run();
-    }
-
-    /// <inheritdoc cref="TransformWithInlineUpdate{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, Action{TDestination, TSource}, Action{Error{TSource, TKey}}, bool)"/>
-    /// <remarks>This overload defaults to <c>transformOnRefresh: false</c> but includes an error handler for factory/update action exceptions.</remarks>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, Action<Error<TSource, TKey>> errorHandler)
-        where TDestination : class
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return source.TransformWithInlineUpdate(transformFactory, updateAction, errorHandler, false);
-    }
-
-    /// <summary>
-    /// Projects each item using a transform factory for Add, and mutates the existing transformed
-    /// item in place (via an update action) for Update, preserving the original object reference.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the transformed items. Must be a reference type since items are mutated in place.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource, TKey}}"/> to transform with in-place mutation on updates.</param>
-    /// <param name="transformFactory">A <see cref="Func{T, TResult}"/> that called on Add (and optionally Refresh) to create a new <typeparamref name="TDestination"/>.</param>
-    /// <param name="updateAction">A <see cref="Action{T}"/> that called on Update. Receives <c>(existingTransformed, newSource)</c>. Mutate the existing transformed item to reflect the new source value. Example: <c>(vm, model) =&gt; vm.Value = model.Value</c>.</param>
-    /// <param name="errorHandler">A <see cref="Action{T}"/> that called when <paramref name="transformFactory"/> or <paramref name="updateAction"/> throws. The faulting item is skipped.</param>
-    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh changes call <paramref name="updateAction"/> on the existing item.</param>
-    /// <returns>An observable changeset of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// This is useful when the destination type is a ViewModel that should maintain its identity across updates.
-    /// Instead of replacing the entire ViewModel, the update action patches the existing instance.
-    /// </para>
-    /// <para><b>Change reason handling:</b></para>
-    /// <list type="table">
-    ///   <listheader><term>Input reason</term><description>Output behavior</description></listheader>
-    ///   <item><term>Add</term><description>Calls <paramref name="transformFactory"/>, emits Add.</description></item>
-    ///   <item><term>Update</term><description>Calls <paramref name="updateAction"/> on the EXISTING transformed item (same reference), emits Update.</description></item>
-    ///   <item><term>Remove</term><description>Emits Remove.</description></item>
-    ///   <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is true, calls <paramref name="updateAction"/>. Otherwise forwarded as Refresh.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="transformFactory"/>, <paramref name="updateAction"/>, or <paramref name="errorHandler"/> is <see langword="null"/>.</exception>
-    public static IObservable<IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this IObservable<IChangeSet<TSource, TKey>> source, Func<TSource, TDestination> transformFactory, Action<TDestination, TSource> updateAction, Action<Error<TSource, TKey>> errorHandler, bool transformOnRefresh)
-        where TDestination : class
-        where TSource : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-        updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
-        errorHandler.ThrowArgumentNullExceptionIfNull(nameof(errorHandler));
-
-        return new TransformWithInlineUpdate<TDestination, TSource, TKey>(source, transformFactory, updateAction, errorHandler, transformOnRefresh).Run();
-    }
-
-    /// <summary>
-    /// Converts moves changes to remove + add.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to convert move events into remove/add pairs.</param>
-    /// <returns>the same SortedChangeSets, except all moves are replaced with remove + add.</returns>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> TreatMovesAsRemoveAdd<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        static IEnumerable<Change<TObject, TKey>> ReplaceMoves(IChangeSet<TObject, TKey> items)
-        {
-            foreach (var change in items.ToConcreteType())
-            {
-                if (change.Reason == ChangeReason.Moved)
-                {
-                    yield return new Change<TObject, TKey>(ChangeReason.Remove, change.Key, change.Current, change.PreviousIndex);
-
-                    yield return new Change<TObject, TKey>(ChangeReason.Add, change.Key, change.Current, change.CurrentIndex);
-                }
-                else
-                {
-                    yield return change;
-                }
-            }
-        }
-
-        return source.Select(changes => new SortedChangeSet<TObject, TKey>(changes.SortedItems, ReplaceMoves(changes)));
-    }
-
-    /// <summary>
-    /// Emits <see langword="true"/> when all items in the cache satisfy a condition based on their per-item observable,
-    /// and <see langword="false"/> otherwise. Re-evaluates whenever the cache changes or any per-item observable emits.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the value emitted by each per-item observable.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across all items in.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
-    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each per-item observable's latest value.</param>
-    /// <returns>An observable of <c>bool</c> that emits whenever the all-items condition changes.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="equalityCondition"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>A new per-item subscription is created. The aggregate condition is recalculated.</description></item>
-    /// <item><term>Update</term><description>The item is replaced in the collection snapshot. Condition recalculated.</description></item>
-    /// <item><term>Remove</term><description>Per-item subscription disposed. Condition recalculated over remaining items.</description></item>
-    /// <item><term>Refresh</term><description>No effect on per-item subscriptions. Condition not recalculated unless the per-item observable emits.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Items whose per-item observable has not yet emitted are treated as not satisfying the condition. An empty cache is vacuously <see langword="true"/>. The result uses <c>DistinctUntilChanged</c>, so duplicate <c>bool</c> values are suppressed.</para>
-    /// </remarks>
-    /// <seealso cref="TrueForAny{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TValue, bool})"/>
-    public static IObservable<bool> TrueForAll<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TValue, bool> equalityCondition)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull => source.TrueFor(observableSelector, items => items.All(o => o.LatestValue.HasValue && equalityCondition(o.LatestValue.Value)));
-
-    /// <summary>
-    /// <para>
-    /// Produces a boolean observable indicating whether the latest resulting value from all of the specified observables matches
-    /// the equality condition. The observable is re-evaluated whenever.
-    /// </para>
-    /// <para>
-    /// i) The cache changes
-    /// or ii) The inner observable changes.
-    /// </para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the value.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across all items in.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> that selector which returns the target observable.</param>
-    /// <param name="equalityCondition">The <see cref="Func{TObject, TValue, bool}"/> equality condition.</param>
-    /// <returns>An observable which boolean values indicating if true.</returns>
-    /// <exception cref="ArgumentNullException">source.</exception>
-    public static IObservable<bool> TrueForAll<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TObject, TValue, bool> equalityCondition)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull => source.TrueFor(observableSelector, items => items.All(o => o.LatestValue.HasValue && equalityCondition(o.Item, o.LatestValue.Value)));
-
-    /// <summary>
-    /// Emits <see langword="true"/> when any item in the cache satisfies a condition based on its per-item observable,
-    /// and <see langword="false"/> when none do. Re-evaluates whenever the cache changes or any per-item observable emits.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the value emitted by each per-item observable.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across any item in.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
-    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each item and its per-item observable's latest value.</param>
-    /// <returns>An observable of <c>bool</c> that emits whenever the any-item condition changes.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="equalityCondition"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>A new per-item subscription is created. The aggregate condition is recalculated.</description></item>
-    /// <item><term>Update</term><description>The item is replaced in the collection snapshot. Condition recalculated.</description></item>
-    /// <item><term>Remove</term><description>Per-item subscription disposed. Condition recalculated over remaining items.</description></item>
-    /// <item><term>Refresh</term><description>No effect on per-item subscriptions. Condition not recalculated unless the per-item observable emits.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Items whose per-item observable has not yet emitted are treated as not satisfying the condition. An empty cache yields <see langword="false"/>. The result uses <c>DistinctUntilChanged</c>, so duplicate <c>bool</c> values are suppressed.</para>
-    /// </remarks>
-    /// <seealso cref="TrueForAll{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TValue, bool})"/>
-    public static IObservable<bool> TrueForAny<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TObject, TValue, bool> equalityCondition)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull => source.TrueFor(observableSelector, items => items.Any(o => o.LatestValue.HasValue && equalityCondition(o.Item, o.LatestValue.Value)));
-
-    /// <inheritdoc cref="TrueForAny{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TValue}}, Func{TObject, TValue, bool})"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to evaluate a condition across any item in.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> factory that produces a condition observable for each item.</param>
-    /// <param name="equalityCondition">A <see cref="Func{T, TResult}"/> that predicate applied to each per-item observable's latest value (without the item).</param>
-    /// <remarks>This overload accepts a predicate that takes only the value, not the item. Useful when the condition depends only on the observed value.</remarks>
-    public static IObservable<bool> TrueForAny<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<TValue, bool> equalityCondition)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-        equalityCondition.ThrowArgumentNullExceptionIfNull(nameof(equalityCondition));
-
-        return source.TrueFor(observableSelector, items => items.Any(o => o.LatestValue.HasValue && equalityCondition(o.LatestValue.Value)));
-    }
-
-    /// <summary>
-    /// Sets the <c>Index</c> property on each item (which must implement <see cref="IIndexAware"/>)
-    /// to reflect its position in the sorted output. Operates on <see cref="ISortedChangeSet{TObject, TKey}"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{ISortedChangeSet{TObject, TKey}}"/> to update index positions in.</param>
-    /// <returns>An observable that emits the sorted changesets after updating item indices.</returns>
-    public static IObservable<ISortedChangeSet<TObject, TKey>> UpdateIndex<TObject, TKey>(this IObservable<ISortedChangeSet<TObject, TKey>> source)
-        where TObject : IIndexAware
-        where TKey : notnull => source.Do(changes => changes.SortedItems.Select((update, index) => new { update, index }).ForEach(u => u.update.Value.Index = u.index));
-
-    /// <summary>
-    /// Filters the source changeset stream to a single key, emitting each <see cref="Change{TObject, TKey}"/> for that key.
-    /// Changes for all other keys are ignored.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
-    /// <returns>An observable of <see cref="Change{TObject, TKey}"/> for the specified key only.</returns>
-    /// <remarks>
-    /// <para>
-    /// Emits Add, Update, Remove, and Refresh changes as they occur for the target key.
-    /// No initial emission occurs if the key is not yet present in the cache. This operator does not
-    /// produce changesets; it produces individual change notifications. For Optional-based watching,
-    /// use <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="WatchValue{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
-    /// <seealso cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>
-    public static IObservable<Change<TObject, TKey>> Watch<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.SelectMany(updates => updates).Where(update => update.Key.Equals(key));
-    }
-
-    /// <summary>
-    /// Filters the source changeset stream to a single key, emitting the current value each time it changes.
-    /// Even emits the value on removal (the removed item's value).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservableCache{TObject, TKey}"/> to watch a single key in.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
-    /// <returns>An observable of the item's value whenever it changes for the specified key.</returns>
-    /// <remarks>
-    /// <para>
-    /// Unlike <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>,
-    /// this does not emit <see cref="Optional.None{T}"/> on removal. It emits the removed item's value instead.
-    /// If you need to distinguish presence from absence, use ToObservableOptional.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Emits the added item's value.</description></item>
-    /// <item><term>Update</term><description>Emits the new value.</description></item>
-    /// <item><term>Remove</term><description>Emits the removed item's value (not <c>None</c>; use <see cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/> if you need removal detection).</description></item>
-    /// <item><term>Refresh</term><description>Emits the current value.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> No emission occurs if the key is not present at subscription time. Changes to other keys are ignored entirely.</para>
-    /// </remarks>
-    /// <seealso cref="Watch{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey)"/>
-    /// <seealso cref="ToObservableOptional{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TKey, IEqualityComparer{TObject}?)"/>
-    public static IObservable<TObject> WatchValue<TObject, TKey>(this IObservableCache<TObject, TKey> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Watch(key).Select(u => u.Current);
-    }
-
-    /// <inheritdoc cref="WatchValue{TObject, TKey}(IObservableCache{TObject, TKey}, TKey)"/>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to watch a single key in.</param>
-    /// <param name="key">The <typeparamref name="TKey"/> key to observe.</param>
-    /// <remarks>This overload extends <see cref="IObservable{T}">IObservable</see>&lt;<see cref="IChangeSet{TObject, TKey}"/>&gt; instead of <see cref="IObservableCache{TObject, TKey}"/>.</remarks>
-    public static IObservable<TObject> WatchValue<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, TKey key)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Watch(key).Select(u => u.Current);
-    }
-
-    /// <summary>
-    /// Emits an item whenever any of its properties change via <see cref="INotifyPropertyChanged"/>.
-    /// Subscribes to PropertyChanged on each cache item using MergeMany.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe property changes on items in.</param>
-    /// <param name="propertiesToMonitor">The specific property names to monitor.  If empty, all property changes trigger emissions.</param>
-    /// <returns>An observable that emits the item itself each time a monitored property changes.</returns>
-    /// <remarks>
-    /// <para>
-    /// Subscriptions are managed per item: created on Add, replaced on Update, disposed on Remove.
-    /// Errors from individual property subscriptions are silently ignored. The output is not a changeset
-    /// stream; it is a plain <c>IObservable&lt;TObject?&gt;</c>. If the same item changes multiple properties
-    /// rapidly, each change emits the item separately (no deduplication).
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Subscribes to PropertyChanged on the new item.</description></item>
-    /// <item><term>Update</term><description>Disposes the old item's subscription and subscribes to the new item.</description></item>
-    /// <item><term>Remove</term><description>Disposes the item's PropertyChanged subscription.</description></item>
-    /// <item><term>Refresh</term><description>No effect on subscriptions.</description></item>
-    /// <item><term>OnError</term><description>Errors from individual property subscriptions are silently ignored. Source errors terminate the stream.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="WhenPropertyChanged{TObject, TKey, TValue}"/>
-    /// <seealso cref="WhenValueChanged{TObject, TKey, TValue}"/>
-    /// <seealso cref="AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableListEx.WhenAnyPropertyChanged"/>
-    public static IObservable<TObject?> WhenAnyPropertyChanged<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params string[] propertiesToMonitor)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.MergeMany(t => t.WhenAnyPropertyChanged(propertiesToMonitor));
-    }
-
-    /// <summary>
-    /// Emits a <see cref="PropertyValue{TObject, TValue}"/> (item + property value) whenever the specified property
-    /// changes on any item in the cache. Subscribes via <see cref="INotifyPropertyChanged"/> using MergeMany.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the monitored property.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe a specific property on items in.</param>
-    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that expression selecting the property to monitor.</param>
-    /// <param name="notifyOnInitialValue">When <see langword="true"/> (the default), the current property value is emitted immediately for each item upon subscription.</param>
-    /// <returns>An observable of <see cref="PropertyValue{TObject, TValue}"/> containing both the item and its property value.</returns>
-    /// <remarks>
-    /// <para>
-    /// Per-item subscriptions are created on Add, replaced on Update, disposed on Remove. Errors from individual
-    /// property subscriptions are silently ignored. The output is not a changeset stream. If you only need
-    /// the value (not the owning item), use <see cref="WhenValueChanged{TObject, TKey, TValue}"/> instead.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Subscribes to the specified property on the new item. If <c>notifyOnInitialValue</c> is true, the current value is emitted immediately.</description></item>
-    /// <item><term>Update</term><description>Disposes the old item's property subscription and subscribes to the new item.</description></item>
-    /// <item><term>Remove</term><description>Disposes the item's property subscription. No further emissions for this item.</description></item>
-    /// <item><term>Refresh</term><description>No effect on subscriptions. The existing property subscription continues.</description></item>
-    /// <item><term>OnError</term><description>Per-item property subscription errors are silently ignored. Source errors terminate the stream.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="ObservableListEx.WhenPropertyChanged"/>
-    public static IObservable<PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
-
-        return source.MergeMany(t => t.WhenPropertyChanged(propertyAccessor, notifyOnInitialValue));
-    }
-
-    /// <summary>
-    /// Emits the property value whenever the specified property changes on any item in the cache.
-    /// Like <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> but emits only the value, discarding the owning item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object (must implement <see cref="INotifyPropertyChanged"/>).</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <typeparam name="TValue">The type of the monitored property.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to observe a specific property value on items in.</param>
-    /// <param name="propertyAccessor">A <see cref="Expression{TDelegate}"/> that expression selecting the property to monitor.</param>
-    /// <param name="notifyOnInitialValue">When <see langword="true"/> (the default), the current property value is emitted immediately for each item upon subscription.</param>
-    /// <returns>An observable of property values. The owning item is not included; use <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> if you need it.</returns>
-    /// <remarks>
-    /// <para>
-    /// Per-item subscriptions are created on Add, replaced on Update, disposed on Remove. Errors from individual
-    /// property subscriptions are silently ignored. If you need to correlate a value back to its source item,
-    /// use <see cref="WhenPropertyChanged{TObject, TKey, TValue}"/> which returns a <see cref="PropertyValue{TObject, TValue}"/> pair.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Subscribes to the specified property. If <c>notifyOnInitialValue</c> is true, the current value is emitted immediately.</description></item>
-    /// <item><term>Update</term><description>Disposes the old subscription, subscribes to the new item's property.</description></item>
-    /// <item><term>Remove</term><description>Disposes the property subscription.</description></item>
-    /// <item><term>Refresh</term><description>No effect on subscriptions.</description></item>
-    /// <item><term>OnError</term><description>Per-item errors silently ignored. Source errors terminate the stream.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="WhenPropertyChanged{TObject, TKey, TValue}"/>
-    /// <seealso cref="WhenAnyPropertyChanged{TObject, TKey}"/>
-    /// <seealso cref="AutoRefresh{TObject, TKey, TProperty}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableListEx.WhenValueChanged"/>
-    public static IObservable<TValue?> WhenValueChanged<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
-        where TObject : INotifyPropertyChanged
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
-
-        return source.MergeMany(t => t.WhenChanged(propertyAccessor, notifyOnInitialValue));
-    }
-
-    /// <summary>
-    /// Includes changes for the specified reasons only.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by change reason.</param>
-    /// <param name="reasons">The <see cref="ChangeReason"/> values to filter by.</param>
-    /// <returns>An observable which emits a change set with items matching the reasons.</returns>
-    /// <exception cref="ArgumentNullException">reasons.</exception>
-    /// <exception cref="ArgumentException">Must select at least on reason.</exception>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes will cause memory leaks in downstream caches, since items are never cleaned up.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> WhereReasonsAre<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params ChangeReason[] reasons)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
-
-        if (reasons.Length == 0)
-        {
-            throw new ArgumentException("Must select at least one reason");
-        }
-
-        var hashed = new HashSet<ChangeReason>(reasons);
-
-        return source.Select(updates => new ChangeSet<TObject, TKey>(updates.Where(u => hashed.Contains(u.Reason)))).NotEmpty();
-    }
-
-    /// <summary>
-    /// Excludes updates for the specified reasons.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to filter by excluding change reasons.</param>
-    /// <param name="reasons">The <see cref="ChangeReason"/> values to filter by.</param>
-    /// <returns>An observable which emits a change set with items not matching the reasons.</returns>
-    /// <exception cref="ArgumentNullException">reasons.</exception>
-    /// <exception cref="ArgumentException">Must select at least on reason.</exception>
-    /// <remarks>
-    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes will cause memory leaks in downstream caches, since items are never cleaned up.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> WhereReasonsAreNot<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params ChangeReason[] reasons)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
-
-        if (reasons.Length == 0)
-        {
-            throw new ArgumentException("Must select at least one reason");
-        }
-
-        var hashed = new HashSet<ChangeReason>(reasons);
-
-        return source.Select(updates => new ChangeSet<TObject, TKey>(updates.Where(u => !hashed.Contains(u.Reason)))).NotEmpty();
-    }
-
-    /// <summary>
-    /// Combines multiple changeset streams using logical XOR (symmetric difference).
-    /// An item appears downstream only if it exists in exactly one source.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject, TKey}}"/> to combine.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{TObject, TKey}}"/> streams to combine with.</param>
-    /// <returns>A changeset stream containing items present in exactly one source.</returns>
-    /// <remarks>
-    /// <para>
-    /// Items are tracked via reference counting. An item appears downstream only when exactly one
-    /// source holds it. Adding the same key from a second source removes it from the result;
-    /// removing from that second source restores it.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>If the key is now held by exactly one source, an <b>Add</b> is emitted. If adding causes the count to reach 2+, a <b>Remove</b> is emitted (the item is no longer exclusive).</description></item>
-    /// <item><term>Update</term><description>If the item is currently downstream (count is 1), an <b>Update</b> is emitted.</description></item>
-    /// <item><term>Remove</term><description>Reference count decremented. If the count drops to exactly 1, an <b>Add</b> is emitted (the item is now exclusive to one source). If it drops to 0, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>If the item is downstream, a <b>Refresh</b> is forwarded.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <seealso cref="ObservableListEx.Xor"/>
-    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, params IObservable<IChangeSet<TObject, TKey>>[] others)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (others is null || others.Length == 0)
-        {
-            throw new ArgumentNullException(nameof(others));
-        }
-
-        return source.Combine(CombineOperator.Xor, others);
-    }
-
-    /// <inheritdoc cref="Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    /// <param name="sources">The <see cref="ICollection{T}"/> of streams to combine.</param>
-    /// <remarks>This overload accepts a pre-built collection of sources instead of a params array.</remarks>
-    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Xor);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
-    /// Items which are only in one of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{T}"/> of streams to combine.</param>
-    /// <returns>An observable which emits a change set.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Xor);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{IObservableCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits a change set.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Xor);
-    }
-
-    /// <summary>
-    /// Dynamically apply a logical Xor operator between the items in the outer observable list.
-    /// Items which are in any of the sources are included in the result.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="sources">The <see cref="IObservableList{ISourceCache{TObject, TKey}}"/> of changeset streams to combine.</param>
-    /// <returns>An observable which emits a change set.</returns>
-    public static IObservable<IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> sources)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Combine(CombineOperator.Xor);
-    }
-
-    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<IObservableCache<TObject, TKey>> source, CombineOperator type)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return Observable.Create<IChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                var connections = source.Connect().Transform(x => x.Connect()).AsObservableList();
-                var subscriber = connections.Combine(type).SubscribeSafe(observer);
-                return new CompositeDisposable(connections, subscriber);
-            });
-    }
-
-    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<ISourceCache<TObject, TKey>> source, CombineOperator type)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return Observable.Create<IChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                var connections = source.Connect().Transform(x => x.Connect()).AsObservableList();
-                var subscriber = connections.Combine(type).SubscribeSafe(observer);
-                return new CompositeDisposable(connections, subscriber);
-            });
-    }
-
-    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, CombineOperator type)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DynamicCombiner<TObject, TKey>(source, type).Run();
-    }
-
-    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this ICollection<IObservable<IChangeSet<TObject, TKey>>> sources, CombineOperator type)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return Observable.Create<IChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                void UpdateAction(IChangeSet<TObject, TKey> updates)
-                {
-                    try
-                    {
-                        observer.OnNext(updates);
-                    }
-                    catch (Exception ex)
-                    {
-                        observer.OnError(ex);
-                    }
-                }
-
-                var subscriber = Disposable.Empty;
-                try
-                {
-                    var combiner = new Combiner<TObject, TKey>(type, UpdateAction);
-                    subscriber = combiner.Subscribe([.. sources]);
-                }
-                catch (Exception ex)
-                {
-                    observer.OnError(ex);
-                    observer.OnCompleted();
-                }
-
-                return subscriber;
-            });
-    }
-
-    private static IObservable<IChangeSet<TObject, TKey>> Combine<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, CombineOperator type, params IObservable<IChangeSet<TObject, TKey>>[] combineTarget)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        combineTarget.ThrowArgumentNullExceptionIfNull(nameof(combineTarget));
-
-        return Observable.Create<IChangeSet<TObject, TKey>>(
-            observer =>
-            {
-                void UpdateAction(IChangeSet<TObject, TKey> updates)
-                {
-                    try
-                    {
-                        observer.OnNext(updates);
-                    }
-                    catch (Exception ex)
-                    {
-                        observer.OnError(ex);
-                        observer.OnCompleted();
-                    }
-                }
-
-                var subscriber = Disposable.Empty;
-                try
-                {
-                    var list = combineTarget.ToList();
-                    list.Insert(0, source);
-
-                    var combiner = new Combiner<TObject, TKey>(type, UpdateAction);
-                    subscriber = combiner.Subscribe([.. list]);
-                }
-                catch (Exception ex)
-                {
-                    observer.OnError(ex);
-                    observer.OnCompleted();
-                }
-
-                return subscriber;
-            });
-    }
-
-    private static IObservable<Func<TSource, TKey, bool>>? ForForced<TSource, TKey>(this IObservable<Unit>? source)
-        where TKey : notnull => source?.Select(
-            _ =>
-            {
-                static bool Transformer(TSource item, TKey key) => true;
-                return (Func<TSource, TKey, bool>)Transformer;
-            });
-
-    private static IObservable<Func<TSource, TKey, bool>>? ForForced<TSource, TKey>(this IObservable<Func<TSource, bool>>? source)
-        where TKey : notnull => source?.Select(
-            condition =>
-            {
-                bool Transformer(TSource item, TKey key) => condition(item);
-                return (Func<TSource, TKey, bool>)Transformer;
-            });
-
-    private static IObservable<IChangeSet<TObject, TKey>> OnChangeAction<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, Predicate<Change<TObject, TKey>> predicate, Action<Change<TObject, TKey>> changeAction)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        return source.Do(changes =>
-        {
-            foreach (var change in changes.ToConcreteType())
-            {
-                if (!predicate(change))
-                {
-                    continue;
-                }
-
-                changeAction(change);
-            }
-        });
-    }
-
-    // TODO: Apply the Adapter to more places
-    private static Func<TObject, TKey, TResult> AdaptSelector<TObject, TKey, TResult>(Func<TObject, TResult> other)
-        where TObject : notnull
-        where TKey : notnull
-        where TResult : notnull => (obj, _) => other(obj);
-
-    private static IObservable<IChangeSet<TObject, TKey>> OnChangeAction<TObject, TKey>(this IObservable<IChangeSet<TObject, TKey>> source, ChangeReason reason, Action<TObject, TKey> action)
-        where TObject : notnull
-        where TKey : notnull
-        => source.OnChangeAction(change => change.Reason == reason, change => action(change.Current, change.Key));
-
-    private static IObservable<bool> TrueFor<TObject, TKey, TValue>(this IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IObservable<TValue>> observableSelector, Func<IEnumerable<ObservableWithValue<TObject, TValue>>, bool> collectionMatcher)
-        where TObject : notnull
-        where TKey : notnull
-        where TValue : notnull => new TrueFor<TObject, TKey, TValue>(source, observableSelector, collectionMatcher).Run();
-
-    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey>(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).AsObservableChangeSet(keySelector);
-
-    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey, TCollection>(Func<TSource, TSourceKey, Task<TCollection>> manySelector, Func<TDestination, TDestinationKey> keySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull
-        where TCollection : INotifyCollectionChanged, IEnumerable<TDestination> => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).ToObservableChangeSet<TCollection, TDestination>().AddKey(keySelector);
-
-    private static Func<TSource, TSourceKey, Task<IObservable<IChangeSet<TDestination, TDestinationKey>>>> CreateChangeSetTransformer<TDestination, TDestinationKey, TSource, TSourceKey>(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>> manySelector)
-        where TDestination : notnull
-        where TDestinationKey : notnull
-        where TSource : notnull
-        where TSourceKey : notnull => async (val, key) => (await manySelector(val, key).ConfigureAwait(false)).Connect();
 }
diff --git a/src/DynamicData/DynamicData.csproj b/src/DynamicData/DynamicData.csproj
index df4385404..fa2926c66 100644
--- a/src/DynamicData/DynamicData.csproj
+++ b/src/DynamicData/DynamicData.csproj
@@ -24,14 +24,9 @@ Dynamic Data is a comprehensive caching and data manipulation solution which int
     </Description>
   </PropertyGroup>
 
-  <ItemGroup>
-
-    <!-- Group nested ObservableCacheEx.x.cs classes with ObservableCacheEx.cs -->
-    <Compile Remove="**\ObservableCacheEx.*.cs" />
-  
-    <Compile Include="**\ObservableCacheEx.*.cs">
-      <DependentUpon>ObservableCacheEx.cs</DependentUpon>
-    </Compile>
+  <!-- AsyncDisposeMany is only supported on platforms that have IAsyncDisposable. -->
+  <ItemGroup Condition="!$(DefineConstants.Contains('SUPPORTS_ASYNC_DISPOSABLE'))">
+    <Compile Remove="Cache\ObservableCacheEx.AsyncDisposeMany.cs" />
   </ItemGroup>
 
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/DynamicData/List/Internal/Filter.Static.cs b/src/DynamicData/List/Internal/Filter.Static.cs
index 36a49c5e9..48b12020c 100644
--- a/src/DynamicData/List/Internal/Filter.Static.cs
+++ b/src/DynamicData/List/Internal/Filter.Static.cs
@@ -26,7 +26,6 @@ public static IObservable<IChangeSet<T>> Create(
 
                 var downstreamItems = new ChangeAwareList<T>();
                 var itemsBuffer = new List<T>();
-
                 var downstream = source.Select(upstreamChanges =>
                 {
                     foreach (var change in upstreamChanges)
@@ -212,13 +211,23 @@ public static IObservable<IChangeSet<T>> Create(
                                 {
                                     var isIncluded = predicate.Invoke(change.Item.Current);
 
-                                    var itemState = upstreamItemsStates[change.Item.CurrentIndex];
-                                    upstreamItemsStates[change.Item.CurrentIndex] = (
+                                    var currentIndex = change.Item.CurrentIndex;
+                                    // A Replace might have a negative CurrentIndex from a Refresh in RemoveKeyEnumerator
+                                    if (currentIndex < 0)
+                                    {
+                                        var previous = upstreamItemsStates.Select(x => x.item)
+                                            .IndexOfOptional(change.Item.Current)
+                                            .ValueOrThrow(() => new InvalidOperationException($"Cannot find index of {typeof(T).Name} -> {change.Item.Current}. Expected to be in the list"));
+                                        currentIndex = previous.Index;
+                                    }
+                                    var itemState = upstreamItemsStates[currentIndex];
+
+                                    upstreamItemsStates[currentIndex] = (
                                         item: change.Item.Current,
                                         isIncluded: isIncluded);
 
                                     var downstreamIndex = (isIncluded || itemState.isIncluded)
-                                        ? change.Item.CurrentIndex - CountExcludedItemsBefore(change.Item.CurrentIndex)
+                                        ? currentIndex - CountExcludedItemsBefore(currentIndex)
                                         : -1;
 
                                     switch (itemState.isIncluded, isIncluded)
diff --git a/src/DynamicData/List/Internal/Filter.cs b/src/DynamicData/List/Internal/Filter.cs
new file mode 100644
index 000000000..b43fc2dd6
--- /dev/null
+++ b/src/DynamicData/List/Internal/Filter.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace DynamicData.List.Internal;
+
+internal static partial class Filter;
diff --git a/src/DynamicData/List/Internal/TransformAsync.cs b/src/DynamicData/List/Internal/TransformAsync.cs
index b43edc030..31f45b1a4 100644
--- a/src/DynamicData/List/Internal/TransformAsync.cs
+++ b/src/DynamicData/List/Internal/TransformAsync.cs
@@ -10,23 +10,23 @@ internal sealed class TransformAsync<TSource, TDestination>
     where TSource : notnull
     where TDestination : notnull
 {
-    private readonly Func<TSource, Optional<TDestination>, int, Task<Transformer<TSource, TDestination>.TransformedItemContainer>> _containerFactory;
+    private readonly Func<TSource, Optional<TDestination>, int, CancellationToken, Task<Transformer<TSource, TDestination>.TransformedItemContainer>> _containerFactory;
 
     private readonly IObservable<IChangeSet<TSource>> _source;
     private readonly bool _transformOnRefresh;
 
     public TransformAsync(
         IObservable<IChangeSet<TSource>> source,
-        Func<TSource, Optional<TDestination>, int, Task<TDestination>> factory,
+        Func<TSource, Optional<TDestination>, int, CancellationToken, Task<TDestination>> factory,
         bool transformOnRefresh)
     {
         factory.ThrowArgumentNullExceptionIfNull(nameof(factory));
 
         _source = source ?? throw new ArgumentNullException(nameof(source));
         _transformOnRefresh = transformOnRefresh;
-        _containerFactory = async (item, prev, index) =>
+        _containerFactory = async (item, prev, index, cancel) =>
         {
-            var destination = await factory(item, prev, index).ConfigureAwait(false);
+            var destination = await factory(item, prev, index, cancel).ConfigureAwait(false);
             return new Transformer<TSource, TDestination>.TransformedItemContainer(item, destination);
         };
     }
@@ -35,33 +35,59 @@ public TransformAsync(
 
     private IObservable<IChangeSet<TDestination>> RunImpl()
     {
-        var state = new ChangeAwareList<Transformer<TSource, TDestination>.TransformedItemContainer>();
-        var asyncLock = new SemaphoreSlim(1, 1);
+        return Observable.Using(
+            () => new SemaphoreSlim(1, 1),
+            asyncLock =>
+            {
+                var state = new ChangeAwareList<Transformer<TSource, TDestination>.TransformedItemContainer>();
 
-        return _source.Select(async changes =>
-                {
-                    try
-                    {
-                        await asyncLock.WaitAsync();
-                        await Transform(state, changes);
-                        return state;
-                    }
-                    finally
+                return _source.Select(changes => Observable.FromAsync(async cancel =>
+                        {
+                            // NOTE: lock outside of the try to avoid releasing another scope's lock if the token is canceled before we acquire the lock.
+                            try
+                            {
+                                await asyncLock.WaitAsync(cancel);
+                            }
+                            catch (Exception e) when (e is ObjectDisposedException)
+                            {
+                                return Optional.None<ChangeAwareList<Transformer<TSource, TDestination>.TransformedItemContainer>>();
+                            }
+
+                            try
+                            {
+                                await Transform(state, changes, cancel);
+                                return Optional.Some(state);
+                            }
+                            finally
+                            {
+                                try
+                                {
+                                    // token is canceled when outer stream is disposed which is attached to the lock's lifetime.
+                                    if (!cancel.IsCancellationRequested)
+                                    {
+                                        asyncLock.Release();
+                                    }
+                                }
+                                catch (ObjectDisposedException)
+                                {
+                                    // outer stream was disposed during inner transform.
+                                }
+                            }
+                        }))
+                    .Concat()
+                    .SelectValues()
+                    .Select(transformed =>
                     {
-                        asyncLock.Release();
-                    }
-                })
-            .Concat()
-            .Select(transformed =>
-            {
-                var changed = transformed.CaptureChanges();
-                return changed.Transform(container => container.Destination);
+                        var changed = transformed.CaptureChanges();
+                        return changed.Transform(container => container.Destination);
+                    });
             });
     }
 
     private async Task Transform(
         ChangeAwareList<Transformer<TSource, TDestination>.TransformedItemContainer> transformed,
-        IChangeSet<TSource> changes)
+        IChangeSet<TSource> changes,
+        CancellationToken cancel)
     {
         changes.ThrowArgumentNullExceptionIfNull(nameof(changes));
 
@@ -78,7 +104,8 @@ private async Task Transform(
                                 await _containerFactory(
                                     item.Item.Current,
                                     Optional<TDestination>.None,
-                                    transformed.Count).ConfigureAwait(false);
+                                    transformed.Count,
+                                    cancel).ConfigureAwait(false);
                             transformed.Add(container);
                         }
                         else
@@ -87,7 +114,8 @@ await _containerFactory(
                                 await _containerFactory(
                                     item.Item.Current,
                                     Optional<TDestination>.None,
-                                    change.CurrentIndex).ConfigureAwait(false);
+                                    change.CurrentIndex,
+                                    cancel).ConfigureAwait(false);
                             transformed.Insert(change.CurrentIndex, container);
                         }
 
@@ -97,7 +125,7 @@ await _containerFactory(
                 case ListChangeReason.AddRange:
                     {
                         var startIndex = item.Range.Index < 0 ? transformed.Count : item.Range.Index;
-                        var tasks = item.Range.Select((t, idx) => _containerFactory(t, Optional<TDestination>.None, idx + startIndex));
+                        var tasks = item.Range.Select((t, idx) => _containerFactory(t, Optional<TDestination>.None, idx + startIndex, cancel));
                         var containers = await Task.WhenAll(tasks).ConfigureAwait(false);
                         transformed.AddOrInsertRange(containers, item.Range.Index);
                         break;
@@ -109,7 +137,7 @@ await _containerFactory(
                         if (_transformOnRefresh)
                         {
                             Optional<TDestination> previous = transformed[change.CurrentIndex].Destination;
-                            var container = await _containerFactory(change.Current, previous, change.CurrentIndex)
+                            var container = await _containerFactory(change.Current, previous, change.CurrentIndex, cancel)
                                 .ConfigureAwait(false);
                             transformed[change.CurrentIndex] = container;
                         }
@@ -128,12 +156,12 @@ await _containerFactory(
                         Optional<TDestination> previous = transformed[change.PreviousIndex].Destination;
                         if (change.CurrentIndex == change.PreviousIndex)
                         {
-                            transformed[change.CurrentIndex] = await _containerFactory(change.Current, previous, change.CurrentIndex);
+                            transformed[change.CurrentIndex] = await _containerFactory(change.Current, previous, change.CurrentIndex, cancel);
                         }
                         else
                         {
                             transformed.RemoveAt(change.PreviousIndex);
-                            transformed.Insert(change.CurrentIndex, await _containerFactory(change.Current, Optional<TDestination>.None, change.CurrentIndex));
+                            transformed.Insert(change.CurrentIndex, await _containerFactory(change.Current, Optional<TDestination>.None, change.CurrentIndex, cancel));
                         }
 
                         break;
diff --git a/src/DynamicData/List/ObservableListEx.Adapt.cs b/src/DynamicData/List/ObservableListEx.Adapt.cs
new file mode 100644
index 000000000..942d943c7
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Adapt.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Injects a side effect into a changeset stream via an <see cref="IChangeSetAdaptor{T}"/>.
+    /// The adaptor's <c>Adapt</c> method is invoked for each changeset before it is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe and adapt.</param>
+    /// <param name="adaptor">The <see cref="IChangeSetAdaptor{T}"/> adaptor whose <c>Adapt</c> method is invoked for each changeset.</param>
+    /// <returns>A list changeset stream identical to the source, with the adaptor side effect applied.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="adaptor"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// This is the primary extension point for custom UI binding adaptors (e.g., <see cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
+    /// delegates to this operator). If the adaptor throws, the exception propagates downstream as <c>OnError</c>.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
+    public static IObservable<IChangeSet<T>> Adapt<T>(this IObservable<IChangeSet<T>> source, IChangeSetAdaptor<T> adaptor)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
+
+        return Observable.Create<IChangeSet<T>>(
+            observer =>
+            {
+                var locker = InternalEx.NewLock();
+                return source.Synchronize(locker).Select(
+                    changes =>
+                    {
+                        adaptor.Adapt(changes);
+                        return changes;
+                    }).SubscribeSafe(observer);
+            });
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.AddKey.cs b/src/DynamicData/List/ObservableListEx.AddKey.cs
new file mode 100644
index 000000000..0ead13a87
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.AddKey.cs
@@ -0,0 +1,51 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Adds a key to each item in a list changeset, converting it to a cache changeset that supports all keyed DynamicData operators.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to add keys to, converting to a cache changeset.</param>
+    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> function to extract a unique key from each item.</param>
+    /// <returns>A cache <see cref="IObservable{IChangeSet{TObject, TKey}}"/> changeset stream with keyed items.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// All index information is dropped during conversion because cache changesets are unordered by default.
+    /// Use this when you need to transition from list-based pipelines to cache-based operators (Filter by key, Join, Group, etc.).
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="ObservableCacheEx.RemoveKey{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<TObject, TKey>> AddKey<TObject, TKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TKey> keySelector)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
+
+        return source.Select(changes => new ChangeSet<TObject, TKey>(new AddKeyEnumerator<TObject, TKey>(changes, keySelector)));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.And.cs b/src/DynamicData/List/ObservableListEx.And.cs
new file mode 100644
index 000000000..2dee36d90
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.And.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies a logical AND (intersection) between multiple list changeset streams.
+    /// Only items present in ALL sources appear in the result.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the lists.</typeparam>
+    /// <param name="source">The first source <see cref="IObservable{IChangeSet{T}}"/> to intersect.</param>
+    /// <param name="others">The additional <see cref="IObservable{IChangeSet{T}}"/> changeset streams to intersect with.</param>
+    /// <returns>A list changeset stream containing items that exist in every source.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Uses reference counting per item across all sources. An item appears downstream only when
+    /// its reference count is non-zero in ALL sources. Item identity is determined by the default equality comparer.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/AddRange</term><description>The item's reference count is incremented in its source tracker. If the item is now present in all sources, an <b>Add</b> is emitted.</description></item>
+    /// <item><term>Replace</term><description>The old item's reference count is decremented and the new item's is incremented. Depending on whether each is present in ALL sources, this emits an <b>Add</b>, <b>Remove</b>, <b>Replace</b>, or nothing.</description></item>
+    /// <item><term>Remove/RemoveRange/Clear</term><description>The item's reference count is decremented. If it was in the result and is no longer in all sources, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently in the result.</description></item>
+    /// <item><term>Moved</term><description>Ignored (set operations are position-independent).</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Item identity uses object equality, not position. Duplicate items in a single source are reference-counted independently.</para>
+    /// </remarks>
+    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="ObservableCacheEx.And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    public static IObservable<IChangeSet<T>> And<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
+        where T : notnull
+    {
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.Combine(CombineOperator.And, others);
+    }
+
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <param name="sources">A <see cref="ICollection{T}"/> of changeset streams to intersect.</param>
+    /// <remarks>
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>This overload accepts a pre-built collection of sources instead of a params array.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> And<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.And);
+
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <param name="sources">An <see cref="IObservableList{T}"/> of changeset streams. Sources can be added or removed dynamically.</param>
+    /// <remarks>
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>This overload supports dynamic source management: adding or removing changeset streams from the observable list triggers re-evaluation.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.And);
+
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <param name="sources">An <see cref="IObservableList{IObservableList{T}}"/> of <see cref="IObservableList{IObservableList{T}}"/>. Each inner list's changes are connected automatically.</param>
+    /// <remarks>
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>This overload accepts <see cref="IObservableList{T}"/> instances directly, calling <c>Connect()</c> internally.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<IObservableList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.And);
+
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <param name="sources">An <see cref="IObservableList{ISourceList{T}}"/> of <see cref="ISourceList{T}"/>. Each inner list's changes are connected automatically.</param>
+    /// <remarks>
+    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>This overload accepts <see cref="ISourceList{T}"/> instances directly, calling <c>Connect()</c> internally.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<ISourceList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.And);
+}
diff --git a/src/DynamicData/List/ObservableListEx.AsObservableList.cs b/src/DynamicData/List/ObservableListEx.AsObservableList.cs
new file mode 100644
index 000000000..478ae5b63
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.AsObservableList.cs
@@ -0,0 +1,64 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Wraps a <see cref="ISourceList{T}"/> as a read-only <see cref="IObservableList{T}"/>, hiding mutation methods.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The <see cref="ISourceList{T}"/> mutable source list to wrap.</param>
+    /// <returns>A read-only observable list that mirrors the source.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static IObservableList<T> AsObservableList<T>(this ISourceList<T> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new AnonymousObservableList<T>(source);
+    }
+
+    /// <summary>
+    /// Materializes a changeset stream into a read-only <see cref="IObservableList{T}"/>.
+    /// The list is kept in sync with the source stream for the lifetime of the subscription.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to materialize into a read-only list.</param>
+    /// <returns>A read-only observable list reflecting the current state of the stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// This is the primary way to <b>multicast</b> a changeset pipeline. Materializing once into an <see cref="IObservableList{T}"/>,
+    /// then calling <c>Connect()</c> on the result for each downstream consumer, ensures the upstream operators are evaluated only once
+    /// regardless of how many subscribers consume the result.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="AsObservableList{T}(ISourceList{T})"/>
+    public static IObservableList<T> AsObservableList<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new AnonymousObservableList<T>(source);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.AutoRefresh.cs b/src/DynamicData/List/ObservableListEx.AutoRefresh.cs
new file mode 100644
index 000000000..d5e0660f8
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.AutoRefresh.cs
@@ -0,0 +1,101 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Monitors all properties on each item (via <see cref="INotifyPropertyChanged"/>) and emits <b>Refresh</b>
+    /// changes when any property changes, causing downstream operators to re-evaluate.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items, which must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to monitor for property-driven refresh signals.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration to batch multiple refresh signals into a single changeset.</param>
+    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications.</param>
+    /// <param name="scheduler">The scheduler for throttle and buffer timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>A list changeset stream with additional <b>Refresh</b> changes injected when properties change.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Wraps <see cref="AutoRefreshOnObservable{TObject, TAny}"/> using <c>WhenAnyPropertyChanged()</c> as the re-evaluator.
+    /// Pair with <see cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/> or <see cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
+    /// to get reactive re-evaluation on property changes.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/AddRange</term><description>Subscribes to <c>PropertyChanged</c> on each new item. The original change is forwarded.</description></item>
+    /// <item><term>Replace</term><description>Unsubscribes from the old item, subscribes to the new. The original change is forwarded.</description></item>
+    /// <item><term>Remove/RemoveRange/Clear</term><description>Unsubscribes from removed items. The original change is forwarded.</description></item>
+    /// <item><term>Moved/Refresh</term><description>Forwarded unchanged.</description></item>
+    /// <item><term>Property changes</term><description>A <b>Refresh</b> change is emitted for the item whose property changed.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Each item generates a subscription. For large lists with frequent property changes, use <paramref name="changeSetBuffer"/> and <paramref name="propertyChangeThrottle"/> to reduce churn.</para>
+    /// </remarks>
+    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="AutoRefreshOnObservable{TObject, TAny}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{TAny}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ObservableCacheEx.AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<TObject>> AutoRefresh<TObject>(this IObservable<IChangeSet<TObject>> source, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.AutoRefreshOnObservable(
+            t =>
+            {
+                if (propertyChangeThrottle is null)
+                {
+                    return t.WhenAnyPropertyChanged();
+                }
+
+                return t.WhenAnyPropertyChanged().Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
+            },
+            changeSetBuffer,
+            scheduler);
+    }
+
+    /// <summary>
+    /// Monitors a single property (selected by <paramref name="propertyAccessor"/>) on each item via <see cref="INotifyPropertyChanged"/>
+    /// and emits <b>Refresh</b> changes when that property changes, causing downstream operators to re-evaluate. More efficient than
+    /// the all-properties overload when only one property (of type <typeparamref name="TProperty"/>) affects downstream behavior.
+    /// </summary>
+    /// <inheritdoc cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<TObject>> AutoRefresh<TObject, TProperty>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TProperty>> propertyAccessor, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
+
+        return source.AutoRefreshOnObservable(
+            t =>
+            {
+                if (propertyChangeThrottle is null)
+                {
+                    return t.WhenPropertyChanged(propertyAccessor, false);
+                }
+
+                return t.WhenPropertyChanged(propertyAccessor, false).Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
+            },
+            changeSetBuffer,
+            scheduler);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.AutoRefreshOnObservable.cs b/src/DynamicData/List/ObservableListEx.AutoRefreshOnObservable.cs
new file mode 100644
index 000000000..dc3ede92c
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.AutoRefreshOnObservable.cs
@@ -0,0 +1,63 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Monitors each item with a custom observable and emits <b>Refresh</b> changes whenever that observable fires,
+    /// causing downstream operators (Filter, Sort, Group) to re-evaluate.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TAny">The type emitted by the re-evaluator observable (value is ignored).</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to monitor for observable-driven refresh signals.</param>
+    /// <param name="reevaluator">A <see cref="Func{T, TResult}"/> factory that, given an item, returns an observable whose emissions trigger a <b>Refresh</b> for that item.</param>
+    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration to batch refresh signals into a single changeset.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> for buffering.</param>
+    /// <returns>A list changeset stream with additional <b>Refresh</b> changes injected when per-item observables fire.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="reevaluator"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// This is the general-purpose refresh mechanism. <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// is a convenience wrapper that uses <c>WhenAnyPropertyChanged()</c> as the re-evaluator.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/AddRange</term><description>Subscribes to the re-evaluator observable for each new item. The original change is forwarded.</description></item>
+    /// <item><term>Replace</term><description>Unsubscribes from the old item's observable, subscribes to the new. The original change is forwarded.</description></item>
+    /// <item><term>Remove/RemoveRange/Clear</term><description>Unsubscribes from removed items. The original change is forwarded.</description></item>
+    /// <item><term>Moved/Refresh</term><description>Forwarded unchanged.</description></item>
+    /// <item><term>Re-evaluator fires</term><description>The item's current index is looked up and a <b>Refresh</b> change is emitted.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ObservableCacheEx.AutoRefreshOnObservable{TObject, TKey, TAny}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TAny}}, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<TObject>> AutoRefreshOnObservable<TObject, TAny>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        reevaluator.ThrowArgumentNullExceptionIfNull(nameof(reevaluator));
+
+        return new AutoRefresh<TObject, TAny>(source, reevaluator, changeSetBuffer, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Bind.cs b/src/DynamicData/List/ObservableListEx.Bind.cs
new file mode 100644
index 000000000..fe14bece5
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Bind.cs
@@ -0,0 +1,149 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies changeset mutations to a target <see cref="IObservableCollection{T}"/> for UI data binding.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to bind to a collection.</param>
+    /// <param name="targetCollection">The <see cref="IObservableCollection{T}"/> target collection to keep in sync.</param>
+    /// <param name="resetThreshold">When a changeset exceeds this many changes, the collection is reset instead of applying individual changes.</param>
+    /// <returns>A continuation of the source changeset stream (allows further chaining).</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="targetCollection"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Delegates to <see cref="Adapt{T}(IObservable{IChangeSet{T}}, IChangeSetAdaptor{T})"/> with an internal collection adaptor.
+    /// Each changeset is applied to the target collection on the calling thread. For UI binding, ensure the source is
+    /// observed on the UI thread (e.g., via <c>ObserveOn</c>).
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Item inserted at the specified index in the target collection.</description></item>
+    /// <item><term>AddRange</term><description>Items inserted as a range. If the count exceeds <paramref name="resetThreshold"/>, the collection is cleared and repopulated.</description></item>
+    /// <item><term>Replace</term><description>Item at the specified index is replaced.</description></item>
+    /// <item><term>Remove</term><description>Item at the specified index is removed.</description></item>
+    /// <item><term>RemoveRange/Clear</term><description>Items removed from the collection.</description></item>
+    /// <item><term>Moved</term><description>Item is moved between positions in the collection.</description></item>
+    /// <item><term>Refresh</term><description>Depends on the adaptor implementation.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, out ReadOnlyObservableCollection{T}, int)"/>
+    /// <seealso cref="Clone{T}(IObservable{IChangeSet{T}}, IList{T})"/>
+    /// <seealso cref="Adapt{T}(IObservable{IChangeSet{T}}, IChangeSetAdaptor{T})"/>
+    /// <seealso cref="ObservableCacheEx.Bind{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservableCollection{TObject}, int)"/>
+    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, IObservableCollection<T> targetCollection, int resetThreshold = BindingOptions.DefaultResetThreshold)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        targetCollection.ThrowArgumentNullExceptionIfNull(nameof(targetCollection));
+
+        // if user has not specified different defaults, use system wide defaults instead.
+        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
+        var defaults = DynamicDataOptions.Binding;
+
+        var options = resetThreshold == BindingOptions.DefaultResetThreshold
+            ? defaults
+            : defaults with { ResetThreshold = resetThreshold };
+
+        return source.Bind(targetCollection, options);
+    }
+
+    /// <summary>
+    /// Binds the source changeset stream to <paramref name="targetCollection"/>, with fine-grained <see cref="BindingOptions"/> control over reset threshold and other behaviors.
+    /// </summary>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, IObservableCollection<T> targetCollection, BindingOptions options)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        targetCollection.ThrowArgumentNullExceptionIfNull(nameof(targetCollection));
+
+        var adaptor = new ObservableCollectionAdaptor<T>(targetCollection, options);
+        return source.Adapt(adaptor);
+    }
+
+    /// <summary>
+    /// Constructs a <see cref="ReadOnlyObservableCollection{T}"/> and binds the changeset stream to it.
+    /// Use this overload when you need a read-only view (typically for UI binding) without managing the backing collection yourself.
+    /// The created collection is returned via the <paramref name="readOnlyObservableCollection"/> output parameter.
+    /// </summary>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    /// <remarks>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    /// <para>The created collection is backed by an internal <c>ObservableCollectionExtended&lt;T&gt;</c>. Callers receive only the read-only wrapper.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, out ReadOnlyObservableCollection<T> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        // if user has not specified different defaults, use system wide defaults instead.
+        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
+        var defaults = DynamicDataOptions.Binding;
+        var options = resetThreshold == BindingOptions.DefaultResetThreshold
+            ? defaults
+            : defaults with { ResetThreshold = resetThreshold };
+
+        return source.Bind(out readOnlyObservableCollection, options);
+    }
+
+    /// <summary>
+    /// Constructs a <see cref="ReadOnlyObservableCollection{T}"/> and binds the changeset stream to it,
+    /// with fine-grained <see cref="BindingOptions"/> control over reset threshold and other behaviors.
+    /// The created collection is returned via the <paramref name="readOnlyObservableCollection"/> output parameter.
+    /// </summary>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    /// <remarks>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    /// <para>The created collection is backed by an internal <c>ObservableCollectionExtended&lt;T&gt;</c>. Callers receive only the read-only wrapper.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, out ReadOnlyObservableCollection<T> readOnlyObservableCollection, BindingOptions options)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        var target = new ObservableCollectionExtended<T>();
+        var result = new ReadOnlyObservableCollection<T>(target);
+        var adaptor = new ObservableCollectionAdaptor<T>(target, options);
+        readOnlyObservableCollection = result;
+        return source.Adapt(adaptor);
+    }
+
+#if SUPPORTS_BINDINGLIST
+    /// <summary>
+    /// Binds the source changeset stream to a WinForms <see cref="BindingList{T}"/>, keeping <paramref name="bindingList"/> in sync.
+    /// </summary>
+    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    public static IObservable<IChangeSet<T>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] T>(this IObservable<IChangeSet<T>> source, BindingList<T> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
+
+        return source.Adapt(new BindingListAdaptor<T>(bindingList, resetThreshold));
+    }
+#endif
+}
diff --git a/src/DynamicData/List/ObservableListEx.BufferIf.cs b/src/DynamicData/List/ObservableListEx.BufferIf.cs
new file mode 100644
index 000000000..37224290f
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.BufferIf.cs
@@ -0,0 +1,92 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <para>This overload starts unpaused and has no timeout.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, IScheduler? scheduler = null)
+        where T : notnull => BufferIf(source, pauseIfTrueSelector, false, scheduler);
+
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <para>This overload allows setting the initial pause state but has no timeout.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState, IScheduler? scheduler = null)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
+
+        return BufferIf(source, pauseIfTrueSelector, initialPauseState, null, scheduler);
+    }
+
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <remarks>
+    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
+    /// <para>This overload starts unpaused and accepts a timeout but not an explicit initial pause state.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, TimeSpan? timeOut, IScheduler? scheduler = null)
+        where T : notnull => BufferIf(source, pauseIfTrueSelector, false, timeOut, scheduler);
+
+    /// <summary>
+    /// Buffers changeset notifications while a pause signal is active, then flushes all buffered changes when resumed.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to conditionally buffer.</param>
+    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> of <see cref="bool"/> that controls buffering: <see langword="true"/> pauses (buffers), <see langword="false"/> resumes (flushes).</param>
+    /// <param name="initialPauseState">The initial pause state. When <see langword="true"/>, buffering starts immediately.</param>
+    /// <param name="timeOut">An optional <see cref="TimeSpan"/> maximum duration to keep the buffer open. After this time, the buffer is flushed regardless of pause state.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> for timeout scheduling.</param>
+    /// <returns>A list changeset stream that buffers during pause and emits combined changesets on resume.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pauseIfTrueSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// All changeset events are buffered at the changeset level (not individual changes) while paused.
+    /// On resume, all buffered changesets are emitted as a single combined changeset. If the buffer is empty on resume,
+    /// no emission occurs.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Any (while paused)</term><description>Accumulated in an internal buffer. Not emitted downstream.</description></item>
+    /// <item><term>Any (while active)</term><description>Passed through immediately.</description></item>
+    /// <item><term>Pause selector emits false</term><description>All buffered changesets are flushed downstream as one combined changeset.</description></item>
+    /// <item><term>Timeout fires</term><description>Automatically resumes and flushes the buffer.</description></item>
+    /// <item><term>OnError</term><description>Forwarded immediately (not buffered).</description></item>
+    /// <item><term>OnCompleted</term><description>Forwarded immediately.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Each pause/resume cycle re-arms the timeout. Rapid toggling can create many small buffer windows.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState, TimeSpan? timeOut, IScheduler? scheduler = null)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
+
+        return new BufferIf<T>(source, pauseIfTrueSelector, initialPauseState, timeOut, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.BufferInitial.cs b/src/DynamicData/List/ObservableListEx.BufferInitial.cs
new file mode 100644
index 000000000..17ad6d43b
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.BufferInitial.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Buffers changesets during an initial time window, then emits a single combined changeset and passes through subsequent changes.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to buffer during the initial loading period.</param>
+    /// <param name="initialBuffer">The <see cref="TimeSpan"/> time period (measured from first emission) during which changes are buffered.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> for timing the buffer window.</param>
+    /// <returns>A list changeset stream where the initial burst is combined into one changeset.</returns>
+    /// <remarks>
+    /// <para>
+    /// For a configured duration after the first emission, all changesets are buffered and combined into a single emission.
+    /// After this initial window, subsequent changesets pass through immediately.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="FlattenBufferResult{T}(IObservable{IList{IChangeSet{T}}})"/>
+    public static IObservable<IChangeSet<TObject>> BufferInitial<TObject>(this IObservable<IChangeSet<TObject>> source, TimeSpan initialBuffer, IScheduler? scheduler = null)
+        where TObject : notnull => source.DeferUntilLoaded().Publish(
+            shared =>
+            {
+                var initial = shared.Buffer(initialBuffer, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult().Take(1);
+
+                return initial.Concat(shared);
+            });
+}
diff --git a/src/DynamicData/List/ObservableListEx.Cast.cs b/src/DynamicData/List/ObservableListEx.Cast.cs
new file mode 100644
index 000000000..7c0f9aad7
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Cast.cs
@@ -0,0 +1,65 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Casts each item in the changeset from <c>object</c> to <typeparamref name="TDestination"/> using a direct cast.
+    /// </summary>
+    /// <typeparam name="TDestination">The target type to cast to.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{object}}"/> of <c>object</c> items.</param>
+    /// <returns>A list changeset stream of cast items.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Cast{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination})"/>
+    /// <seealso cref="CastToObject{T}(IObservable{IChangeSet{T}})"/>
+    public static IObservable<IChangeSet<TDestination>> Cast<TDestination>(this IObservable<IChangeSet<object>> source)
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Select(changes => changes.Transform(t => (TDestination)t));
+    }
+
+    /// <summary>
+    /// Transforms each item in the changeset using a conversion function.
+    /// </summary>
+    /// <typeparam name="TSource">The source item type.</typeparam>
+    /// <typeparam name="TDestination">The destination item type.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to cast.</param>
+    /// <param name="conversionFactory">A <see cref="Func{T, TResult}"/> function to convert each item from <typeparamref name="TSource"/> to <typeparamref name="TDestination"/>.</param>
+    /// <returns>A list changeset stream of converted items.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="conversionFactory"/> is <see langword="null"/>.</exception>
+    /// <remarks>Use this overload when type inference requires explicit specification of both source and destination types. Alternatively, call <see cref="CastToObject{T}"/> first, then the single-type-parameter <see cref="Cast{TDestination}"/> overload.</remarks>
+    /// <seealso cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/>
+    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    public static IObservable<IChangeSet<TDestination>> Cast<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, TDestination> conversionFactory)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
+
+        return source.Select(changes => changes.Transform(conversionFactory));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.CastToObject.cs b/src/DynamicData/List/ObservableListEx.CastToObject.cs
new file mode 100644
index 000000000..4695297da
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.CastToObject.cs
@@ -0,0 +1,35 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Casts each item in the changeset to <c>object</c>. Typically used before <see cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/> to work around type inference limitations.
+    /// </summary>
+    /// <typeparam name="T">The source item type (must be a reference type).</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to cast to object.</param>
+    /// <returns>A list changeset stream of <c>object</c> items.</returns>
+    /// <seealso cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/>
+    public static IObservable<IChangeSet<object>> CastToObject<T>(this IObservable<IChangeSet<T>> source)
+        where T : class => source.Select(changes => changes.Transform(t => (object)t));
+}
diff --git a/src/DynamicData/List/ObservableListEx.Clone.cs b/src/DynamicData/List/ObservableListEx.Clone.cs
new file mode 100644
index 000000000..2588c8927
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Clone.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies each changeset to the target list as a side effect, keeping it synchronized with the source.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to clone.</param>
+    /// <param name="target">The <see cref="IList{T}"/> target list to clone changes into.</param>
+    /// <returns>A continuation of the source changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Lower-level than <see cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>. Uses <see cref="IList{T}"/>.Clone() to apply all changeset operations directly.</para>
+    /// </remarks>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
+    /// <seealso cref="PopulateInto{T}(IObservable{IChangeSet{T}}, ISourceList{T})"/>
+    public static IObservable<IChangeSet<T>> Clone<T>(this IObservable<IChangeSet<T>> source, IList<T> target)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Do(target.Clone);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Combine.cs b/src/DynamicData/List/ObservableListEx.Combine.cs
new file mode 100644
index 000000000..13a617439
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Combine.cs
@@ -0,0 +1,84 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    private static IObservable<IChangeSet<T>> Combine<T>(this ICollection<IObservable<IChangeSet<T>>> sources, CombineOperator type)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return new Combiner<T>(sources, type).Run();
+    }
+
+    private static IObservable<IChangeSet<T>> Combine<T>(this IObservable<IChangeSet<T>> source, CombineOperator type, params IObservable<IChangeSet<T>>[] others)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        if (others.Length == 0)
+        {
+            throw new ArgumentException("Must be at least one item to combine with", nameof(others));
+        }
+
+        var items = source.EnumerateOne().Union(others).ToList();
+        return new Combiner<T>(items, type).Run();
+    }
+
+    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<ISourceList<T>> sources, CombineOperator type)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return Observable.Create<IChangeSet<T>>(
+            observer =>
+            {
+                var changesSetList = sources.Connect().Transform(s => s.Connect()).AsObservableList();
+                var subscriber = changesSetList.Combine(type).SubscribeSafe(observer);
+                return new CompositeDisposable(changesSetList, subscriber);
+            });
+    }
+
+    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<IObservableList<T>> sources, CombineOperator type)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return Observable.Create<IChangeSet<T>>(
+            observer =>
+            {
+                var changesSetList = sources.Connect().Transform(s => s.Connect()).AsObservableList();
+                var subscriber = changesSetList.Combine(type).SubscribeSafe(observer);
+                return new CompositeDisposable(changesSetList, subscriber);
+            });
+    }
+
+    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<IObservable<IChangeSet<T>>> sources, CombineOperator type)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return new DynamicCombiner<T>(sources, type).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Convert.cs b/src/DynamicData/List/ObservableListEx.Convert.cs
new file mode 100644
index 000000000..4380c296d
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Convert.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// <para>Convert the object using the specified conversion function.</para>
+    /// <para>This is a lighter equivalent of Transform and is designed to be used with non-disposable objects.</para>
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to convert.</param>
+    /// <param name="conversionFactory">The <see cref="Func{T, TResult}"/> conversion factory.</param>
+    /// <returns>An observable which emits the change set.</returns>
+    [Obsolete("Prefer Cast as it is does the same thing but is semantically correct")]
+    public static IObservable<IChangeSet<TDestination>> Convert<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TDestination> conversionFactory)
+        where TObject : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
+
+        return source.Select(changes => changes.Transform(conversionFactory));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.DeferUntilLoaded.cs b/src/DynamicData/List/ObservableListEx.DeferUntilLoaded.cs
new file mode 100644
index 000000000..1e6b5d037
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.DeferUntilLoaded.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Defers downstream delivery until the source emits its first changeset, then forwards all subsequent changesets.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to defer until the first changeset arrives.</param>
+    /// <returns>A list changeset stream that begins emitting only after the source has produced its first changeset.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Subscribes to the source immediately but buffers internally until the first changeset arrives, at which point it emits
+    /// the initial data and all subsequent changesets. This is useful when downstream consumers should not receive an empty initial state.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="SkipInitial{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
+    public static IObservable<IChangeSet<T>> DeferUntilLoaded<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DeferUntilLoaded<T>(source).Run();
+    }
+
+    /// <inheritdoc cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
+    /// <remarks>
+    /// <inheritdoc cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
+    /// <para>Convenience overload that calls <c>source.Connect().DeferUntilLoaded()</c>.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> DeferUntilLoaded<T>(this IObservableList<T> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Connect().DeferUntilLoaded();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.DisposeMany.cs b/src/DynamicData/List/ObservableListEx.DisposeMany.cs
new file mode 100644
index 000000000..ec463f21d
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.DisposeMany.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Disposes items that implement <see cref="IDisposable"/> when they are removed, replaced, or cleared from the stream.
+    /// All remaining tracked items are disposed when the stream finalizes (OnCompleted, OnError, or subscription disposal).
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to track for disposal on removal.</param>
+    /// <returns>A continuation of the source changeset stream with disposal side effects applied.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Items are cast to <see cref="IDisposable"/> and disposed after the changeset has been forwarded downstream.
+    /// Items that do not implement <see cref="IDisposable"/> are silently ignored.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Items are tracked for future disposal. Changeset forwarded.</description></item>
+    /// <item><term><b>Replace</b></term><description>The previous (replaced) item is disposed after the changeset is forwarded. The new item is tracked.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>Removed items are disposed after the changeset is forwarded.</description></item>
+    /// <item><term><b>Clear</b></term><description>All tracked items are disposed after the changeset is forwarded.</description></item>
+    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Forwarded. No disposal occurs.</description></item>
+    /// <item><term>OnError/OnCompleted/Disposal</term><description>All remaining tracked items are disposed during finalization.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Disposal happens after the changeset is delivered downstream, so subscribers see the change before items are disposed.</para>
+    /// </remarks>
+    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
+    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
+    /// <seealso cref="ObservableCacheEx.DisposeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<T>> DisposeMany<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new DisposeMany<T>(source).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.DistinctValues.cs b/src/DynamicData/List/ObservableListEx.DistinctValues.cs
new file mode 100644
index 000000000..39181d6c8
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.DistinctValues.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Extracts distinct values from source items using <paramref name="valueSelector"/>, with reference counting to track when values enter and leave the result set.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
+    /// <typeparam name="TValue">The type of distinct values produced.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to extract distinct values.</param>
+    /// <param name="valueSelector">A <see cref="Func{T, TResult}"/> function that extracts the value to track from each source item.</param>
+    /// <returns>A list changeset stream of distinct values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="valueSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Maintains an internal reference count per distinct value. A value is included when its count first exceeds zero
+    /// and removed when its count drops back to zero.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Value extracted. If first occurrence, an <b>Add</b> is emitted. Otherwise the reference count is incremented silently.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old value's reference count decremented (removed if zero), new value's count incremented (added if first). If the value did not change, no emission.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>Reference count decremented. If the count reaches zero, a <b>Remove</b> is emitted for that distinct value.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Value is re-extracted. If changed, old value decremented and new value incremented (same as Replace logic).</description></item>
+    /// <item><term><b>Clear</b></term><description>All reference counts cleared. <b>Remove</b> emitted for every tracked distinct value.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="ObservableCacheEx.DistinctValues{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TValue})"/>
+    public static IObservable<IChangeSet<TValue>> DistinctValues<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TValue> valueSelector)
+        where TObject : notnull
+        where TValue : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        valueSelector.ThrowArgumentNullExceptionIfNull(nameof(valueSelector));
+
+        return new Distinct<TObject, TValue>(source, valueSelector).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Except.cs b/src/DynamicData/List/ObservableListEx.Except.cs
new file mode 100644
index 000000000..7c19912d8
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Except.cs
@@ -0,0 +1,96 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies a logical set-difference (Except) between the source and other streams.
+    /// Items present in the first source but not in any of the <paramref name="others"/> are included in the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The primary <see cref="IObservable{IChangeSet{T}}"/> from which other streams are subtracted.</param>
+    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to exclude from the result.</param>
+    /// <returns>A list changeset stream containing items from <paramref name="source"/> that are not in any of <paramref name="others"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Across all sources, items are tracked
+    /// by reference-counted equality (not by index position).
+    /// The first source has a special role: only items from it can appear in the result, and only if they do not exist in any other source.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b> (first source)</term><description>If the item does not exist in any other source, an <b>Add</b> is emitted.</description></item>
+    /// <item><term><b>Add</b>/<b>AddRange</b> (other source)</term><description>If the item was in the result (from first source), a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (first source)</term><description>If the item was in the result, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (other source)</term><description>If the item exists in the first source and no longer in any other, an <b>Add</b> is emitted.</description></item>
+    /// <item><term><b>Replace</b></term><description>Treated as a Remove of the old item plus an Add of the new item, with set logic re-evaluated.</description></item>
+    /// <item><term><b>Moved</b></term><description>Ignored by the set logic (no positional semantics).</description></item>
+    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is currently in the result set.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Unlike <see cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>, the first source is asymmetric: only its items can appear in the result.</para>
+    /// </remarks>
+    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="ObservableCacheEx.Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    public static IObservable<IChangeSet<T>> Except<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
+        where T : notnull
+    {
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.Combine(CombineOperator.Except, others);
+    }
+
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <remarks>
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>Static overload accepting a pre-built collection of sources. The first item in the collection is the primary source.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Except<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Except);
+
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <remarks>
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>Dynamic overload: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime. The first source in the list acts as the primary.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Except);
+
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <remarks>
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>Dynamic overload accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<IObservableList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Except);
+
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <remarks>
+    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <para>Dynamic overload accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.</para>
+    /// </remarks>
+    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<ISourceList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Except);
+}
diff --git a/src/DynamicData/List/ObservableListEx.ExpireAfter.cs b/src/DynamicData/List/ObservableListEx.ExpireAfter.cs
new file mode 100644
index 000000000..4df348372
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ExpireAfter.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Automatically removes items from the <paramref name="source"/> list after the duration returned by <paramref name="timeSelector"/>.
+    /// Returns an observable of the items that were expired and removed.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The <see cref="ISourceList{T}"/> source list to apply time-based expiration to.</param>
+    /// <param name="timeSelector">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for items that should never expire.</param>
+    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> polling interval to batch expiry checks. If omitted, a separate timer is created for each unique expiry time.</param>
+    /// <param name="scheduler">The scheduler for scheduling expiry timers. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>An observable that emits collections of items each time expired items are removed from the source list.</returns>
+    /// <remarks>
+    /// <para>
+    /// This operator acts directly on an <see cref="ISourceList{T}"/>, not on a changeset stream. It monitors items as they are added,
+    /// schedules their removal, and physically removes them from the source list when their time expires.
+    /// </para>
+    /// <para>
+    /// When <paramref name="pollingInterval"/> is specified, all items due for removal are batched into a single removal at each polling tick,
+    /// which can improve performance when many items expire around the same time.
+    /// </para>
+    /// <para><b>Worth noting:</b> The returned observable emits the expired items (not changesets). Subscribe to this observable to trigger the expiry mechanism; if not subscribed, no items will be removed.</para>
+    /// </remarks>
+    /// <seealso cref="LimitSizeTo{T}(ISourceList{T}, int, IScheduler?)"/>
+    /// <seealso cref="ToObservableChangeSet{T}(IObservable{T}, Func{T, TimeSpan?}, IScheduler?)"/>
+    public static IObservable<IEnumerable<T>> ExpireAfter<T>(
+                this ISourceList<T> source,
+                Func<T, TimeSpan?> timeSelector,
+                TimeSpan? pollingInterval = null,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ExpireAfter<T>.Create(
+            source: source,
+            timeSelector: timeSelector,
+            pollingInterval: pollingInterval,
+            scheduler: scheduler);
+}
diff --git a/src/DynamicData/List/ObservableListEx.Filter.cs b/src/DynamicData/List/ObservableListEx.Filter.cs
new file mode 100644
index 000000000..2165375b0
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Filter.cs
@@ -0,0 +1,150 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Filters items from the source list changeset stream using a static predicate.
+    /// Only items satisfying <paramref name="predicate"/> are included downstream.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
+    /// <param name="predicate">A <see cref="Func{T, TResult}"/> predicate that determines which items are included. Items returning <see langword="true"/> appear downstream; items returning <see langword="false"/> are excluded.</param>
+    /// <returns>A list changeset stream containing only items that satisfy <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Use this overload when you need only a single predicate function for the lifetime of the subscription;
+    /// unlike the dynamic-predicate and state-driven overloads, the predicate function itself never changes.
+    /// Note that this does not mean an item's inclusion is fixed: Refresh events can re-evaluate each item against the predicate
+    /// and promote a previously-excluded item to included (or vice versa).
+    /// Item ordering is preserved.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The predicate is evaluated. If the item passes, an <b>Add</b> is emitted at the calculated downstream index. Otherwise dropped.</description></item>
+    /// <item><term>AddRange</term><description>Each item in the range is evaluated. Matching items are emitted as an <b>AddRange</b>.</description></item>
+    /// <item><term>Replace</term><description>The predicate is re-evaluated. Four outcomes: both pass produces <b>Replace</b>; new passes but old didn't produces <b>Add</b>; old passed but new doesn't produces <b>Remove</b>; neither passes is dropped.</description></item>
+    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>RemoveRange</term><description>Included items in the range are emitted as individual <b>Remove</b> changes.</description></item>
+    /// <item><term>Refresh</term><description>The predicate is re-evaluated. If the item now passes but previously did not, an <b>Add</b> is emitted. If it previously passed but no longer does, a <b>Remove</b> is emitted. If still passes, the <b>Refresh</b> is forwarded. If still fails, dropped.</description></item>
+    /// <item><term>Clear</term><description>All downstream items are cleared.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> Refresh events trigger re-evaluation, which can promote or demote items (turning a Refresh into an Add or Remove). Pair with <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/> for property-change-driven filtering.</para>
+    /// </remarks>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
+    /// <seealso cref="FilterOnObservable{TObject}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableCacheEx.Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
+    public static IObservable<IChangeSet<T>> Filter<T>(
+                this IObservable<IChangeSet<T>> source,
+                Func<T, bool> predicate)
+            where T : notnull
+        => List.Internal.Filter.Static<T>.Create(
+            source: source,
+            predicate: predicate,
+            suppressEmptyChangesets: true);
+
+    /// <summary>
+    /// Filters items using a dynamically changing predicate.
+    /// When <paramref name="predicate"/> emits a new function, all items are re-evaluated.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
+    /// <param name="predicate">An <see cref="IObservable{Func{T, bool}}"/> that emits new predicate functions. Each emission triggers a full re-evaluation of all items.</param>
+    /// <param name="filterPolicy">The <see cref="ListFilterPolicy"/> that controls re-filtering behavior when the predicate changes.</param>
+    /// <returns>A list changeset stream containing only items that satisfy the most recent predicate.</returns>
+    /// <remarks>
+    /// <para>
+    /// Each time <paramref name="predicate"/> emits, every item is re-evaluated against the new predicate.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The current predicate is evaluated. If the item passes, an <b>Add</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>AddRange</term><description>Each item is evaluated. Matching items are emitted as <b>AddRange</b>.</description></item>
+    /// <item><term>Replace</term><description>Re-evaluated. Same four-outcome logic as the static overload (Replace, Add, Remove, or dropped).</description></item>
+    /// <item><term>Remove</term><description>If the item was downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
+    /// <item><term>Refresh</term><description>Re-evaluated. If inclusion status changed, an <b>Add</b> or <b>Remove</b> is emitted. If unchanged, <b>Refresh</b> forwarded or dropped.</description></item>
+    /// <item><term>Clear</term><description>All downstream items are cleared.</description></item>
+    /// <item><term>Predicate changed</term><description>All items are re-evaluated against the new predicate. The output is shaped by <paramref name="filterPolicy"/>.</description></item>
+    /// <item><term>OnCompleted</term><description>Independent completion of <paramref name="predicate"/> does not terminate the filter.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> No items are included until <paramref name="predicate"/> emits its first function.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
+    /// <seealso cref="FilterOnObservable{TObject}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<T>> Filter<T>(this IObservable<IChangeSet<T>> source, IObservable<Func<T, bool>> predicate, ListFilterPolicy filterPolicy = ListFilterPolicy.CalculateDiff)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
+
+        return new List.Internal.Filter.Dynamic<T>(source, predicate, filterPolicy).Run();
+    }
+
+    /// <summary>
+    /// Filters items using a predicate that receives external state. When <paramref name="predicateState"/> emits a new state value,
+    /// all items are re-evaluated against <paramref name="predicate"/> using the updated state.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <typeparam name="TState">The type of state value required by <paramref name="predicate"/>.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
+    /// <param name="predicateState">An <see cref="IObservable{TState}"/> stream of state values to be passed to <paramref name="predicate"/>.</param>
+    /// <param name="predicate">A static <see cref="Func{T, TResult}"/> predicate receiving the current state and an item, returning <see langword="true"/> to include or <see langword="false"/> to exclude. The function itself does not change; only the state value passed to it changes.</param>
+    /// <param name="filterPolicy">The <see cref="ListFilterPolicy"/> that controls re-filtering behavior when the state changes.</param>
+    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed. Set to <see langword="false"/> to publish empty changesets (useful for monitoring loading status).</param>
+    /// <returns>A list changeset stream containing only items satisfying <paramref name="predicate"/> with the current state.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="predicateState"/>, or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// The predicate cannot be invoked until the first state value is received. Until then, all items are treated as excluded.
+    /// Each subsequent state emission triggers a full re-evaluation of all items according to <paramref name="filterPolicy"/>.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Evaluated using current state. Matching items emitted as <b>Add</b>/<b>AddRange</b>.</description></item>
+    /// <item><term><b>Replace</b></term><description>Re-evaluated. Same four-outcome logic as the static filter (Replace, Add, Remove, or dropped).</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>If the item was downstream, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Re-evaluated against current state. Inclusion status may change.</description></item>
+    /// <item><term><b>Clear</b></term><description>All downstream items are cleared.</description></item>
+    /// <item><term>State changed</term><description>All items are re-evaluated with the new state value. The output is shaped by <paramref name="filterPolicy"/>.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
+    public static IObservable<IChangeSet<T>> Filter<T, TState>(
+                this IObservable<IChangeSet<T>> source,
+                IObservable<TState> predicateState,
+                Func<TState, T, bool> predicate,
+                ListFilterPolicy filterPolicy = ListFilterPolicy.CalculateDiff,
+                bool suppressEmptyChangeSets = true)
+            where T : notnull
+        => List.Internal.Filter.WithPredicateState<T, TState>.Create(
+            source: source,
+            predicateState: predicateState,
+            predicate: predicate,
+            filterPolicy: filterPolicy,
+            suppressEmptyChangeSets: suppressEmptyChangeSets);
+}
diff --git a/src/DynamicData/List/ObservableListEx.FilterOnObservable.cs b/src/DynamicData/List/ObservableListEx.FilterOnObservable.cs
new file mode 100644
index 000000000..bd49bf1db
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.FilterOnObservable.cs
@@ -0,0 +1,66 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Filters each item using a per-item <see cref="IObservable{T}"/> of <see cref="bool"/> that dynamically controls inclusion.
+    /// When an item's observable emits <see langword="true"/> the item enters the result; when it emits <see langword="false"/> the item is removed.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to filter by property value.</param>
+    /// <param name="objectFilterObservable">A function that returns an observable of <see cref="bool"/> for each item, controlling its inclusion.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration applied to each per-item observable to reduce re-evaluation frequency.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling. Defaults to the system default scheduler.</param>
+    /// <returns>A list changeset stream containing only items whose per-item observable most recently emitted <see langword="true"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="objectFilterObservable"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Each item in the source gets its own subscription to the observable returned by <paramref name="objectFilterObservable"/>.
+    /// The item's inclusion is determined by the most recent boolean value emitted by that observable.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the per-item observable. Item is included when it first emits <see langword="true"/>.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old subscription disposed, new subscription created for the replacement item.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscription disposed. If the item was downstream, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is currently included.</description></item>
+    /// </list>
+    /// <list type="table">
+    /// <listheader><term>Event (per-item observable)</term><description>Behavior</description></listheader>
+    /// <item><term>Emits <see langword="true"/></term><description>If not already included, an <b>Add</b> is emitted downstream.</description></item>
+    /// <item><term>Emits <see langword="false"/></term><description>If currently included, a <b>Remove</b> is emitted downstream.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableCacheEx.FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<TObject>> FilterOnObservable<TObject>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<bool>> objectFilterObservable, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new FilterOnObservable<TObject>(source, objectFilterObservable, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.FilterOnProperty.cs b/src/DynamicData/List/ObservableListEx.FilterOnProperty.cs
new file mode 100644
index 000000000..b9b297d77
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.FilterOnProperty.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Filters items based on a property value, automatically re-evaluating when the specified property changes on any item.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to filter by property value.</param>
+    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property to monitor for changes.</param>
+    /// <param name="predicate">A <see cref="Func{T, TResult}"/> predicate evaluated against the item to determine inclusion.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
+    /// <returns>A list changeset stream of items satisfying the predicate, re-evaluated on property changes.</returns>
+    /// <remarks>
+    /// <para>Deprecated. Use <see cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/> followed by <see cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/> instead.</para>
+    /// </remarks>
+    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
+    [Obsolete("Use AutoRefresh(), followed by Filter() instead")]
+    public static IObservable<IChangeSet<TObject>> FilterOnProperty<TObject, TProperty>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TProperty>> propertySelector, Func<TObject, bool> predicate, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
+
+        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
+
+        return new FilterOnProperty<TObject, TProperty>(source, propertySelector, predicate, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.FlattenBufferResult.cs b/src/DynamicData/List/ObservableListEx.FlattenBufferResult.cs
new file mode 100644
index 000000000..667a494ad
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.FlattenBufferResult.cs
@@ -0,0 +1,40 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Flattens buffered changesets (e.g. from <see cref="System.Reactive.Linq.Observable.Buffer{TSource}(IObservable{TSource}, TimeSpan)"/>) back into single changesets.
+    /// Empty buffers are dropped.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The <see cref="IObservable{T}"/> of buffered changeset lists.</param>
+    /// <returns>A list changeset stream with all buffered changes concatenated into single changesets.</returns>
+    /// <remarks>
+    /// <para>Use this after applying <c>Observable.Buffer()</c> to a changeset stream to re-merge the batched changesets into a single stream.</para>
+    /// </remarks>
+    /// <seealso cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, IScheduler?)"/>
+    /// <seealso cref="BufferInitial{T}(IObservable{IChangeSet{T}}, TimeSpan, IScheduler?)"/>
+    public static IObservable<IChangeSet<T>> FlattenBufferResult<T>(this IObservable<IList<IChangeSet<T>>> source)
+        where T : notnull => source.Where(x => x.Count != 0).Select(updates => new ChangeSet<T>(updates.SelectMany(u => u)));
+}
diff --git a/src/DynamicData/List/ObservableListEx.ForEachChange.cs b/src/DynamicData/List/ObservableListEx.ForEachChange.cs
new file mode 100644
index 000000000..f4066e413
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ForEachChange.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Invokes <paramref name="action"/> once for every <see cref="Change{T}"/> in each changeset. Range changes
+    /// (AddRange, RemoveRange, Clear) are delivered as a single <see cref="Change{T}"/>; they are not flattened into per-item changes.
+    /// The changeset is forwarded downstream unchanged.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe each change in.</param>
+    /// <param name="action">The action invoked for each <see cref="Change{T}"/>.</param>
+    /// <returns>A continuation of the source changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>This is a side-effect operator. It does not modify the changeset. If you need each individual item from range operations flattened out, use <see cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/> instead.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/Replace/Remove/Moved/Refresh</term><description>Callback invoked with the <see cref="Change{T}"/> (single-item change). Changeset forwarded.</description></item>
+    /// <item><term>AddRange/RemoveRange/Clear</term><description>Callback invoked once with the <see cref="Change{T}"/> containing the range (accessible via <c>Range</c> property). Changeset forwarded.</description></item>
+    /// <item><term>OnError</term><description>If the callback throws, the exception propagates as OnError.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/>
+    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
+    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
+    /// <seealso cref="ObservableCacheEx.ForEachChange{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{Change{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<TObject>> ForEachChange<TObject>(this IObservable<IChangeSet<TObject>> source, Action<Change<TObject>> action)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        action.ThrowArgumentNullExceptionIfNull(nameof(action));
+
+        return source.Do(changes => changes.ForEach(action));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.ForEachItemChange.cs b/src/DynamicData/List/ObservableListEx.ForEachItemChange.cs
new file mode 100644
index 000000000..f39760fac
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ForEachItemChange.cs
@@ -0,0 +1,51 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Invokes <paramref name="action"/> for every individual <see cref="ItemChange{TObject}"/> in each changeset.
+    /// Range changes are flattened into individual item changes first, so the callback only receives Add, Replace, Remove, and Refresh.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe each item-level change in.</param>
+    /// <param name="action">The <see cref="Action{ItemChange{TObject}}"/> action invoked for each individual item change.</param>
+    /// <returns>A continuation of the source changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Unlike <see cref="ForEachChange{TObject}(IObservable{IChangeSet{TObject}}, Action{Change{TObject}})"/>, this operator flattens
+    /// <b>AddRange</b>, <b>RemoveRange</b>, and <b>Clear</b> into individual <see cref="ItemChange{TObject}"/> entries before invoking the callback.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="ForEachChange{TObject}(IObservable{IChangeSet{TObject}}, Action{Change{TObject}})"/>
+    public static IObservable<IChangeSet<TObject>> ForEachItemChange<TObject>(this IObservable<IChangeSet<TObject>> source, Action<ItemChange<TObject>> action)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        action.ThrowArgumentNullExceptionIfNull(nameof(action));
+
+        return source.Do(changes => changes.Flatten().ForEach(action));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.GroupOn.cs b/src/DynamicData/List/ObservableListEx.GroupOn.cs
new file mode 100644
index 000000000..180c98ff6
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.GroupOn.cs
@@ -0,0 +1,64 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Groups source items by the value returned by <paramref name="groupSelector"/>. Each group is an <see cref="IGroup{TObject, TGroup}"/>
+    /// containing an inner observable list of its members.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TGroup">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group.</param>
+    /// <param name="groupSelector">A <see cref="Func{T, TResult}"/> function that returns the group key for each item.</param>
+    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces all items to be re-evaluated against <paramref name="groupSelector"/> when it fires. Useful for time-based groupings (e.g., "Last Hour", "Today").</param>
+    /// <returns>A list changeset stream of <see cref="IGroup{TObject, TGroup}"/> objects, each containing the items belonging to that group.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="groupSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Groups are created lazily and removed when empty. Each group exposes an inner observable list that receives incremental updates.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Group key evaluated. Item added to its group. If the group is new, an <b>Add</b> of the group is emitted.</description></item>
+    /// <item><term><b>Replace</b></term><description>Group key re-evaluated. If the group changed, the item is removed from the old group and added to the new one. Empty old groups are removed.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Item removed from its group. Empty groups are removed from the result.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Group key re-evaluated. If changed, the item moves between groups.</description></item>
+    /// <item><term><b>Moved</b></term><description>Not handled by group logic.</description></item>
+    /// <item><term>Regrouper fires</term><description>All items re-evaluated. Items that changed group key are moved between groups. Empty groups removed, new groups added.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>
+    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    public static IObservable<IChangeSet<IGroup<TObject, TGroup>>> GroupOn<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TGroup> groupSelector, IObservable<Unit>? regrouper = null)
+        where TObject : notnull
+        where TGroup : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        groupSelector.ThrowArgumentNullExceptionIfNull(nameof(groupSelector));
+
+        return new GroupOn<TObject, TGroup>(source, groupSelector, regrouper).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.GroupOnProperty.cs b/src/DynamicData/List/ObservableListEx.GroupOnProperty.cs
new file mode 100644
index 000000000..4bf1bb98a
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.GroupOnProperty.cs
@@ -0,0 +1,57 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Groups items by a property value, automatically re-grouping when the specified property changes on any item.
+    /// Each group contains an inner observable list.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <typeparam name="TGroup">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group by property value.</param>
+    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property whose value determines the group key.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
+    /// <returns>A list changeset stream of <see cref="IGroup{TObject, TGroup}"/> objects.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertySelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Convenience operator equivalent to <c>.AutoRefresh(propertySelector).GroupOn(item => property)</c>.
+    /// Property changes trigger re-evaluation of the group key, potentially moving items between groups.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
+    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<IGroup<TObject, TGroup>>> GroupOnProperty<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TGroup>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TGroup : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
+
+        return new GroupOnProperty<TObject, TGroup>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.GroupOnPropertyWithImmutableState.cs b/src/DynamicData/List/ObservableListEx.GroupOnPropertyWithImmutableState.cs
new file mode 100644
index 000000000..dad726079
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.GroupOnPropertyWithImmutableState.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Groups items by a property value, automatically re-grouping when the specified property changes.
+    /// Each group emits immutable snapshots (not live observable lists).
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <typeparam name="TGroup">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group by property value with immutable snapshots.</param>
+    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property whose value determines the group key.</param>
+    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
+    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
+    /// <returns>A list changeset stream of <see cref="List.IGrouping{TObject, TGroup}"/> immutable group snapshots.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertySelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Combines <see cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// with <see cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>.
+    /// Unlike <see cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>,
+    /// this produces immutable snapshots per group rather than live inner observable lists.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>
+    public static IObservable<IChangeSet<List.IGrouping<TObject, TGroup>>> GroupOnPropertyWithImmutableState<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TGroup>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
+        where TObject : INotifyPropertyChanged
+        where TGroup : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
+
+        return new GroupOnPropertyWithImmutableState<TObject, TGroup>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.GroupWithImmutableState.cs b/src/DynamicData/List/ObservableListEx.GroupWithImmutableState.cs
new file mode 100644
index 000000000..b607a56f4
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.GroupWithImmutableState.cs
@@ -0,0 +1,56 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Groups source items by the value returned by <paramref name="groupSelectorKey"/>. Each update produces immutable grouping snapshots
+    /// rather than live inner observable lists.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group with immutable snapshots.</param>
+    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> function that returns the group key for each item.</param>
+    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces all items to be re-evaluated when it fires.</param>
+    /// <returns>A list changeset stream of <see cref="List.IGrouping{TObject, TGroupKey}"/> immutable snapshots.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="groupSelectorKey"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Works like <see cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
+    /// but each affected group emits a new immutable snapshot on every change rather than updating a live inner list.
+    /// This is useful when consumers need thread-safe, point-in-time snapshots of each group.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
+    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<List.IGrouping<TObject, TGroupKey>>> GroupWithImmutableState<TObject, TGroupKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit>? regrouper = null)
+        where TObject : notnull
+        where TGroupKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
+
+        return new GroupOnImmutable<TObject, TGroupKey>(source, groupSelectorKey, regrouper).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.LimitSizeTo.cs b/src/DynamicData/List/ObservableListEx.LimitSizeTo.cs
new file mode 100644
index 000000000..fd01dcfa6
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.LimitSizeTo.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Limits the source list to a maximum number of items using FIFO eviction.
+    /// When the list exceeds <paramref name="sizeLimit"/>, the oldest items are removed.
+    /// Returns an observable of the items that were removed.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The <see cref="ISourceList{T}"/> source list to apply size limits to.</param>
+    /// <param name="sizeLimit">The maximum number of items allowed. Must be greater than zero.</param>
+    /// <param name="scheduler">The scheduler for scheduling size checks. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
+    /// <returns>An observable that emits collections of items each time excess items are removed from the source list.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentException"><paramref name="sizeLimit"/> is zero or negative.</exception>
+    /// <remarks>
+    /// <para>
+    /// This operator acts directly on an <see cref="ISourceList{T}"/>. It subscribes to the source's changes,
+    /// tracks insertion order using an internal Transform, and removes the oldest items when the size limit is exceeded.
+    /// </para>
+    /// <para><b>Worth noting:</b> The returned observable emits the removed items (not changesets). Subscribe to this observable to activate the size-limiting mechanism. Removal is performed synchronously under a lock shared with the change tracking.</para>
+    /// </remarks>
+    /// <seealso cref="ExpireAfter{T}(ISourceList{T}, Func{T, TimeSpan?}, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
+    public static IObservable<IEnumerable<T>> LimitSizeTo<T>(this ISourceList<T> source, int sizeLimit, IScheduler? scheduler = null)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (sizeLimit <= 0)
+        {
+            throw new ArgumentException("sizeLimit cannot be zero", nameof(sizeLimit));
+        }
+
+        var locker = InternalEx.NewLock();
+        var limiter = new LimitSizeTo<T>(source, sizeLimit, scheduler ?? GlobalConfig.DefaultScheduler, locker);
+
+        return limiter.Run().Synchronize(locker).Do(source.RemoveMany);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.MergeChangeSets.cs b/src/DynamicData/List/ObservableListEx.MergeChangeSets.cs
new file mode 100644
index 000000000..4f58c05cc
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.MergeChangeSets.cs
@@ -0,0 +1,217 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
+    /// <summary>
+    /// Merges multiple list changeset streams from an observable-of-observables into a single unified changeset stream.
+    /// Unlike <see cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>, list merging performs no key-based deduplication.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> of nested changeset observables.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used by the merge tracker to compare items.</param>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new MergeChangeSets<TObject>(source, equalityComparer).Run();
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
+    /// <summary>
+    /// Merges two list changeset streams into a single unified stream.
+    /// </summary>
+    /// <param name="source">The first <see cref="IObservable{IChangeSet{TObject}}"/> to merge.</param>
+    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject}}"/> to merge with.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used to compare items.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
+    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<TObject>> source, IObservable<IChangeSet<TObject>> other, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        other.ThrowArgumentNullExceptionIfNull(nameof(other));
+
+        return new[] { source, other }.MergeChangeSets(equalityComparer, scheduler, completable);
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
+    /// <summary>
+    /// Merges the source list changeset stream with additional changeset streams into a single unified stream.
+    /// </summary>
+    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{TObject}}"/> to merge.</param>
+    /// <param name="others">The additional <see cref="IEnumerable{T}"/> of list changeset streams to merge with.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used to compare items.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
+    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<TObject>> source, IEnumerable<IObservable<IChangeSet<TObject>>> others, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, scheduler, completable);
+    }
+
+    /// <summary>
+    /// Merges a collection of list changeset streams into a single unified changeset stream.
+    /// This is the canonical list MergeChangeSets overload: other overloads accepting <see cref="IObservable{T}"/>, <see cref="IObservableList{T}"/>, or pair/params variants ultimately produce equivalent behavior.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The <see cref="IEnumerable{T}"/> collection of list changeset streams to merge.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used by the merge tracker to compare items. Defaults to <see cref="EqualityComparer{T}.Default"/> when <see langword="null"/>.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
+    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
+    /// <returns>A single list changeset stream containing all changes from all sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// All changes from inner streams are forwarded to the output. There is no key-based deduplication (unlike <see cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>): if the same item appears in multiple inner streams, it will appear multiple times in the merged output.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Forwarded to the merged output.</description></item>
+    /// <item><term><b>Replace</b></term><description>The old value is replaced by the new value in the merged output. If the old value is not found (by <paramref name="equalityComparer"/>), the new value is added instead.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Forwarded to the merged output.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Forwarded to the merged output.</description></item>
+    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IEnumerable<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new MergeChangeSets<TObject>(source, equalityComparer, completable, scheduler).Run();
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
+    /// <summary>
+    /// Merges list changeset streams from an <see cref="IObservableList{T}"/> into a single stream. Sources can be added or removed dynamically.
+    /// </summary>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservableList<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Connect().MergeChangeSets(equalityComparer);
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
+    /// <summary>
+    /// Merges list changeset streams from a list-of-list-changeset-observables into a single stream.
+    /// Each inner list changeset observable in the source list is merged, and parent item removal triggers child cleanup.
+    /// </summary>
+    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject>>>> source, IEqualityComparer<TObject>? equalityComparer = null)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.MergeManyChangeSets(static src => src, equalityComparer);
+    }
+
+    /// <summary>
+    /// Merges cache changeset streams from an <see cref="IObservableList{T}"/> into a single cache changeset stream.
+    /// Uses <paramref name="comparer"/> to resolve conflicts when the same key appears in multiple child streams.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TKey">The type of the object key.</typeparam>
+    /// <param name="source">The <see cref="IObservableList{T}"/> of cache changeset observables.</param>
+    /// <param name="comparer"><see cref="IComparer{TObject}"/> to resolve which value wins when the same key appears in multiple sources.</param>
+    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Sources can be added or removed dynamically from the observable list. Parent item removal triggers cleanup of all child items from that source.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b> (child)</term><description>If the destination key is new, an <b>Add</b> is emitted. If another source already contributed a child with the same key, <paramref name="comparer"/> resolves the conflict (lowest-ordered value wins). The losing value is tracked internally but not emitted.</description></item>
+    /// <item><term><b>Update</b> (child)</term><description>If this source currently owns the destination key downstream, an <b>Update</b> is emitted. Otherwise <paramref name="comparer"/> re-evaluates all sources; a different source's value may win, producing an <b>Update</b> to that value instead.</description></item>
+    /// <item><term><b>Remove</b> (child)</term><description>If this source's value was the one published downstream for that destination key, the operator scans other sources for the same key. If found, an <b>Update</b> is emitted with the replacement (per <paramref name="comparer"/>). Otherwise a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Refresh</b> (child)</term><description>If the child item is the one currently published downstream, the <b>Refresh</b> is forwarded. Otherwise <paramref name="comparer"/> re-evaluates all sources; if a different value now wins, an <b>Update</b> is emitted instead.</description></item>
+    /// <item><term>Source list <b>Add</b></term><description>Subscribes to the new child changeset stream and merges its keys into the output.</description></item>
+    /// <item><term>Source list <b>Remove</b></term><description>Disposes that source's subscription. All keys it contributed are removed. For keys also contributed by other sources, the next-best value (per <paramref name="comparer"/>) is promoted as an <b>Update</b>, not an Add.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject}?, IComparer{TObject}?)"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Connect().MergeChangeSets(comparer);
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
+    /// <summary>
+    /// Merges cache changeset streams from an <see cref="IObservableList{T}"/> into a single cache changeset stream, with optional equality and ordering comparers.
+    /// </summary>
+    /// <param name="source">The <see cref="IObservableList{T}"/> of cache changeset observables.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> to determine if two elements are the same.</param>
+    /// <param name="comparer">An optional <see cref="IComparer{TObject}"/> to resolve conflicts when the same key appears in multiple sources.</param>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject>? equalityComparer = null, IComparer<TObject>? comparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Connect().MergeChangeSets(equalityComparer, comparer);
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
+    /// <summary>
+    /// Merges cache changeset streams from a list changeset of cache changeset observables, using a comparer for conflict resolution.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> whose items are cache changeset observables.</param>
+    /// <param name="comparer"><see cref="IComparer{TObject}"/> to resolve which value wins when the same key appears in multiple sources.</param>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject, TKey>>>> source, IComparer<TObject> comparer)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return source.MergeChangeSets(comparer);
+    }
+
+    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
+    /// <summary>
+    /// Merges cache changeset streams from a list changeset of cache changeset observables, with optional equality and ordering comparers.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> whose items are cache changeset observables.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> to determine if two elements are the same.</param>
+    /// <param name="comparer">An optional <see cref="IComparer{TObject}"/> to resolve conflicts when the same key appears in multiple sources.</param>
+    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject, TKey>>>> source, IEqualityComparer<TObject>? equalityComparer = null, IComparer<TObject>? comparer = null)
+        where TObject : notnull
+        where TKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.MergeManyChangeSets(static src => src, equalityComparer, comparer);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.MergeMany.cs b/src/DynamicData/List/ObservableListEx.MergeMany.cs
new file mode 100644
index 000000000..55dfa4f19
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.MergeMany.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Subscribes to a per-item observable for each item in the source and merges all emissions into a single <see cref="IObservable{TDestination}"/> stream.
+    /// This is NOT a changeset operator: it returns a flat observable of values.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the source list.</typeparam>
+    /// <typeparam name="TDestination">The type of values emitted by per-item observables.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> whose items each produce an observable.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns an observable for each source item.</param>
+    /// <returns>An observable that emits values from all per-item observables, merged together.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event (source)</term><description>Subscription behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the per-item observable. Emissions are merged into the output.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old subscription disposed, new subscription created for the replacement item.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscription disposed.</description></item>
+    /// <item><term><b>Refresh</b>/<b>Moved</b></term><description>No effect on subscriptions.</description></item>
+    /// <item><term>OnCompleted (source)</term><description>Completes only after the source and all active inner observables have completed.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
+    /// <seealso cref="ObservableCacheEx.MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
+    public static IObservable<TDestination> MergeMany<T, TDestination>(this IObservable<IChangeSet<T>> source, Func<T, IObservable<TDestination>> observableSelector)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeMany<T, TDestination>(source, observableSelector).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.MergeManyChangeSets.cs b/src/DynamicData/List/ObservableListEx.MergeManyChangeSets.cs
new file mode 100644
index 000000000..e10118cef
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.MergeManyChangeSets.cs
@@ -0,0 +1,146 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Transforms each source item into a child list changeset stream using <paramref name="observableSelector"/>,
+    /// then merges all child streams into a single flat list changeset stream. Parent item removal cleans up all associated children.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child list changeset stream for each source item.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> used to compare child items.</param>
+    /// <returns>A single list changeset stream containing all items from all child streams.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Internally subscribes to each child stream when a source item is added and disposes the subscription when it is removed.
+    /// All child items from a removed parent are removed from the merged output.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the child stream. Child emissions are merged into the output.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old child subscription disposed (and its items removed from output). New child subscription created.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Child subscription disposed. All child items from that parent are removed.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <seealso cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="ObservableCacheEx.MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}, IComparer{TDestination})"/>
+    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TObject : notnull
+        where TDestination : notnull
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (observableSelector == null)
+        {
+            throw new ArgumentNullException(nameof(observableSelector));
+        }
+
+        return new MergeManyListChangeSets<TObject, TDestination>(source, observableSelector, equalityComparer).Run();
+    }
+
+    /// <summary>
+    /// Transforms each source item into a child cache changeset stream and merges all children into a single cache changeset stream.
+    /// Uses <paramref name="comparer"/> to resolve key conflicts when the same key appears in multiple child streams.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child cache changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key in the child cache changesets.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child cache changeset stream for each source item.</param>
+    /// <param name="comparer"><see cref="IComparer{TDestination}"/> to resolve which value wins when the same key appears from multiple children.</param>
+    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="comparer"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <inheritdoc cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    /// <para>Delegates to <see cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/> with a <see langword="null"/> equality comparer.</para>
+    /// </remarks>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
+        where TObject : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return source.MergeManyChangeSets(observableSelector, equalityComparer: null, comparer: comparer);
+    }
+
+    /// <summary>
+    /// Transforms each source item into a child cache changeset stream and merges all children into a single cache changeset stream.
+    /// This is the primary list-to-cache MergeManyChangeSets overload.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
+    /// <typeparam name="TDestination">The type of items in the child cache changeset streams.</typeparam>
+    /// <typeparam name="TDestinationKey">The type of the key in the child cache changesets.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
+    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child cache changeset stream for each source item.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> to determine if two elements are the same.</param>
+    /// <param name="comparer">An optional <see cref="IComparer{TDestination}"/> to resolve conflicts when the same key appears from multiple children.</param>
+    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Each source item produces a keyed child stream via <paramref name="observableSelector"/>. All child items are tracked by key.
+    /// When a parent item is removed, all its child items are removed from the merged output.
+    /// When the same key appears from multiple children, <paramref name="comparer"/> determines which value wins.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the child cache stream. Child key/value pairs are merged into the output cache.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old child subscription disposed (and its keys removed from output). New child subscription created.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Child subscription disposed. All keys originating from that child are removed from the output.</description></item>
+    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Ignored; this operator emits a cache changeset and source ordering/refresh does not affect key membership.</description></item>
+    /// </list>
+    /// <para>
+    /// <b>Error and completion:</b>
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>OnError</term><description>An error from the source (parent) stream or from any child changeset stream terminates the entire output. Unlike <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>, child errors are NOT swallowed.</description></item>
+    /// <item><term>OnCompleted</term><description>The output completes when the source (parent) stream completes <b>and</b> all active child changeset streams have also completed.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
+    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
+        where TObject : notnull
+        where TDestination : notnull
+        where TDestinationKey : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
+
+        return new MergeManyCacheChangeSets<TObject, TDestination, TDestinationKey>(source, observableSelector, equalityComparer, comparer).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.NotEmpty.cs b/src/DynamicData/List/ObservableListEx.NotEmpty.cs
new file mode 100644
index 000000000..efc183cb6
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.NotEmpty.cs
@@ -0,0 +1,42 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Suppresses empty changesets from the stream. Only changesets with at least one change are forwarded.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to suppress empty changesets.</param>
+    /// <returns>A list changeset stream with empty changesets filtered out.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="WhereReasonsAre{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
+    public static IObservable<IChangeSet<T>> NotEmpty<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Where(s => s.Count != 0);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.OnItemAdded.cs b/src/DynamicData/List/ObservableListEx.OnItemAdded.cs
new file mode 100644
index 000000000..f07beed67
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.OnItemAdded.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Invokes <paramref name="addAction"/> for every item added to the source list stream.
+    /// Triggers on <see cref="ListChangeReason.Add"/>, <see cref="ListChangeReason.AddRange"/>, and the new item of <see cref="ListChangeReason.Replace"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item additions in.</param>
+    /// <param name="addAction">The <see cref="Action{T}"/> action to invoke for each added item.</param>
+    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="addAction"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>The action fires before the changeset is forwarded downstream.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>Callback invoked with the added item. Changeset forwarded.</description></item>
+    /// <item><term>AddRange</term><description>Callback invoked for each item in the range. Changeset forwarded.</description></item>
+    /// <item><term>Replace</term><description>Callback invoked for the <b>new</b> (replacement) item. Changeset forwarded.</description></item>
+    /// <item><term>Remove/RemoveRange/Clear</term><description>No callback. Changeset forwarded.</description></item>
+    /// <item><term>Moved/Refresh</term><description>No callback. Changeset forwarded.</description></item>
+    /// <item><term>OnError</term><description>If the callback throws, the exception propagates as OnError.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
+    /// <seealso cref="OnItemRefreshed{T}(IObservable{IChangeSet{T}}, Action{T})"/>
+    /// <seealso cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/>
+    /// <seealso cref="ObservableCacheEx.OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject})"/>
+    public static IObservable<IChangeSet<T>> OnItemAdded<T>(
+                this IObservable<IChangeSet<T>> source,
+                Action<T> addAction)
+            where T : notnull
+        => List.Internal.OnItemAdded<T>.Create(
+            source: source,
+            addAction: addAction);
+}
diff --git a/src/DynamicData/List/ObservableListEx.OnItemRefreshed.cs b/src/DynamicData/List/ObservableListEx.OnItemRefreshed.cs
new file mode 100644
index 000000000..53824aba0
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.OnItemRefreshed.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Invokes <paramref name="refreshAction"/> for every item with a <see cref="ListChangeReason.Refresh"/> change in the source stream.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item refresh events in.</param>
+    /// <param name="refreshAction">The <see cref="Action{T}"/> action to invoke for each refreshed item.</param>
+    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="refreshAction"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
+    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableCacheEx.OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject})"/>
+    public static IObservable<IChangeSet<T>> OnItemRefreshed<T>(
+                this IObservable<IChangeSet<T>> source,
+                Action<T> refreshAction)
+            where T : notnull
+        => List.Internal.OnItemRefreshed<T>.Create(
+            source: source,
+            refreshAction: refreshAction);
+}
diff --git a/src/DynamicData/List/ObservableListEx.OnItemRemoved.cs b/src/DynamicData/List/ObservableListEx.OnItemRemoved.cs
new file mode 100644
index 000000000..7a63f9247
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.OnItemRemoved.cs
@@ -0,0 +1,66 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Invokes <paramref name="removeAction"/> for every item removed from the source list stream.
+    /// Triggers on <see cref="ListChangeReason.Remove"/>, <see cref="ListChangeReason.RemoveRange"/>, <see cref="ListChangeReason.Clear"/>, and the old item of <see cref="ListChangeReason.Replace"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item removals in.</param>
+    /// <param name="removeAction">The <see cref="Action{T}"/> action to invoke for each removed item.</param>
+    /// <param name="invokeOnUnsubscribe">When <see langword="true"/> (default), <paramref name="removeAction"/> is also invoked for all remaining tracked items upon stream disposal, completion, or error.</param>
+    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="removeAction"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// When <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, the operator tracks all items that have been added but not yet removed,
+    /// and fires <paramref name="removeAction"/> for each of them during finalization. This is useful for resource cleanup patterns.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/AddRange</term><description>Tracked internally (when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>). No callback invoked. Changeset forwarded.</description></item>
+    /// <item><term>Replace</term><description>Callback invoked for the <b>previous</b> (replaced) item. New item tracked. Changeset forwarded.</description></item>
+    /// <item><term>Remove</term><description>Callback invoked for the removed item. Changeset forwarded.</description></item>
+    /// <item><term>RemoveRange/Clear</term><description>Callback invoked for each removed item. Changeset forwarded.</description></item>
+    /// <item><term>Moved/Refresh</term><description>No callback. Changeset forwarded.</description></item>
+    /// <item><term>OnError</term><description>If <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, callback is invoked for all tracked items before the error propagates.</description></item>
+    /// <item><term>OnCompleted</term><description>If <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, callback is invoked for all tracked items before completion propagates.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> When <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/> (the default), disposing the subscription also invokes the callback for every item still in the list, not just items that were explicitly removed during the subscription. Exceptions in <paramref name="removeAction"/> are not caught.</para>
+    /// </remarks>
+    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
+    /// <seealso cref="DisposeMany{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
+    /// <seealso cref="ObservableCacheEx.OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject}, bool)"/>
+    public static IObservable<IChangeSet<T>> OnItemRemoved<T>(
+                this IObservable<IChangeSet<T>> source,
+                Action<T> removeAction,
+                bool invokeOnUnsubscribe = true)
+            where T : notnull
+        => List.Internal.OnItemRemoved<T>.Create(
+            source: source,
+            removeAction: removeAction,
+            invokeOnUnsubscribe: invokeOnUnsubscribe);
+}
diff --git a/src/DynamicData/List/ObservableListEx.Or.cs b/src/DynamicData/List/ObservableListEx.Or.cs
new file mode 100644
index 000000000..b47acd986
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Or.cs
@@ -0,0 +1,89 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Applies a logical OR (union) between a pre-built collection of list changeset sources. Items present in any source are included.
+    /// </summary>
+    /// <seealso cref="ObservableCacheEx.Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    public static IObservable<IChangeSet<T>> Or<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Or);
+
+    /// <summary>
+    /// Applies a logical OR (union) between the source and other list changeset streams.
+    /// Items present in any of the sources are included in the result, using reference-counted equality.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{T}}"/> to union.</param>
+    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to combine with.</param>
+    /// <returns>A list changeset stream containing items that exist in at least one source.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Uses reference-counted equality: an item is included when it first appears in any source and removed when it no longer exists in any source.
+    /// <b>Moved</b> changes are ignored by the set logic.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b> (any source)</term><description>If the item is new to the result, an <b>Add</b> is emitted. Otherwise the reference count is incremented.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (any source)</term><description>Reference count decremented. If count reaches zero, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old item reference count decremented, new item reference count incremented. Add/Remove emitted as needed.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is in the result set.</description></item>
+    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
+    public static IObservable<IChangeSet<T>> Or<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
+        where T : notnull
+    {
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.Combine(CombineOperator.Or, others);
+    }
+
+    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic OR: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Or);
+
+    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic OR accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<IObservableList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Or);
+
+    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic OR accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<ISourceList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Or);
+}
diff --git a/src/DynamicData/List/ObservableListEx.Page.cs b/src/DynamicData/List/ObservableListEx.Page.cs
new file mode 100644
index 000000000..da8dc2c3d
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Page.cs
@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies page-based windowing to the source list. Only items within the current page (determined by page number and page size from <paramref name="requests"/>) are included downstream.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to page.</param>
+    /// <param name="requests">An observable of <see cref="IPageRequest"/> controlling which page to display (page number and page size).</param>
+    /// <returns>An <see cref="IPageChangeSet{T}"/> stream containing only items within the current page window.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="requests"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Maintains the full source list internally and calculates the page window on each change or page request.
+    /// Items entering the page window produce <b>Add</b>; items leaving produce <b>Remove</b>. A new page request triggers
+    /// a full recalculation of the page contents.
+    /// </para>
+    /// <para><b>Worth noting:</b> Duplicate items are removed from the result via <c>Distinct()</c> using the default equality comparer for <typeparamref name="T"/>, regardless of source order. The source should ideally be sorted before paging, since list order determines which items fall within each page window.</para>
+    /// </remarks>
+    /// <seealso cref="Virtualise{T}(IObservable{IChangeSet{T}}, IObservable{IVirtualRequest})"/>
+    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
+    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
+    public static IObservable<IPageChangeSet<T>> Page<T>(this IObservable<IChangeSet<T>> source, IObservable<IPageRequest> requests)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        requests.ThrowArgumentNullExceptionIfNull(nameof(requests));
+
+        return new Pager<T>(source, requests).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.PopulateInto.cs b/src/DynamicData/List/ObservableListEx.PopulateInto.cs
new file mode 100644
index 000000000..d5431ff4a
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.PopulateInto.cs
@@ -0,0 +1,48 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Subscribes to the source changeset stream and pipes all changes into the <paramref name="destination"/> <see cref="ISourceList{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to pipe into a target list.</param>
+    /// <param name="destination">The destination <see cref="ISourceList{T}"/> to receive all changes.</param>
+    /// <returns>An <see cref="IDisposable"/> representing the subscription. Dispose to stop piping changes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="destination"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Each changeset is applied to the destination using <c>Clone()</c> inside an <c>Edit()</c> call, producing a single batch update per changeset.</para>
+    /// </remarks>
+    /// <seealso cref="Clone{T}(IObservable{IChangeSet{T}}, IList{T})"/>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
+    /// <seealso cref="ObservableCacheEx.PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
+    public static IDisposable PopulateInto<T>(this IObservable<IChangeSet<T>> source, ISourceList<T> destination)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
+
+        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.QueryWhenChanged.cs b/src/DynamicData/List/ObservableListEx.QueryWhenChanged.cs
new file mode 100644
index 000000000..0e9984894
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.QueryWhenChanged.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Emits a projected value from the current list snapshot after every changeset.
+    /// The <paramref name="resultSelector"/> receives an <see cref="IReadOnlyCollection{T}"/> representing the current state.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TDestination">The type of the projected result.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to project on each change.</param>
+    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> function projecting the current list snapshot to a result value.</param>
+    /// <returns>An observable emitting the projected value after each changeset.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Delegates to <see cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/> and applies <paramref name="resultSelector"/> via <c>Select</c>.</para>
+    /// </remarks>
+    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
+    /// <seealso cref="ObservableCacheEx.QueryWhenChanged{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{IQuery{TObject, TKey}, TDestination})"/>
+    public static IObservable<TDestination> QueryWhenChanged<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<IReadOnlyCollection<TObject>, TDestination> resultSelector)
+        where TObject : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
+
+        return source.QueryWhenChanged().Select(resultSelector);
+    }
+
+    /// <summary>
+    /// Emits an <see cref="IReadOnlyCollection{T}"/> snapshot of the current list state after every changeset.
+    /// Maintains an internal list updated by cloning each changeset.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to project on each change.</param>
+    /// <returns>An observable emitting the full list snapshot as <see cref="IReadOnlyCollection{T}"/> after each change.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>This is a non-changeset operator. It emits the entire collection state on each change, not incremental diffs.</para>
+    /// <para><b>Worth noting:</b> A new snapshot is emitted on every changeset, which can be chatty. The collection is rebuilt by cloning each changeset into an internal list. For sorted output, use <see cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>.</para>
+    /// </remarks>
+    /// <seealso cref="QueryWhenChanged{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{IReadOnlyCollection{TObject}, TDestination})"/>
+    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
+    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
+    public static IObservable<IReadOnlyCollection<T>> QueryWhenChanged<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new QueryWhenChanged<T>(source).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.RefCount.cs b/src/DynamicData/List/ObservableListEx.RefCount.cs
new file mode 100644
index 000000000..4e8f03a10
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.RefCount.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Reference-counted materialization of the source changeset stream into an <see cref="IObservableList{T}"/>.
+    /// The shared list is created on the first subscriber and disposed when the last subscriber unsubscribes.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to share via reference counting.</param>
+    /// <returns>A list changeset stream backed by a shared, reference-counted <see cref="IObservableList{T}"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Equivalent to <c>Publish().RefCount()</c> for changeset streams. The underlying list is created lazily on first subscription.</para>
+    /// </remarks>
+    /// <seealso cref="AsObservableList{T}(IObservable{IChangeSet{T}})"/>
+    public static IObservable<IChangeSet<T>> RefCount<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return new RefCount<T>(source).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.RemoveIndex.cs b/src/DynamicData/List/ObservableListEx.RemoveIndex.cs
new file mode 100644
index 000000000..9f0e434f7
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.RemoveIndex.cs
@@ -0,0 +1,44 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Strips index information from all changes in the stream.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to strip index information.</param>
+    /// <returns>A list changeset stream with all index values removed from changes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Removes index positions from every change in each changeset. This is useful when downstream operators do not require or support index-based operations.</para>
+    /// </remarks>
+    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
+    public static IObservable<IChangeSet<T>> RemoveIndex<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Select(changes => new ChangeSet<T>(changes.YieldWithoutIndex()));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Reverse.cs b/src/DynamicData/List/ObservableListEx.Reverse.cs
new file mode 100644
index 000000000..757954e35
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Reverse.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Reverses the order of items in the changeset stream by transforming all indices: <c>new_index = length - old_index - 1</c>.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to reverse.</param>
+    /// <returns>A list changeset stream with all index positions reversed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>This is a pure index transformation. The items themselves are unchanged; only their positional indices are inverted.</para>
+    /// </remarks>
+    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
+    public static IObservable<IChangeSet<T>> Reverse<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        var reverser = new Reverser<T>();
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.Select(changes => new ChangeSet<T>(reverser.Reverse(changes)));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.SkipInitial.cs b/src/DynamicData/List/ObservableListEx.SkipInitial.cs
new file mode 100644
index 000000000..a7d50fbf0
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.SkipInitial.cs
@@ -0,0 +1,52 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Skips the initial changeset (the snapshot emitted on subscription) and forwards all subsequent changesets.
+    /// Internally defers until loaded, then skips the first emission.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to skip the initial changeset.</param>
+    /// <returns>A list changeset stream that omits the initial snapshot.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// <b>Warning:</b> This operator assumes the initial changeset is empty. If the source emits a non-empty
+    /// initial snapshot, those items are silently dropped while downstream consumers remain unaware of them.
+    /// Any later <b>Refresh</b>, <b>Replace</b>, <b>Remove</b>, or <b>Moved</b> change targeting one of those
+    /// dropped items will throw because the downstream collection has no record of them. Only use this against
+    /// a source you know starts empty (for example, a <see cref="ISourceList{T}"/> that has not yet been populated).
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
+    public static IObservable<IChangeSet<T>> SkipInitial<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.DeferUntilLoaded().Skip(1);
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Sort.cs b/src/DynamicData/List/ObservableListEx.Sort.cs
new file mode 100644
index 000000000..c0c67e484
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Sort.cs
@@ -0,0 +1,87 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Sorts the list using the specified comparer, maintaining a sorted output that incrementally updates as items change.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to sort.</param>
+    /// <param name="comparer">The <see cref="IComparer{T}"/> used for sorting.</param>
+    /// <param name="options">The <see cref="SortOptions.UseBinarySearch"/> for improved performance when sorted values are immutable.</param>
+    /// <param name="resort">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces a full re-sort when it fires. Required when sorted property values are mutable.</param>
+    /// <param name="comparerChanged">An optional <see cref="IObservable{IComparer{T}}"/> of <see cref="IComparer{T}"/> that replaces the comparer, triggering a full re-sort.</param>
+    /// <param name="resetThreshold">When the number of changes exceeds this threshold, a full reset is performed instead of incremental updates. Default is 50.</param>
+    /// <returns>A list changeset stream with items in sorted order.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Maintains an internal sorted list. Each incoming change is applied incrementally: adds are inserted at the correct sorted position,
+    /// removes are removed by index, and refreshes re-evaluate position (emitting <b>Moved</b> if changed).
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Inserted at the correct sorted position. May trigger a full reset if the count exceeds <paramref name="resetThreshold"/>.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old item removed, new item inserted at sorted position.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Removed from sorted list.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Sort position re-evaluated. If position changed, a <b>Moved</b> is emitted.</description></item>
+    /// <item><term>Comparer changed</term><description>Full re-sort of all items.</description></item>
+    /// <item><term>Re-sort signal</term><description>Full re-sort using the current comparer.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> <see cref="SortOptions.UseBinarySearch"/> is faster but requires that the values being sorted on never mutate. If they do, use the <paramref name="resort"/> signal or <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>.</para>
+    /// </remarks>
+    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IObservable{IComparer{T}}, SortOptions, IObservable{Unit}?, int)"/>
+    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
+    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
+    /// <seealso cref="ObservableCacheEx.Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>
+    public static IObservable<IChangeSet<T>> Sort<T>(this IObservable<IChangeSet<T>> source, IComparer<T> comparer, SortOptions options = SortOptions.None, IObservable<Unit>? resort = null, IObservable<IComparer<T>>? comparerChanged = null, int resetThreshold = 50)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
+
+        return new Sort<T>(source, comparer, options, resort, comparerChanged, resetThreshold).Run();
+    }
+
+    /// <inheritdoc cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
+    /// <summary>
+    /// Sorts the list using an observable comparer. The initial comparer is taken from the first emission; subsequent emissions trigger a full re-sort.
+    /// </summary>
+    /// <remarks>
+    /// <para>Until <paramref name="comparerChanged"/> emits its first comparer, items are sorted using <see cref="Comparer{T}.Default"/>. Downstream still receives changesets immediately; the initial ordering is whatever <see cref="Comparer{T}.Default"/> produces, then a full re-sort happens once the first comparer arrives.</para>
+    /// </remarks>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to sort.</param>
+    /// <param name="comparerChanged">An <see cref="IObservable{IComparer{T}}"/> of <see cref="IComparer{T}"/> that emits comparers. The first emission provides the initial sort order; subsequent emissions trigger re-sorts.</param>
+    /// <param name="options"><see cref="SortOptions"/> for controlling sort behavior.</param>
+    /// <param name="resort">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> to force a re-sort with the current comparer.</param>
+    /// <param name="resetThreshold">The threshold for triggering a full reset instead of incremental updates.</param>
+    public static IObservable<IChangeSet<T>> Sort<T>(this IObservable<IChangeSet<T>> source, IObservable<IComparer<T>> comparerChanged, SortOptions options = SortOptions.None, IObservable<Unit>? resort = null, int resetThreshold = 50)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        comparerChanged.ThrowArgumentNullExceptionIfNull(nameof(comparerChanged));
+
+        return new Sort<T>(source, null, options, resort, comparerChanged, resetThreshold).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.StartWithEmpty.cs b/src/DynamicData/List/ObservableListEx.StartWithEmpty.cs
new file mode 100644
index 000000000..91c7100e0
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.StartWithEmpty.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Prepends an empty changeset to the source stream. Useful for initializing downstream consumers that expect an initial emission.
+    /// </summary>
+    /// <typeparam name="T">The type of item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to prepend an empty changeset to.</param>
+    /// <returns>A list changeset stream that begins with an empty changeset.</returns>
+    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="SkipInitial{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ObservableCacheEx.StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IChangeSet<T>> StartWithEmpty<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull => source.StartWith(ChangeSet<T>.Empty);
+}
diff --git a/src/DynamicData/List/ObservableListEx.SubscribeMany.cs b/src/DynamicData/List/ObservableListEx.SubscribeMany.cs
new file mode 100644
index 000000000..6f4745a2a
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.SubscribeMany.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Creates an <see cref="IDisposable"/> subscription for each item via <paramref name="subscriptionFactory"/> when it is added.
+    /// The subscription is disposed when the item is removed or replaced. All subscriptions are disposed when the stream terminates.
+    /// The changeset is forwarded downstream unmodified.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to create a subscription for each item in.</param>
+    /// <param name="subscriptionFactory">A function that creates an <see cref="IDisposable"/> for each item.</param>
+    /// <returns>A continuation of the source changeset stream with per-item subscriptions managed as a side effect.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="subscriptionFactory"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscription created for each item via the factory. Changeset forwarded.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old item's subscription disposed, new subscription created. Changeset forwarded.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscriptions for removed items are disposed. Changeset forwarded.</description></item>
+    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Forwarded. No subscription changes.</description></item>
+    /// <item><term>OnError/OnCompleted/Disposal</term><description>All active subscriptions are disposed.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>
+    /// <seealso cref="DisposeMany{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
+    /// <seealso cref="ObservableCacheEx.SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
+    public static IObservable<IChangeSet<T>> SubscribeMany<T>(this IObservable<IChangeSet<T>> source, Func<T, IDisposable> subscriptionFactory)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
+
+        return new SubscribeMany<T>(source, subscriptionFactory).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.SuppressRefresh.cs b/src/DynamicData/List/ObservableListEx.SuppressRefresh.cs
new file mode 100644
index 000000000..ac040d07f
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.SuppressRefresh.cs
@@ -0,0 +1,36 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Suppresses all <see cref="ListChangeReason.Refresh"/> changes from the stream. All other change reasons pass through.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to strip refresh events.</param>
+    /// <returns>A list changeset stream with Refresh changes removed.</returns>
+    /// <seealso cref="WhereReasonsAreNot{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    public static IObservable<IChangeSet<T>> SuppressRefresh<T>(this IObservable<IChangeSet<T>> source)
+        where T : notnull => source.WhereReasonsAreNot(ListChangeReason.Refresh);
+}
diff --git a/src/DynamicData/List/ObservableListEx.Switch.cs b/src/DynamicData/List/ObservableListEx.Switch.cs
new file mode 100644
index 000000000..0df10e44b
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Switch.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Subscribes to the latest inner <see cref="IObservableList{T}"/>, switching to each new source and clearing the result when switching.
+    /// This is the changeset-aware equivalent of Rx's <see cref="Observable.Switch{TSource}(IObservable{IObservable{TSource}})"/>, which cannot be applied directly to changeset streams.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="sources">An observable that emits <see cref="IObservableList{T}"/> instances. Each emission triggers a switch to the new list.</param>
+    /// <returns>A list changeset stream reflecting the most recently received inner list.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Convenience overload that calls <c>Connect()</c> on each inner list, then delegates to <see cref="Switch{T}(IObservable{IObservable{IChangeSet{T}}})"/>.</para>
+    /// </remarks>
+    /// <seealso cref="Switch{T}(IObservable{IObservable{IChangeSet{T}}})"/>
+    public static IObservable<IChangeSet<T>> Switch<T>(this IObservable<IObservableList<T>> sources)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return sources.Select(cache => cache.Connect()).Switch();
+    }
+
+    /// <summary>
+    /// Subscribes to the latest inner changeset stream, switching to each new source and clearing the destination when switching.
+    /// Previous subscriptions are disposed and the result set is emptied before subscribing to the new inner stream.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="sources">An <see cref="IObservable{T}"/> of <see cref="IObservable{T}"/> changeset streams. The operator subscribes to the latest inner stream.</param>
+    /// <returns>A list changeset stream reflecting the most recently received inner changeset stream.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// On each new inner stream, the operator clears the destination, disposes the previous subscription, and subscribes to the new stream.
+    /// This is the changeset-aware equivalent of Rx's <c>Switch()</c>.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="Switch{T}(IObservable{IObservableList{T}})"/>
+    public static IObservable<IChangeSet<T>> Switch<T>(this IObservable<IObservable<IChangeSet<T>>> sources)
+        where T : notnull
+    {
+        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
+
+        return new Switch<T>(sources).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.ToCollection.cs b/src/DynamicData/List/ObservableListEx.ToCollection.cs
new file mode 100644
index 000000000..072451c92
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ToCollection.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Emits the full collection as an <see cref="IReadOnlyCollection{T}"/> after every changeset. Equivalent to <c>QueryWhenChanged(items => items)</c>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a collection on each change.</param>
+    /// <returns>An observable emitting the full collection snapshot after each change.</returns>
+    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
+    /// <seealso cref="ObservableCacheEx.ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
+    public static IObservable<IReadOnlyCollection<TObject>> ToCollection<TObject>(this IObservable<IChangeSet<TObject>> source)
+        where TObject : notnull => source.QueryWhenChanged(items => items);
+}
diff --git a/src/DynamicData/List/ObservableListEx.ToObservableChangeSet.cs b/src/DynamicData/List/ObservableListEx.ToObservableChangeSet.cs
new file mode 100644
index 000000000..1c465dddc
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ToObservableChangeSet.cs
@@ -0,0 +1,185 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> into the DynamicData world by converting each emitted item into a list changeset.
+    /// Each emission becomes an <b>Add</b> operation in the resulting changeset stream.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for time-based operations (expiry, size limiting).</param>
+    /// <returns>A list changeset stream where each source emission is an <b>Add</b>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// This is the primary bridge from standard Rx into DynamicData's list changeset model. Each item emitted by <paramref name="source"/>
+    /// is added to an internal list and an <b>Add</b> changeset is emitted. The list grows unboundedly unless size or time limits
+    /// are specified via other overloads.
+    /// </para>
+    /// <para><b>Worth noting:</b> Source completion and errors are propagated. The internal list is disposed on unsubscribe.</para>
+    /// </remarks>
+    /// <seealso cref="ToObservableChangeSet{T}(IObservable{T}, Func{T, TimeSpan?}, int, IScheduler?)"/>
+    /// <seealso cref="ToObservableChangeSet{T}(IObservable{IEnumerable{T}}, IScheduler?)"/>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<T> source,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: null,
+            limitSizeTo: -1,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with per-item time-based expiry.
+    /// Expired items are automatically removed.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<T> source,
+                Func<T, TimeSpan?> expireAfter,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: expireAfter,
+            limitSizeTo: -1,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with FIFO size limiting.
+    /// When the list exceeds <paramref name="limitSizeTo"/>, the oldest items are removed.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="limitSizeTo">The maximum list size. Supply -1 to disable size limiting.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling removals.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<T> source,
+                int limitSizeTo,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: null,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with both time-based expiry and FIFO size limiting.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
+    /// <param name="limitSizeTo">The maximum list size. Supply -1 to disable size limiting.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers and size-limit checks.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<T> source,
+                Func<T, TimeSpan?>? expireAfter,
+                int limitSizeTo,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: expireAfter,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream.
+    /// Each emitted batch becomes an <b>AddRange</b>.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for time-based operations.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<IEnumerable<T>> source,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: null,
+            limitSizeTo: -1,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with FIFO size limiting.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="limitSizeTo">The maximum list size. Oldest items are removed when the limit is exceeded.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling removals.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<IEnumerable<T>> source,
+                int limitSizeTo,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: null,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with time-based expiry.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<IEnumerable<T>> source,
+                Func<T, TimeSpan?> expireAfter,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: expireAfter,
+            limitSizeTo: -1,
+            scheduler: scheduler);
+
+    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
+    /// <summary>
+    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with both time-based expiry and FIFO size limiting.
+    /// </summary>
+    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
+    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
+    /// <param name="limitSizeTo">The maximum list size. Oldest items removed when exceeded.</param>
+    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers and size-limit checks.</param>
+    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
+                this IObservable<IEnumerable<T>> source,
+                Func<T, TimeSpan?>? expireAfter,
+                int limitSizeTo,
+                IScheduler? scheduler = null)
+            where T : notnull
+        => List.Internal.ToObservableChangeSet<T>.Create(
+            source: source,
+            expireAfter: expireAfter,
+            limitSizeTo: limitSizeTo,
+            scheduler: scheduler);
+}
diff --git a/src/DynamicData/List/ObservableListEx.ToSortedCollection.cs b/src/DynamicData/List/ObservableListEx.ToSortedCollection.cs
new file mode 100644
index 000000000..860079901
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.ToSortedCollection.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Emits a sorted <see cref="IReadOnlyCollection{T}"/> after every changeset, sorted by the value returned by <paramref name="sort"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <typeparam name="TSortKey">The type of the sort key.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a sorted collection on each change.</param>
+    /// <param name="sort">A <see cref="Func{T, TResult}"/> function extracting the sort key from each item.</param>
+    /// <param name="sortOrder">The <see cref="SortDirection"/> sort direction. Defaults to ascending.</param>
+    /// <returns>An observable emitting a sorted collection snapshot after each change.</returns>
+    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
+    /// <seealso cref="ToSortedCollection{TObject}(IObservable{IChangeSet{TObject}}, IComparer{TObject})"/>
+    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ObservableCacheEx.ToSortedCollection{TObject, TKey}"/>
+    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TSortKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TSortKey> sort, SortDirection sortOrder = SortDirection.Ascending)
+        where TObject : notnull => source.QueryWhenChanged(query => sortOrder == SortDirection.Ascending ? new ReadOnlyCollectionLight<TObject>(query.OrderBy(sort)) : new ReadOnlyCollectionLight<TObject>(query.OrderByDescending(sort)));
+
+    /// <summary>
+    /// Emits a sorted <see cref="IReadOnlyCollection{T}"/> after every changeset, sorted using the specified <paramref name="comparer"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of items in the list.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a sorted collection on each change.</param>
+    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used for sorting.</param>
+    /// <returns>An observable emitting a sorted collection snapshot after each change.</returns>
+    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
+    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
+    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject>(this IObservable<IChangeSet<TObject>> source, IComparer<TObject> comparer)
+        where TObject : notnull => source.QueryWhenChanged(
+            query =>
+            {
+                var items = query.AsList();
+                items.Sort(comparer);
+                return new ReadOnlyCollectionLight<TObject>(items);
+            });
+}
diff --git a/src/DynamicData/List/ObservableListEx.Top.cs b/src/DynamicData/List/ObservableListEx.Top.cs
new file mode 100644
index 000000000..17a128f99
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Top.cs
@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Takes the first <paramref name="numberOfItems"/> items from the source list. Implemented as <c>Virtualise</c> with a fixed window starting at index 0.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to take the top items.</param>
+    /// <param name="numberOfItems">The maximum number of items to include. Must be greater than zero.</param>
+    /// <returns>A virtual changeset stream containing at most <paramref name="numberOfItems"/> items from the beginning of the source.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="numberOfItems"/> is zero or negative.</exception>
+    /// <remarks>
+    /// <para>The source should ideally be sorted before applying Top, since list order determines which items appear.</para>
+    /// </remarks>
+    /// <seealso cref="Virtualise{T}(IObservable{IChangeSet{T}}, IObservable{IVirtualRequest})"/>
+    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
+    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
+    public static IObservable<IChangeSet<T>> Top<T>(this IObservable<IChangeSet<T>> source, int numberOfItems)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        if (numberOfItems <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(numberOfItems), "Number of items should be greater than zero");
+        }
+
+        return source.Virtualise(Observable.Return(new VirtualRequest(0, numberOfItems)));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Transform.cs b/src/DynamicData/List/ObservableListEx.Transform.cs
new file mode 100644
index 000000000..64a856a24
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Transform.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Projects each item to a new form using a synchronous transform function.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to transform.</param>
+    /// <param name="transformFactory">The <see cref="Func{T, TResult}"/> transform function applied to each item.</param>
+    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh events re-invoke the factory and emit an update. When <see langword="false"/> (the default), Refresh is forwarded without re-transforming.</param>
+    /// <returns>A list changeset stream of transformed items.</returns>
+    /// <remarks>
+    /// <para>
+    /// Maintains an internal list of transformed items. Each source changeset is
+    /// processed and a corresponding output changeset is produced with the transformed items.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add</term><description>The factory is called and an <b>Add</b> is emitted at the same index.</description></item>
+    /// <item><term>AddRange</term><description>The factory is called for each item. An <b>AddRange</b> is emitted at the same start index.</description></item>
+    /// <item><term>Replace</term><description>The factory is called for the new item. A <b>Replace</b> is emitted at the same index. The previous transformed value is available to overloads that accept <see cref="Optional{TDestination}"/>.</description></item>
+    /// <item><term>Remove</term><description>A <b>Remove</b> is emitted (no factory call).</description></item>
+    /// <item><term>RemoveRange</term><description>A <b>RemoveRange</b> is emitted.</description></item>
+    /// <item><term>Moved</term><description>A <b>Moved</b> is emitted with updated indices (no factory call). Throws <see cref="UnspecifiedIndexException"/> if the source change has no index information.</description></item>
+    /// <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is <see langword="false"/> (default), the <b>Refresh</b> is forwarded without re-transforming. If <see langword="true"/>, the factory is re-invoked and the result replaces the current value.</description></item>
+    /// <item><term>Clear</term><description>A <b>Clear</b> is emitted and the internal list is emptied.</description></item>
+    /// <item><term>OnError</term><description>If the factory throws, the exception propagates as OnError.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> By default, Refresh does NOT re-transform the item (it just forwards the signal). Set <paramref name="transformOnRefresh"/> to <see langword="true"/> if you need the factory re-invoked on Refresh. Add operations with out-of-bounds indices silently append to the end.</para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
+    /// <seealso cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="Convert{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination})"/>
+    /// <seealso cref="ObservableCacheEx.Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, bool)"/>
+    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, TDestination> transformFactory, bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform<TSource, TDestination>((t, _, _) => transformFactory(t), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    /// <summary>
+    /// Projects each item using a transform function that also receives the item's index.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, int, TDestination> transformFactory, bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform<TSource, TDestination>((t, _, idx) => transformFactory(t, idx), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    /// <summary>
+    /// Projects each item using a transform function that also receives the previously transformed value (if any).
+    /// Type arguments must be specified explicitly as type inference fails for this overload.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, Optional<TDestination>, TDestination> transformFactory, bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.Transform<TSource, TDestination>((t, previous, _) => transformFactory(t, previous), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    /// <summary>
+    /// Projects each item using a transform function that receives the source item, the previously transformed value, and the index.
+    /// Type arguments must be specified explicitly as type inference fails for this overload.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, Optional<TDestination>, int, TDestination> transformFactory, bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new Transformer<TSource, TDestination>(source, transformFactory, transformOnRefresh).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.TransformAsync.cs b/src/DynamicData/List/ObservableListEx.TransformAsync.cs
new file mode 100644
index 000000000..d130fa3b9
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.TransformAsync.cs
@@ -0,0 +1,138 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Projects each item to a new form using an async transform function. Behaves like <see cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/> but the factory returns a <see cref="Task{T}"/>.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to transform asynchronously.</param>
+    /// <param name="transformFactory">An <see cref="Func{T, TResult}"/> async function that transforms each source item.</param>
+    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh events re-invoke the factory.</param>
+    /// <returns>A list changeset stream of asynchronously transformed items.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Change handling is identical to the synchronous <see cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/> except the factory is awaited. Operations are serialized per changeset via a semaphore.</para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term>Add/AddRange</term><description>The async factory is awaited for each item. An <b>Add</b>/<b>AddRange</b> is emitted with the transformed results.</description></item>
+    /// <item><term>Replace</term><description>The async factory is awaited for the new item. A <b>Replace</b> is emitted.</description></item>
+    /// <item><term>Remove/RemoveRange</term><description>Emitted without invoking the factory.</description></item>
+    /// <item><term>Moved</term><description>Emitted with updated indices (no factory call).</description></item>
+    /// <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is <see langword="false"/> (default), forwarded without re-transforming. If <see langword="true"/>, the factory is re-awaited.</description></item>
+    /// <item><term>Clear</term><description>Emitted and internal list cleared.</description></item>
+    /// <item><term>OnError</term><description>If the async factory throws, the exception propagates as OnError.</description></item>
+    /// <item><term>OnCompleted</term><description>Forwarded after the last changeset is processed.</description></item>
+    /// </list>
+    /// <para><b>Worth noting:</b> All async transforms within a single changeset are serialized (not parallel). Each changeset is fully processed before the next begins. By default, Refresh does NOT re-transform.</para>
+    /// </remarks>
+    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    /// <seealso cref="ObservableCacheEx.TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}})"/>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
+        this IObservable<IChangeSet<TSource>> source,
+        Func<TSource, Task<TDestination>> transformFactory,
+        bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync<TSource, TDestination>((t, _, _) => transformFactory(t), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
+    /// <summary>
+    /// Async transform overload receiving the source item and its index.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
+        this IObservable<IChangeSet<TSource>> source,
+        Func<TSource, int, Task<TDestination>> transformFactory,
+        bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync<TSource, TDestination>((t, _, i) => transformFactory(t, i), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
+    /// <summary>
+    /// Async transform overload receiving the source item and the previously transformed value.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
+        this IObservable<IChangeSet<TSource>> source,
+        Func<TSource, Optional<TDestination>, Task<TDestination>> transformFactory,
+        bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return source.TransformAsync<TSource, TDestination>((t, d, _) => transformFactory(t, d), transformOnRefresh);
+    }
+
+    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
+    /// <summary>
+    /// Async transform overload receiving the source item, previously transformed value, and index.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
+        this IObservable<IChangeSet<TSource>> source,
+        Func<TSource, Optional<TDestination>, int, Task<TDestination>> transformFactory,
+        bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformAsync<TSource, TDestination>(source, (t, d, i, _) => transformFactory(t, d, i), transformOnRefresh).Run();
+    }
+
+    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
+    /// <summary>
+    /// Async transform overload receiving the source item, previously transformed value, index, and CancellationToken attached to the underlying subscription. This is the terminal overload that all other TransformAsync overloads delegate to.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
+    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
+        this IObservable<IChangeSet<TSource>> source,
+        Func<TSource, Optional<TDestination>, int, CancellationToken, Task<TDestination>> transformFactory,
+        bool transformOnRefresh = false)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
+
+        return new TransformAsync<TSource, TDestination>(source, transformFactory, transformOnRefresh).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.TransformMany.cs b/src/DynamicData/List/ObservableListEx.TransformMany.cs
new file mode 100644
index 000000000..6b3e3e327
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.TransformMany.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Flattens each source item into multiple destination items using <paramref name="manySelector"/>. Each source item produces zero or more children,
+    /// all of which are merged into a single flat list changeset stream.
+    /// </summary>
+    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
+    /// <typeparam name="TSource">The type of the source items.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to expand each item into multiple children.</param>
+    /// <param name="manySelector">A <see cref="Func{T, TResult}"/> function that returns the child items for each source item.</param>
+    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> used during Replace to determine which child items changed between old and new parent values.</param>
+    /// <returns>A list changeset stream of all child items from all source items.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="manySelector"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Children expanded and added to the output.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old children diffed against new children (using <paramref name="equalityComparer"/>). Removed, added, or kept as appropriate.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>All children of the removed parents are removed from the output.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Children re-expanded and diffed.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
+    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
+    /// <seealso cref="ObservableCacheEx.TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
+    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, IEnumerable<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TDestination : notnull
+        where TSource : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
+
+        return new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
+    }
+
+    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
+    /// <summary>
+    /// Flattens each source item into children from an <see cref="ObservableCollection{T}"/>. The collection is observed for subsequent changes.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, ObservableCollection<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TDestination : notnull
+        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
+
+    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
+    /// <summary>
+    /// Flattens each source item into children from a <see cref="ReadOnlyObservableCollection{T}"/>. The collection is observed for subsequent changes.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, ReadOnlyObservableCollection<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TDestination : notnull
+        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
+
+    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
+    /// <summary>
+    /// Flattens each source item into children from an <see cref="IObservableList{T}"/>. The inner list is observed for subsequent changes.
+    /// </summary>
+    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, IObservableList<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
+        where TDestination : notnull
+        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
+}
diff --git a/src/DynamicData/List/ObservableListEx.Virtualise.cs b/src/DynamicData/List/ObservableListEx.Virtualise.cs
new file mode 100644
index 000000000..a2d2ec09d
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Virtualise.cs
@@ -0,0 +1,52 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies a sliding window to the source list using start index and size from <paramref name="requests"/>.
+    /// Only items within the window are included downstream.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to virtualize.</param>
+    /// <param name="requests">An observable of <see cref="IVirtualRequest"/> specifying the start index and size of the window.</param>
+    /// <returns>An <see cref="IVirtualChangeSet{T}"/> stream containing only items within the current virtual window.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="requests"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Like <see cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/> but uses absolute start index and size instead of page number and page size.
+    /// Internally maintains the full source list and recalculates the window on each change or request.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
+    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
+    public static IObservable<IVirtualChangeSet<T>> Virtualise<T>(this IObservable<IChangeSet<T>> source, IObservable<IVirtualRequest> requests)
+        where T : notnull
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        requests.ThrowArgumentNullExceptionIfNull(nameof(requests));
+
+        return new Virtualiser<T>(source, requests).Run();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.WhenAnyPropertyChanged.cs b/src/DynamicData/List/ObservableListEx.WhenAnyPropertyChanged.cs
new file mode 100644
index 000000000..a6529e3f3
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.WhenAnyPropertyChanged.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Watches all items in the source list and emits the item when any of its properties change.
+    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
+    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe property changes on items in.</param>
+    /// <param name="propertiesToMonitor">An optional list of property names to monitor. If empty, all property changes are observed.</param>
+    /// <returns>An observable emitting the item whenever any monitored property changes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Implemented via <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>. Subscriptions are managed per item: created on add, disposed on remove.</para>
+    /// </remarks>
+    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
+    /// <seealso cref="WhenValueChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
+    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
+    /// <seealso cref="ObservableCacheEx.WhenAnyPropertyChanged{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, string[])"/>
+    public static IObservable<TObject?> WhenAnyPropertyChanged<TObject>(this IObservable<IChangeSet<TObject>> source, params string[] propertiesToMonitor)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+
+        return source.MergeMany(t => t.WhenAnyPropertyChanged(propertiesToMonitor));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.WhenPropertyChanged.cs b/src/DynamicData/List/ObservableListEx.WhenPropertyChanged.cs
new file mode 100644
index 000000000..4a91bd035
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.WhenPropertyChanged.cs
@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Watches a specific property on all items in the source list and emits a <see cref="PropertyValue{TObject, TValue}"/> (item + value pair) when it changes.
+    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
+    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of item. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <typeparam name="TValue">The type of the property value.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe a specific property on items in.</param>
+    /// <param name="propertyAccessor">An <see cref="Expression{TDelegate}"/> expression selecting the property to observe.</param>
+    /// <param name="notifyOnInitialValue">When <see langword="true"/> (default), the current value is emitted immediately upon subscribing to each item.</param>
+    /// <returns>An observable emitting <see cref="PropertyValue{TObject, TValue}"/> whenever the property changes on any tracked item.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertyAccessor"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>Implemented via <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>.</para>
+    /// </remarks>
+    /// <seealso cref="WhenValueChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
+    /// <seealso cref="WhenAnyPropertyChanged{TObject}(IObservable{IChangeSet{TObject}}, string[])"/>
+    /// <seealso cref="ObservableCacheEx.WhenPropertyChanged{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TValue}}, bool)"/>
+    public static IObservable<PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
+
+        var factory = propertyAccessor.GetFactory();
+        return source.MergeMany(t => factory(t, notifyOnInitialValue));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.WhenValueChanged.cs b/src/DynamicData/List/ObservableListEx.WhenValueChanged.cs
new file mode 100644
index 000000000..0328218fc
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.WhenValueChanged.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Watches a specific property on all items and emits just the property value (without the sender) when it changes.
+    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
+    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
+    /// </summary>
+    /// <typeparam name="TObject">The type of item. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
+    /// <typeparam name="TValue">The type of the property value.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe a specific property value on items in.</param>
+    /// <param name="propertyAccessor">An <see cref="Expression{TDelegate}"/> expression selecting the property to observe.</param>
+    /// <param name="notifyOnInitialValue">When <see langword="true"/> (default), the current value is emitted immediately upon subscribing to each item.</param>
+    /// <returns>An observable emitting the property value whenever it changes on any tracked item.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertyAccessor"/> is <see langword="null"/>.</exception>
+    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
+    /// <seealso cref="WhenAnyPropertyChanged{TObject}(IObservable{IChangeSet{TObject}}, string[])"/>
+    /// <seealso cref="ObservableCacheEx.WhenValueChanged{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TValue}}, bool)"/>
+    public static IObservable<TValue?> WhenValueChanged<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+        where TObject : INotifyPropertyChanged
+    {
+        source.ThrowArgumentNullExceptionIfNull(nameof(source));
+        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
+
+        var factory = propertyAccessor.GetFactory();
+        return source.MergeMany(t => factory(t, notifyOnInitialValue).Select(pv => pv.Value));
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.WhereReasonsAre.cs b/src/DynamicData/List/ObservableListEx.WhereReasonsAre.cs
new file mode 100644
index 000000000..c2e61653d
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.WhereReasonsAre.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Filters the changeset stream to include only changes with the specified <see cref="ListChangeReason"/> values.
+    /// Index information is stripped from the output because removing some changes invalidates the original index positions.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter by change reason.</param>
+    /// <param name="reasons">The <see cref="ListChangeReason"/> change reasons to include. Must specify at least one.</param>
+    /// <returns>A list changeset stream containing only changes with the specified reasons.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="reasons"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentException"><paramref name="reasons"/> is empty.</exception>
+    /// <remarks>
+    /// <para>Filters individual changes within each changeset. If filtering removes all changes from a changeset, the empty changeset is suppressed via <see cref="NotEmpty{T}(IObservable{IChangeSet{T}})"/>.</para>
+    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes can cause downstream operators to accumulate items indefinitely (memory leak). Index information is stripped because removing some changes invalidates the original index positions.</para>
+    /// </remarks>
+    /// <seealso cref="WhereReasonsAreNot{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
+    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
+    public static IObservable<IChangeSet<T>> WhereReasonsAre<T>(this IObservable<IChangeSet<T>> source, params ListChangeReason[] reasons)
+        where T : notnull
+    {
+        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
+
+        if (reasons.Length == 0)
+        {
+            throw new ArgumentException("Must enter at least 1 reason", nameof(reasons));
+        }
+
+        var matches = new HashSet<ListChangeReason>(reasons);
+        return source.Select(
+            changes =>
+            {
+                var filtered = changes.Where(change => matches.Contains(change.Reason)).YieldWithoutIndex();
+                return new ChangeSet<T>(filtered);
+            }).NotEmpty();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.WhereReasonsAreNot.cs b/src/DynamicData/List/ObservableListEx.WhereReasonsAreNot.cs
new file mode 100644
index 000000000..aabb2b3c2
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.WhereReasonsAreNot.cs
@@ -0,0 +1,74 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Filters the changeset stream to exclude changes with the specified <see cref="ListChangeReason"/> values.
+    /// Index information is stripped from the output because removing some changes invalidates the original index positions.
+    /// The exception is when only <see cref="ListChangeReason.Refresh"/> is excluded, since removing Refresh does not affect index calculations.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter by excluding change reasons.</param>
+    /// <param name="reasons">The <see cref="ListChangeReason"/> change reasons to exclude. Must specify at least one.</param>
+    /// <returns>A list changeset stream with the specified change reasons removed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="reasons"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentException"><paramref name="reasons"/> is empty.</exception>
+    /// <remarks>
+    /// <para>
+    /// Empty changesets (after filtering) are automatically suppressed. When only <see cref="ListChangeReason.Refresh"/> is excluded,
+    /// indices are preserved, since removing Refresh does not affect index calculations.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="WhereReasonsAre{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
+    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
+    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
+    public static IObservable<IChangeSet<T>> WhereReasonsAreNot<T>(this IObservable<IChangeSet<T>> source, params ListChangeReason[] reasons)
+        where T : notnull
+    {
+        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
+
+        if (reasons.Length == 0)
+        {
+            throw new ArgumentException("Must enter at least 1 reason", nameof(reasons));
+        }
+
+        if (reasons.Length == 1 && reasons[0] == ListChangeReason.Refresh)
+        {
+            // If only refresh changes are removed, then there's no need to remove the indexes
+            return source.Select(changes =>
+            {
+                var filtered = changes.Where(c => c.Reason != ListChangeReason.Refresh);
+                return new ChangeSet<T>(filtered);
+            }).NotEmpty();
+        }
+
+        var matches = new HashSet<ListChangeReason>(reasons);
+        return source.Select(
+            updates =>
+            {
+                var filtered = updates.Where(u => !matches.Contains(u.Reason)).YieldWithoutIndex();
+                return new ChangeSet<T>(filtered);
+            }).NotEmpty();
+    }
+}
diff --git a/src/DynamicData/List/ObservableListEx.Xor.cs b/src/DynamicData/List/ObservableListEx.Xor.cs
new file mode 100644
index 000000000..b63b5c6d0
--- /dev/null
+++ b/src/DynamicData/List/ObservableListEx.Xor.cs
@@ -0,0 +1,89 @@
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using DynamicData.Binding;
+using DynamicData.Cache.Internal;
+using DynamicData.List.Internal;
+using DynamicData.List.Linq;
+
+// ReSharper disable once CheckNamespace
+namespace DynamicData;
+
+/// <summary>
+/// Extensions for ObservableList.
+/// </summary>
+public static partial class ObservableListEx
+{
+    /// <summary>
+    /// Applies a logical XOR (symmetric difference) between the source and other streams.
+    /// Items present in exactly one source are included in the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{T}}"/> to exclusively combine.</param>
+    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to combine with.</param>
+    /// <returns>A list changeset stream containing items that exist in exactly one source.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// <para>
+    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Uses reference-counted equality: an item is included when it exists in exactly one source.
+    /// If it appears in a second source, it is removed from the result. If it then leaves one source,
+    /// it re-enters the result. <b>Moved</b> changes are ignored.
+    /// </para>
+    /// <list type="table">
+    /// <listheader><term>Event</term><description>Behavior</description></listheader>
+    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Reference count updated. If the item is now in exactly one source, an <b>Add</b> is emitted. If now in two or more, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Reference count decremented. If now in exactly one source, an <b>Add</b> is emitted. If now in zero, a <b>Remove</b> is emitted.</description></item>
+    /// <item><term><b>Replace</b></term><description>Old item reference count decremented, new item incremented, with Xor logic applied.</description></item>
+    /// <item><term><b>Refresh</b></term><description>Forwarded if item is in the result set.</description></item>
+    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
+    /// </list>
+    /// </remarks>
+    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <seealso cref="ObservableCacheEx.Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
+    public static IObservable<IChangeSet<T>> Xor<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
+        where T : notnull
+    {
+        others.ThrowArgumentNullExceptionIfNull(nameof(others));
+
+        return source.Combine(CombineOperator.Xor, others);
+    }
+
+    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Applies a logical XOR between a pre-built collection of list changeset sources.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Xor<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Xor);
+
+    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic XOR: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Xor);
+
+    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic XOR accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<IObservableList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Xor);
+
+    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
+    /// <summary>
+    /// Dynamic XOR accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
+    /// </summary>
+    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<ISourceList<T>> sources)
+        where T : notnull => sources.Combine(CombineOperator.Xor);
+}
diff --git a/src/DynamicData/List/ObservableListEx.cs b/src/DynamicData/List/ObservableListEx.cs
index 37f3a3966..ffe07170a 100644
--- a/src/DynamicData/List/ObservableListEx.cs
+++ b/src/DynamicData/List/ObservableListEx.cs
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
+// Copyright (c) 2011-2025 Roland Pheasant. All rights reserved.
 // Roland Pheasant licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
@@ -21,2909 +21,6 @@ namespace DynamicData;
 /// <summary>
 /// Extensions for ObservableList.
 /// </summary>
-public static class ObservableListEx
+public static partial class ObservableListEx
 {
-    /// <summary>
-    /// Injects a side effect into a changeset stream via an <see cref="IChangeSetAdaptor{T}"/>.
-    /// The adaptor's <c>Adapt</c> method is invoked for each changeset before it is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe and adapt.</param>
-    /// <param name="adaptor">The <see cref="IChangeSetAdaptor{T}"/> adaptor whose <c>Adapt</c> method is invoked for each changeset.</param>
-    /// <returns>A list changeset stream identical to the source, with the adaptor side effect applied.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="adaptor"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// This is the primary extension point for custom UI binding adaptors (e.g., <see cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
-    /// delegates to this operator). If the adaptor throws, the exception propagates downstream as <c>OnError</c>.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
-    public static IObservable<IChangeSet<T>> Adapt<T>(this IObservable<IChangeSet<T>> source, IChangeSetAdaptor<T> adaptor)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        adaptor.ThrowArgumentNullExceptionIfNull(nameof(adaptor));
-
-        return Observable.Create<IChangeSet<T>>(
-            observer =>
-            {
-                var locker = InternalEx.NewLock();
-                return source.Synchronize(locker).Select(
-                    changes =>
-                    {
-                        adaptor.Adapt(changes);
-                        return changes;
-                    }).SubscribeSafe(observer);
-            });
-    }
-
-    /// <summary>
-    /// Adds a key to each item in a list changeset, converting it to a cache changeset that supports all keyed DynamicData operators.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TKey">The type of the key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to add keys to, converting to a cache changeset.</param>
-    /// <param name="keySelector">A <see cref="Func{T, TResult}"/> function to extract a unique key from each item.</param>
-    /// <returns>A cache <see cref="IObservable{IChangeSet{TObject, TKey}}"/> changeset stream with keyed items.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// All index information is dropped during conversion because cache changesets are unordered by default.
-    /// Use this when you need to transition from list-based pipelines to cache-based operators (Filter by key, Join, Group, etc.).
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="ObservableCacheEx.RemoveKey{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<TObject, TKey>> AddKey<TObject, TKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TKey> keySelector)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        keySelector.ThrowArgumentNullExceptionIfNull(nameof(keySelector));
-
-        return source.Select(changes => new ChangeSet<TObject, TKey>(new AddKeyEnumerator<TObject, TKey>(changes, keySelector)));
-    }
-
-    /// <summary>
-    /// Applies a logical AND (intersection) between multiple list changeset streams.
-    /// Only items present in ALL sources appear in the result.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the lists.</typeparam>
-    /// <param name="source">The first source <see cref="IObservable{IChangeSet{T}}"/> to intersect.</param>
-    /// <param name="others">The additional <see cref="IObservable{IChangeSet{T}}"/> changeset streams to intersect with.</param>
-    /// <returns>A list changeset stream containing items that exist in every source.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Uses reference counting per item across all sources. An item appears downstream only when
-    /// its reference count is non-zero in ALL sources. Item identity is determined by the default equality comparer.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/AddRange</term><description>The item's reference count is incremented in its source tracker. If the item is now present in all sources, an <b>Add</b> is emitted.</description></item>
-    /// <item><term>Replace</term><description>The old item's reference count is decremented and the new item's is incremented. Depending on whether each is present in ALL sources, this emits an <b>Add</b>, <b>Remove</b>, <b>Replace</b>, or nothing.</description></item>
-    /// <item><term>Remove/RemoveRange/Clear</term><description>The item's reference count is decremented. If it was in the result and is no longer in all sources, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term>Refresh</term><description>Forwarded as <b>Refresh</b> if the item is currently in the result.</description></item>
-    /// <item><term>Moved</term><description>Ignored (set operations are position-independent).</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Item identity uses object equality, not position. Duplicate items in a single source are reference-counted independently.</para>
-    /// </remarks>
-    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="ObservableCacheEx.And{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    public static IObservable<IChangeSet<T>> And<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
-        where T : notnull
-    {
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.Combine(CombineOperator.And, others);
-    }
-
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <param name="sources">A <see cref="ICollection{T}"/> of changeset streams to intersect.</param>
-    /// <remarks>
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>This overload accepts a pre-built collection of sources instead of a params array.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> And<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.And);
-
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <param name="sources">An <see cref="IObservableList{T}"/> of changeset streams. Sources can be added or removed dynamically.</param>
-    /// <remarks>
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>This overload supports dynamic source management: adding or removing changeset streams from the observable list triggers re-evaluation.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.And);
-
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <param name="sources">An <see cref="IObservableList{IObservableList{T}}"/> of <see cref="IObservableList{IObservableList{T}}"/>. Each inner list's changes are connected automatically.</param>
-    /// <remarks>
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>This overload accepts <see cref="IObservableList{T}"/> instances directly, calling <c>Connect()</c> internally.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<IObservableList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.And);
-
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <param name="sources">An <see cref="IObservableList{ISourceList{T}}"/> of <see cref="ISourceList{T}"/>. Each inner list's changes are connected automatically.</param>
-    /// <remarks>
-    /// <inheritdoc cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>This overload accepts <see cref="ISourceList{T}"/> instances directly, calling <c>Connect()</c> internally.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> And<T>(this IObservableList<ISourceList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.And);
-
-    /// <summary>
-    /// Wraps a <see cref="ISourceList{T}"/> as a read-only <see cref="IObservableList{T}"/>, hiding mutation methods.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The <see cref="ISourceList{T}"/> mutable source list to wrap.</param>
-    /// <returns>A read-only observable list that mirrors the source.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    public static IObservableList<T> AsObservableList<T>(this ISourceList<T> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new AnonymousObservableList<T>(source);
-    }
-
-    /// <summary>
-    /// Materializes a changeset stream into a read-only <see cref="IObservableList{T}"/>.
-    /// The list is kept in sync with the source stream for the lifetime of the subscription.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to materialize into a read-only list.</param>
-    /// <returns>A read-only observable list reflecting the current state of the stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// This is the primary way to <b>multicast</b> a changeset pipeline. Materializing once into an <see cref="IObservableList{T}"/>,
-    /// then calling <c>Connect()</c> on the result for each downstream consumer, ensures the upstream operators are evaluated only once
-    /// regardless of how many subscribers consume the result.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="AsObservableList{T}(ISourceList{T})"/>
-    public static IObservableList<T> AsObservableList<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new AnonymousObservableList<T>(source);
-    }
-
-    /// <summary>
-    /// Monitors all properties on each item (via <see cref="INotifyPropertyChanged"/>) and emits <b>Refresh</b>
-    /// changes when any property changes, causing downstream operators to re-evaluate.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items, which must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to monitor for property-driven refresh signals.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration to batch multiple refresh signals into a single changeset.</param>
-    /// <param name="propertyChangeThrottle">An optional <see cref="TimeSpan"/> throttle applied to each item's property change notifications.</param>
-    /// <param name="scheduler">The scheduler for throttle and buffer timing. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>A list changeset stream with additional <b>Refresh</b> changes injected when properties change.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Wraps <see cref="AutoRefreshOnObservable{TObject, TAny}"/> using <c>WhenAnyPropertyChanged()</c> as the re-evaluator.
-    /// Pair with <see cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/> or <see cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
-    /// to get reactive re-evaluation on property changes.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/AddRange</term><description>Subscribes to <c>PropertyChanged</c> on each new item. The original change is forwarded.</description></item>
-    /// <item><term>Replace</term><description>Unsubscribes from the old item, subscribes to the new. The original change is forwarded.</description></item>
-    /// <item><term>Remove/RemoveRange/Clear</term><description>Unsubscribes from removed items. The original change is forwarded.</description></item>
-    /// <item><term>Moved/Refresh</term><description>Forwarded unchanged.</description></item>
-    /// <item><term>Property changes</term><description>A <b>Refresh</b> change is emitted for the item whose property changed.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Each item generates a subscription. For large lists with frequent property changes, use <paramref name="changeSetBuffer"/> and <paramref name="propertyChangeThrottle"/> to reduce churn.</para>
-    /// </remarks>
-    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="AutoRefreshOnObservable{TObject, TAny}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{TAny}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ObservableCacheEx.AutoRefresh{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<TObject>> AutoRefresh<TObject>(this IObservable<IChangeSet<TObject>> source, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.AutoRefreshOnObservable(
-            t =>
-            {
-                if (propertyChangeThrottle is null)
-                {
-                    return t.WhenAnyPropertyChanged();
-                }
-
-                return t.WhenAnyPropertyChanged().Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
-            },
-            changeSetBuffer,
-            scheduler);
-    }
-
-    /// <summary>
-    /// Monitors a single property (selected by <paramref name="propertyAccessor"/>) on each item via <see cref="INotifyPropertyChanged"/>
-    /// and emits <b>Refresh</b> changes when that property changes, causing downstream operators to re-evaluate. More efficient than
-    /// the all-properties overload when only one property (of type <typeparamref name="TProperty"/>) affects downstream behavior.
-    /// </summary>
-    /// <inheritdoc cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<TObject>> AutoRefresh<TObject, TProperty>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TProperty>> propertyAccessor, TimeSpan? changeSetBuffer = null, TimeSpan? propertyChangeThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
-
-        return source.AutoRefreshOnObservable(
-            t =>
-            {
-                if (propertyChangeThrottle is null)
-                {
-                    return t.WhenPropertyChanged(propertyAccessor, false);
-                }
-
-                return t.WhenPropertyChanged(propertyAccessor, false).Throttle(propertyChangeThrottle.Value, scheduler ?? GlobalConfig.DefaultScheduler);
-            },
-            changeSetBuffer,
-            scheduler);
-    }
-
-    /// <summary>
-    /// Monitors each item with a custom observable and emits <b>Refresh</b> changes whenever that observable fires,
-    /// causing downstream operators (Filter, Sort, Group) to re-evaluate.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TAny">The type emitted by the re-evaluator observable (value is ignored).</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to monitor for observable-driven refresh signals.</param>
-    /// <param name="reevaluator">A <see cref="Func{T, TResult}"/> factory that, given an item, returns an observable whose emissions trigger a <b>Refresh</b> for that item.</param>
-    /// <param name="changeSetBuffer">An optional <see cref="TimeSpan"/> buffer duration to batch refresh signals into a single changeset.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> for buffering.</param>
-    /// <returns>A list changeset stream with additional <b>Refresh</b> changes injected when per-item observables fire.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="reevaluator"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// This is the general-purpose refresh mechanism. <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// is a convenience wrapper that uses <c>WhenAnyPropertyChanged()</c> as the re-evaluator.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/AddRange</term><description>Subscribes to the re-evaluator observable for each new item. The original change is forwarded.</description></item>
-    /// <item><term>Replace</term><description>Unsubscribes from the old item's observable, subscribes to the new. The original change is forwarded.</description></item>
-    /// <item><term>Remove/RemoveRange/Clear</term><description>Unsubscribes from removed items. The original change is forwarded.</description></item>
-    /// <item><term>Moved/Refresh</term><description>Forwarded unchanged.</description></item>
-    /// <item><term>Re-evaluator fires</term><description>The item's current index is looked up and a <b>Refresh</b> change is emitted.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ObservableCacheEx.AutoRefreshOnObservable{TObject, TKey, TAny}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TAny}}, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<TObject>> AutoRefreshOnObservable<TObject, TAny>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<TAny>> reevaluator, TimeSpan? changeSetBuffer = null, IScheduler? scheduler = null)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        reevaluator.ThrowArgumentNullExceptionIfNull(nameof(reevaluator));
-
-        return new AutoRefresh<TObject, TAny>(source, reevaluator, changeSetBuffer, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Applies changeset mutations to a target <see cref="IObservableCollection{T}"/> for UI data binding.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to bind to a collection.</param>
-    /// <param name="targetCollection">The <see cref="IObservableCollection{T}"/> target collection to keep in sync.</param>
-    /// <param name="resetThreshold">When a changeset exceeds this many changes, the collection is reset instead of applying individual changes.</param>
-    /// <returns>A continuation of the source changeset stream (allows further chaining).</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="targetCollection"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Delegates to <see cref="Adapt{T}(IObservable{IChangeSet{T}}, IChangeSetAdaptor{T})"/> with an internal collection adaptor.
-    /// Each changeset is applied to the target collection on the calling thread. For UI binding, ensure the source is
-    /// observed on the UI thread (e.g., via <c>ObserveOn</c>).
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Item inserted at the specified index in the target collection.</description></item>
-    /// <item><term>AddRange</term><description>Items inserted as a range. If the count exceeds <paramref name="resetThreshold"/>, the collection is cleared and repopulated.</description></item>
-    /// <item><term>Replace</term><description>Item at the specified index is replaced.</description></item>
-    /// <item><term>Remove</term><description>Item at the specified index is removed.</description></item>
-    /// <item><term>RemoveRange/Clear</term><description>Items removed from the collection.</description></item>
-    /// <item><term>Moved</term><description>Item is moved between positions in the collection.</description></item>
-    /// <item><term>Refresh</term><description>Depends on the adaptor implementation.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, out ReadOnlyObservableCollection{T}, int)"/>
-    /// <seealso cref="Clone{T}(IObservable{IChangeSet{T}}, IList{T})"/>
-    /// <seealso cref="Adapt{T}(IObservable{IChangeSet{T}}, IChangeSetAdaptor{T})"/>
-    /// <seealso cref="ObservableCacheEx.Bind{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservableCollection{TObject}, int)"/>
-    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, IObservableCollection<T> targetCollection, int resetThreshold = BindingOptions.DefaultResetThreshold)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        targetCollection.ThrowArgumentNullExceptionIfNull(nameof(targetCollection));
-
-        // if user has not specified different defaults, use system wide defaults instead.
-        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
-        var defaults = DynamicDataOptions.Binding;
-
-        var options = resetThreshold == BindingOptions.DefaultResetThreshold
-            ? defaults
-            : defaults with { ResetThreshold = resetThreshold };
-
-        return source.Bind(targetCollection, options);
-    }
-
-    /// <summary>
-    /// Binds the source changeset stream to <paramref name="targetCollection"/>, with fine-grained <see cref="BindingOptions"/> control over reset threshold and other behaviors.
-    /// </summary>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, IObservableCollection<T> targetCollection, BindingOptions options)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        targetCollection.ThrowArgumentNullExceptionIfNull(nameof(targetCollection));
-
-        var adaptor = new ObservableCollectionAdaptor<T>(targetCollection, options);
-        return source.Adapt(adaptor);
-    }
-
-    /// <summary>
-    /// Constructs a <see cref="ReadOnlyObservableCollection{T}"/> and binds the changeset stream to it.
-    /// Use this overload when you need a read-only view (typically for UI binding) without managing the backing collection yourself.
-    /// The created collection is returned via the <paramref name="readOnlyObservableCollection"/> output parameter.
-    /// </summary>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    /// <remarks>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    /// <para>The created collection is backed by an internal <c>ObservableCollectionExtended&lt;T&gt;</c>. Callers receive only the read-only wrapper.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, out ReadOnlyObservableCollection<T> readOnlyObservableCollection, int resetThreshold = BindingOptions.DefaultResetThreshold)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        // if user has not specified different defaults, use system wide defaults instead.
-        // This is a hack to retro fit system wide defaults which override the hard coded defaults above
-        var defaults = DynamicDataOptions.Binding;
-        var options = resetThreshold == BindingOptions.DefaultResetThreshold
-            ? defaults
-            : defaults with { ResetThreshold = resetThreshold };
-
-        return source.Bind(out readOnlyObservableCollection, options);
-    }
-
-    /// <summary>
-    /// Constructs a <see cref="ReadOnlyObservableCollection{T}"/> and binds the changeset stream to it,
-    /// with fine-grained <see cref="BindingOptions"/> control over reset threshold and other behaviors.
-    /// The created collection is returned via the <paramref name="readOnlyObservableCollection"/> output parameter.
-    /// </summary>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    /// <remarks>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    /// <para>The created collection is backed by an internal <c>ObservableCollectionExtended&lt;T&gt;</c>. Callers receive only the read-only wrapper.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Bind<T>(this IObservable<IChangeSet<T>> source, out ReadOnlyObservableCollection<T> readOnlyObservableCollection, BindingOptions options)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        var target = new ObservableCollectionExtended<T>();
-        var result = new ReadOnlyObservableCollection<T>(target);
-        var adaptor = new ObservableCollectionAdaptor<T>(target, options);
-        readOnlyObservableCollection = result;
-        return source.Adapt(adaptor);
-    }
-
-#if SUPPORTS_BINDINGLIST
-
-    /// <summary>
-    /// Binds the source changeset stream to a WinForms <see cref="BindingList{T}"/>, keeping <paramref name="bindingList"/> in sync.
-    /// </summary>
-    /// <inheritdoc cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    public static IObservable<IChangeSet<T>> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] T>(this IObservable<IChangeSet<T>> source, BindingList<T> bindingList, int resetThreshold = BindingOptions.DefaultResetThreshold)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        bindingList.ThrowArgumentNullExceptionIfNull(nameof(bindingList));
-
-        return source.Adapt(new BindingListAdaptor<T>(bindingList, resetThreshold));
-    }
-
-#endif
-
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <para>This overload starts unpaused and has no timeout.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, IScheduler? scheduler = null)
-        where T : notnull => BufferIf(source, pauseIfTrueSelector, false, scheduler);
-
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <para>This overload allows setting the initial pause state but has no timeout.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState, IScheduler? scheduler = null)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
-
-        return BufferIf(source, pauseIfTrueSelector, initialPauseState, null, scheduler);
-    }
-
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <remarks>
-    /// <inheritdoc cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, bool, TimeSpan?, IScheduler?)"/>
-    /// <para>This overload starts unpaused and accepts a timeout but not an explicit initial pause state.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, TimeSpan? timeOut, IScheduler? scheduler = null)
-        where T : notnull => BufferIf(source, pauseIfTrueSelector, false, timeOut, scheduler);
-
-    /// <summary>
-    /// Buffers changeset notifications while a pause signal is active, then flushes all buffered changes when resumed.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to conditionally buffer.</param>
-    /// <param name="pauseIfTrueSelector">An <see cref="IObservable{bool}"/> of <see cref="bool"/> that controls buffering: <see langword="true"/> pauses (buffers), <see langword="false"/> resumes (flushes).</param>
-    /// <param name="initialPauseState">The initial pause state. When <see langword="true"/>, buffering starts immediately.</param>
-    /// <param name="timeOut">An optional <see cref="TimeSpan"/> maximum duration to keep the buffer open. After this time, the buffer is flushed regardless of pause state.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> for timeout scheduling.</param>
-    /// <returns>A list changeset stream that buffers during pause and emits combined changesets on resume.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="pauseIfTrueSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// All changeset events are buffered at the changeset level (not individual changes) while paused.
-    /// On resume, all buffered changesets are emitted as a single combined changeset. If the buffer is empty on resume,
-    /// no emission occurs.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Any (while paused)</term><description>Accumulated in an internal buffer. Not emitted downstream.</description></item>
-    /// <item><term>Any (while active)</term><description>Passed through immediately.</description></item>
-    /// <item><term>Pause selector emits false</term><description>All buffered changesets are flushed downstream as one combined changeset.</description></item>
-    /// <item><term>Timeout fires</term><description>Automatically resumes and flushes the buffer.</description></item>
-    /// <item><term>OnError</term><description>Forwarded immediately (not buffered).</description></item>
-    /// <item><term>OnCompleted</term><description>Forwarded immediately.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Each pause/resume cycle re-arms the timeout. Rapid toggling can create many small buffer windows.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> BufferIf<T>(this IObservable<IChangeSet<T>> source, IObservable<bool> pauseIfTrueSelector, bool initialPauseState, TimeSpan? timeOut, IScheduler? scheduler = null)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        pauseIfTrueSelector.ThrowArgumentNullExceptionIfNull(nameof(pauseIfTrueSelector));
-
-        return new BufferIf<T>(source, pauseIfTrueSelector, initialPauseState, timeOut, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Buffers changesets during an initial time window, then emits a single combined changeset and passes through subsequent changes.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to buffer during the initial loading period.</param>
-    /// <param name="initialBuffer">The <see cref="TimeSpan"/> time period (measured from first emission) during which changes are buffered.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> for timing the buffer window.</param>
-    /// <returns>A list changeset stream where the initial burst is combined into one changeset.</returns>
-    /// <remarks>
-    /// <para>
-    /// For a configured duration after the first emission, all changesets are buffered and combined into a single emission.
-    /// After this initial window, subsequent changesets pass through immediately.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="FlattenBufferResult{T}(IObservable{IList{IChangeSet{T}}})"/>
-    public static IObservable<IChangeSet<TObject>> BufferInitial<TObject>(this IObservable<IChangeSet<TObject>> source, TimeSpan initialBuffer, IScheduler? scheduler = null)
-        where TObject : notnull => source.DeferUntilLoaded().Publish(
-            shared =>
-            {
-                var initial = shared.Buffer(initialBuffer, scheduler ?? GlobalConfig.DefaultScheduler).FlattenBufferResult().Take(1);
-
-                return initial.Concat(shared);
-            });
-
-    /// <summary>
-    /// Casts each item in the changeset from <c>object</c> to <typeparamref name="TDestination"/> using a direct cast.
-    /// </summary>
-    /// <typeparam name="TDestination">The target type to cast to.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{object}}"/> of <c>object</c> items.</param>
-    /// <returns>A list changeset stream of cast items.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Cast{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination})"/>
-    /// <seealso cref="CastToObject{T}(IObservable{IChangeSet{T}})"/>
-    public static IObservable<IChangeSet<TDestination>> Cast<TDestination>(this IObservable<IChangeSet<object>> source)
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Select(changes => changes.Transform(t => (TDestination)t));
-    }
-
-    /// <summary>
-    /// Transforms each item in the changeset using a conversion function.
-    /// </summary>
-    /// <typeparam name="TSource">The source item type.</typeparam>
-    /// <typeparam name="TDestination">The destination item type.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to cast.</param>
-    /// <param name="conversionFactory">A <see cref="Func{T, TResult}"/> function to convert each item from <typeparamref name="TSource"/> to <typeparamref name="TDestination"/>.</param>
-    /// <returns>A list changeset stream of converted items.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="conversionFactory"/> is <see langword="null"/>.</exception>
-    /// <remarks>Use this overload when type inference requires explicit specification of both source and destination types. Alternatively, call <see cref="CastToObject{T}"/> first, then the single-type-parameter <see cref="Cast{TDestination}"/> overload.</remarks>
-    /// <seealso cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/>
-    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    public static IObservable<IChangeSet<TDestination>> Cast<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, TDestination> conversionFactory)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
-
-        return source.Select(changes => changes.Transform(conversionFactory));
-    }
-
-    /// <summary>
-    /// Casts each item in the changeset to <c>object</c>. Typically used before <see cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/> to work around type inference limitations.
-    /// </summary>
-    /// <typeparam name="T">The source item type (must be a reference type).</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to cast to object.</param>
-    /// <returns>A list changeset stream of <c>object</c> items.</returns>
-    /// <seealso cref="Cast{TDestination}(IObservable{IChangeSet{object}})"/>
-    public static IObservable<IChangeSet<object>> CastToObject<T>(this IObservable<IChangeSet<T>> source)
-        where T : class => source.Select(changes => changes.Transform(t => (object)t));
-
-    /// <summary>
-    /// Applies each changeset to the target list as a side effect, keeping it synchronized with the source.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to clone.</param>
-    /// <param name="target">The <see cref="IList{T}"/> target list to clone changes into.</param>
-    /// <returns>A continuation of the source changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Lower-level than <see cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>. Uses <see cref="IList{T}"/>.Clone() to apply all changeset operations directly.</para>
-    /// </remarks>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, int)"/>
-    /// <seealso cref="PopulateInto{T}(IObservable{IChangeSet{T}}, ISourceList{T})"/>
-    public static IObservable<IChangeSet<T>> Clone<T>(this IObservable<IChangeSet<T>> source, IList<T> target)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Do(target.Clone);
-    }
-
-    /// <summary>
-    /// <para>Convert the object using the specified conversion function.</para>
-    /// <para>This is a lighter equivalent of Transform and is designed to be used with non-disposable objects.</para>
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to convert.</param>
-    /// <param name="conversionFactory">The <see cref="Func{T, TResult}"/> conversion factory.</param>
-    /// <returns>An observable which emits the change set.</returns>
-    [Obsolete("Prefer Cast as it is does the same thing but is semantically correct")]
-    public static IObservable<IChangeSet<TDestination>> Convert<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TDestination> conversionFactory)
-        where TObject : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        conversionFactory.ThrowArgumentNullExceptionIfNull(nameof(conversionFactory));
-
-        return source.Select(changes => changes.Transform(conversionFactory));
-    }
-
-    /// <summary>
-    /// Defers downstream delivery until the source emits its first changeset, then forwards all subsequent changesets.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to defer until the first changeset arrives.</param>
-    /// <returns>A list changeset stream that begins emitting only after the source has produced its first changeset.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Subscribes to the source immediately but buffers internally until the first changeset arrives, at which point it emits
-    /// the initial data and all subsequent changesets. This is useful when downstream consumers should not receive an empty initial state.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="SkipInitial{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
-    public static IObservable<IChangeSet<T>> DeferUntilLoaded<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DeferUntilLoaded<T>(source).Run();
-    }
-
-    /// <inheritdoc cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
-    /// <remarks>
-    /// <inheritdoc cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
-    /// <para>Convenience overload that calls <c>source.Connect().DeferUntilLoaded()</c>.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> DeferUntilLoaded<T>(this IObservableList<T> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Connect().DeferUntilLoaded();
-    }
-
-    /// <summary>
-    /// Disposes items that implement <see cref="IDisposable"/> when they are removed, replaced, or cleared from the stream.
-    /// All remaining tracked items are disposed when the stream finalizes (OnCompleted, OnError, or subscription disposal).
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to track for disposal on removal.</param>
-    /// <returns>A continuation of the source changeset stream with disposal side effects applied.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Items are cast to <see cref="IDisposable"/> and disposed after the changeset has been forwarded downstream.
-    /// Items that do not implement <see cref="IDisposable"/> are silently ignored.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Items are tracked for future disposal. Changeset forwarded.</description></item>
-    /// <item><term><b>Replace</b></term><description>The previous (replaced) item is disposed after the changeset is forwarded. The new item is tracked.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>Removed items are disposed after the changeset is forwarded.</description></item>
-    /// <item><term><b>Clear</b></term><description>All tracked items are disposed after the changeset is forwarded.</description></item>
-    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Forwarded. No disposal occurs.</description></item>
-    /// <item><term>OnError/OnCompleted/Disposal</term><description>All remaining tracked items are disposed during finalization.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Disposal happens after the changeset is delivered downstream, so subscribers see the change before items are disposed.</para>
-    /// </remarks>
-    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
-    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
-    /// <seealso cref="ObservableCacheEx.DisposeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<T>> DisposeMany<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new DisposeMany<T>(source).Run();
-    }
-
-    /// <summary>
-    /// Extracts distinct values from source items using <paramref name="valueSelector"/>, with reference counting to track when values enter and leave the result set.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
-    /// <typeparam name="TValue">The type of distinct values produced.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to extract distinct values.</param>
-    /// <param name="valueSelector">A <see cref="Func{T, TResult}"/> function that extracts the value to track from each source item.</param>
-    /// <returns>A list changeset stream of distinct values.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="valueSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Maintains an internal reference count per distinct value. A value is included when its count first exceeds zero
-    /// and removed when its count drops back to zero.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Value extracted. If first occurrence, an <b>Add</b> is emitted. Otherwise the reference count is incremented silently.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old value's reference count decremented (removed if zero), new value's count incremented (added if first). If the value did not change, no emission.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>Reference count decremented. If the count reaches zero, a <b>Remove</b> is emitted for that distinct value.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Value is re-extracted. If changed, old value decremented and new value incremented (same as Replace logic).</description></item>
-    /// <item><term><b>Clear</b></term><description>All reference counts cleared. <b>Remove</b> emitted for every tracked distinct value.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="ObservableCacheEx.DistinctValues{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, TValue})"/>
-    public static IObservable<IChangeSet<TValue>> DistinctValues<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TValue> valueSelector)
-        where TObject : notnull
-        where TValue : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        valueSelector.ThrowArgumentNullExceptionIfNull(nameof(valueSelector));
-
-        return new Distinct<TObject, TValue>(source, valueSelector).Run();
-    }
-
-    /// <summary>
-    /// Applies a logical set-difference (Except) between the source and other streams.
-    /// Items present in the first source but not in any of the <paramref name="others"/> are included in the result.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The primary <see cref="IObservable{IChangeSet{T}}"/> from which other streams are subtracted.</param>
-    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to exclude from the result.</param>
-    /// <returns>A list changeset stream containing items from <paramref name="source"/> that are not in any of <paramref name="others"/>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Across all sources, items are tracked
-    /// by reference-counted equality (not by index position).
-    /// The first source has a special role: only items from it can appear in the result, and only if they do not exist in any other source.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b> (first source)</term><description>If the item does not exist in any other source, an <b>Add</b> is emitted.</description></item>
-    /// <item><term><b>Add</b>/<b>AddRange</b> (other source)</term><description>If the item was in the result (from first source), a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (first source)</term><description>If the item was in the result, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (other source)</term><description>If the item exists in the first source and no longer in any other, an <b>Add</b> is emitted.</description></item>
-    /// <item><term><b>Replace</b></term><description>Treated as a Remove of the old item plus an Add of the new item, with set logic re-evaluated.</description></item>
-    /// <item><term><b>Moved</b></term><description>Ignored by the set logic (no positional semantics).</description></item>
-    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is currently in the result set.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Unlike <see cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>, the first source is asymmetric: only its items can appear in the result.</para>
-    /// </remarks>
-    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="ObservableCacheEx.Except{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    public static IObservable<IChangeSet<T>> Except<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
-        where T : notnull
-    {
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.Combine(CombineOperator.Except, others);
-    }
-
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <remarks>
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>Static overload accepting a pre-built collection of sources. The first item in the collection is the primary source.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Except<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Except);
-
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <remarks>
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>Dynamic overload: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime. The first source in the list acts as the primary.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Except);
-
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <remarks>
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>Dynamic overload accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<IObservableList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Except);
-
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <remarks>
-    /// <inheritdoc cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <para>Dynamic overload accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.</para>
-    /// </remarks>
-    public static IObservable<IChangeSet<T>> Except<T>(this IObservableList<ISourceList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Except);
-
-    /// <summary>
-    /// Automatically removes items from the <paramref name="source"/> list after the duration returned by <paramref name="timeSelector"/>.
-    /// Returns an observable of the items that were expired and removed.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The <see cref="ISourceList{T}"/> source list to apply time-based expiration to.</param>
-    /// <param name="timeSelector">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for items that should never expire.</param>
-    /// <param name="pollingInterval">An optional <see cref="TimeSpan"/> polling interval to batch expiry checks. If omitted, a separate timer is created for each unique expiry time.</param>
-    /// <param name="scheduler">The scheduler for scheduling expiry timers. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>An observable that emits collections of items each time expired items are removed from the source list.</returns>
-    /// <remarks>
-    /// <para>
-    /// This operator acts directly on an <see cref="ISourceList{T}"/>, not on a changeset stream. It monitors items as they are added,
-    /// schedules their removal, and physically removes them from the source list when their time expires.
-    /// </para>
-    /// <para>
-    /// When <paramref name="pollingInterval"/> is specified, all items due for removal are batched into a single removal at each polling tick,
-    /// which can improve performance when many items expire around the same time.
-    /// </para>
-    /// <para><b>Worth noting:</b> The returned observable emits the expired items (not changesets). Subscribe to this observable to trigger the expiry mechanism; if not subscribed, no items will be removed.</para>
-    /// </remarks>
-    /// <seealso cref="LimitSizeTo{T}(ISourceList{T}, int, IScheduler?)"/>
-    /// <seealso cref="ToObservableChangeSet{T}(IObservable{T}, Func{T, TimeSpan?}, IScheduler?)"/>
-    public static IObservable<IEnumerable<T>> ExpireAfter<T>(
-                this ISourceList<T> source,
-                Func<T, TimeSpan?> timeSelector,
-                TimeSpan? pollingInterval = null,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ExpireAfter<T>.Create(
-            source: source,
-            timeSelector: timeSelector,
-            pollingInterval: pollingInterval,
-            scheduler: scheduler);
-
-    /// <summary>
-    /// Filters items from the source list changeset stream using a static predicate.
-    /// Only items satisfying <paramref name="predicate"/> are included downstream.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
-    /// <param name="predicate">A <see cref="Func{T, TResult}"/> predicate that determines which items are included. Items returning <see langword="true"/> appear downstream; items returning <see langword="false"/> are excluded.</param>
-    /// <returns>A list changeset stream containing only items that satisfy <paramref name="predicate"/>.</returns>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Use this overload when you need only a single predicate function for the lifetime of the subscription;
-    /// unlike the dynamic-predicate and state-driven overloads, the predicate function itself never changes.
-    /// Note that this does not mean an item's inclusion is fixed: Refresh events can re-evaluate each item against the predicate
-    /// and promote a previously-excluded item to included (or vice versa).
-    /// Item ordering is preserved.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The predicate is evaluated. If the item passes, an <b>Add</b> is emitted at the calculated downstream index. Otherwise dropped.</description></item>
-    /// <item><term>AddRange</term><description>Each item in the range is evaluated. Matching items are emitted as an <b>AddRange</b>.</description></item>
-    /// <item><term>Replace</term><description>The predicate is re-evaluated. Four outcomes: both pass produces <b>Replace</b>; new passes but old didn't produces <b>Add</b>; old passed but new doesn't produces <b>Remove</b>; neither passes is dropped.</description></item>
-    /// <item><term>Remove</term><description>If the item was included downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>RemoveRange</term><description>Included items in the range are emitted as individual <b>Remove</b> changes.</description></item>
-    /// <item><term>Refresh</term><description>The predicate is re-evaluated. If the item now passes but previously did not, an <b>Add</b> is emitted. If it previously passed but no longer does, a <b>Remove</b> is emitted. If still passes, the <b>Refresh</b> is forwarded. If still fails, dropped.</description></item>
-    /// <item><term>Clear</term><description>All downstream items are cleared.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> Refresh events trigger re-evaluation, which can promote or demote items (turning a Refresh into an Add or Remove). Pair with <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/> for property-change-driven filtering.</para>
-    /// </remarks>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
-    /// <seealso cref="FilterOnObservable{TObject}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableCacheEx.Filter{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, bool}, bool)"/>
-    public static IObservable<IChangeSet<T>> Filter<T>(
-                this IObservable<IChangeSet<T>> source,
-                Func<T, bool> predicate)
-            where T : notnull
-        => List.Internal.Filter.Static<T>.Create(
-            source: source,
-            predicate: predicate,
-            suppressEmptyChangesets: true);
-
-    /// <summary>
-    /// Filters items using a dynamically changing predicate.
-    /// When <paramref name="predicate"/> emits a new function, all items are re-evaluated.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
-    /// <param name="predicate">An <see cref="IObservable{Func{T, bool}}"/> that emits new predicate functions. Each emission triggers a full re-evaluation of all items.</param>
-    /// <param name="filterPolicy">The <see cref="ListFilterPolicy"/> that controls re-filtering behavior when the predicate changes.</param>
-    /// <returns>A list changeset stream containing only items that satisfy the most recent predicate.</returns>
-    /// <remarks>
-    /// <para>
-    /// Each time <paramref name="predicate"/> emits, every item is re-evaluated against the new predicate.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The current predicate is evaluated. If the item passes, an <b>Add</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>AddRange</term><description>Each item is evaluated. Matching items are emitted as <b>AddRange</b>.</description></item>
-    /// <item><term>Replace</term><description>Re-evaluated. Same four-outcome logic as the static overload (Replace, Add, Remove, or dropped).</description></item>
-    /// <item><term>Remove</term><description>If the item was downstream, a <b>Remove</b> is emitted. Otherwise dropped.</description></item>
-    /// <item><term>Refresh</term><description>Re-evaluated. If inclusion status changed, an <b>Add</b> or <b>Remove</b> is emitted. If unchanged, <b>Refresh</b> forwarded or dropped.</description></item>
-    /// <item><term>Clear</term><description>All downstream items are cleared.</description></item>
-    /// <item><term>Predicate changed</term><description>All items are re-evaluated against the new predicate. The output is shaped by <paramref name="filterPolicy"/>.</description></item>
-    /// <item><term>OnCompleted</term><description>Independent completion of <paramref name="predicate"/> does not terminate the filter.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> No items are included until <paramref name="predicate"/> emits its first function.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
-    /// <seealso cref="FilterOnObservable{TObject}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<T>> Filter<T>(this IObservable<IChangeSet<T>> source, IObservable<Func<T, bool>> predicate, ListFilterPolicy filterPolicy = ListFilterPolicy.CalculateDiff)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
-
-        return new List.Internal.Filter.Dynamic<T>(source, predicate, filterPolicy).Run();
-    }
-
-    /// <summary>
-    /// Filters items using a predicate that receives external state. When <paramref name="predicateState"/> emits a new state value,
-    /// all items are re-evaluated against <paramref name="predicate"/> using the updated state.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <typeparam name="TState">The type of state value required by <paramref name="predicate"/>.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter.</param>
-    /// <param name="predicateState">An <see cref="IObservable{TState}"/> stream of state values to be passed to <paramref name="predicate"/>.</param>
-    /// <param name="predicate">A static <see cref="Func{T, TResult}"/> predicate receiving the current state and an item, returning <see langword="true"/> to include or <see langword="false"/> to exclude. The function itself does not change; only the state value passed to it changes.</param>
-    /// <param name="filterPolicy">The <see cref="ListFilterPolicy"/> that controls re-filtering behavior when the state changes.</param>
-    /// <param name="suppressEmptyChangeSets">When <see langword="true"/> (default), empty changesets are suppressed. Set to <see langword="false"/> to publish empty changesets (useful for monitoring loading status).</param>
-    /// <returns>A list changeset stream containing only items satisfying <paramref name="predicate"/> with the current state.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="predicateState"/>, or <paramref name="predicate"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// The predicate cannot be invoked until the first state value is received. Until then, all items are treated as excluded.
-    /// Each subsequent state emission triggers a full re-evaluation of all items according to <paramref name="filterPolicy"/>.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Evaluated using current state. Matching items emitted as <b>Add</b>/<b>AddRange</b>.</description></item>
-    /// <item><term><b>Replace</b></term><description>Re-evaluated. Same four-outcome logic as the static filter (Replace, Add, Remove, or dropped).</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b></term><description>If the item was downstream, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Re-evaluated against current state. Inclusion status may change.</description></item>
-    /// <item><term><b>Clear</b></term><description>All downstream items are cleared.</description></item>
-    /// <item><term>State changed</term><description>All items are re-evaluated with the new state value. The output is shaped by <paramref name="filterPolicy"/>.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
-    public static IObservable<IChangeSet<T>> Filter<T, TState>(
-                this IObservable<IChangeSet<T>> source,
-                IObservable<TState> predicateState,
-                Func<TState, T, bool> predicate,
-                ListFilterPolicy filterPolicy = ListFilterPolicy.CalculateDiff,
-                bool suppressEmptyChangeSets = true)
-            where T : notnull
-        => List.Internal.Filter.WithPredicateState<T, TState>.Create(
-            source: source,
-            predicateState: predicateState,
-            predicate: predicate,
-            filterPolicy: filterPolicy,
-            suppressEmptyChangeSets: suppressEmptyChangeSets);
-
-    /// <summary>
-    /// Filters each item using a per-item <see cref="IObservable{T}"/> of <see cref="bool"/> that dynamically controls inclusion.
-    /// When an item's observable emits <see langword="true"/> the item enters the result; when it emits <see langword="false"/> the item is removed.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to filter by property value.</param>
-    /// <param name="objectFilterObservable">A function that returns an observable of <see cref="bool"/> for each item, controlling its inclusion.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration applied to each per-item observable to reduce re-evaluation frequency.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling. Defaults to the system default scheduler.</param>
-    /// <returns>A list changeset stream containing only items whose per-item observable most recently emitted <see langword="true"/>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="objectFilterObservable"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Each item in the source gets its own subscription to the observable returned by <paramref name="objectFilterObservable"/>.
-    /// The item's inclusion is determined by the most recent boolean value emitted by that observable.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the per-item observable. Item is included when it first emits <see langword="true"/>.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old subscription disposed, new subscription created for the replacement item.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscription disposed. If the item was downstream, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is currently included.</description></item>
-    /// </list>
-    /// <list type="table">
-    /// <listheader><term>Event (per-item observable)</term><description>Behavior</description></listheader>
-    /// <item><term>Emits <see langword="true"/></term><description>If not already included, an <b>Add</b> is emitted downstream.</description></item>
-    /// <item><term>Emits <see langword="false"/></term><description>If currently included, a <b>Remove</b> is emitted downstream.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, IObservable{Func{T, bool}}, ListFilterPolicy)"/>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableCacheEx.FilterOnObservable{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{bool}}, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<TObject>> FilterOnObservable<TObject>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<bool>> objectFilterObservable, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new FilterOnObservable<TObject>(source, objectFilterObservable, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Filters items based on a property value, automatically re-evaluating when the specified property changes on any item.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <typeparam name="TProperty">The type of the property.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to filter by property value.</param>
-    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property to monitor for changes.</param>
-    /// <param name="predicate">A <see cref="Func{T, TResult}"/> predicate evaluated against the item to determine inclusion.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
-    /// <returns>A list changeset stream of items satisfying the predicate, re-evaluated on property changes.</returns>
-    /// <remarks>
-    /// <para>Deprecated. Use <see cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/> followed by <see cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/> instead.</para>
-    /// </remarks>
-    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="Filter{T}(IObservable{IChangeSet{T}}, Func{T, bool})"/>
-    [Obsolete("Use AutoRefresh(), followed by Filter() instead")]
-    public static IObservable<IChangeSet<TObject>> FilterOnProperty<TObject, TProperty>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TProperty>> propertySelector, Func<TObject, bool> predicate, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
-
-        predicate.ThrowArgumentNullExceptionIfNull(nameof(predicate));
-
-        return new FilterOnProperty<TObject, TProperty>(source, propertySelector, predicate, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Flattens buffered changesets (e.g. from <see cref="System.Reactive.Linq.Observable.Buffer{TSource}(IObservable{TSource}, TimeSpan)"/>) back into single changesets.
-    /// Empty buffers are dropped.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The <see cref="IObservable{T}"/> of buffered changeset lists.</param>
-    /// <returns>A list changeset stream with all buffered changes concatenated into single changesets.</returns>
-    /// <remarks>
-    /// <para>Use this after applying <c>Observable.Buffer()</c> to a changeset stream to re-merge the batched changesets into a single stream.</para>
-    /// </remarks>
-    /// <seealso cref="BufferIf{T}(IObservable{IChangeSet{T}}, IObservable{bool}, IScheduler?)"/>
-    /// <seealso cref="BufferInitial{T}(IObservable{IChangeSet{T}}, TimeSpan, IScheduler?)"/>
-    public static IObservable<IChangeSet<T>> FlattenBufferResult<T>(this IObservable<IList<IChangeSet<T>>> source)
-        where T : notnull => source.Where(x => x.Count != 0).Select(updates => new ChangeSet<T>(updates.SelectMany(u => u)));
-
-    /// <summary>
-    /// Invokes <paramref name="action"/> once for every <see cref="Change{T}"/> in each changeset. Range changes
-    /// (AddRange, RemoveRange, Clear) are delivered as a single <see cref="Change{T}"/>; they are not flattened into per-item changes.
-    /// The changeset is forwarded downstream unchanged.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe each change in.</param>
-    /// <param name="action">The action invoked for each <see cref="Change{T}"/>.</param>
-    /// <returns>A continuation of the source changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>This is a side-effect operator. It does not modify the changeset. If you need each individual item from range operations flattened out, use <see cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/> instead.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/Replace/Remove/Moved/Refresh</term><description>Callback invoked with the <see cref="Change{T}"/> (single-item change). Changeset forwarded.</description></item>
-    /// <item><term>AddRange/RemoveRange/Clear</term><description>Callback invoked once with the <see cref="Change{T}"/> containing the range (accessible via <c>Range</c> property). Changeset forwarded.</description></item>
-    /// <item><term>OnError</term><description>If the callback throws, the exception propagates as OnError.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/>
-    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
-    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
-    /// <seealso cref="ObservableCacheEx.ForEachChange{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{Change{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<TObject>> ForEachChange<TObject>(this IObservable<IChangeSet<TObject>> source, Action<Change<TObject>> action)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        action.ThrowArgumentNullExceptionIfNull(nameof(action));
-
-        return source.Do(changes => changes.ForEach(action));
-    }
-
-    /// <summary>
-    /// Invokes <paramref name="action"/> for every individual <see cref="ItemChange{TObject}"/> in each changeset.
-    /// Range changes are flattened into individual item changes first, so the callback only receives Add, Replace, Remove, and Refresh.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe each item-level change in.</param>
-    /// <param name="action">The <see cref="Action{ItemChange{TObject}}"/> action invoked for each individual item change.</param>
-    /// <returns>A continuation of the source changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Unlike <see cref="ForEachChange{TObject}(IObservable{IChangeSet{TObject}}, Action{Change{TObject}})"/>, this operator flattens
-    /// <b>AddRange</b>, <b>RemoveRange</b>, and <b>Clear</b> into individual <see cref="ItemChange{TObject}"/> entries before invoking the callback.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="ForEachChange{TObject}(IObservable{IChangeSet{TObject}}, Action{Change{TObject}})"/>
-    public static IObservable<IChangeSet<TObject>> ForEachItemChange<TObject>(this IObservable<IChangeSet<TObject>> source, Action<ItemChange<TObject>> action)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        action.ThrowArgumentNullExceptionIfNull(nameof(action));
-
-        return source.Do(changes => changes.Flatten().ForEach(action));
-    }
-
-    /// <summary>
-    /// Groups source items by the value returned by <paramref name="groupSelector"/>. Each group is an <see cref="IGroup{TObject, TGroup}"/>
-    /// containing an inner observable list of its members.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TGroup">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group.</param>
-    /// <param name="groupSelector">A <see cref="Func{T, TResult}"/> function that returns the group key for each item.</param>
-    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces all items to be re-evaluated against <paramref name="groupSelector"/> when it fires. Useful for time-based groupings (e.g., "Last Hour", "Today").</param>
-    /// <returns>A list changeset stream of <see cref="IGroup{TObject, TGroup}"/> objects, each containing the items belonging to that group.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="groupSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Groups are created lazily and removed when empty. Each group exposes an inner observable list that receives incremental updates.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Group key evaluated. Item added to its group. If the group is new, an <b>Add</b> of the group is emitted.</description></item>
-    /// <item><term><b>Replace</b></term><description>Group key re-evaluated. If the group changed, the item is removed from the old group and added to the new one. Empty old groups are removed.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Item removed from its group. Empty groups are removed from the result.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Group key re-evaluated. If changed, the item moves between groups.</description></item>
-    /// <item><term><b>Moved</b></term><description>Not handled by group logic.</description></item>
-    /// <item><term>Regrouper fires</term><description>All items re-evaluated. Items that changed group key are moved between groups. Empty groups removed, new groups added.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>
-    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    public static IObservable<IChangeSet<IGroup<TObject, TGroup>>> GroupOn<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TGroup> groupSelector, IObservable<Unit>? regrouper = null)
-        where TObject : notnull
-        where TGroup : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        groupSelector.ThrowArgumentNullExceptionIfNull(nameof(groupSelector));
-
-        return new GroupOn<TObject, TGroup>(source, groupSelector, regrouper).Run();
-    }
-
-    /// <summary>
-    /// Groups items by a property value, automatically re-grouping when the specified property changes on any item.
-    /// Each group contains an inner observable list.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <typeparam name="TGroup">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group by property value.</param>
-    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property whose value determines the group key.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
-    /// <returns>A list changeset stream of <see cref="IGroup{TObject, TGroup}"/> objects.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertySelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Convenience operator equivalent to <c>.AutoRefresh(propertySelector).GroupOn(item => property)</c>.
-    /// Property changes trigger re-evaluation of the group key, potentially moving items between groups.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
-    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<IGroup<TObject, TGroup>>> GroupOnProperty<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TGroup>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TGroup : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
-
-        return new GroupOnProperty<TObject, TGroup>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Groups items by a property value, automatically re-grouping when the specified property changes.
-    /// Each group emits immutable snapshots (not live observable lists).
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <typeparam name="TGroup">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group by property value with immutable snapshots.</param>
-    /// <param name="propertySelector"><see cref="Expression{TDelegate}"/> selecting the property whose value determines the group key.</param>
-    /// <param name="propertyChangedThrottle">An optional <see cref="TimeSpan"/> throttle duration for property change notifications.</param>
-    /// <param name="scheduler">The <see cref="IScheduler"/> used when throttling.</param>
-    /// <returns>A list changeset stream of <see cref="List.IGrouping{TObject, TGroup}"/> immutable group snapshots.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertySelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Combines <see cref="AutoRefresh{TObject, TProperty}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TProperty}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// with <see cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>.
-    /// Unlike <see cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>,
-    /// this produces immutable snapshots per group rather than live inner observable lists.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="GroupOnProperty{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="GroupWithImmutableState{TObject, TGroupKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroupKey}, IObservable{Unit}?)"/>
-    public static IObservable<IChangeSet<List.IGrouping<TObject, TGroup>>> GroupOnPropertyWithImmutableState<TObject, TGroup>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TGroup>> propertySelector, TimeSpan? propertyChangedThrottle = null, IScheduler? scheduler = null)
-        where TObject : INotifyPropertyChanged
-        where TGroup : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        propertySelector.ThrowArgumentNullExceptionIfNull(nameof(propertySelector));
-
-        return new GroupOnPropertyWithImmutableState<TObject, TGroup>(source, propertySelector, propertyChangedThrottle, scheduler).Run();
-    }
-
-    /// <summary>
-    /// Groups source items by the value returned by <paramref name="groupSelectorKey"/>. Each update produces immutable grouping snapshots
-    /// rather than live inner observable lists.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TGroupKey">The type of the group key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to group with immutable snapshots.</param>
-    /// <param name="groupSelectorKey">A <see cref="Func{T, TResult}"/> function that returns the group key for each item.</param>
-    /// <param name="regrouper">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces all items to be re-evaluated when it fires.</param>
-    /// <returns>A list changeset stream of <see cref="List.IGrouping{TObject, TGroupKey}"/> immutable snapshots.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="groupSelectorKey"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Works like <see cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
-    /// but each affected group emits a new immutable snapshot on every change rather than updating a live inner list.
-    /// This is useful when consumers need thread-safe, point-in-time snapshots of each group.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="GroupOn{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Func{TObject, TGroup}, IObservable{Unit}?)"/>
-    /// <seealso cref="GroupOnPropertyWithImmutableState{TObject, TGroup}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TGroup}}, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<List.IGrouping<TObject, TGroupKey>>> GroupWithImmutableState<TObject, TGroupKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TGroupKey> groupSelectorKey, IObservable<Unit>? regrouper = null)
-        where TObject : notnull
-        where TGroupKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        groupSelectorKey.ThrowArgumentNullExceptionIfNull(nameof(groupSelectorKey));
-
-        return new GroupOnImmutable<TObject, TGroupKey>(source, groupSelectorKey, regrouper).Run();
-    }
-
-    /// <summary>
-    /// Limits the source list to a maximum number of items using FIFO eviction.
-    /// When the list exceeds <paramref name="sizeLimit"/>, the oldest items are removed.
-    /// Returns an observable of the items that were removed.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The <see cref="ISourceList{T}"/> source list to apply size limits to.</param>
-    /// <param name="sizeLimit">The maximum number of items allowed. Must be greater than zero.</param>
-    /// <param name="scheduler">The scheduler for scheduling size checks. Defaults to <see cref="GlobalConfig.DefaultScheduler"/>.</param>
-    /// <returns>An observable that emits collections of items each time excess items are removed from the source list.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="sizeLimit"/> is zero or negative.</exception>
-    /// <remarks>
-    /// <para>
-    /// This operator acts directly on an <see cref="ISourceList{T}"/>. It subscribes to the source's changes,
-    /// tracks insertion order using an internal Transform, and removes the oldest items when the size limit is exceeded.
-    /// </para>
-    /// <para><b>Worth noting:</b> The returned observable emits the removed items (not changesets). Subscribe to this observable to activate the size-limiting mechanism. Removal is performed synchronously under a lock shared with the change tracking.</para>
-    /// </remarks>
-    /// <seealso cref="ExpireAfter{T}(ISourceList{T}, Func{T, TimeSpan?}, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
-    public static IObservable<IEnumerable<T>> LimitSizeTo<T>(this ISourceList<T> source, int sizeLimit, IScheduler? scheduler = null)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (sizeLimit <= 0)
-        {
-            throw new ArgumentException("sizeLimit cannot be zero", nameof(sizeLimit));
-        }
-
-        var locker = InternalEx.NewLock();
-        var limiter = new LimitSizeTo<T>(source, sizeLimit, scheduler ?? GlobalConfig.DefaultScheduler, locker);
-
-        return limiter.Run().Synchronize(locker).Do(source.RemoveMany);
-    }
-
-    /// <summary>
-    /// Subscribes to a per-item observable for each item in the source and merges all emissions into a single <see cref="IObservable{TDestination}"/> stream.
-    /// This is NOT a changeset operator: it returns a flat observable of values.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the source list.</typeparam>
-    /// <typeparam name="TDestination">The type of values emitted by per-item observables.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> whose items each produce an observable.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns an observable for each source item.</param>
-    /// <returns>An observable that emits values from all per-item observables, merged together.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event (source)</term><description>Subscription behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the per-item observable. Emissions are merged into the output.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old subscription disposed, new subscription created for the replacement item.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscription disposed.</description></item>
-    /// <item><term><b>Refresh</b>/<b>Moved</b></term><description>No effect on subscriptions.</description></item>
-    /// <item><term>OnCompleted (source)</term><description>Completes only after the source and all active inner observables have completed.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
-    /// <seealso cref="ObservableCacheEx.MergeMany{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{TDestination}})"/>
-    public static IObservable<TDestination> MergeMany<T, TDestination>(this IObservable<IChangeSet<T>> source, Func<T, IObservable<TDestination>> observableSelector)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeMany<T, TDestination>(source, observableSelector).Run();
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
-    /// <summary>
-    /// Merges multiple list changeset streams from an observable-of-observables into a single unified changeset stream.
-    /// Unlike <see cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>, list merging performs no key-based deduplication.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> of nested changeset observables.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used by the merge tracker to compare items.</param>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new MergeChangeSets<TObject>(source, equalityComparer).Run();
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
-    /// <summary>
-    /// Merges two list changeset streams into a single unified stream.
-    /// </summary>
-    /// <param name="source">The first <see cref="IObservable{IChangeSet{TObject}}"/> to merge.</param>
-    /// <param name="other">The second <see cref="IObservable{IChangeSet{TObject}}"/> to merge with.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used to compare items.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
-    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<TObject>> source, IObservable<IChangeSet<TObject>> other, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        other.ThrowArgumentNullExceptionIfNull(nameof(other));
-
-        return new[] { source, other }.MergeChangeSets(equalityComparer, scheduler, completable);
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
-    /// <summary>
-    /// Merges the source list changeset stream with additional changeset streams into a single unified stream.
-    /// </summary>
-    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{TObject}}"/> to merge.</param>
-    /// <param name="others">The additional <see cref="IEnumerable{T}"/> of list changeset streams to merge with.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used to compare items.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
-    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<TObject>> source, IEnumerable<IObservable<IChangeSet<TObject>>> others, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.EnumerateOne().Concat(others).MergeChangeSets(equalityComparer, scheduler, completable);
-    }
-
-    /// <summary>
-    /// Merges a collection of list changeset streams into a single unified changeset stream.
-    /// This is the canonical list MergeChangeSets overload: other overloads accepting <see cref="IObservable{T}"/>, <see cref="IObservableList{T}"/>, or pair/params variants ultimately produce equivalent behavior.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The <see cref="IEnumerable{T}"/> collection of list changeset streams to merge.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> used by the merge tracker to compare items. Defaults to <see cref="EqualityComparer{T}.Default"/> when <see langword="null"/>.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling enumeration.</param>
-    /// <param name="completable">When <see langword="true"/> (default), the result completes when all sources complete.</param>
-    /// <returns>A single list changeset stream containing all changes from all sources.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// All changes from inner streams are forwarded to the output. There is no key-based deduplication (unlike <see cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>): if the same item appears in multiple inner streams, it will appear multiple times in the merged output.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Forwarded to the merged output.</description></item>
-    /// <item><term><b>Replace</b></term><description>The old value is replaced by the new value in the merged output. If the old value is not found (by <paramref name="equalityComparer"/>), the new value is added instead.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Forwarded to the merged output.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Forwarded to the merged output.</description></item>
-    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="ObservableCacheEx.MergeChangeSets{TObject, TKey}(IObservable{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject})"/>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IEnumerable<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null, IScheduler? scheduler = null, bool completable = true)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new MergeChangeSets<TObject>(source, equalityComparer, completable, scheduler).Run();
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
-    /// <summary>
-    /// Merges list changeset streams from an <see cref="IObservableList{T}"/> into a single stream. Sources can be added or removed dynamically.
-    /// </summary>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservableList<IObservable<IChangeSet<TObject>>> source, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Connect().MergeChangeSets(equalityComparer);
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject}(IObservable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?)"/>
-    /// <summary>
-    /// Merges list changeset streams from a list-of-list-changeset-observables into a single stream.
-    /// Each inner list changeset observable in the source list is merged, and parent item removal triggers child cleanup.
-    /// </summary>
-    public static IObservable<IChangeSet<TObject>> MergeChangeSets<TObject>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject>>>> source, IEqualityComparer<TObject>? equalityComparer = null)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.MergeManyChangeSets(static src => src, equalityComparer);
-    }
-
-    /// <summary>
-    /// Merges cache changeset streams from an <see cref="IObservableList{T}"/> into a single cache changeset stream.
-    /// Uses <paramref name="comparer"/> to resolve conflicts when the same key appears in multiple child streams.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TKey">The type of the object key.</typeparam>
-    /// <param name="source">The <see cref="IObservableList{T}"/> of cache changeset observables.</param>
-    /// <param name="comparer"><see cref="IComparer{TObject}"/> to resolve which value wins when the same key appears in multiple sources.</param>
-    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Sources can be added or removed dynamically from the observable list. Parent item removal triggers cleanup of all child items from that source.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b> (child)</term><description>If the destination key is new, an <b>Add</b> is emitted. If another source already contributed a child with the same key, <paramref name="comparer"/> resolves the conflict (lowest-ordered value wins). The losing value is tracked internally but not emitted.</description></item>
-    /// <item><term><b>Update</b> (child)</term><description>If this source currently owns the destination key downstream, an <b>Update</b> is emitted. Otherwise <paramref name="comparer"/> re-evaluates all sources; a different source's value may win, producing an <b>Update</b> to that value instead.</description></item>
-    /// <item><term><b>Remove</b> (child)</term><description>If this source's value was the one published downstream for that destination key, the operator scans other sources for the same key. If found, an <b>Update</b> is emitted with the replacement (per <paramref name="comparer"/>). Otherwise a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Refresh</b> (child)</term><description>If the child item is the one currently published downstream, the <b>Refresh</b> is forwarded. Otherwise <paramref name="comparer"/> re-evaluates all sources; if a different value now wins, an <b>Update</b> is emitted instead.</description></item>
-    /// <item><term>Source list <b>Add</b></term><description>Subscribes to the new child changeset stream and merges its keys into the output.</description></item>
-    /// <item><term>Source list <b>Remove</b></term><description>Disposes that source's subscription. All keys it contributed are removed. For keys also contributed by other sources, the next-best value (per <paramref name="comparer"/>) is promoted as an <b>Update</b>, not an Add.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IEqualityComparer{TObject}?, IComparer{TObject}?)"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, IComparer<TObject> comparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Connect().MergeChangeSets(comparer);
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
-    /// <summary>
-    /// Merges cache changeset streams from an <see cref="IObservableList{T}"/> into a single cache changeset stream, with optional equality and ordering comparers.
-    /// </summary>
-    /// <param name="source">The <see cref="IObservableList{T}"/> of cache changeset observables.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> to determine if two elements are the same.</param>
-    /// <param name="comparer">An optional <see cref="IComparer{TObject}"/> to resolve conflicts when the same key appears in multiple sources.</param>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservableList<IObservable<IChangeSet<TObject, TKey>>> source, IEqualityComparer<TObject>? equalityComparer = null, IComparer<TObject>? comparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Connect().MergeChangeSets(equalityComparer, comparer);
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
-    /// <summary>
-    /// Merges cache changeset streams from a list changeset of cache changeset observables, using a comparer for conflict resolution.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> whose items are cache changeset observables.</param>
-    /// <param name="comparer"><see cref="IComparer{TObject}"/> to resolve which value wins when the same key appears in multiple sources.</param>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject, TKey>>>> source, IComparer<TObject> comparer)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return source.MergeChangeSets(comparer);
-    }
-
-    /// <inheritdoc cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
-    /// <summary>
-    /// Merges cache changeset streams from a list changeset of cache changeset observables, with optional equality and ordering comparers.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> whose items are cache changeset observables.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TObject}"/> to determine if two elements are the same.</param>
-    /// <param name="comparer">An optional <see cref="IComparer{TObject}"/> to resolve conflicts when the same key appears in multiple sources.</param>
-    public static IObservable<IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this IObservable<IChangeSet<IObservable<IChangeSet<TObject, TKey>>>> source, IEqualityComparer<TObject>? equalityComparer = null, IComparer<TObject>? comparer = null)
-        where TObject : notnull
-        where TKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.MergeManyChangeSets(static src => src, equalityComparer, comparer);
-    }
-
-    /// <summary>
-    /// Transforms each source item into a child list changeset stream using <paramref name="observableSelector"/>,
-    /// then merges all child streams into a single flat list changeset stream. Parent item removal cleans up all associated children.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child changeset streams.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child list changeset stream for each source item.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> used to compare child items.</param>
-    /// <returns>A single list changeset stream containing all items from all child streams.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Internally subscribes to each child stream when a source item is added and disposes the subscription when it is removed.
-    /// All child items from a removed parent are removed from the merged output.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the child stream. Child emissions are merged into the output.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old child subscription disposed (and its items removed from output). New child subscription created.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Child subscription disposed. All child items from that parent are removed.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <seealso cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="ObservableCacheEx.MergeManyChangeSets{TObject, TKey, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}, IComparer{TDestination})"/>
-    public static IObservable<IChangeSet<TDestination>> MergeManyChangeSets<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TObject : notnull
-        where TDestination : notnull
-    {
-        if (source == null)
-        {
-            throw new ArgumentNullException(nameof(source));
-        }
-
-        if (observableSelector == null)
-        {
-            throw new ArgumentNullException(nameof(observableSelector));
-        }
-
-        return new MergeManyListChangeSets<TObject, TDestination>(source, observableSelector, equalityComparer).Run();
-    }
-
-    /// <summary>
-    /// Transforms each source item into a child cache changeset stream and merges all children into a single cache changeset stream.
-    /// Uses <paramref name="comparer"/> to resolve key conflicts when the same key appears in multiple child streams.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child cache changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key in the child cache changesets.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child cache changeset stream for each source item.</param>
-    /// <param name="comparer"><see cref="IComparer{TDestination}"/> to resolve which value wins when the same key appears from multiple children.</param>
-    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="observableSelector"/>, or <paramref name="comparer"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <inheritdoc cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    /// <para>Delegates to <see cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/> with a <see langword="null"/> equality comparer.</para>
-    /// </remarks>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination, TDestinationKey}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination, TDestinationKey}}}, IEqualityComparer{TDestination}?, IComparer{TDestination}?)"/>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IComparer<TDestination> comparer)
-        where TObject : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return source.MergeManyChangeSets(observableSelector, equalityComparer: null, comparer: comparer);
-    }
-
-    /// <summary>
-    /// Transforms each source item into a child cache changeset stream and merges all children into a single cache changeset stream.
-    /// This is the primary list-to-cache MergeManyChangeSets overload.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the source list.</typeparam>
-    /// <typeparam name="TDestination">The type of items in the child cache changeset streams.</typeparam>
-    /// <typeparam name="TDestinationKey">The type of the key in the child cache changesets.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> whose items each produce a child changeset stream.</param>
-    /// <param name="observableSelector">A <see cref="Func{T, TResult}"/> function that returns a child cache changeset stream for each source item.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> to determine if two elements are the same.</param>
-    /// <param name="comparer">An optional <see cref="IComparer{TDestination}"/> to resolve conflicts when the same key appears from multiple children.</param>
-    /// <returns>A single cache changeset stream with key-based deduplication.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observableSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Each source item produces a keyed child stream via <paramref name="observableSelector"/>. All child items are tracked by key.
-    /// When a parent item is removed, all its child items are removed from the merged output.
-    /// When the same key appears from multiple children, <paramref name="comparer"/> determines which value wins.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event (source)</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscribes to the child cache stream. Child key/value pairs are merged into the output cache.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old child subscription disposed (and its keys removed from output). New child subscription created.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Child subscription disposed. All keys originating from that child are removed from the output.</description></item>
-    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Ignored; this operator emits a cache changeset and source ordering/refresh does not affect key membership.</description></item>
-    /// </list>
-    /// <para>
-    /// <b>Error and completion:</b>
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>OnError</term><description>An error from the source (parent) stream or from any child changeset stream terminates the entire output. Unlike <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>, child errors are NOT swallowed.</description></item>
-    /// <item><term>OnCompleted</term><description>The output completes when the source (parent) stream completes <b>and</b> all active child changeset streams have also completed.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="MergeChangeSets{TObject, TKey}(IObservableList{IObservable{IChangeSet{TObject, TKey}}}, IComparer{TObject})"/>
-    public static IObservable<IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TDestination, TDestinationKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>> observableSelector, IEqualityComparer<TDestination>? equalityComparer = null, IComparer<TDestination>? comparer = null)
-        where TObject : notnull
-        where TDestination : notnull
-        where TDestinationKey : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        observableSelector.ThrowArgumentNullExceptionIfNull(nameof(observableSelector));
-
-        return new MergeManyCacheChangeSets<TObject, TDestination, TDestinationKey>(source, observableSelector, equalityComparer, comparer).Run();
-    }
-
-    /// <summary>
-    /// Suppresses empty changesets from the stream. Only changesets with at least one change are forwarded.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to suppress empty changesets.</param>
-    /// <returns>A list changeset stream with empty changesets filtered out.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="WhereReasonsAre{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
-    public static IObservable<IChangeSet<T>> NotEmpty<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Where(s => s.Count != 0);
-    }
-
-    /// <summary>
-    /// Invokes <paramref name="addAction"/> for every item added to the source list stream.
-    /// Triggers on <see cref="ListChangeReason.Add"/>, <see cref="ListChangeReason.AddRange"/>, and the new item of <see cref="ListChangeReason.Replace"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item additions in.</param>
-    /// <param name="addAction">The <see cref="Action{T}"/> action to invoke for each added item.</param>
-    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="addAction"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>The action fires before the changeset is forwarded downstream.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>Callback invoked with the added item. Changeset forwarded.</description></item>
-    /// <item><term>AddRange</term><description>Callback invoked for each item in the range. Changeset forwarded.</description></item>
-    /// <item><term>Replace</term><description>Callback invoked for the <b>new</b> (replacement) item. Changeset forwarded.</description></item>
-    /// <item><term>Remove/RemoveRange/Clear</term><description>No callback. Changeset forwarded.</description></item>
-    /// <item><term>Moved/Refresh</term><description>No callback. Changeset forwarded.</description></item>
-    /// <item><term>OnError</term><description>If the callback throws, the exception propagates as OnError.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
-    /// <seealso cref="OnItemRefreshed{T}(IObservable{IChangeSet{T}}, Action{T})"/>
-    /// <seealso cref="ForEachItemChange{TObject}(IObservable{IChangeSet{TObject}}, Action{ItemChange{TObject}})"/>
-    /// <seealso cref="ObservableCacheEx.OnItemAdded{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject})"/>
-    public static IObservable<IChangeSet<T>> OnItemAdded<T>(
-                this IObservable<IChangeSet<T>> source,
-                Action<T> addAction)
-            where T : notnull
-        => List.Internal.OnItemAdded<T>.Create(
-            source: source,
-            addAction: addAction);
-
-    /// <summary>
-    /// Invokes <paramref name="refreshAction"/> for every item with a <see cref="ListChangeReason.Refresh"/> change in the source stream.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item refresh events in.</param>
-    /// <param name="refreshAction">The <see cref="Action{T}"/> action to invoke for each refreshed item.</param>
-    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="refreshAction"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
-    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableCacheEx.OnItemRefreshed{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject})"/>
-    public static IObservable<IChangeSet<T>> OnItemRefreshed<T>(
-                this IObservable<IChangeSet<T>> source,
-                Action<T> refreshAction)
-            where T : notnull
-        => List.Internal.OnItemRefreshed<T>.Create(
-            source: source,
-            refreshAction: refreshAction);
-
-    /// <summary>
-    /// Invokes <paramref name="removeAction"/> for every item removed from the source list stream.
-    /// Triggers on <see cref="ListChangeReason.Remove"/>, <see cref="ListChangeReason.RemoveRange"/>, <see cref="ListChangeReason.Clear"/>, and the old item of <see cref="ListChangeReason.Replace"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to observe item removals in.</param>
-    /// <param name="removeAction">The <see cref="Action{T}"/> action to invoke for each removed item.</param>
-    /// <param name="invokeOnUnsubscribe">When <see langword="true"/> (default), <paramref name="removeAction"/> is also invoked for all remaining tracked items upon stream disposal, completion, or error.</param>
-    /// <returns>A continuation of the source changeset stream, with the side effect applied before forwarding.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="removeAction"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// When <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, the operator tracks all items that have been added but not yet removed,
-    /// and fires <paramref name="removeAction"/> for each of them during finalization. This is useful for resource cleanup patterns.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/AddRange</term><description>Tracked internally (when <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>). No callback invoked. Changeset forwarded.</description></item>
-    /// <item><term>Replace</term><description>Callback invoked for the <b>previous</b> (replaced) item. New item tracked. Changeset forwarded.</description></item>
-    /// <item><term>Remove</term><description>Callback invoked for the removed item. Changeset forwarded.</description></item>
-    /// <item><term>RemoveRange/Clear</term><description>Callback invoked for each removed item. Changeset forwarded.</description></item>
-    /// <item><term>Moved/Refresh</term><description>No callback. Changeset forwarded.</description></item>
-    /// <item><term>OnError</term><description>If <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, callback is invoked for all tracked items before the error propagates.</description></item>
-    /// <item><term>OnCompleted</term><description>If <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/>, callback is invoked for all tracked items before completion propagates.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> When <paramref name="invokeOnUnsubscribe"/> is <see langword="true"/> (the default), disposing the subscription also invokes the callback for every item still in the list, not just items that were explicitly removed during the subscription. Exceptions in <paramref name="removeAction"/> are not caught.</para>
-    /// </remarks>
-    /// <seealso cref="OnItemAdded{T}(IObservable{IChangeSet{T}}, Action{T})"/>
-    /// <seealso cref="DisposeMany{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="SubscribeMany{T}(IObservable{IChangeSet{T}}, Func{T, IDisposable})"/>
-    /// <seealso cref="ObservableCacheEx.OnItemRemoved{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Action{TObject}, bool)"/>
-    public static IObservable<IChangeSet<T>> OnItemRemoved<T>(
-                this IObservable<IChangeSet<T>> source,
-                Action<T> removeAction,
-                bool invokeOnUnsubscribe = true)
-            where T : notnull
-        => List.Internal.OnItemRemoved<T>.Create(
-            source: source,
-            removeAction: removeAction,
-            invokeOnUnsubscribe: invokeOnUnsubscribe);
-
-    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Applies a logical OR (union) between a pre-built collection of list changeset sources. Items present in any source are included.
-    /// </summary>
-    /// <seealso cref="ObservableCacheEx.Or{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    public static IObservable<IChangeSet<T>> Or<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Or);
-
-    /// <summary>
-    /// Applies a logical OR (union) between the source and other list changeset streams.
-    /// Items present in any of the sources are included in the result, using reference-counted equality.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{T}}"/> to union.</param>
-    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to combine with.</param>
-    /// <returns>A list changeset stream containing items that exist in at least one source.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Uses reference-counted equality: an item is included when it first appears in any source and removed when it no longer exists in any source.
-    /// <b>Moved</b> changes are ignored by the set logic.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b> (any source)</term><description>If the item is new to the result, an <b>Add</b> is emitted. Otherwise the reference count is incremented.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b> (any source)</term><description>Reference count decremented. If count reaches zero, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old item reference count decremented, new item reference count incremented. Add/Remove emitted as needed.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Forwarded if the item is in the result set.</description></item>
-    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="MergeChangeSets{TObject}(IEnumerable{IObservable{IChangeSet{TObject}}}, IEqualityComparer{TObject}?, IScheduler?, bool)"/>
-    public static IObservable<IChangeSet<T>> Or<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
-        where T : notnull
-    {
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.Combine(CombineOperator.Or, others);
-    }
-
-    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic OR: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Or);
-
-    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic OR accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<IObservableList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Or);
-
-    /// <inheritdoc cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic OR accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Or<T>(this IObservableList<ISourceList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Or);
-
-    /// <summary>
-    /// Applies page-based windowing to the source list. Only items within the current page (determined by page number and page size from <paramref name="requests"/>) are included downstream.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to page.</param>
-    /// <param name="requests">An observable of <see cref="IPageRequest"/> controlling which page to display (page number and page size).</param>
-    /// <returns>An <see cref="IPageChangeSet{T}"/> stream containing only items within the current page window.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="requests"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Maintains the full source list internally and calculates the page window on each change or page request.
-    /// Items entering the page window produce <b>Add</b>; items leaving produce <b>Remove</b>. A new page request triggers
-    /// a full recalculation of the page contents.
-    /// </para>
-    /// <para><b>Worth noting:</b> Duplicate items are removed from the result via <c>Distinct()</c> using the default equality comparer for <typeparamref name="T"/>, regardless of source order. The source should ideally be sorted before paging, since list order determines which items fall within each page window.</para>
-    /// </remarks>
-    /// <seealso cref="Virtualise{T}(IObservable{IChangeSet{T}}, IObservable{IVirtualRequest})"/>
-    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
-    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
-    public static IObservable<IPageChangeSet<T>> Page<T>(this IObservable<IChangeSet<T>> source, IObservable<IPageRequest> requests)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        requests.ThrowArgumentNullExceptionIfNull(nameof(requests));
-
-        return new Pager<T>(source, requests).Run();
-    }
-
-    /// <summary>
-    /// Subscribes to the source changeset stream and pipes all changes into the <paramref name="destination"/> <see cref="ISourceList{T}"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to pipe into a target list.</param>
-    /// <param name="destination">The destination <see cref="ISourceList{T}"/> to receive all changes.</param>
-    /// <returns>An <see cref="IDisposable"/> representing the subscription. Dispose to stop piping changes.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="destination"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Each changeset is applied to the destination using <c>Clone()</c> inside an <c>Edit()</c> call, producing a single batch update per changeset.</para>
-    /// </remarks>
-    /// <seealso cref="Clone{T}(IObservable{IChangeSet{T}}, IList{T})"/>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
-    /// <seealso cref="ObservableCacheEx.PopulateInto{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, ISourceCache{TObject, TKey})"/>
-    public static IDisposable PopulateInto<T>(this IObservable<IChangeSet<T>> source, ISourceList<T> destination)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        destination.ThrowArgumentNullExceptionIfNull(nameof(destination));
-
-        return source.Subscribe(changes => destination.Edit(updater => updater.Clone(changes)));
-    }
-
-    /// <summary>
-    /// Emits a projected value from the current list snapshot after every changeset.
-    /// The <paramref name="resultSelector"/> receives an <see cref="IReadOnlyCollection{T}"/> representing the current state.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TDestination">The type of the projected result.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to project on each change.</param>
-    /// <param name="resultSelector">A <see cref="Func{T, TResult}"/> function projecting the current list snapshot to a result value.</param>
-    /// <returns>An observable emitting the projected value after each changeset.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Delegates to <see cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/> and applies <paramref name="resultSelector"/> via <c>Select</c>.</para>
-    /// </remarks>
-    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
-    /// <seealso cref="ObservableCacheEx.QueryWhenChanged{TObject, TKey, TDestination}(IObservable{IChangeSet{TObject, TKey}}, Func{IQuery{TObject, TKey}, TDestination})"/>
-    public static IObservable<TDestination> QueryWhenChanged<TObject, TDestination>(this IObservable<IChangeSet<TObject>> source, Func<IReadOnlyCollection<TObject>, TDestination> resultSelector)
-        where TObject : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        resultSelector.ThrowArgumentNullExceptionIfNull(nameof(resultSelector));
-
-        return source.QueryWhenChanged().Select(resultSelector);
-    }
-
-    /// <summary>
-    /// Emits an <see cref="IReadOnlyCollection{T}"/> snapshot of the current list state after every changeset.
-    /// Maintains an internal list updated by cloning each changeset.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to project on each change.</param>
-    /// <returns>An observable emitting the full list snapshot as <see cref="IReadOnlyCollection{T}"/> after each change.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>This is a non-changeset operator. It emits the entire collection state on each change, not incremental diffs.</para>
-    /// <para><b>Worth noting:</b> A new snapshot is emitted on every changeset, which can be chatty. The collection is rebuilt by cloning each changeset into an internal list. For sorted output, use <see cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>.</para>
-    /// </remarks>
-    /// <seealso cref="QueryWhenChanged{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{IReadOnlyCollection{TObject}, TDestination})"/>
-    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
-    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
-    public static IObservable<IReadOnlyCollection<T>> QueryWhenChanged<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new QueryWhenChanged<T>(source).Run();
-    }
-
-    /// <summary>
-    /// Reference-counted materialization of the source changeset stream into an <see cref="IObservableList{T}"/>.
-    /// The shared list is created on the first subscriber and disposed when the last subscriber unsubscribes.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to share via reference counting.</param>
-    /// <returns>A list changeset stream backed by a shared, reference-counted <see cref="IObservableList{T}"/>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Equivalent to <c>Publish().RefCount()</c> for changeset streams. The underlying list is created lazily on first subscription.</para>
-    /// </remarks>
-    /// <seealso cref="AsObservableList{T}(IObservable{IChangeSet{T}})"/>
-    public static IObservable<IChangeSet<T>> RefCount<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return new RefCount<T>(source).Run();
-    }
-
-    /// <summary>
-    /// Strips index information from all changes in the stream.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to strip index information.</param>
-    /// <returns>A list changeset stream with all index values removed from changes.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Removes index positions from every change in each changeset. This is useful when downstream operators do not require or support index-based operations.</para>
-    /// </remarks>
-    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
-    public static IObservable<IChangeSet<T>> RemoveIndex<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Select(changes => new ChangeSet<T>(changes.YieldWithoutIndex()));
-    }
-
-    /// <summary>
-    /// Reverses the order of items in the changeset stream by transforming all indices: <c>new_index = length - old_index - 1</c>.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to reverse.</param>
-    /// <returns>A list changeset stream with all index positions reversed.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>This is a pure index transformation. The items themselves are unchanged; only their positional indices are inverted.</para>
-    /// </remarks>
-    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
-    public static IObservable<IChangeSet<T>> Reverse<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        var reverser = new Reverser<T>();
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.Select(changes => new ChangeSet<T>(reverser.Reverse(changes)));
-    }
-
-    /// <summary>
-    /// Skips the initial changeset (the snapshot emitted on subscription) and forwards all subsequent changesets.
-    /// Internally defers until loaded, then skips the first emission.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to skip the initial changeset.</param>
-    /// <returns>A list changeset stream that omits the initial snapshot.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// <b>Warning:</b> This operator assumes the initial changeset is empty. If the source emits a non-empty
-    /// initial snapshot, those items are silently dropped while downstream consumers remain unaware of them.
-    /// Any later <b>Refresh</b>, <b>Replace</b>, <b>Remove</b>, or <b>Moved</b> change targeting one of those
-    /// dropped items will throw because the downstream collection has no record of them. Only use this against
-    /// a source you know starts empty (for example, a <see cref="ISourceList{T}"/> that has not yet been populated).
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="StartWithEmpty{T}(IObservable{IChangeSet{T}})"/>
-    public static IObservable<IChangeSet<T>> SkipInitial<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.DeferUntilLoaded().Skip(1);
-    }
-
-    /// <summary>
-    /// Sorts the list using the specified comparer, maintaining a sorted output that incrementally updates as items change.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to sort.</param>
-    /// <param name="comparer">The <see cref="IComparer{T}"/> used for sorting.</param>
-    /// <param name="options">The <see cref="SortOptions.UseBinarySearch"/> for improved performance when sorted values are immutable.</param>
-    /// <param name="resort">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> that forces a full re-sort when it fires. Required when sorted property values are mutable.</param>
-    /// <param name="comparerChanged">An optional <see cref="IObservable{IComparer{T}}"/> of <see cref="IComparer{T}"/> that replaces the comparer, triggering a full re-sort.</param>
-    /// <param name="resetThreshold">When the number of changes exceeds this threshold, a full reset is performed instead of incremental updates. Default is 50.</param>
-    /// <returns>A list changeset stream with items in sorted order.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Maintains an internal sorted list. Each incoming change is applied incrementally: adds are inserted at the correct sorted position,
-    /// removes are removed by index, and refreshes re-evaluate position (emitting <b>Moved</b> if changed).
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Inserted at the correct sorted position. May trigger a full reset if the count exceeds <paramref name="resetThreshold"/>.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old item removed, new item inserted at sorted position.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Removed from sorted list.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Sort position re-evaluated. If position changed, a <b>Moved</b> is emitted.</description></item>
-    /// <item><term>Comparer changed</term><description>Full re-sort of all items.</description></item>
-    /// <item><term>Re-sort signal</term><description>Full re-sort using the current comparer.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> <see cref="SortOptions.UseBinarySearch"/> is faster but requires that the values being sorted on never mutate. If they do, use the <paramref name="resort"/> signal or <see cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>.</para>
-    /// </remarks>
-    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IObservable{IComparer{T}}, SortOptions, IObservable{Unit}?, int)"/>
-    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
-    /// <seealso cref="Bind{T}(IObservable{IChangeSet{T}}, IObservableCollection{T}, BindingOptions)"/>
-    /// <seealso cref="ObservableCacheEx.Sort{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IComparer{TObject}, SortOptimisations, int)"/>
-    public static IObservable<IChangeSet<T>> Sort<T>(this IObservable<IChangeSet<T>> source, IComparer<T> comparer, SortOptions options = SortOptions.None, IObservable<Unit>? resort = null, IObservable<IComparer<T>>? comparerChanged = null, int resetThreshold = 50)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparer.ThrowArgumentNullExceptionIfNull(nameof(comparer));
-
-        return new Sort<T>(source, comparer, options, resort, comparerChanged, resetThreshold).Run();
-    }
-
-    /// <inheritdoc cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
-    /// <summary>
-    /// Sorts the list using an observable comparer. The initial comparer is taken from the first emission; subsequent emissions trigger a full re-sort.
-    /// </summary>
-    /// <remarks>
-    /// <para>Until <paramref name="comparerChanged"/> emits its first comparer, items are sorted using <see cref="Comparer{T}.Default"/>. Downstream still receives changesets immediately; the initial ordering is whatever <see cref="Comparer{T}.Default"/> produces, then a full re-sort happens once the first comparer arrives.</para>
-    /// </remarks>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to sort.</param>
-    /// <param name="comparerChanged">An <see cref="IObservable{IComparer{T}}"/> of <see cref="IComparer{T}"/> that emits comparers. The first emission provides the initial sort order; subsequent emissions trigger re-sorts.</param>
-    /// <param name="options"><see cref="SortOptions"/> for controlling sort behavior.</param>
-    /// <param name="resort">An optional <see cref="IObservable{Unit}"/> of <see cref="Unit"/> to force a re-sort with the current comparer.</param>
-    /// <param name="resetThreshold">The threshold for triggering a full reset instead of incremental updates.</param>
-    public static IObservable<IChangeSet<T>> Sort<T>(this IObservable<IChangeSet<T>> source, IObservable<IComparer<T>> comparerChanged, SortOptions options = SortOptions.None, IObservable<Unit>? resort = null, int resetThreshold = 50)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        comparerChanged.ThrowArgumentNullExceptionIfNull(nameof(comparerChanged));
-
-        return new Sort<T>(source, null, options, resort, comparerChanged, resetThreshold).Run();
-    }
-
-    /// <summary>
-    /// Prepends an empty changeset to the source stream. Useful for initializing downstream consumers that expect an initial emission.
-    /// </summary>
-    /// <typeparam name="T">The type of item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to prepend an empty changeset to.</param>
-    /// <returns>A list changeset stream that begins with an empty changeset.</returns>
-    /// <seealso cref="DeferUntilLoaded{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="SkipInitial{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ObservableCacheEx.StartWithEmpty{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IChangeSet<T>> StartWithEmpty<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull => source.StartWith(ChangeSet<T>.Empty);
-
-    /// <summary>
-    /// Creates an <see cref="IDisposable"/> subscription for each item via <paramref name="subscriptionFactory"/> when it is added.
-    /// The subscription is disposed when the item is removed or replaced. All subscriptions are disposed when the stream terminates.
-    /// The changeset is forwarded downstream unmodified.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to create a subscription for each item in.</param>
-    /// <param name="subscriptionFactory">A function that creates an <see cref="IDisposable"/> for each item.</param>
-    /// <returns>A continuation of the source changeset stream with per-item subscriptions managed as a side effect.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="subscriptionFactory"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Subscription created for each item via the factory. Changeset forwarded.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old item's subscription disposed, new subscription created. Changeset forwarded.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Subscriptions for removed items are disposed. Changeset forwarded.</description></item>
-    /// <item><term><b>Moved</b>/<b>Refresh</b></term><description>Forwarded. No subscription changes.</description></item>
-    /// <item><term>OnError/OnCompleted/Disposal</term><description>All active subscriptions are disposed.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>
-    /// <seealso cref="DisposeMany{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="OnItemRemoved{T}(IObservable{IChangeSet{T}}, Action{T}, bool)"/>
-    /// <seealso cref="ObservableCacheEx.SubscribeMany{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, Func{TObject, IDisposable})"/>
-    public static IObservable<IChangeSet<T>> SubscribeMany<T>(this IObservable<IChangeSet<T>> source, Func<T, IDisposable> subscriptionFactory)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        subscriptionFactory.ThrowArgumentNullExceptionIfNull(nameof(subscriptionFactory));
-
-        return new SubscribeMany<T>(source, subscriptionFactory).Run();
-    }
-
-    /// <summary>
-    /// Suppresses all <see cref="ListChangeReason.Refresh"/> changes from the stream. All other change reasons pass through.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to strip refresh events.</param>
-    /// <returns>A list changeset stream with Refresh changes removed.</returns>
-    /// <seealso cref="WhereReasonsAreNot{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    public static IObservable<IChangeSet<T>> SuppressRefresh<T>(this IObservable<IChangeSet<T>> source)
-        where T : notnull => source.WhereReasonsAreNot(ListChangeReason.Refresh);
-
-    /// <summary>
-    /// Subscribes to the latest inner <see cref="IObservableList{T}"/>, switching to each new source and clearing the result when switching.
-    /// This is the changeset-aware equivalent of Rx's <see cref="Observable.Switch{TSource}(IObservable{IObservable{TSource}})"/>, which cannot be applied directly to changeset streams.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="sources">An observable that emits <see cref="IObservableList{T}"/> instances. Each emission triggers a switch to the new list.</param>
-    /// <returns>A list changeset stream reflecting the most recently received inner list.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Convenience overload that calls <c>Connect()</c> on each inner list, then delegates to <see cref="Switch{T}(IObservable{IObservable{IChangeSet{T}}})"/>.</para>
-    /// </remarks>
-    /// <seealso cref="Switch{T}(IObservable{IObservable{IChangeSet{T}}})"/>
-    public static IObservable<IChangeSet<T>> Switch<T>(this IObservable<IObservableList<T>> sources)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return sources.Select(cache => cache.Connect()).Switch();
-    }
-
-    /// <summary>
-    /// Subscribes to the latest inner changeset stream, switching to each new source and clearing the destination when switching.
-    /// Previous subscriptions are disposed and the result set is emptied before subscribing to the new inner stream.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="sources">An <see cref="IObservable{T}"/> of <see cref="IObservable{T}"/> changeset streams. The operator subscribes to the latest inner stream.</param>
-    /// <returns>A list changeset stream reflecting the most recently received inner changeset stream.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// On each new inner stream, the operator clears the destination, disposes the previous subscription, and subscribes to the new stream.
-    /// This is the changeset-aware equivalent of Rx's <c>Switch()</c>.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="Switch{T}(IObservable{IObservableList{T}})"/>
-    public static IObservable<IChangeSet<T>> Switch<T>(this IObservable<IObservable<IChangeSet<T>>> sources)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return new Switch<T>(sources).Run();
-    }
-
-    /// <summary>
-    /// Emits the full collection as an <see cref="IReadOnlyCollection{T}"/> after every changeset. Equivalent to <c>QueryWhenChanged(items => items)</c>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a collection on each change.</param>
-    /// <returns>An observable emitting the full collection snapshot after each change.</returns>
-    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
-    /// <seealso cref="ObservableCacheEx.ToCollection{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}})"/>
-    public static IObservable<IReadOnlyCollection<TObject>> ToCollection<TObject>(this IObservable<IChangeSet<TObject>> source)
-        where TObject : notnull => source.QueryWhenChanged(items => items);
-
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> into the DynamicData world by converting each emitted item into a list changeset.
-    /// Each emission becomes an <b>Add</b> operation in the resulting changeset stream.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for time-based operations (expiry, size limiting).</param>
-    /// <returns>A list changeset stream where each source emission is an <b>Add</b>.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// This is the primary bridge from standard Rx into DynamicData's list changeset model. Each item emitted by <paramref name="source"/>
-    /// is added to an internal list and an <b>Add</b> changeset is emitted. The list grows unboundedly unless size or time limits
-    /// are specified via other overloads.
-    /// </para>
-    /// <para><b>Worth noting:</b> Source completion and errors are propagated. The internal list is disposed on unsubscribe.</para>
-    /// </remarks>
-    /// <seealso cref="ToObservableChangeSet{T}(IObservable{T}, Func{T, TimeSpan?}, int, IScheduler?)"/>
-    /// <seealso cref="ToObservableChangeSet{T}(IObservable{IEnumerable{T}}, IScheduler?)"/>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<T> source,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: null,
-            limitSizeTo: -1,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with per-item time-based expiry.
-    /// Expired items are automatically removed.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<T> source,
-                Func<T, TimeSpan?> expireAfter,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: expireAfter,
-            limitSizeTo: -1,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with FIFO size limiting.
-    /// When the list exceeds <paramref name="limitSizeTo"/>, the oldest items are removed.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="limitSizeTo">The maximum list size. Supply -1 to disable size limiting.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling removals.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<T> source,
-                int limitSizeTo,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: null,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> into a list changeset stream with both time-based expiry and FIFO size limiting.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
-    /// <param name="limitSizeTo">The maximum list size. Supply -1 to disable size limiting.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers and size-limit checks.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<T> source,
-                Func<T, TimeSpan?>? expireAfter,
-                int limitSizeTo,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: expireAfter,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream.
-    /// Each emitted batch becomes an <b>AddRange</b>.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for time-based operations.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<IEnumerable<T>> source,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: null,
-            limitSizeTo: -1,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with FIFO size limiting.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="limitSizeTo">The maximum list size. Oldest items are removed when the limit is exceeded.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for scheduling removals.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<IEnumerable<T>> source,
-                int limitSizeTo,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: null,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with time-based expiry.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<IEnumerable<T>> source,
-                Func<T, TimeSpan?> expireAfter,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: expireAfter,
-            limitSizeTo: -1,
-            scheduler: scheduler);
-
-    /// <inheritdoc cref="ToObservableChangeSet{T}(IObservable{T}, IScheduler?)"/>
-    /// <summary>
-    /// Bridges an <see cref="IObservable{T}"/> of <see cref="IEnumerable{T}"/> batches into a list changeset stream with both time-based expiry and FIFO size limiting.
-    /// </summary>
-    /// <param name="source">The source <see cref="IObservable{IEnumerable{T}}"/> of <see cref="IEnumerable{T}"/> to convert into a changeset stream.</param>
-    /// <param name="expireAfter">A <see cref="Func{T, TResult}"/> function returning the time-to-live for each item. Return <see langword="null"/> for non-expiring items.</param>
-    /// <param name="limitSizeTo">The maximum list size. Oldest items removed when exceeded.</param>
-    /// <param name="scheduler">An optional <see cref="IScheduler"/> for expiry timers and size-limit checks.</param>
-    public static IObservable<IChangeSet<T>> ToObservableChangeSet<T>(
-                this IObservable<IEnumerable<T>> source,
-                Func<T, TimeSpan?>? expireAfter,
-                int limitSizeTo,
-                IScheduler? scheduler = null)
-            where T : notnull
-        => List.Internal.ToObservableChangeSet<T>.Create(
-            source: source,
-            expireAfter: expireAfter,
-            limitSizeTo: limitSizeTo,
-            scheduler: scheduler);
-
-    /// <summary>
-    /// Takes the first <paramref name="numberOfItems"/> items from the source list. Implemented as <c>Virtualise</c> with a fixed window starting at index 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to take the top items.</param>
-    /// <param name="numberOfItems">The maximum number of items to include. Must be greater than zero.</param>
-    /// <returns>A virtual changeset stream containing at most <paramref name="numberOfItems"/> items from the beginning of the source.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentOutOfRangeException"><paramref name="numberOfItems"/> is zero or negative.</exception>
-    /// <remarks>
-    /// <para>The source should ideally be sorted before applying Top, since list order determines which items appear.</para>
-    /// </remarks>
-    /// <seealso cref="Virtualise{T}(IObservable{IChangeSet{T}}, IObservable{IVirtualRequest})"/>
-    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
-    /// <seealso cref="Sort{T}(IObservable{IChangeSet{T}}, IComparer{T}, SortOptions, IObservable{Unit}?, IObservable{IComparer{T}}?, int)"/>
-    public static IObservable<IChangeSet<T>> Top<T>(this IObservable<IChangeSet<T>> source, int numberOfItems)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        if (numberOfItems <= 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(numberOfItems), "Number of items should be greater than zero");
-        }
-
-        return source.Virtualise(Observable.Return(new VirtualRequest(0, numberOfItems)));
-    }
-
-    /// <summary>
-    /// Emits a sorted <see cref="IReadOnlyCollection{T}"/> after every changeset, sorted by the value returned by <paramref name="sort"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <typeparam name="TSortKey">The type of the sort key.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a sorted collection on each change.</param>
-    /// <param name="sort">A <see cref="Func{T, TResult}"/> function extracting the sort key from each item.</param>
-    /// <param name="sortOrder">The <see cref="SortDirection"/> sort direction. Defaults to ascending.</param>
-    /// <returns>An observable emitting a sorted collection snapshot after each change.</returns>
-    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
-    /// <seealso cref="ToSortedCollection{TObject}(IObservable{IChangeSet{TObject}}, IComparer{TObject})"/>
-    /// <seealso cref="QueryWhenChanged{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ObservableCacheEx.ToSortedCollection{TObject, TKey}"/>
-    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TSortKey>(this IObservable<IChangeSet<TObject>> source, Func<TObject, TSortKey> sort, SortDirection sortOrder = SortDirection.Ascending)
-        where TObject : notnull => source.QueryWhenChanged(query => sortOrder == SortDirection.Ascending ? new ReadOnlyCollectionLight<TObject>(query.OrderBy(sort)) : new ReadOnlyCollectionLight<TObject>(query.OrderByDescending(sort)));
-
-    /// <summary>
-    /// Emits a sorted <see cref="IReadOnlyCollection{T}"/> after every changeset, sorted using the specified <paramref name="comparer"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of items in the list.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to materialize into a sorted collection on each change.</param>
-    /// <param name="comparer">The <see cref="IComparer{TObject}"/> used for sorting.</param>
-    /// <returns>An observable emitting a sorted collection snapshot after each change.</returns>
-    /// <seealso cref="ToSortedCollection{TObject, TSortKey}(IObservable{IChangeSet{TObject}}, Func{TObject, TSortKey}, SortDirection)"/>
-    /// <seealso cref="ToCollection{TObject}(IObservable{IChangeSet{TObject}})"/>
-    public static IObservable<IReadOnlyCollection<TObject>> ToSortedCollection<TObject>(this IObservable<IChangeSet<TObject>> source, IComparer<TObject> comparer)
-        where TObject : notnull => source.QueryWhenChanged(
-            query =>
-            {
-                var items = query.AsList();
-                items.Sort(comparer);
-                return new ReadOnlyCollectionLight<TObject>(items);
-            });
-
-    /// <summary>
-    /// Projects each item to a new form using a synchronous transform function.
-    /// </summary>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to transform.</param>
-    /// <param name="transformFactory">The <see cref="Func{T, TResult}"/> transform function applied to each item.</param>
-    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh events re-invoke the factory and emit an update. When <see langword="false"/> (the default), Refresh is forwarded without re-transforming.</param>
-    /// <returns>A list changeset stream of transformed items.</returns>
-    /// <remarks>
-    /// <para>
-    /// Maintains an internal list of transformed items. Each source changeset is
-    /// processed and a corresponding output changeset is produced with the transformed items.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add</term><description>The factory is called and an <b>Add</b> is emitted at the same index.</description></item>
-    /// <item><term>AddRange</term><description>The factory is called for each item. An <b>AddRange</b> is emitted at the same start index.</description></item>
-    /// <item><term>Replace</term><description>The factory is called for the new item. A <b>Replace</b> is emitted at the same index. The previous transformed value is available to overloads that accept <see cref="Optional{TDestination}"/>.</description></item>
-    /// <item><term>Remove</term><description>A <b>Remove</b> is emitted (no factory call).</description></item>
-    /// <item><term>RemoveRange</term><description>A <b>RemoveRange</b> is emitted.</description></item>
-    /// <item><term>Moved</term><description>A <b>Moved</b> is emitted with updated indices (no factory call). Throws <see cref="UnspecifiedIndexException"/> if the source change has no index information.</description></item>
-    /// <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is <see langword="false"/> (default), the <b>Refresh</b> is forwarded without re-transforming. If <see langword="true"/>, the factory is re-invoked and the result replaces the current value.</description></item>
-    /// <item><term>Clear</term><description>A <b>Clear</b> is emitted and the internal list is emptied.</description></item>
-    /// <item><term>OnError</term><description>If the factory throws, the exception propagates as OnError.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> By default, Refresh does NOT re-transform the item (it just forwards the signal). Set <paramref name="transformOnRefresh"/> to <see langword="true"/> if you need the factory re-invoked on Refresh. Add operations with out-of-bounds indices silently append to the end.</para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
-    /// <seealso cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="Convert{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination})"/>
-    /// <seealso cref="ObservableCacheEx.Transform{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, TDestination}, bool)"/>
-    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, TDestination> transformFactory, bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform<TSource, TDestination>((t, _, _) => transformFactory(t), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    /// <summary>
-    /// Projects each item using a transform function that also receives the item's index.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, int, TDestination> transformFactory, bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform<TSource, TDestination>((t, _, idx) => transformFactory(t, idx), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    /// <summary>
-    /// Projects each item using a transform function that also receives the previously transformed value (if any).
-    /// Type arguments must be specified explicitly as type inference fails for this overload.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, Optional<TDestination>, TDestination> transformFactory, bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.Transform<TSource, TDestination>((t, previous, _) => transformFactory(t, previous), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    /// <summary>
-    /// Projects each item using a transform function that receives the source item, the previously transformed value, and the index.
-    /// Type arguments must be specified explicitly as type inference fails for this overload.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> Transform<TSource, TDestination>(this IObservable<IChangeSet<TSource>> source, Func<TSource, Optional<TDestination>, int, TDestination> transformFactory, bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new Transformer<TSource, TDestination>(source, transformFactory, transformOnRefresh).Run();
-    }
-
-    /// <summary>
-    /// Projects each item to a new form using an async transform function. Behaves like <see cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/> but the factory returns a <see cref="Task{T}"/>.
-    /// </summary>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to transform asynchronously.</param>
-    /// <param name="transformFactory">An <see cref="Func{T, TResult}"/> async function that transforms each source item.</param>
-    /// <param name="transformOnRefresh">When <see langword="true"/>, Refresh events re-invoke the factory.</param>
-    /// <returns>A list changeset stream of asynchronously transformed items.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="transformFactory"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Change handling is identical to the synchronous <see cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/> except the factory is awaited. Operations are serialized per changeset via a semaphore.</para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term>Add/AddRange</term><description>The async factory is awaited for each item. An <b>Add</b>/<b>AddRange</b> is emitted with the transformed results.</description></item>
-    /// <item><term>Replace</term><description>The async factory is awaited for the new item. A <b>Replace</b> is emitted.</description></item>
-    /// <item><term>Remove/RemoveRange</term><description>Emitted without invoking the factory.</description></item>
-    /// <item><term>Moved</term><description>Emitted with updated indices (no factory call).</description></item>
-    /// <item><term>Refresh</term><description>If <paramref name="transformOnRefresh"/> is <see langword="false"/> (default), forwarded without re-transforming. If <see langword="true"/>, the factory is re-awaited.</description></item>
-    /// <item><term>Clear</term><description>Emitted and internal list cleared.</description></item>
-    /// <item><term>OnError</term><description>If the async factory throws, the exception propagates as OnError.</description></item>
-    /// <item><term>OnCompleted</term><description>Forwarded after the last changeset is processed.</description></item>
-    /// </list>
-    /// <para><b>Worth noting:</b> All async transforms within a single changeset are serialized (not parallel). Each changeset is fully processed before the next begins. By default, Refresh does NOT re-transform.</para>
-    /// </remarks>
-    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    /// <seealso cref="ObservableCacheEx.TransformAsync{TDestination, TSource, TKey}(IObservable{IChangeSet{TSource, TKey}}, Func{TSource, Task{TDestination}}, IObservable{Func{TSource, TKey, bool}})"/>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
-        this IObservable<IChangeSet<TSource>> source,
-        Func<TSource, Task<TDestination>> transformFactory,
-        bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync<TSource, TDestination>((t, _, _) => transformFactory(t), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
-    /// <summary>
-    /// Async transform overload receiving the source item and its index.
-    /// </summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
-        this IObservable<IChangeSet<TSource>> source,
-        Func<TSource, int, Task<TDestination>> transformFactory,
-        bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync<TSource, TDestination>((t, _, i) => transformFactory(t, i), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
-    /// <summary>
-    /// Async transform overload receiving the source item and the previously transformed value.
-    /// </summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
-        this IObservable<IChangeSet<TSource>> source,
-        Func<TSource, Optional<TDestination>, Task<TDestination>> transformFactory,
-        bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return source.TransformAsync<TSource, TDestination>((t, d, _) => transformFactory(t, d), transformOnRefresh);
-    }
-
-    /// <inheritdoc cref="TransformAsync{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, Task{TDestination}}, bool)"/>
-    /// <summary>
-    /// Async transform overload receiving the source item, previously transformed value, and index. This is the terminal overload that all other TransformAsync overloads delegate to.
-    /// </summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with 'Async'.", Justification = "By Design.")]
-    public static IObservable<IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(
-        this IObservable<IChangeSet<TSource>> source,
-        Func<TSource, Optional<TDestination>, int, Task<TDestination>> transformFactory,
-        bool transformOnRefresh = false)
-        where TSource : notnull
-        where TDestination : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        transformFactory.ThrowArgumentNullExceptionIfNull(nameof(transformFactory));
-
-        return new TransformAsync<TSource, TDestination>(source, transformFactory, transformOnRefresh).Run();
-    }
-
-    /// <summary>
-    /// Flattens each source item into multiple destination items using <paramref name="manySelector"/>. Each source item produces zero or more children,
-    /// all of which are merged into a single flat list changeset stream.
-    /// </summary>
-    /// <typeparam name="TDestination">The type of the destination items.</typeparam>
-    /// <typeparam name="TSource">The type of the source items.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TSource}}"/> to expand each item into multiple children.</param>
-    /// <param name="manySelector">A <see cref="Func{T, TResult}"/> function that returns the child items for each source item.</param>
-    /// <param name="equalityComparer">An optional <see cref="IEqualityComparer{TDestination}"/> used during Replace to determine which child items changed between old and new parent values.</param>
-    /// <returns>A list changeset stream of all child items from all source items.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="manySelector"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Children expanded and added to the output.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old children diffed against new children (using <paramref name="equalityComparer"/>). Removed, added, or kept as appropriate.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>All children of the removed parents are removed from the output.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Children re-expanded and diffed.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="Transform{TSource, TDestination}(IObservable{IChangeSet{TSource}}, Func{TSource, TDestination}, bool)"/>
-    /// <seealso cref="MergeManyChangeSets{TObject, TDestination}(IObservable{IChangeSet{TObject}}, Func{TObject, IObservable{IChangeSet{TDestination}}}, IEqualityComparer{TDestination}?)"/>
-    /// <seealso cref="ObservableCacheEx.TransformMany{TDestination, TDestinationKey, TSource, TSourceKey}(IObservable{IChangeSet{TSource, TSourceKey}}, Func{TSource, IEnumerable{TDestination}}, Func{TDestination, TDestinationKey})"/>
-    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, IEnumerable<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TDestination : notnull
-        where TSource : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        manySelector.ThrowArgumentNullExceptionIfNull(nameof(manySelector));
-
-        return new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
-    }
-
-    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
-    /// <summary>
-    /// Flattens each source item into children from an <see cref="ObservableCollection{T}"/>. The collection is observed for subsequent changes.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, ObservableCollection<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TDestination : notnull
-        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
-
-    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
-    /// <summary>
-    /// Flattens each source item into children from a <see cref="ReadOnlyObservableCollection{T}"/>. The collection is observed for subsequent changes.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, ReadOnlyObservableCollection<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TDestination : notnull
-        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
-
-    /// <inheritdoc cref="TransformMany{TDestination, TSource}(IObservable{IChangeSet{TSource}}, Func{TSource, IEnumerable{TDestination}}, IEqualityComparer{TDestination}?)"/>
-    /// <summary>
-    /// Flattens each source item into children from an <see cref="IObservableList{T}"/>. The inner list is observed for subsequent changes.
-    /// </summary>
-    public static IObservable<IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this IObservable<IChangeSet<TSource>> source, Func<TSource, IObservableList<TDestination>> manySelector, IEqualityComparer<TDestination>? equalityComparer = null)
-        where TDestination : notnull
-        where TSource : notnull => new TransformMany<TSource, TDestination>(source, manySelector, equalityComparer).Run();
-
-    /// <summary>
-    /// Applies a sliding window to the source list using start index and size from <paramref name="requests"/>.
-    /// Only items within the window are included downstream.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to virtualize.</param>
-    /// <param name="requests">An observable of <see cref="IVirtualRequest"/> specifying the start index and size of the window.</param>
-    /// <returns>An <see cref="IVirtualChangeSet{T}"/> stream containing only items within the current virtual window.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="requests"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Like <see cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/> but uses absolute start index and size instead of page number and page size.
-    /// Internally maintains the full source list and recalculates the window on each change or request.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="Page{T}(IObservable{IChangeSet{T}}, IObservable{IPageRequest})"/>
-    /// <seealso cref="Top{T}(IObservable{IChangeSet{T}}, int)"/>
-    public static IObservable<IVirtualChangeSet<T>> Virtualise<T>(this IObservable<IChangeSet<T>> source, IObservable<IVirtualRequest> requests)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        requests.ThrowArgumentNullExceptionIfNull(nameof(requests));
-
-        return new Virtualiser<T>(source, requests).Run();
-    }
-
-    /// <summary>
-    /// Watches all items in the source list and emits the item when any of its properties change.
-    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
-    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of the object. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe property changes on items in.</param>
-    /// <param name="propertiesToMonitor">An optional list of property names to monitor. If empty, all property changes are observed.</param>
-    /// <returns>An observable emitting the item whenever any monitored property changes.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Implemented via <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>. Subscriptions are managed per item: created on add, disposed on remove.</para>
-    /// </remarks>
-    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
-    /// <seealso cref="WhenValueChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
-    /// <seealso cref="AutoRefresh{TObject}(IObservable{IChangeSet{TObject}}, TimeSpan?, TimeSpan?, IScheduler?)"/>
-    /// <seealso cref="ObservableCacheEx.WhenAnyPropertyChanged{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, string[])"/>
-    public static IObservable<TObject?> WhenAnyPropertyChanged<TObject>(this IObservable<IChangeSet<TObject>> source, params string[] propertiesToMonitor)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-
-        return source.MergeMany(t => t.WhenAnyPropertyChanged(propertiesToMonitor));
-    }
-
-    /// <summary>
-    /// Watches a specific property on all items in the source list and emits a <see cref="PropertyValue{TObject, TValue}"/> (item + value pair) when it changes.
-    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
-    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of item. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <typeparam name="TValue">The type of the property value.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe a specific property on items in.</param>
-    /// <param name="propertyAccessor">An <see cref="Expression{TDelegate}"/> expression selecting the property to observe.</param>
-    /// <param name="notifyOnInitialValue">When <see langword="true"/> (default), the current value is emitted immediately upon subscribing to each item.</param>
-    /// <returns>An observable emitting <see cref="PropertyValue{TObject, TValue}"/> whenever the property changes on any tracked item.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertyAccessor"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>Implemented via <see cref="MergeMany{T, TDestination}(IObservable{IChangeSet{T}}, Func{T, IObservable{TDestination}})"/>.</para>
-    /// </remarks>
-    /// <seealso cref="WhenValueChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
-    /// <seealso cref="WhenAnyPropertyChanged{TObject}(IObservable{IChangeSet{TObject}}, string[])"/>
-    /// <seealso cref="ObservableCacheEx.WhenPropertyChanged{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TValue}}, bool)"/>
-    public static IObservable<PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
-
-        var factory = propertyAccessor.GetFactory();
-        return source.MergeMany(t => factory(t, notifyOnInitialValue));
-    }
-
-    /// <summary>
-    /// Watches a specific property on all items and emits just the property value (without the sender) when it changes.
-    /// Requires <typeparamref name="TObject"/> to implement <see cref="INotifyPropertyChanged"/>.
-    /// This is NOT a changeset operator: it returns a flat <see cref="IObservable{T}"/>.
-    /// </summary>
-    /// <typeparam name="TObject">The type of item. Must implement <see cref="INotifyPropertyChanged"/>.</typeparam>
-    /// <typeparam name="TValue">The type of the property value.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{TObject}}"/> to observe a specific property value on items in.</param>
-    /// <param name="propertyAccessor">An <see cref="Expression{TDelegate}"/> expression selecting the property to observe.</param>
-    /// <param name="notifyOnInitialValue">When <see langword="true"/> (default), the current value is emitted immediately upon subscribing to each item.</param>
-    /// <returns>An observable emitting the property value whenever it changes on any tracked item.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="propertyAccessor"/> is <see langword="null"/>.</exception>
-    /// <seealso cref="WhenPropertyChanged{TObject, TValue}(IObservable{IChangeSet{TObject}}, Expression{Func{TObject, TValue}}, bool)"/>
-    /// <seealso cref="WhenAnyPropertyChanged{TObject}(IObservable{IChangeSet{TObject}}, string[])"/>
-    /// <seealso cref="ObservableCacheEx.WhenValueChanged{TObject, TKey, TValue}(IObservable{IChangeSet{TObject, TKey}}, Expression{Func{TObject, TValue}}, bool)"/>
-    public static IObservable<TValue?> WhenValueChanged<TObject, TValue>(this IObservable<IChangeSet<TObject>> source, Expression<Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
-        where TObject : INotifyPropertyChanged
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        propertyAccessor.ThrowArgumentNullExceptionIfNull(nameof(propertyAccessor));
-
-        var factory = propertyAccessor.GetFactory();
-        return source.MergeMany(t => factory(t, notifyOnInitialValue).Select(pv => pv.Value));
-    }
-
-    /// <summary>
-    /// Filters the changeset stream to include only changes with the specified <see cref="ListChangeReason"/> values.
-    /// Index information is stripped from the output because removing some changes invalidates the original index positions.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter by change reason.</param>
-    /// <param name="reasons">The <see cref="ListChangeReason"/> change reasons to include. Must specify at least one.</param>
-    /// <returns>A list changeset stream containing only changes with the specified reasons.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="reasons"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="reasons"/> is empty.</exception>
-    /// <remarks>
-    /// <para>Filters individual changes within each changeset. If filtering removes all changes from a changeset, the empty changeset is suppressed via <see cref="NotEmpty{T}(IObservable{IChangeSet{T}})"/>.</para>
-    /// <para><b>Worth noting:</b> Filtering out <b>Remove</b> changes can cause downstream operators to accumulate items indefinitely (memory leak). Index information is stripped because removing some changes invalidates the original index positions.</para>
-    /// </remarks>
-    /// <seealso cref="WhereReasonsAreNot{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
-    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
-    public static IObservable<IChangeSet<T>> WhereReasonsAre<T>(this IObservable<IChangeSet<T>> source, params ListChangeReason[] reasons)
-        where T : notnull
-    {
-        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
-
-        if (reasons.Length == 0)
-        {
-            throw new ArgumentException("Must enter at least 1 reason", nameof(reasons));
-        }
-
-        var matches = new HashSet<ListChangeReason>(reasons);
-        return source.Select(
-            changes =>
-            {
-                var filtered = changes.Where(change => matches.Contains(change.Reason)).YieldWithoutIndex();
-                return new ChangeSet<T>(filtered);
-            }).NotEmpty();
-    }
-
-    /// <summary>
-    /// Filters the changeset stream to exclude changes with the specified <see cref="ListChangeReason"/> values.
-    /// Index information is stripped from the output because removing some changes invalidates the original index positions.
-    /// The exception is when only <see cref="ListChangeReason.Refresh"/> is excluded, since removing Refresh does not affect index calculations.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The source <see cref="IObservable{IChangeSet{T}}"/> to filter by excluding change reasons.</param>
-    /// <param name="reasons">The <see cref="ListChangeReason"/> change reasons to exclude. Must specify at least one.</param>
-    /// <returns>A list changeset stream with the specified change reasons removed.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="reasons"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="reasons"/> is empty.</exception>
-    /// <remarks>
-    /// <para>
-    /// Empty changesets (after filtering) are automatically suppressed. When only <see cref="ListChangeReason.Refresh"/> is excluded,
-    /// indices are preserved, since removing Refresh does not affect index calculations.
-    /// </para>
-    /// </remarks>
-    /// <seealso cref="WhereReasonsAre{T}(IObservable{IChangeSet{T}}, ListChangeReason[])"/>
-    /// <seealso cref="SuppressRefresh{T}(IObservable{IChangeSet{T}})"/>
-    /// <seealso cref="ChangeSetEx.YieldWithoutIndex{T}(IEnumerable{Change{T}})"/>
-    public static IObservable<IChangeSet<T>> WhereReasonsAreNot<T>(this IObservable<IChangeSet<T>> source, params ListChangeReason[] reasons)
-        where T : notnull
-    {
-        reasons.ThrowArgumentNullExceptionIfNull(nameof(reasons));
-
-        if (reasons.Length == 0)
-        {
-            throw new ArgumentException("Must enter at least 1 reason", nameof(reasons));
-        }
-
-        if (reasons.Length == 1 && reasons[0] == ListChangeReason.Refresh)
-        {
-            // If only refresh changes are removed, then there's no need to remove the indexes
-            return source.Select(changes =>
-            {
-                var filtered = changes.Where(c => c.Reason != ListChangeReason.Refresh);
-                return new ChangeSet<T>(filtered);
-            }).NotEmpty();
-        }
-
-        var matches = new HashSet<ListChangeReason>(reasons);
-        return source.Select(
-            updates =>
-            {
-                var filtered = updates.Where(u => !matches.Contains(u.Reason)).YieldWithoutIndex();
-                return new ChangeSet<T>(filtered);
-            }).NotEmpty();
-    }
-
-    /// <summary>
-    /// Applies a logical XOR (symmetric difference) between the source and other streams.
-    /// Items present in exactly one source are included in the result.
-    /// </summary>
-    /// <typeparam name="T">The type of the item.</typeparam>
-    /// <param name="source">The primary source <see cref="IObservable{IChangeSet{T}}"/> to exclusively combine.</param>
-    /// <param name="others">The other <see cref="IObservable{IChangeSet{T}}"/> changeset streams to combine with.</param>
-    /// <returns>A list changeset stream containing items that exist in exactly one source.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="others"/> is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// <para>
-    /// Item identity is determined by the default equality comparer for <typeparamref name="T"/>. Uses reference-counted equality: an item is included when it exists in exactly one source.
-    /// If it appears in a second source, it is removed from the result. If it then leaves one source,
-    /// it re-enters the result. <b>Moved</b> changes are ignored.
-    /// </para>
-    /// <list type="table">
-    /// <listheader><term>Event</term><description>Behavior</description></listheader>
-    /// <item><term><b>Add</b>/<b>AddRange</b></term><description>Reference count updated. If the item is now in exactly one source, an <b>Add</b> is emitted. If now in two or more, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Remove</b>/<b>RemoveRange</b>/<b>Clear</b></term><description>Reference count decremented. If now in exactly one source, an <b>Add</b> is emitted. If now in zero, a <b>Remove</b> is emitted.</description></item>
-    /// <item><term><b>Replace</b></term><description>Old item reference count decremented, new item incremented, with Xor logic applied.</description></item>
-    /// <item><term><b>Refresh</b></term><description>Forwarded if item is in the result set.</description></item>
-    /// <item><term><b>Moved</b></term><description>Ignored.</description></item>
-    /// </list>
-    /// </remarks>
-    /// <seealso cref="And{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Or{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="Except{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <seealso cref="ObservableCacheEx.Xor{TObject, TKey}(IObservable{IChangeSet{TObject, TKey}}, IObservable{IChangeSet{TObject, TKey}}[])"/>
-    public static IObservable<IChangeSet<T>> Xor<T>(this IObservable<IChangeSet<T>> source, params IObservable<IChangeSet<T>>[] others)
-        where T : notnull
-    {
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        return source.Combine(CombineOperator.Xor, others);
-    }
-
-    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Applies a logical XOR between a pre-built collection of list changeset sources.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Xor<T>(this ICollection<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Xor);
-
-    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic XOR: sources can be added or removed from the <see cref="IObservableList{T}"/> at runtime.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<IObservable<IChangeSet<T>>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Xor);
-
-    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic XOR accepting <see cref="IObservableList{T}"/> of <see cref="IObservableList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<IObservableList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Xor);
-
-    /// <inheritdoc cref="Xor{T}(IObservable{IChangeSet{T}}, IObservable{IChangeSet{T}}[])"/>
-    /// <summary>
-    /// Dynamic XOR accepting <see cref="IObservableList{T}"/> of <see cref="ISourceList{T}"/>. Each inner list's <c>Connect()</c> is used as a source.
-    /// </summary>
-    public static IObservable<IChangeSet<T>> Xor<T>(this IObservableList<ISourceList<T>> sources)
-        where T : notnull => sources.Combine(CombineOperator.Xor);
-
-    private static IObservable<IChangeSet<T>> Combine<T>(this ICollection<IObservable<IChangeSet<T>>> sources, CombineOperator type)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return new Combiner<T>(sources, type).Run();
-    }
-
-    private static IObservable<IChangeSet<T>> Combine<T>(this IObservable<IChangeSet<T>> source, CombineOperator type, params IObservable<IChangeSet<T>>[] others)
-        where T : notnull
-    {
-        source.ThrowArgumentNullExceptionIfNull(nameof(source));
-        others.ThrowArgumentNullExceptionIfNull(nameof(others));
-
-        if (others.Length == 0)
-        {
-            throw new ArgumentException("Must be at least one item to combine with", nameof(others));
-        }
-
-        var items = source.EnumerateOne().Union(others).ToList();
-        return new Combiner<T>(items, type).Run();
-    }
-
-    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<ISourceList<T>> sources, CombineOperator type)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return Observable.Create<IChangeSet<T>>(
-            observer =>
-            {
-                var changesSetList = sources.Connect().Transform(s => s.Connect()).AsObservableList();
-                var subscriber = changesSetList.Combine(type).SubscribeSafe(observer);
-                return new CompositeDisposable(changesSetList, subscriber);
-            });
-    }
-
-    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<IObservableList<T>> sources, CombineOperator type)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return Observable.Create<IChangeSet<T>>(
-            observer =>
-            {
-                var changesSetList = sources.Connect().Transform(s => s.Connect()).AsObservableList();
-                var subscriber = changesSetList.Combine(type).SubscribeSafe(observer);
-                return new CompositeDisposable(changesSetList, subscriber);
-            });
-    }
-
-    private static IObservable<IChangeSet<T>> Combine<T>(this IObservableList<IObservable<IChangeSet<T>>> sources, CombineOperator type)
-        where T : notnull
-    {
-        sources.ThrowArgumentNullExceptionIfNull(nameof(sources));
-
-        return new DynamicCombiner<T>(sources, type).Run();
-    }
 }