diff --git a/src/DynamicData.Benchmarks/Cache/DeliveryQueueBenchmarks.cs b/src/DynamicData.Benchmarks/Cache/DeliveryQueueBenchmarks.cs
new file mode 100644
index 000000000..f5e397006
--- /dev/null
+++ b/src/DynamicData.Benchmarks/Cache/DeliveryQueueBenchmarks.cs
@@ -0,0 +1,226 @@
+// 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.Linq;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using BenchmarkDotNet.Attributes;
+
+using DynamicData.Binding;
+
+namespace DynamicData.Benchmarks.Cache;
+
+/// <summary>
+/// Multi-threaded SourceCache contention benchmarks. Measures aggregate throughput
+/// when N threads write concurrently with varying subscriber complexity.
+/// Exercises the DeliveryQueue path (ObservableCache).
+/// </summary>
+[MemoryDiagnoser]
+[MarkdownExporterAttribute.GitHub]
+public class ContentionBenchmarks
+{
+    private SourceCache<ContentionItem, int> _cache = null!;
+    private IDisposable? _subscription;
+
+    [Params(1, 2, 4)]
+    public int ThreadCount;
+
+    [Params("None", "Sort", "Chain")]
+    public string SubscriberWork = "None";
+
+    private const int ItemsPerThread = 1_000;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _cache = new SourceCache<ContentionItem, int>(i => i.Id);
+    }
+
+    [GlobalCleanup]
+    public void GlobalCleanup()
+    {
+        _subscription?.Dispose();
+        _cache.Dispose();
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+        _subscription?.Dispose();
+        _cache.Clear();
+
+        _subscription = SubscriberWork switch
+        {
+            "Sort" => _cache.Connect()
+                .Sort(SortExpressionComparer<ContentionItem>.Ascending(i => i.Name))
+                .Subscribe(_ => { }),
+
+            "Chain" => _cache.Connect()
+                .Filter(i => i.Price > 0)
+                .Sort(SortExpressionComparer<ContentionItem>.Ascending(i => i.Name))
+                .Transform(i => new ContentionItemVm(i))
+                .Subscribe(_ => { }),
+
+            _ => _cache.Connect().Subscribe(_ => { }),
+        };
+    }
+
+    [Benchmark]
+    public void ConcurrentAddOrUpdate()
+    {
+        if (ThreadCount == 1)
+        {
+            for (var i = 0; i < ItemsPerThread; i++)
+                _cache.AddOrUpdate(new ContentionItem(i, $"Item_{i}", i * 0.1m));
+        }
+        else
+        {
+            var barrier = new Barrier(ThreadCount);
+            var tasks = new Task[ThreadCount];
+
+            for (var t = 0; t < ThreadCount; t++)
+            {
+                var threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    for (var i = 0; i < ItemsPerThread; i++)
+                    {
+                        var id = (threadId * ItemsPerThread) + i;
+                        _cache.AddOrUpdate(new ContentionItem(id, $"Item_{id}", id * 0.1m));
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+            barrier.Dispose();
+        }
+    }
+
+    public sealed record ContentionItem(int Id, string Name, decimal Price);
+    public sealed record ContentionItemVm(ContentionItem Source);
+}
+
+/// <summary>
+/// MergeManyChangeSets contention benchmark. Multiple threads mutating child
+/// SourceCaches while a CPS pipeline is subscribed. Uses SourceCache (not
+/// SourceList) for children so the full path exercises DeliveryQueue + SDQ.
+/// </summary>
+[MemoryDiagnoser]
+[MarkdownExporterAttribute.GitHub]
+public class MmcsContentionBenchmarks
+{
+    private SourceCache<MmcsParent, int> _parents = null!;
+    private MmcsParent[] _parentItems = null!;
+    private IDisposable? _subscription;
+
+    [Params(1, 2, 4)]
+    public int ThreadCount;
+
+    [Params("None", "Sort", "Transform")]
+    public string SubscriberWork = "None";
+
+    private const int ParentCount = 50;
+    private const int ChildOpsPerThread = 200;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _parents = new SourceCache<MmcsParent, int>(p => p.Id);
+        _parentItems = Enumerable.Range(0, ParentCount).Select(i =>
+        {
+            var p = new MmcsParent(i);
+            p.Children.Edit(u =>
+            {
+                for (var j = 0; j < 10; j++)
+                    u.AddOrUpdate(new MmcsChild(i * 100 + j, $"Child_{i}_{j}"));
+            });
+            return p;
+        }).ToArray();
+    }
+
+    [GlobalCleanup]
+    public void GlobalCleanup()
+    {
+        _subscription?.Dispose();
+        foreach (var p in _parentItems) p.Dispose();
+        _parents.Dispose();
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+        _subscription?.Dispose();
+        _parents.Clear();
+        _parents.AddOrUpdate(_parentItems);
+
+        var pipeline = _parents.Connect()
+            .MergeManyChangeSets(p => p.Children.Connect());
+
+        _subscription = SubscriberWork switch
+        {
+            "Sort" => pipeline
+                .Sort(SortExpressionComparer<MmcsChild>.Ascending(c => c.Name))
+                .Bind(out _)
+                .Subscribe(_ => { }),
+
+            "Transform" => pipeline
+                .Transform(c => new MmcsChildVm(c))
+                .Subscribe(_ => { }),
+
+            _ => pipeline.Subscribe(_ => { }),
+        };
+    }
+
+    [Benchmark]
+    public void ConcurrentChildMutations()
+    {
+        if (ThreadCount == 1)
+        {
+            MutateChildren(0);
+        }
+        else
+        {
+            var barrier = new Barrier(ThreadCount);
+            var tasks = new Task[ThreadCount];
+            for (var t = 0; t < ThreadCount; t++)
+            {
+                var threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+                    MutateChildren(threadId);
+                });
+            }
+            Task.WaitAll(tasks);
+            barrier.Dispose();
+        }
+    }
+
+    private void MutateChildren(int threadId)
+    {
+        for (var i = 0; i < ChildOpsPerThread; i++)
+        {
+            var parentIdx = (threadId * ChildOpsPerThread + i) % ParentCount;
+            var parent = _parentItems[parentIdx];
+            var childId = threadId * 100_000 + i;
+            parent.Children.AddOrUpdate(new MmcsChild(childId, $"New_{childId}"));
+            if (parent.Children.Count > 15)
+                parent.Children.RemoveKey(parent.Children.Keys.First());
+        }
+    }
+
+    public sealed record MmcsChild(int Id, string Name);
+    public sealed record MmcsChildVm(MmcsChild Source);
+
+    public sealed class MmcsParent(int id) : IDisposable
+    {
+        public int Id { get; } = id;
+        public SourceCache<MmcsChild, int> Children { get; } = new(c => c.Id);
+        public void Dispose() => Children.Dispose();
+    }
+}
diff --git a/src/DynamicData.Benchmarks/DynamicData.Benchmarks.csproj b/src/DynamicData.Benchmarks/DynamicData.Benchmarks.csproj
index d997f15cb..451ac4697 100644
--- a/src/DynamicData.Benchmarks/DynamicData.Benchmarks.csproj
+++ b/src/DynamicData.Benchmarks/DynamicData.Benchmarks.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0-windows</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <IsPackable>false</IsPackable>
     <NoWarn>;1591;1701;1702;1705;CA1822;CA1001</NoWarn>
diff --git a/src/DynamicData.Tests/Cache/CrossCacheDeadlockStressTest.cs b/src/DynamicData.Tests/Cache/CrossCacheDeadlockStressTest.cs
new file mode 100644
index 000000000..8915bc6bc
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/CrossCacheDeadlockStressTest.cs
@@ -0,0 +1,869 @@
+// 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.Linq;
+using System.Reactive;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Bogus;
+
+using DynamicData.Binding;
+using DynamicData.Kernel;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Cache;
+
+/// <summary>
+/// Mega cross-cache stress test exercising every operator migrated from
+/// Synchronize to SynchronizeSafe in multi-threaded bidirectional pipelines.
+/// Every numeric parameter is derived from a seeded Randomizer (deterministic
+/// but not hardcoded). Proves: no deadlocks, correct final state, Rx compliance.
+/// </summary>
+public sealed class CrossCacheDeadlockStressTest
+{
+    // ════════════════════════════════════════════════════════════════
+    // Bound constants — ONLY the seed and Min/Max bounds are hardcoded.
+    // Every actual test value is derived from the seeded Randomizer.
+    // ════════════════════════════════════════════════════════════════
+
+    private const int Seed = 42;
+
+    // Market counts
+    private const int SourceMarketCountMin = 80;
+    private const int SourceMarketCountMax = 120;
+    private const int OverlappingCountMin = 5;
+    private const int OverlappingCountMax = 15;
+    private const int TreeMarketCountMin = 12;
+    private const int TreeMarketCountMax = 25;
+
+    // Per-market price generation
+    private const int PricesPerMarketMin = 2;
+    private const int PricesPerMarketMax = 8;
+
+    // Market property ranges
+    private const int PriorityMin = 1;
+    private const int PriorityMax = 10;
+    private const double RatingMin = 1.0;
+    private const double RatingMax = 10.0;
+    private const int RegionCountMin = 3;
+    private const int RegionCountMax = 7;
+
+    // Price ranges
+    private const decimal PriceMin = 1.0m;
+    private const decimal PriceMax = 500.0m;
+
+    // Pipeline parameters
+    private const double RatingFilterThresholdMin = 2.0;
+    private const double RatingFilterThresholdMax = 5.0;
+    private const double TransformMultiplierMin = 1.5;
+    private const double TransformMultiplierMax = 3.0;
+    private const int PageSizeMin = 20;
+    private const int PageSizeMax = 60;
+    private const int VirtualSizeMin = 15;
+    private const int VirtualSizeMax = 40;
+
+    // Stress parameters
+    private const int WriterThreadCountMin = 2;
+    private const int WriterThreadCountMax = 6;
+    private const int RatingMutationsMin = 10;
+    private const int RatingMutationsMax = 30;
+    private const int RegionMutationsMin = 5;
+    private const int RegionMutationsMax = 15;
+
+    // ID range spacing (generous gaps to prevent overlap)
+    private const int IdRangeSpacing = 10_000;
+
+    // Timeout
+    private const int TimeoutSecondsMin = 30;
+    private const int TimeoutSecondsMax = 60;
+
+    // ════════════════════════════════════════════════════════════════
+    // Domain types
+    // ════════════════════════════════════════════════════════════════
+
+    private sealed class StressMarket : AbstractNotifyPropertyChanged, IDisposable
+    {
+        private double _rating;
+        private string _region;
+
+        public StressMarket(int id, string name, string region, int priority, double rating, int? parentId = null)
+        {
+            Id = id;
+            Name = name;
+            _region = region;
+            Priority = priority;
+            _rating = rating;
+            ParentId = parentId;
+            Prices = new SourceCache<StressPrice, int>(p => p.Id);
+        }
+
+        public int Id { get; }
+
+        public string Name { get; }
+
+        public string Region
+        {
+            get => _region;
+            set => SetAndRaise(ref _region, value);
+        }
+
+        public int Priority { get; }
+
+        public double Rating
+        {
+            get => _rating;
+            set => SetAndRaise(ref _rating, value);
+        }
+
+        public int? ParentId { get; }
+
+        public SourceCache<StressPrice, int> Prices { get; }
+
+        public IObservable<IChangeSet<StressPrice, int>> LatestPrices => Prices.Connect();
+
+        public void Dispose() => Prices.Dispose();
+
+        public override string ToString() => $"Market({Id}, {Name}, R={Rating:F1}, P={Priority})";
+    }
+
+    private sealed class StressPrice(int id, int marketId, decimal price)
+    {
+        public int Id { get; } = id;
+
+        public int MarketId { get; } = marketId;
+
+        public decimal Price { get; set; } = price;
+
+        public override string ToString() => $"Price({Id}, M={MarketId}, ${Price:F2})";
+    }
+
+    private sealed class RatingDescComparer : IComparer<StressMarket>
+    {
+        public static RatingDescComparer Instance { get; } = new();
+
+        public int Compare(StressMarket? x, StressMarket? y) =>
+            (y?.Rating ?? 0).CompareTo(x?.Rating ?? 0);
+    }
+
+    private sealed class PriorityAscComparer : IComparer<StressMarket>
+    {
+        public static PriorityAscComparer Instance { get; } = new();
+
+        public int Compare(StressMarket? x, StressMarket? y) =>
+            (x?.Priority ?? 0).CompareTo(y?.Priority ?? 0);
+    }
+
+    private sealed class PriceDescComparer : IComparer<StressPrice>
+    {
+        public static PriceDescComparer Instance { get; } = new();
+
+        public int Compare(StressPrice? x, StressPrice? y) =>
+            (y?.Price ?? 0).CompareTo(x?.Price ?? 0);
+    }
+
+    // ════════════════════════════════════════════════════════════════
+    // The Test
+    // ════════════════════════════════════════════════════════════════
+
+    [Fact]
+    public async Task AllOperators_CrossCache_NoDeadlock_CorrectResults()
+    {
+        // ── Derive ALL test parameters from seeded Randomizer ────────
+        var rand = new Randomizer(Seed);
+
+        var sourceACount = rand.Number(SourceMarketCountMin, SourceMarketCountMax);
+        var sourceBCount = rand.Number(SourceMarketCountMin, SourceMarketCountMax);
+        var overlappingCount = rand.Number(OverlappingCountMin, OverlappingCountMax);
+        var treeCount = rand.Number(TreeMarketCountMin, TreeMarketCountMax);
+        var regionCount = rand.Number(RegionCountMin, RegionCountMax);
+        var regions = Enumerable.Range(0, regionCount).Select(i => $"Region-{i}").ToArray();
+        var ratingThreshold = rand.Double(RatingFilterThresholdMin, RatingFilterThresholdMax);
+        var transformMultiplier = rand.Double(TransformMultiplierMin, TransformMultiplierMax);
+        var pageSize = rand.Number(PageSizeMin, PageSizeMax);
+        var virtualSize = rand.Number(VirtualSizeMin, VirtualSizeMax);
+        var writerThreads = rand.Number(WriterThreadCountMin, WriterThreadCountMax);
+        var ratingMutations = rand.Number(RatingMutationsMin, RatingMutationsMax);
+        var regionMutations = rand.Number(RegionMutationsMin, RegionMutationsMax);
+        var timeoutSeconds = rand.Number(TimeoutSecondsMin, TimeoutSecondsMax);
+
+        // ID ranges (non-overlapping, derived from spacing)
+        var idA = rand.Number(1, IdRangeSpacing / 2);
+        var idB = idA + IdRangeSpacing;
+        var idOverlap = idB + IdRangeSpacing;
+        var idForward = idOverlap + IdRangeSpacing;
+        var idReverse = idForward + IdRangeSpacing;
+        var idTree = idReverse + IdRangeSpacing;
+
+        // ── Data Generation ─────────────────────────────────────────
+        var marketsA = GenerateMarkets(rand, idA, sourceACount, regions);
+        var marketsB = GenerateMarkets(rand, idB, sourceBCount, regions);
+        var overlapping = GenerateMarkets(rand, idOverlap, overlappingCount, regions);
+        var treeMarkets = GenerateTreeMarkets(rand, idTree, treeCount, regions);
+
+        // ── Source Caches ───────────────────────────────────────────
+        using var sourceA = new SourceCache<StressMarket, int>(m => m.Id);
+        using var sourceB = new SourceCache<StressMarket, int>(m => m.Id);
+        using var treeSource = new SourceCache<StressMarket, int>(m => m.Id);
+
+        // ── Subjects for dynamic parameters ─────────────────────────
+        using var pageRequests = new BehaviorSubject<IPageRequest>(new PageRequest(1, pageSize));
+        using var virtualRequests = new BehaviorSubject<IVirtualRequest>(new VirtualRequest(0, virtualSize));
+        using var pauseBatch = new BehaviorSubject<bool>(false);
+        using var forceTransform = new Subject<Func<StressMarket, bool>>();
+        using var switchSource = new BehaviorSubject<IObservable<IChangeSet<StressMarket, int>>>(sourceA.Connect());
+        using var comparerSubject = new BehaviorSubject<IComparer<StressMarket>>(RatingDescComparer.Instance);
+
+        // Stop signal for operators with a library gap — they don't forward OnCompleted:
+        // Static Combiner (Or/And/Except), BatchIf, TransformToTree, Switch
+        using var stopSignal = new Subject<Unit>();
+
+        // ── Completion tracking ─────────────────────────────────────
+        var completionTasks = new List<Task>();
+        var completionNames = new List<string>();
+        using var subs = new CompositeDisposable();
+
+        // Helpers
+        IObservableCache<TObj, TKey> TrackCache<TObj, TKey>(IObservable<IChangeSet<TObj, TKey>> pipeline, [System.Runtime.CompilerServices.CallerArgumentExpression(nameof(pipeline))] string? name = null)
+            where TObj : notnull where TKey : notnull
+        {
+            var pub = pipeline.Publish();
+            completionTasks.Add(pub.LastOrDefaultAsync().ToTask());
+            completionNames.Add(name ?? "?");
+            var cache = pub.AsObservableCache();
+            subs.Add(cache);
+            subs.Add(pub.Connect());
+            return cache;
+        }
+
+        // Bidirectional flows need writable SourceCaches
+        using var forwardTarget = new SourceCache<StressMarket, int>(m => m.Id);
+        using var reverseTarget = new SourceCache<StressMarket, int>(m => m.Id);
+
+        void TrackIntoCache(IObservable<IChangeSet<StressMarket, int>> pipeline, SourceCache<StressMarket, int> target, [System.Runtime.CompilerServices.CallerArgumentExpression(nameof(pipeline))] string? name = null)
+        {
+            var pub = pipeline.Publish();
+            completionTasks.Add(pub.LastOrDefaultAsync().ToTask());
+            completionNames.Add(name ?? "?");
+            subs.Add(pub.PopulateInto(target));
+            subs.Add(pub.Connect());
+        }
+
+        // ── Auto-dispose items removed from source caches ───────────
+        subs.Add(sourceA.Connect().DisposeMany().Subscribe());
+        subs.Add(sourceB.Connect().DisposeMany().Subscribe());
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 1 — Forward Bidirectional: sourceA → forwardTarget → sourceB
+        // Operators: AutoRefresh, Filter(dynamic), Transform(forceTransform),
+        //            OnItemRemoved, DisposeMany, Sort, Page, BatchIf
+        // ════════════════════════════════════════════════════════════
+
+        var forwardRemovals = 0;
+        var forwardIdCounter = idForward;
+
+        TrackIntoCache(
+            sourceA.Connect()
+                .AutoRefresh(m => m.Rating)                                   // AutoRefresh [1]
+                .Filter(m => m.Id >= idA && m.Id < idA + sourceACount         // Filter(dynamic) [1]
+                          && m.Rating >= ratingThreshold)
+                .Transform(                                                    // Transform(forceTransform) [1]
+                    m => new StressMarket(
+                        Interlocked.Increment(ref forwardIdCounter),
+                        $"F-{m.Name}", m.Region, m.Priority,
+                        m.Rating * transformMultiplier),
+                    forceTransform)
+                .OnItemRemoved(m =>                                            // OnItemRemoved [1]
+                    Interlocked.Increment(ref forwardRemovals))
+                .DisposeMany()                                                 // DisposeMany [1]
+                .Sort(RatingDescComparer.Instance)                             // Sort [1]
+                .Page(pageRequests)                                            // Page [1]
+                .BatchIf(pauseBatch, false, (TimeSpan?)null)                   // BatchIf [1]
+                .TakeUntil(stopSignal),
+            forwardTarget);
+
+        subs.Add(forwardTarget.Connect().PopulateInto(sourceB));
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 2 — Reverse Bidirectional: sourceB → reverseTarget → sourceA
+        // Operators: AutoRefresh, Filter(dynamic), Sort, Virtualise
+        // ════════════════════════════════════════════════════════════
+
+        var reverseIdCounter = idReverse;
+
+        TrackIntoCache(
+            sourceB.Connect()
+                .AutoRefresh(m => m.Rating)                                   // AutoRefresh [2]
+                .Filter(m => m.Id >= idB && m.Id < idB + sourceBCount         // Filter(dynamic) [2]
+                          && m.Rating >= ratingThreshold)
+                .Sort(RatingDescComparer.Instance)                             // Sort [2]
+                .Virtualise(virtualRequests)                                   // Virtualise [1]
+                .Transform(m => new StressMarket(                              // Transform [2]
+                    Interlocked.Increment(ref reverseIdCounter),
+                    $"R-{m.Name}", m.Region, m.Priority, m.Rating))
+                .TakeUntil(stopSignal),                                        // AutoRefresh doesn't forward OnCompleted
+            reverseTarget);
+
+        subs.Add(reverseTarget.Connect().PopulateInto(sourceA));
+
+        // Side chains
+        using var sortVirtResults = sourceB.Connect()
+            .SortAndVirtualize(comparerSubject, virtualRequests)               // SortAndVirtualize [1]
+            .AsAggregator();
+
+        IQuery<StressMarket, int>? lastQuery = null;
+        var qwcTcs = new TaskCompletionSource();
+        subs.Add(sourceB.Connect()
+            .QueryWhenChanged()                                                // QueryWhenChanged [1]
+            .Subscribe(q => lastQuery = q, ex => qwcTcs.TrySetException(ex), () => qwcTcs.TrySetResult()));
+        completionTasks.Add(qwcTcs.Task);
+        completionNames.Add("QueryWhenChanged-B");
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 3 — Joins: sourceA × sourceB
+        // Operators: FullJoin, InnerJoin, LeftJoin, RightJoin
+        // ════════════════════════════════════════════════════════════
+
+        var fullJoinCache = TrackCache(
+            sourceA.Connect().FullJoin(                                        // FullJoin [1]
+                sourceB.Connect(), r => r.Id,
+                (key, left, right) =>
+                {
+                    var src = left.HasValue ? left.Value : right.Value;
+                    return new StressMarket(key, $"FJ-{src.Name}", src.Region, src.Priority, src.Rating);
+                }));
+
+        var innerJoinCache = TrackCache(
+            sourceA.Connect().InnerJoin(                                       // InnerJoin [1]
+                sourceB.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key.leftKey, $"IJ-{left.Name}", left.Region, left.Priority, right.Rating))
+                .ChangeKey(m => m.Id));
+
+        var leftJoinCache = TrackCache(
+            sourceA.Connect().LeftJoin(                                        // LeftJoin [1]
+                sourceB.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key, $"LJ-{left.Name}", left.Region, left.Priority,
+                        right.HasValue ? right.Value.Rating : left.Rating)));
+
+        var rightJoinCache = TrackCache(
+            sourceA.Connect().RightJoin(                                       // RightJoin [1]
+                sourceB.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key, $"RJ-{right.Name}", right.Region, right.Priority,
+                        left.HasValue ? left.Value.Rating : right.Rating)));
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 4 — Combiners + second join uses
+        // Operators: Or, And, Except, MergeChangeSets, FullJoin[2], InnerJoin[2]
+        // ════════════════════════════════════════════════════════════
+
+        var orCache = TrackCache(
+            sourceA.Connect().Or(sourceB.Connect())                            // Or [1]
+                .TakeUntil(stopSignal));
+
+        var andCache = TrackCache(
+            sourceA.Connect().And(sourceB.Connect())                           // And [1]
+                .TakeUntil(stopSignal));
+
+        var exceptCache = TrackCache(
+            sourceA.Connect().Except(sourceB.Connect())                        // Except [1]
+                .TakeUntil(stopSignal));
+
+        var mergedCache = TrackCache(
+            new[] { sourceA.Connect(), sourceB.Connect() }
+                .MergeChangeSets());                                           // MergeChangeSets [1]
+
+        // Second join uses: join the join outputs together
+        var joinedJoinsCache = TrackCache(
+            fullJoinCache.Connect().FullJoin(                                  // FullJoin [2]
+                rightJoinCache.Connect(), r => r.Id,
+                (key, left, right) =>
+                {
+                    var src = left.HasValue ? left.Value : right.Value;
+                    return new StressMarket(key, $"JJ-{src.Name}", src.Region, src.Priority, src.Rating);
+                }));
+
+        // Second InnerJoin on the overlapping subset
+        var innerJoin2Cache = TrackCache(
+            leftJoinCache.Connect().InnerJoin(                                 // InnerJoin [2]
+                rightJoinCache.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key.leftKey, $"IJ2-{left.Name}", left.Region, left.Priority, right.Rating))
+                .ChangeKey(m => m.Id));
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 5 — Groups: sourceA → grouped → flattened
+        // Operators: GroupOn, GroupOnImmutable, GroupOnObservable, MergeMany
+        // ════════════════════════════════════════════════════════════
+
+        var groupCache = TrackCache(
+            sourceA.Connect()
+                .Group(m => m.Region)                                          // GroupOn [1]
+                .MergeMany(group => group.Cache.Connect()));                   // MergeMany [1]
+
+        using var immGroupAgg = sourceA.Connect()
+            .GroupWithImmutableState(m => m.Region)                            // GroupOnImmutable [1]
+            .AsAggregator();
+
+        var dynGroupCache = TrackCache(
+            sourceA.Connect()
+                .GroupOnObservable(m => m.WhenPropertyChanged(x => x.Region)   // GroupOnObservable [1]
+                    .Select(pv => pv.Value ?? regions[0]))
+                .MergeMany(group => group.Cache.Connect())
+                .TakeUntil(stopSignal));                                        // WhenPropertyChanged children don't complete
+
+        // Second GroupOn use on sourceB
+        var groupBCache = TrackCache(
+            sourceB.Connect()
+                .Group(m => m.Region)                                          // GroupOn [2]
+                .MergeMany(group => group.Cache.Connect()));                   // MergeMany [3]
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 6 — MergeManyChangeSets (both overloads)
+        // ════════════════════════════════════════════════════════════
+
+        // 6a: Child comparer — highest price wins across markets
+        var childPriceCache = TrackCache(
+            sourceA.Connect()
+                .MergeManyChangeSets(m => m.LatestPrices,                      // MergeManyCS(child) [1]
+                    PriceDescComparer.Instance));
+
+        // 6b: Source comparer + child comparer — priority then price
+        var sourcePriceCache = TrackCache(
+            sourceB.Connect()
+                .MergeManyChangeSets(m => m.LatestPrices,                      // MergeManyCS(source) [1]
+                    PriorityAscComparer.Instance, PriceDescComparer.Instance));
+
+        // Second uses: reversed sources
+        var childPriceBCache = TrackCache(
+            sourceB.Connect()
+                .MergeManyChangeSets(m => m.LatestPrices,                      // MergeManyCS(child) [2]
+                    PriceDescComparer.Instance));
+
+        var sourcePriceACache = TrackCache(
+            sourceA.Connect()
+                .MergeManyChangeSets(m => m.LatestPrices,                      // MergeManyCS(source) [2]
+                    PriorityAscComparer.Instance, PriceDescComparer.Instance));
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 7 — Sort Variants, Switch, second BatchIf/Page/Virtualise
+        // ════════════════════════════════════════════════════════════
+
+        var boundListA = new List<StressMarket>();
+        subs.Add(sourceA.Connect()
+            .SortAndBind(boundListA, RatingDescComparer.Instance)              // SortAndBind [1]
+            .Subscribe());
+
+        var boundListB = new List<StressMarket>();
+        subs.Add(sourceA.Connect()
+            .SortAndBind(boundListB, comparerSubject)                          // SortAndBind [2]
+            .Subscribe());
+
+        var switchCache = TrackCache(
+            switchSource.Switch()                                              // Switch [1]
+                .TakeUntil(stopSignal));
+
+        // Second Page + Virtualise + BatchIf uses on sourceB
+        using var pageBSubject = new BehaviorSubject<IPageRequest>(new PageRequest(1, pageSize));
+        using var pauseB = new BehaviorSubject<bool>(false);
+
+        var pageBCache = TrackCache(
+            sourceB.Connect()
+                .Sort(PriorityAscComparer.Instance)                            // Sort [3]
+                .Page(pageBSubject)                                            // Page [2]
+                .BatchIf(pauseB, false, (TimeSpan?)null)                       // BatchIf [2]
+                .TakeUntil(stopSignal));
+
+        using var virtBRequests = new BehaviorSubject<IVirtualRequest>(new VirtualRequest(0, virtualSize));
+        var virtBCache = TrackCache(
+            sourceB.Connect()
+                .Sort(PriorityAscComparer.Instance)                            // Sort [4]
+                .Virtualise(virtBRequests));                                    // Virtualise [2]
+
+        // ════════════════════════════════════════════════════════════
+        // FLOW 8 — TransformMany, TransformToTree, second OnItemRemoved
+        // ════════════════════════════════════════════════════════════
+
+        var allPricesACache = TrackCache(
+            sourceA.Connect()
+                .TransformMany(m => (IObservableCache<StressPrice, int>)m.Prices, // TransformMany [1]
+                    p => p.Id));
+
+        var allPricesBCache = TrackCache(
+            sourceB.Connect()
+                .TransformMany(m => (IObservableCache<StressPrice, int>)m.Prices, // TransformMany [2]
+                    p => p.Id));
+
+        // TransformToTree doesn't forward OnCompleted (library gap) — needs TakeUntil
+        var treeCache = TrackCache(
+            treeSource.Connect()
+                .TransformToTree(m => m.ParentId ?? 0)                         // TransformToTree [1]
+                .TakeUntil(stopSignal));
+
+        // Second OnItemRemoved + DisposeMany on sourceB
+        var reverseRemovals = 0;
+        subs.Add(sourceB.Connect()
+            .OnItemRemoved(m => Interlocked.Increment(ref reverseRemovals))    // OnItemRemoved [2]
+            .DisposeMany()                                                     // DisposeMany [2]
+            .Subscribe());
+
+        // Operators not covered here (AsyncDisposeMany, TransformAsync, TransformOnObservable,
+        // TransformManyAsync, SortAndPage, MergeManyListChangeSets) are exercised
+        // in their dedicated fixture tests under concurrent load.
+
+        // Second SortAndVirtualize on sourceA
+        using var sortVirtAResults = sourceA.Connect()
+            .SortAndVirtualize(comparerSubject, virtualRequests)               // SortAndVirtualize [2]
+            .AsAggregator();
+
+        // Second QueryWhenChanged on sourceA
+        IQuery<StressMarket, int>? lastQueryA = null;
+        var qwcATcs = new TaskCompletionSource();
+        subs.Add(sourceA.Connect()
+            .QueryWhenChanged()                                                // QueryWhenChanged [2]
+            .Subscribe(q => lastQueryA = q, ex => qwcATcs.TrySetException(ex), () => qwcATcs.TrySetResult()));
+        completionTasks.Add(qwcATcs.Task);
+        completionNames.Add("QueryWhenChanged-A");
+
+        // Second Switch + GroupOnImmutable + GroupOnObservable
+        using var switchSource2 = new BehaviorSubject<IObservable<IChangeSet<StressMarket, int>>>(sourceB.Connect());
+        var switchCache2 = TrackCache(
+            switchSource2.Switch()                                             // Switch [2]
+                .TakeUntil(stopSignal));
+
+        using var immGroupBAgg = sourceB.Connect()
+            .GroupWithImmutableState(m => m.Region)                            // GroupOnImmutable [2]
+            .AsAggregator();
+
+        var dynGroupBCache = TrackCache(
+            sourceB.Connect()
+                .GroupOnObservable(m => m.WhenPropertyChanged(x => x.Region)   // GroupOnObservable [2]
+                    .Select(pv => pv.Value ?? regions[0]))
+                .MergeMany(group => group.Cache.Connect())
+                .TakeUntil(stopSignal));                                        // WhenPropertyChanged children don't complete
+
+        // Second LeftJoin + RightJoin + Or + And + Except + MergeChangeSets
+        var leftJoin2Cache = TrackCache(
+            sourceB.Connect().LeftJoin(                                        // LeftJoin [2]
+                sourceA.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key, $"LJ2-{left.Name}", left.Region, left.Priority,
+                        right.HasValue ? right.Value.Rating : left.Rating)));
+
+        var rightJoin2Cache = TrackCache(
+            sourceB.Connect().RightJoin(                                       // RightJoin [2]
+                sourceA.Connect(), r => r.Id,
+                (key, left, right) =>
+                    new StressMarket(key, $"RJ2-{right.Name}", right.Region, right.Priority,
+                        left.HasValue ? left.Value.Rating : right.Rating)));
+
+        var orCache2 = TrackCache(
+            sourceB.Connect().Or(sourceA.Connect())                            // Or [2]
+                .TakeUntil(stopSignal));
+
+        var andCache2 = TrackCache(
+            sourceB.Connect().And(sourceA.Connect())                           // And [2]
+                .TakeUntil(stopSignal));
+
+        var exceptCache2 = TrackCache(
+            sourceB.Connect().Except(sourceA.Connect())                        // Except [2]
+                .TakeUntil(stopSignal));
+
+        var mergedCache2 = TrackCache(
+            new[] { sourceB.Connect(), sourceA.Connect() }
+                .MergeChangeSets());                                           // MergeChangeSets [2]
+
+        // Second TransformToTree using a different subset
+        var treeCache2 = TrackCache(
+            treeSource.Connect()
+                .Filter(m => m.ParentId.HasValue || m.Id < idTree + treeCount / 2)
+                .TransformToTree(m => m.ParentId ?? 0)                         // TransformToTree [2]
+                .TakeUntil(stopSignal));
+
+        // ════════════════════════════════════════════════════════════
+        // Multi-Threaded Writers
+        // ════════════════════════════════════════════════════════════
+
+        var barrier = new Barrier(writerThreads * 2 + 1);
+        var slicesA = PartitionList(marketsA, writerThreads);
+        var slicesB = PartitionList(marketsB, writerThreads);
+        var writerTasks = new List<Task>();
+
+        for (var t = 0; t < writerThreads; t++)
+        {
+            var slice = slicesA[t];
+            var tRand = new Randomizer(Seed + t + 1);
+            writerTasks.Add(Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                sourceA.Edit(updater => { foreach (var m in slice) updater.AddOrUpdate(m); });
+                for (var i = 0; i < ratingMutations; i++)
+                    slice[tRand.Number(0, slice.Count - 1)].Rating = tRand.Double(RatingMin, RatingMax);
+                for (var i = 0; i < regionMutations; i++)
+                    slice[tRand.Number(0, slice.Count - 1)].Region = regions[tRand.Number(0, regionCount - 1)];
+                barrier.SignalAndWait();
+            }));
+        }
+
+        for (var t = 0; t < writerThreads; t++)
+        {
+            var slice = slicesB[t];
+            var tRand = new Randomizer(Seed + writerThreads + t + 1);
+            writerTasks.Add(Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                sourceB.Edit(updater => { foreach (var m in slice) updater.AddOrUpdate(m); });
+                for (var i = 0; i < ratingMutations; i++)
+                    slice[tRand.Number(0, slice.Count - 1)].Rating = tRand.Double(RatingMin, RatingMax);
+                barrier.SignalAndWait();
+            }));
+        }
+
+        // ── Start writers ───────────────────────────────────────────
+        barrier.SignalAndWait();
+        pauseBatch.OnNext(true);
+        barrier.SignalAndWait();
+        await Task.WhenAll(writerTasks);
+        pauseBatch.OnNext(false);
+
+        // Post-write operations
+        sourceA.AddOrUpdate(overlapping);
+        sourceB.AddOrUpdate(overlapping);
+        treeSource.AddOrUpdate(treeMarkets);
+        forceTransform.OnNext(m => m.Rating > ratingThreshold);
+        switchSource.OnNext(sourceB.Connect());
+        switchSource2.OnNext(sourceA.Connect());
+        comparerSubject.OnNext(PriorityAscComparer.Instance);
+
+        // ── Teardown ────────────────────────────────────────────────
+        // 1. Signal stop for operators with library gaps (don't forward OnCompleted):
+        //    Static Combiner (Or/And/Except), BatchIf, TransformToTree, Switch
+        stopSignal.OnNext(Unit.Default);
+        stopSignal.OnCompleted();
+
+        // ── Snapshot final state (bidirectional flows are frozen by stopSignal) ──
+        var finalAKeys = new HashSet<int>(sourceA.Keys);
+        var finalBKeys = new HashSet<int>(sourceB.Keys);
+
+        // 2. Complete all BehaviorSubjects so multi-source operators can complete
+        forceTransform.OnCompleted();
+        pageRequests.OnCompleted();
+        pageBSubject.OnCompleted();
+        virtualRequests.OnCompleted();
+        virtBRequests.OnCompleted();
+        comparerSubject.OnCompleted();
+        pauseBatch.OnCompleted();
+        pauseB.OnCompleted();
+        switchSource.OnCompleted();
+        switchSource2.OnCompleted();
+
+        // 2. Dispose source caches — fires OnCompleted on Connect() streams,
+        //    DisposeMany auto-disposes inner price caches (completing MMCS/TransformMany)
+        sourceA.Dispose();
+        sourceB.Dispose();
+        treeSource.Dispose();
+
+        // 3. Dispose subscriptions — disconnects Publish, firing OnCompleted on
+        //    all published streams (completes operators like AutoRefresh, TreeBuilder
+        //    that don't propagate OnCompleted naturally)
+        subs.Dispose();
+
+        // 4. Wait for all completion tasks with timeout (deadlock detector)
+        var allCompleted = Task.WhenAll(completionTasks);
+        var timeout = Task.Delay(TimeSpan.FromSeconds(timeoutSeconds));
+        var finished = await Task.WhenAny(allCompleted, timeout);
+        if (!ReferenceEquals(finished, allCompleted))
+        {
+            var pending = completionTasks.Select((t2, i) => new { Index = i, t2.Status, Name = completionNames[i] })
+                .Where(x => x.Status != TaskStatus.RanToCompletion)
+                .Select(x => $"[{x.Index}] {x.Name} ({x.Status})").ToList();
+            pending.Should().BeEmpty($"all {completionTasks.Count} tasks should finish within {timeoutSeconds}s. Pending: {string.Join(", ", pending)}");
+        }
+
+        // ════════════════════════════════════════════════════════════
+        // Verification — exact contents with BeEquivalentTo
+        // ════════════════════════════════════════════════════════════
+
+        // Flow 1: Forward — filtered, transformed, paged subset of sourceA
+        forwardTarget.Count.Should().BeGreaterThan(0, "Flow1 should produce results");
+        forwardTarget.Count.Should().BeLessThanOrEqualTo(pageSize, "Page should limit");
+        forwardTarget.Items.Should().OnlyContain(m => m.Name.StartsWith("F-"), "Transform prefixes 'F-'");
+        forwardTarget.Items.Should().OnlyContain(
+            m => m.Rating >= ratingThreshold * transformMultiplier,
+            "Transform multiplies rating of items that passed filter");
+        forwardRemovals.Should().BeGreaterThan(0, "OnItemRemoved fires on rating mutation exits");
+
+        // Flow 2: Reverse — filtered, sorted, virtualized, transformed subset of sourceB
+        reverseTarget.Count.Should().BeGreaterThan(0, "Flow2 should produce results");
+        reverseTarget.Count.Should().BeLessThanOrEqualTo(virtualSize, "Virtualise limits");
+        reverseTarget.Items.Should().OnlyContain(m => m.Name.StartsWith("R-"), "Transform prefixes 'R-'");
+
+        // Flow 3: Joins — verify mathematical relationships hold
+        // Each cache may see a slightly different snapshot due to bidirectional flow timing,
+        // but the set-theoretic relationships must hold within each cache's own view.
+        fullJoinCache.Items.Should().OnlyContain(m => m.Name.StartsWith("FJ-"), "FullJoin prefixes 'FJ-'");
+        innerJoinCache.Items.Should().OnlyContain(m => m.Name.StartsWith("IJ-"), "InnerJoin prefixes 'IJ-'");
+        leftJoinCache.Items.Should().OnlyContain(m => m.Name.StartsWith("LJ-"), "LeftJoin prefixes 'LJ-'");
+        rightJoinCache.Items.Should().OnlyContain(m => m.Name.StartsWith("RJ-"), "RightJoin prefixes 'RJ-'");
+
+        // InnerJoin keys ⊂ FullJoin keys (intersection ⊂ union)
+        new HashSet<int>(innerJoinCache.Keys).IsSubsetOf(new HashSet<int>(fullJoinCache.Keys)).Should()
+            .BeTrue("InnerJoin ⊂ FullJoin");
+        // InnerJoin must have at least the overlapping keys
+        innerJoinCache.Count.Should().BeGreaterThanOrEqualTo(overlappingCount,
+            "InnerJoin finds at least overlapping items");
+
+        // Flow 4: Combiners — Or and Merged share the same Publish, so they're identical
+        orCache.Keys.Should().BeEquivalentTo(mergedCache.Keys, "Or = Merged (same Publish sources)");
+        // And ⊂ Or
+        new HashSet<int>(andCache.Keys).IsSubsetOf(new HashSet<int>(orCache.Keys)).Should()
+            .BeTrue("And ⊂ Or");
+        // Except ∩ And = ∅
+        new HashSet<int>(exceptCache.Keys).Overlaps(andCache.Keys).Should()
+            .BeFalse("Except ∩ And = ∅");
+        // Except ∪ And ∪ (items only in B) = Or
+        var exceptPlusAnd = new HashSet<int>(exceptCache.Keys);
+        exceptPlusAnd.UnionWith(andCache.Keys);
+        exceptPlusAnd.IsSubsetOf(new HashSet<int>(orCache.Keys)).Should()
+            .BeTrue("Except ∪ And ⊂ Or");
+
+        // Second joins — cross-verify with first joins (same sources, same completion)
+        leftJoin2Cache.Keys.Should().BeEquivalentTo(rightJoinCache.Keys, "LeftJoin2(B×A) = RightJoin(A×B)");
+        leftJoin2Cache.Items.Should().OnlyContain(m => m.Name.StartsWith("LJ2-"), "LeftJoin2 prefixes");
+        rightJoin2Cache.Keys.Should().BeEquivalentTo(leftJoinCache.Keys, "RightJoin2(B×A) = LeftJoin(A×B)");
+        rightJoin2Cache.Items.Should().OnlyContain(m => m.Name.StartsWith("RJ2-"), "RightJoin2 prefixes");
+        orCache2.Keys.Should().BeEquivalentTo(orCache.Keys, "Or2 = Or (same sources, same completion)");
+        andCache2.Keys.Should().BeEquivalentTo(andCache.Keys, "And2 = And (same sources)");
+        mergedCache2.Keys.Should().BeEquivalentTo(mergedCache.Keys, "MergedCache2 = Merged (same sources)");
+
+        // Flow 5: Groups — verify grouping preserves all items from same snapshot
+        groupCache.Items.Select(m => m.Region).Distinct().Count().Should()
+            .BeGreaterThan(1, "GroupOn creates multiple regions");
+        immGroupAgg.Data.Count.Should().BeGreaterThan(1, "GroupOnImmutable produces groups");
+        immGroupBAgg.Data.Count.Should().BeGreaterThan(1, "GroupOnImmutable(B) produces groups");
+
+        // Flow 6: MergeManyChangeSets — exact price key verification
+        // MMCS(child/A) and MMCS(source/A) see the same sourceA markets, same price keys
+        childPriceCache.Keys.Should().BeEquivalentTo(sourcePriceACache.Keys,
+            "MMCS(child/A) = MMCS(source/A) — same source markets, same price keys");
+        childPriceBCache.Keys.Should().BeEquivalentTo(sourcePriceCache.Keys,
+            "MMCS(child/B) = MMCS(source/B) — same source markets, same price keys");
+
+        // Flow 7: SortAndBind — exact count matching sourceA
+        boundListA.Count.Should().Be(leftJoinCache.Count, "SortAndBind = LeftJoin count (both see all sourceA)");
+        boundListB.Count.Should().Be(leftJoinCache.Count, "SortAndBind(obs) = LeftJoin count");
+        for (var i = 1; i < boundListB.Count; i++)
+            boundListB[i - 1].Priority.Should().BeLessThanOrEqualTo(boundListB[i].Priority,
+                "SortAndBind(obs) re-sorted by priority after comparer switch");
+
+        // Switch: after switching, should have items from the switched-to source
+        switchCache.Count.Should().BeGreaterThan(0, "Switch (switched to B) has items");
+        switchCache2.Count.Should().BeGreaterThan(0, "Switch2 (switched to A) has items");
+
+        pageBCache.Count.Should().BeGreaterThan(0, "Page(B) produces results");
+        pageBCache.Count.Should().BeLessThanOrEqualTo(pageSize, "Page(B) respects page limit");
+        virtBCache.Count.Should().BeGreaterThan(0, "Virtualise(B) produces results");
+        virtBCache.Count.Should().BeLessThanOrEqualTo(virtualSize, "Virtualise(B) respects virtual limit");
+
+        // Flow 8: TransformMany — exact price key sets from original markets
+        var expectedPriceKeysA = new HashSet<int>(marketsA.SelectMany(m => m.Prices.Keys));
+        new HashSet<int>(allPricesACache.Keys).IsSupersetOf(expectedPriceKeysA).Should()
+            .BeTrue("TransformMany(A) contains all original sourceA prices");
+        var expectedPriceKeysB = new HashSet<int>(marketsB.SelectMany(m => m.Prices.Keys));
+        new HashSet<int>(allPricesBCache.Keys).IsSupersetOf(expectedPriceKeysB).Should()
+            .BeTrue("TransformMany(B) contains all original sourceB prices");
+
+        // TransformToTree
+        static int CountAll(IEnumerable<Node<StressMarket, int>> nodes)
+        {
+            var c = 0;
+            foreach (var n in nodes) { c++; c += CountAll(n.Children.Items); }
+            return c;
+        }
+
+        CountAll(treeCache.Items).Should().Be(treeCount, "Tree has all markets across depths");
+        treeCache.Items.Any(n => n.Children.Count > 0).Should().BeTrue("Tree has child nodes");
+        treeCache2.Count.Should().BeGreaterThan(0, "Tree2 produces results");
+
+        
+
+        // Side chains
+        lastQuery.Should().NotBeNull("QueryWhenChanged(B) fired");
+        lastQueryA.Should().NotBeNull("QueryWhenChanged(A) fired");
+        sortVirtResults.Data.Count.Should().BeLessThanOrEqualTo(virtualSize, "SortAndVirtualize respects limit");
+        sortVirtAResults.Data.Count.Should().BeLessThanOrEqualTo(virtualSize, "SortAndVirtualize(A) respects limit");
+    }
+
+    // ════════════════════════════════════════════════════════════════
+    // Data Generation
+    // ════════════════════════════════════════════════════════════════
+
+    private static List<StressMarket> GenerateMarkets(Randomizer rand, int idStart, int count, string[] regions)
+    {
+        var markets = new List<StressMarket>(count);
+        for (var i = 0; i < count; i++)
+        {
+            var id = idStart + i;
+            var market = new StressMarket(
+                id, $"Market-{id}",
+                regions[rand.Number(0, regions.Length - 1)],
+                rand.Number(PriorityMin, PriorityMax),
+                rand.Double(RatingMin, RatingMax));
+
+            var priceCount = rand.Number(PricesPerMarketMin, PricesPerMarketMax);
+            market.Prices.Edit(u =>
+            {
+                for (var p = 0; p < priceCount; p++)
+                    u.AddOrUpdate(new StressPrice(id * 1000 + p, id, rand.Decimal(PriceMin, PriceMax)));
+            });
+
+            markets.Add(market);
+        }
+
+        return markets;
+    }
+
+    private static List<StressMarket> GenerateTreeMarkets(Randomizer rand, int idStart, int count, string[] regions)
+    {
+        var markets = new List<StressMarket>(count);
+        var rootCount = Math.Max(2, count / 3);
+
+        for (var i = 0; i < rootCount; i++)
+            markets.Add(new StressMarket(idStart + i, $"Tree-Root-{i}",
+                regions[rand.Number(0, regions.Length - 1)],
+                rand.Number(PriorityMin, PriorityMax),
+                rand.Double(RatingMin, RatingMax)));
+
+        for (var i = rootCount; i < count; i++)
+        {
+            var parentIdx = rand.Number(0, i - 1);
+            markets.Add(new StressMarket(idStart + i, $"Tree-Child-{i}",
+                regions[rand.Number(0, regions.Length - 1)],
+                rand.Number(PriorityMin, PriorityMax),
+                rand.Double(RatingMin, RatingMax),
+                markets[parentIdx].Id));
+        }
+
+        return markets;
+    }
+
+    private static List<List<T>> PartitionList<T>(List<T> source, int partitions)
+    {
+        var result = Enumerable.Range(0, partitions).Select(_ => new List<T>()).ToList();
+        for (var i = 0; i < source.Count; i++)
+            result[i % partitions].Add(source[i]);
+        return result;
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/DeadlockTortureTest.cs b/src/DynamicData.Tests/Cache/DeadlockTortureTest.cs
new file mode 100644
index 000000000..4f4ddf9a4
--- /dev/null
+++ b/src/DynamicData.Tests/Cache/DeadlockTortureTest.cs
@@ -0,0 +1,148 @@
+// 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.Reactive.Subjects;
+using System.Threading;
+using System.Threading.Tasks;
+
+using DynamicData.Binding;
+using DynamicData.Tests.Domain;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Cache;
+
+/// <summary>
+/// Deadlock torture test. Every dangerous operator (one that holds a lock during
+/// downstream delivery) is wired into a bidirectional cross-cache pipeline.
+/// Two threads write simultaneously, creating the ABBA lock cycle:
+///   Thread A: sourceA._locker -> operator lock -> PopulateInto -> sourceB._locker
+///   Thread B: sourceB._locker -> operator lock -> PopulateInto -> sourceA._locker
+///
+/// On main (Synchronize(lock)): deadlocks reliably within seconds.
+/// On the PR branch (SynchronizeSafe queue-drain): no deadlock possible.
+/// </summary>
+public sealed class DeadlockTortureTest
+{
+    private const int ItemCount = 200;
+    private const int Iterations = 50;
+    private const int TimeoutSeconds = 15;
+
+    private static async Task<bool> RunBidirectionalDeadlockTest(
+        Func<IObservable<IChangeSet<Person, string>>, IObservable<IChangeSet<Person, string>>> pipeline,
+        int iterations = Iterations)
+    {
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            using var sourceA = new SourceCache<Person, string>(p => p.UniqueKey);
+            using var sourceB = new SourceCache<Person, string>(p => p.UniqueKey);
+
+            using var aToB = pipeline(sourceA.Connect().Filter(x => x.Name.StartsWith("A"))).PopulateInto(sourceB);
+            using var bToA = pipeline(sourceB.Connect().Filter(x => x.Name.StartsWith("B"))).PopulateInto(sourceA);
+
+            using var barrier = new Barrier(2);
+            var taskA = Task.Run(() => { barrier.SignalAndWait(); for (var i = 0; i < ItemCount; i++) sourceA.AddOrUpdate(new Person("A-" + iter + "-" + i, i)); });
+            var taskB = Task.Run(() => { barrier.SignalAndWait(); for (var i = 0; i < ItemCount; i++) sourceB.AddOrUpdate(new Person("B-" + iter + "-" + i, i)); });
+
+            var completed = Task.WhenAll(taskA, taskB);
+            if (await Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds))) != completed)
+                return false;
+        }
+        return true;
+    }
+
+    [Fact] public async Task Sort_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)))).Should().BeTrue();
+
+    [Fact] public async Task AutoRefresh_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.AutoRefresh(p => p.Age))).Should().BeTrue();
+
+    [Fact] public async Task GroupOn_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.Group(p => p.Age % 3).MergeMany(g => g.Cache.Connect()))).Should().BeTrue();
+
+    [Fact] public async Task Page_DoesNotDeadlock()
+    {
+        using var req = new BehaviorSubject<IPageRequest>(new PageRequest(1, 50));
+        (await RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)).Page(req))).Should().BeTrue();
+    }
+
+    [Fact] public async Task Virtualise_DoesNotDeadlock()
+    {
+        using var req = new BehaviorSubject<IVirtualRequest>(new VirtualRequest(0, 50));
+        (await RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)).Virtualise(req))).Should().BeTrue();
+    }
+
+    [Fact] public async Task TransformWithForce_DoesNotDeadlock()
+    {
+        using var force = new Subject<Func<Person, string, bool>>();
+        (await RunBidirectionalDeadlockTest(s => s.Transform((p, k) => new Person("T-" + p.Name, p.Age), force))).Should().BeTrue();
+    }
+
+    [Fact] public async Task BatchIf_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.BatchIf(new BehaviorSubject<bool>(false), false, (TimeSpan?)null))).Should().BeTrue();
+
+    [Fact] public async Task DisposeMany_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.DisposeMany())).Should().BeTrue();
+
+    [Fact] public async Task OnItemRemoved_DoesNotDeadlock() =>
+        (await RunBidirectionalDeadlockTest(s => s.OnItemRemoved(_ => { }))).Should().BeTrue();
+
+    [Fact] public async Task AllDangerous_Stacked_DoNotDeadlock()
+    {
+        using var pageReq = new BehaviorSubject<IPageRequest>(new PageRequest(1, 100));
+        using var force = new Subject<Func<Person, string, bool>>();
+        (await RunBidirectionalDeadlockTest(
+            s => s.AutoRefresh(p => p.Age)
+                  .Filter(p => p.Age >= 0)
+                  .Transform((p, k) => new Person("X-" + p.Name, p.Age), force)
+                  .OnItemRemoved(_ => { })
+                  .DisposeMany()
+                  .Sort(SortExpressionComparer<Person>.Ascending(p => p.Age))
+                  .Page(pageReq),
+            iterations: Iterations * 2)).Should().BeTrue();
+    }
+
+    [Fact] public async Task MultiplePairs_Simultaneous_NoDeadlock()
+    {
+        using var pageReq = new BehaviorSubject<IPageRequest>(new PageRequest(1, 50));
+        using var virtReq = new BehaviorSubject<IVirtualRequest>(new VirtualRequest(0, 50));
+        var results = await Task.WhenAll(
+            RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)), 30),
+            RunBidirectionalDeadlockTest(s => s.AutoRefresh(p => p.Age), 30),
+            RunBidirectionalDeadlockTest(s => s.Group(p => p.Age % 3).MergeMany(g => g.Cache.Connect()), 30),
+            RunBidirectionalDeadlockTest(s => s.OnItemRemoved(_ => { }), 30),
+            RunBidirectionalDeadlockTest(s => s.DisposeMany(), 30),
+            RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)).Page(pageReq), 30),
+            RunBidirectionalDeadlockTest(s => s.Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)).Virtualise(virtReq), 30),
+            RunBidirectionalDeadlockTest(s => s.BatchIf(new BehaviorSubject<bool>(false), false, (TimeSpan?)null), 30));
+        results.Should().AllSatisfy(r => r.Should().BeTrue());
+    }
+
+    [Fact] public async Task ThreeWayCircular_DoesNotDeadlock()
+    {
+        for (var iter = 0; iter < Iterations; iter++)
+        {
+            using var a = new SourceCache<Person, string>(p => p.UniqueKey);
+            using var b = new SourceCache<Person, string>(p => p.UniqueKey);
+            using var c = new SourceCache<Person, string>(p => p.UniqueKey);
+
+            using var ab = a.Connect().Filter(p => p.Name.StartsWith("A")).Sort(SortExpressionComparer<Person>.Ascending(p => p.Age)).PopulateInto(b);
+            using var bc = b.Connect().Filter(p => p.Name.StartsWith("A")).AutoRefresh(p => p.Age).PopulateInto(c);
+            using var ca = c.Connect().Filter(p => p.Name.StartsWith("A")).Transform((p, _) => new Person("C-" + p.Name, p.Age)).Filter(p => p.Name.StartsWith("C")).PopulateInto(a);
+
+            using var barrier = new Barrier(3);
+            var tasks = new[]
+            {
+                Task.Run(() => { barrier.SignalAndWait(); for (var i = 0; i < ItemCount; i++) a.AddOrUpdate(new Person("A-" + iter + "-" + i, i)); }),
+                Task.Run(() => { barrier.SignalAndWait(); for (var i = 0; i < ItemCount; i++) b.AddOrUpdate(new Person("B-" + iter + "-" + i, i)); }),
+                Task.Run(() => { barrier.SignalAndWait(); for (var i = 0; i < ItemCount; i++) c.AddOrUpdate(new Person("CC-" + iter + "-" + i, i)); }),
+            };
+            var completed = Task.WhenAll(tasks);
+            (await Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds)))).Should().BeSameAs(completed, "iteration " + iter);
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheSourceCompareFixture.cs b/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheSourceCompareFixture.cs
index 33db06f05..ce6cc89fd 100644
--- a/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheSourceCompareFixture.cs
+++ b/src/DynamicData.Tests/Cache/MergeManyChangeSetsCacheSourceCompareFixture.cs
@@ -5,6 +5,7 @@
 using System.Reactive.Disposables;
 using System.Reactive;
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Threading.Tasks;
 using Bogus;
 using DynamicData.Kernel;
@@ -90,9 +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, Market.RatingCompare, resortOnSourceRefresh: true);
+        var merged = _marketCache.Connect().MergeManyChangeSets(market => market.LatestPrices, Market.RatingCompare, resortOnSourceRefresh: true).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)
@@ -118,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, Market.RatingCompare);
     }
diff --git a/src/DynamicData.Tests/Cache/SourceCacheFixture.cs b/src/DynamicData.Tests/Cache/SourceCacheFixture.cs
index a1380137b..99b79fbfd 100644
--- a/src/DynamicData.Tests/Cache/SourceCacheFixture.cs
+++ b/src/DynamicData.Tests/Cache/SourceCacheFixture.cs
@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 using DynamicData.Tests.Domain;
 
@@ -188,4 +191,168 @@ public void StaticFilterRemove()
 
     public record class SomeObject(int Id, int Value);
 
+
+    [Fact]
+    public async Task MultiCacheFanInDoesNotDeadlock()
+    {
+        const int itemCount = 100;
+
+        using var cacheA = new SourceCache<TestItem, string>(static x => x.Key);
+        using var cacheB = new SourceCache<TestItem, string>(static x => x.Key);
+        using var destination = new SourceCache<TestItem, string>(static x => x.Key);
+        using var subA = cacheA.Connect().PopulateInto(destination);
+        using var subB = cacheB.Connect().PopulateInto(destination);
+        using var results = destination.Connect().AsAggregator();
+
+        var taskA = Task.Run(() =>
+        {
+            for (var i = 0; i < itemCount; i++)
+            {
+                cacheA.AddOrUpdate(new TestItem($"a-{i}", $"ValueA-{i}"));
+            }
+        });
+
+        var taskB = Task.Run(() =>
+        {
+            for (var i = 0; i < itemCount; i++)
+            {
+                cacheB.AddOrUpdate(new TestItem($"b-{i}", $"ValueB-{i}"));
+            }
+        });
+
+        var completed = Task.WhenAll(taskA, taskB);
+        var finished = await Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(10)));
+
+        finished.Should().BeSameAs(completed, "concurrent edits with cross-cache subscribers should not deadlock");
+        results.Error.Should().BeNull();
+        results.Data.Count.Should().Be(itemCount * 2, "all items from both caches should arrive in the destination");
+        results.Data.Items.Should().BeEquivalentTo([.. cacheA.Items, .. cacheB.Items], "all items should be in the destination");
+    }
+
+    [Fact]
+    public async Task DirectCrossWriteDoesNotDeadlock()
+    {
+        const int iterations = 50;
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            using var cacheA = new SourceCache<TestItem, string>(static x => x.Key);
+            using var cacheB = new SourceCache<TestItem, string>(static x => x.Key);
+
+            // Bidirectional: A items flow into B, B items flow into A.
+            // Filter by prefix prevents infinite feedback.
+            using var aToB = cacheA.Connect()
+                .Filter(static x => x.Key.StartsWith('a'))
+                .Transform(static (item, _) => new TestItem("from-a-" + item.Key, item.Value))
+                .PopulateInto(cacheB);
+
+            using var bToA = cacheB.Connect()
+                .Filter(static x => x.Key.StartsWith('b'))
+                .Transform(static (item, _) => new TestItem("from-b-" + item.Key, item.Value))
+                .PopulateInto(cacheA);
+
+            using var barrier = new Barrier(2);
+
+            var taskA = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                for (var i = 0; i < 1000; i++)
+                {
+                    cacheA.AddOrUpdate(new TestItem("a" + i, "V" + i));
+                }
+            });
+
+            var taskB = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                for (var i = 0; i < 1000; i++)
+                {
+                    cacheB.AddOrUpdate(new TestItem("b" + i, "V" + i));
+                }
+            });
+
+            var completed = Task.WhenAll(taskA, taskB);
+            var finished = await Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(60)));
+
+            finished.Should().BeSameAs(completed, $"iteration {iter}: bidirectional cross-cache writes should not deadlock");
+        }
+    }
+
+    [Fact]
+    public void ConnectDuringDeliveryDoesNotDuplicate()
+    {
+        // Exploits the dequeue-to-OnNext window. Thread A writes two items in
+        // separate batches. The first delivery is held by a slow subscriber.
+        // While item1 delivery is blocked, item2 is committed to ReaderWriter
+        // and sitting in the queue. Thread B calls Connect(), takes a snapshot
+        // (sees both items), subscribes to _changes, then item2 is delivered
+        // via OnNext — producing a duplicate if not guarded by a generation counter.
+        using var cache = new SourceCache<TestItem, string>(static x => x.Key);
+
+        using var delivering = new ManualResetEventSlim(false);
+        using var item2Written = new ManualResetEventSlim(false);
+        using var connectDone = new ManualResetEventSlim(false);
+
+        var firstDelivery = true;
+
+        // First subscriber: blocks on the first delivery to create the window
+        using var slowSub = cache.Connect().Subscribe(_ =>
+        {
+            if (firstDelivery)
+            {
+                firstDelivery = false;
+                delivering.Set();
+
+                // Wait until item2 has been written and the Connect has subscribed
+                connectDone.Wait(TimeSpan.FromSeconds(5));
+            }
+        });
+
+        // Write item1 on a background thread — delivery starts, slow subscriber blocks
+        var writeTask = Task.Run(() =>
+        {
+            cache.AddOrUpdate(new TestItem("k1", "v1"));
+        });
+
+        // Wait for delivery of item1 to be in progress (slow sub is blocking)
+        delivering.Wait(TimeSpan.FromSeconds(5)).Should().BeTrue("delivery should have started");
+
+        // Now write item2 on another thread. It will acquire the lock, commit to
+        // ReaderWriter, enqueue a notification, and return. The notification sits
+        // in the queue because the deliverer (Thread A) is blocked by the slow sub.
+        var writeTask2 = Task.Run(() =>
+        {
+            cache.AddOrUpdate(new TestItem("k2", "v2"));
+            item2Written.Set();
+        });
+        item2Written.Wait(TimeSpan.FromSeconds(5)).Should().BeTrue("item2 should have been written");
+
+        // Now Connect on the main thread. The snapshot from ReaderWriter includes
+        // BOTH k1 and k2. The subscription to _changes is added. When the slow
+        // subscriber unblocks, item2's notification will be delivered via OnNext
+        // and the new subscriber will see k2 again — a duplicate Add.
+        var addCounts = new Dictionary<string, int>();
+        using var newSub = cache.Connect().Subscribe(changes =>
+        {
+            foreach (var c in changes)
+            {
+                if (c.Reason == ChangeReason.Add)
+                {
+                    var key = c.Current.Key;
+                    addCounts[key] = addCounts.GetValueOrDefault(key) + 1;
+                }
+            }
+        });
+
+        // Unblock the slow subscriber — delivery resumes, item2 delivered
+        connectDone.Set();
+        writeTask.Wait(TimeSpan.FromSeconds(5)).Should().BeTrue("writeTask should complete");
+        writeTask2.Wait(TimeSpan.FromSeconds(5)).Should().BeTrue("writeTask2 should complete");
+
+        // Each key should appear exactly once in the new subscriber's view
+        addCounts.GetValueOrDefault("k1").Should().Be(1, "k1 should appear once (snapshot only)");
+        addCounts.GetValueOrDefault("k2").Should().Be(1, "k2 should appear once, not duplicated from snapshot + queued delivery");
+    }
+
+    private sealed record TestItem(string Key, string Value);
 }
diff --git a/src/DynamicData.Tests/Cache/SuspendNotificationsFixture.cs b/src/DynamicData.Tests/Cache/SuspendNotificationsFixture.cs
index e73de850e..db39604a5 100644
--- a/src/DynamicData.Tests/Cache/SuspendNotificationsFixture.cs
+++ b/src/DynamicData.Tests/Cache/SuspendNotificationsFixture.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using DynamicData.Kernel;
 using FluentAssertions;
@@ -352,6 +353,234 @@ public async Task SuspensionsAreThreadSafe()
         _results.Messages[0].Adds.Should().Be(100, "Should have 100 adds");
     }
 
+    [Fact]
+    public void ResumeThenReSuspendDeliversFirstBatchOnly()
+    {
+        // Forces the ordering: resume completes before re-suspend.
+        // The deferred subscriber activates with the first batch snapshot,
+        // then re-suspend holds the second batch until final resume.
+        using var cache = new SourceCache<int, int>(static x => x);
+        var dataSet1 = Enumerable.Range(0, 100).ToList();
+        var dataSet2 = Enumerable.Range(1000, 100).ToList();
+        var allData = dataSet1.Concat(dataSet2).ToList();
+
+        var suspend1 = cache.SuspendNotifications();
+        cache.AddOrUpdate(dataSet1);
+
+        using var results = cache.Connect().AsAggregator();
+        results.Messages.Count.Should().Be(0, "no messages during suspension");
+
+        // Resume first — subscriber activates
+        suspend1.Dispose();
+
+        results.Messages.Count.Should().Be(1, "exactly one message after resume");
+        results.Messages[0].Adds.Should().Be(dataSet1.Count, $"snapshot should have {dataSet1.Count} adds");
+        results.Messages[0].Removes.Should().Be(0, "no removes");
+        results.Messages[0].Updates.Should().Be(0, "no updates");
+        results.Messages[0].Select(x => x.Key).Should().Equal(dataSet1, "snapshot should contain first batch keys");
+
+        // Re-suspend, write second batch
+        var suspend2 = cache.SuspendNotifications();
+        cache.AddOrUpdate(dataSet2);
+
+        results.Messages.Count.Should().Be(1, "still one message — second batch held by suspension");
+        results.Summary.Overall.Adds.Should().Be(dataSet1.Count, $"still {dataSet1.Count} adds total");
+
+        // Final resume
+        suspend2.Dispose();
+
+        results.Messages.Count.Should().Be(2, "two messages total");
+        results.Messages[1].Adds.Should().Be(dataSet2.Count, $"second message has {dataSet2.Count} adds");
+        results.Messages[1].Removes.Should().Be(0, "no removes in second message");
+        results.Messages[1].Updates.Should().Be(0, "no updates in second message");
+        results.Messages[1].Select(x => x.Key).Should().Equal(dataSet2, "second message should contain second batch keys");
+
+        results.Summary.Overall.Adds.Should().Be(allData.Count, $"exactly {allData.Count} adds total");
+        results.Summary.Overall.Removes.Should().Be(0, "no removes");
+        results.Data.Count.Should().Be(allData.Count, $"{allData.Count} items in final state");
+        results.Error.Should().BeNull();
+        results.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public void ReSuspendThenResumeDeliversAllInSingleBatch()
+    {
+        // Forces the ordering: re-suspend before resume.
+        // Suspend count goes 1→2→1, no resume signal fires.
+        // Both batches accumulate and arrive as a single changeset on final resume.
+        using var cache = new SourceCache<int, int>(static x => x);
+        var dataSet1 = Enumerable.Range(0, 100).ToList();
+        var dataSet2 = Enumerable.Range(1000, 100).ToList();
+        var allData = dataSet1.Concat(dataSet2).ToList();
+
+        var suspend1 = cache.SuspendNotifications();
+        cache.AddOrUpdate(dataSet1);
+
+        using var results = cache.Connect().AsAggregator();
+        results.Messages.Count.Should().Be(0, "no messages during suspension");
+
+        // Re-suspend first — count goes 1→2
+        var suspend2 = cache.SuspendNotifications();
+
+        // Resume first suspend — count goes 2→1, still suspended
+        suspend1.Dispose();
+
+        results.Messages.Count.Should().Be(0, "no messages — still suspended (count=1)");
+        results.Summary.Overall.Adds.Should().Be(0, "no adds — still suspended");
+
+        // Write second batch while still suspended
+        cache.AddOrUpdate(dataSet2);
+
+        results.Messages.Count.Should().Be(0, "still no messages");
+
+        // Final resume — count goes 1→0
+        suspend2.Dispose();
+
+        results.Messages.Count.Should().Be(1, "single message with all data");
+        results.Messages[0].Adds.Should().Be(allData.Count, $"all {allData.Count} items in one changeset");
+        results.Messages[0].Removes.Should().Be(0, "no removes");
+        results.Messages[0].Updates.Should().Be(0, "no updates");
+        results.Messages[0].Select(c => c.Key).OrderBy(k => k).Should().Equal(allData, "should contain both batches in order");
+
+        results.Summary.Overall.Adds.Should().Be(allData.Count, $"exactly {allData.Count} adds total");
+        results.Summary.Overall.Removes.Should().Be(0, "no removes");
+        results.Summary.Overall.Updates.Should().Be(0, "no updates");
+        results.Data.Count.Should().Be(allData.Count, $"{allData.Count} items in final state");
+        results.Error.Should().BeNull();
+        results.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task ConcurrentSuspendDuringResumeDoesNotCorrupt()
+    {
+        // Stress test: races resume against re-suspend on two threads.
+        // Both orderings are correct (tested deterministically above).
+        // This test verifies no corruption, deadlocks, or data loss under contention.
+        const int iterations = 200;
+        var dataSet1 = Enumerable.Range(0, 100).ToList();
+        var dataSet2 = Enumerable.Range(1000, 100).ToList();
+        var allData = dataSet1.Concat(dataSet2).ToList();
+
+        for (var iter = 0; iter < iterations; iter++)
+        {
+            using var cache = new SourceCache<int, int>(static x => x);
+
+            var suspend1 = cache.SuspendNotifications();
+            cache.AddOrUpdate(dataSet1);
+            using var results = cache.Connect().AsAggregator();
+
+            using var barrier = new Barrier(2);
+            var resumeTask = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                suspend1.Dispose();
+            });
+
+            var reSuspendTask = Task.Run(() =>
+            {
+                barrier.SignalAndWait();
+                return cache.SuspendNotifications();
+            });
+
+            await Task.WhenAll(resumeTask, reSuspendTask);
+            var suspend2 = await reSuspendTask;
+
+            cache.AddOrUpdate(dataSet2);
+            suspend2.Dispose();
+
+            results.Summary.Overall.Adds.Should().Be(allData.Count, $"iteration {iter}: exactly {allData.Count} adds");
+            results.Summary.Overall.Removes.Should().Be(0, $"iteration {iter}: no removes");
+            results.Summary.Overall.Updates.Should().Be(0, $"iteration {iter}: no updates because keys don't overlap");
+            results.Data.Count.Should().Be(allData.Count, $"iteration {iter}: {allData.Count} items in final state");
+            results.Data.Keys.OrderBy(k => k).Should().Equal(allData, $"iteration {iter}: all keys present in order");
+            results.Error.Should().BeNull($"iteration {iter}: no errors");
+            results.IsCompleted.Should().BeFalse($"iteration {iter}: not completed");
+        }
+    }
+
+    [Fact]
+    public async Task ResumeSignalUnderLockPreventsStaleSnapshotFromReSuspend()
+    {
+        // Verifies that a deferred Connect subscriber never sees data written during
+        // a re-suspension. The resume signal fires under the lock (reentrant), so the
+        // deferred subscriber activates and takes its snapshot before any other thread
+        // can re-suspend or write new data.
+        //
+        // A slow first subscriber blocks delivery of accumulated changes, creating a
+        // window where the main thread re-suspends and writes a second batch. The
+        // deferred subscriber's snapshot must contain only the first batch.
+        using var cache = new SourceCache<int, int>(static x => x);
+        var dataSet1 = Enumerable.Range(0, 100).ToList();
+        var dataSet2 = Enumerable.Range(1000, 100).ToList();
+        var allData = dataSet1.Concat(dataSet2).ToList();
+
+        using var delivering = new SemaphoreSlim(0, 1);
+        using var proceedWithResuspend = new SemaphoreSlim(0, 1);
+
+        var suspend1 = cache.SuspendNotifications();
+        cache.AddOrUpdate(dataSet1);
+
+        // First subscriber blocks on delivery to hold the delivery thread
+        var firstDelivery = true;
+        using var slowSub = cache.Connect().Subscribe(_ =>
+        {
+            if (firstDelivery)
+            {
+                firstDelivery = false;
+                delivering.Release();
+                proceedWithResuspend.Wait(TimeSpan.FromSeconds(5));
+            }
+        });
+
+        // Deferred subscriber — will activate when resume signal fires
+        using var results = cache.Connect().AsAggregator();
+        results.Messages.Count.Should().Be(0, "no messages during suspension");
+
+        // Resume on background thread — delivery blocks on slow subscriber
+        var resumeTask = Task.Run(() => suspend1.Dispose());
+        (await delivering.WaitAsync(TimeSpan.FromSeconds(5))).Should().BeTrue("delivery should have started");
+
+        // Re-suspend and write second batch while delivery is blocked
+        var suspend2 = cache.SuspendNotifications();
+        cache.AddOrUpdate(dataSet2);
+
+        // dataSet2 must not appear in any message received so far
+        foreach (var msg in results.Messages)
+        {
+            foreach (var change in msg)
+            {
+                change.Key.Should().BeInRange(0, 99,
+                    "deferred subscriber should only have first-batch keys before second resume");
+            }
+        }
+
+        // Unblock delivery
+        proceedWithResuspend.Release();
+        await resumeTask;
+
+        // Only dataSet1 should have been delivered — dataSet2 is held by second suspension
+        results.Summary.Overall.Adds.Should().Be(dataSet1.Count,
+            $"exactly {dataSet1.Count} adds before second resume — dataSet2 must be held by suspension");
+        results.Messages.Should().HaveCount(1, "exactly one message (snapshot of dataSet1)");
+        results.Messages[0].Adds.Should().Be(dataSet1.Count);
+        results.Messages[0].Select(c => c.Key).Should().Equal(dataSet1,
+            "snapshot should contain exactly first-batch keys in order");
+
+        // Resume second suspension — dataSet2 arrives now
+        suspend2.Dispose();
+
+        results.Summary.Overall.Adds.Should().Be(allData.Count, $"exactly {allData.Count} adds total");
+        results.Summary.Overall.Removes.Should().Be(0, "no removes");
+        results.Messages.Should().HaveCount(2, "two messages: snapshot + second batch");
+        results.Messages[1].Adds.Should().Be(dataSet2.Count);
+        results.Messages[1].Select(c => c.Key).Should().Equal(dataSet2,
+            "second message should contain exactly second-batch keys in order");
+        results.Data.Count.Should().Be(allData.Count);
+        results.Data.Keys.OrderBy(k => k).Should().Equal(allData);
+        results.Error.Should().BeNull();
+        results.IsCompleted.Should().BeFalse();
+    }
+
     public void Dispose()
     {
         _source.Dispose();
diff --git a/src/DynamicData.Tests/Internal/BitsetFixture.cs b/src/DynamicData.Tests/Internal/BitsetFixture.cs
new file mode 100644
index 000000000..fd33ce09e
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/BitsetFixture.cs
@@ -0,0 +1,449 @@
+// 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 DynamicData.Internal;
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+public class BitsetFixture
+{
+    [Fact]
+    public void NewBitset_HasNoActiveBits()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act (no action, testing initial state)
+
+        // Assert
+        bitset.HasAny().Should().BeFalse();
+        bitset.Count.Should().Be(0);
+        bitset.FindHighest().Should().Be(-1);
+        bitset.FindLowest().Should().Be(-1);
+    }
+
+    [Fact]
+    public void Set_SingleBit_IsActiveAndQueryable()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(0);
+
+        // Assert
+        bitset.IsSet(0).Should().BeTrue();
+        bitset.HasAny().Should().BeTrue();
+        bitset.Count.Should().Be(1);
+        bitset.FindHighest().Should().Be(0);
+        bitset.FindLowest().Should().Be(0);
+    }
+
+    [Fact]
+    public void Set_MultipleBits_FindHighestReturnsLargest()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(3);
+        bitset.Set(17);
+        bitset.Set(42);
+
+        // Assert
+        bitset.IsSet(3).Should().BeTrue();
+        bitset.IsSet(17).Should().BeTrue();
+        bitset.IsSet(42).Should().BeTrue();
+        bitset.IsSet(4).Should().BeFalse();
+        bitset.Count.Should().Be(3);
+        bitset.FindHighest().Should().Be(42);
+        bitset.FindLowest().Should().Be(3);
+    }
+
+    [Fact]
+    public void Clear_RemovesBitAndUpdatesQueries()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(5);
+        bitset.Set(10);
+
+        // Act
+        bitset.Clear(10);
+
+        // Assert
+        bitset.IsSet(10).Should().BeFalse();
+        bitset.IsSet(5).Should().BeTrue();
+        bitset.HasAny().Should().BeTrue();
+        bitset.Count.Should().Be(1);
+        bitset.FindHighest().Should().Be(5);
+    }
+
+    [Fact]
+    public void Clear_LastBit_HasAnyReturnsFalse()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(7);
+
+        // Act
+        bitset.Clear(7);
+
+        // Assert
+        bitset.IsSet(7).Should().BeFalse();
+        bitset.HasAny().Should().BeFalse();
+        bitset.Count.Should().Be(0);
+        bitset.FindHighest().Should().Be(-1);
+    }
+
+    [Fact]
+    public void Set_IsIdempotent()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(3);
+        bitset.Set(3);
+        bitset.Set(3);
+
+        // Assert
+        bitset.IsSet(3).Should().BeTrue();
+        bitset.FindHighest().Should().Be(3);
+        bitset.Clear(3);
+        bitset.HasAny().Should().BeFalse("single Clear should undo any number of Sets");
+    }
+
+    [Fact]
+    public void Clear_IsIdempotent()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(5);
+
+        // Act
+        bitset.Clear(5);
+        bitset.Clear(5);
+        bitset.Clear(5);
+
+        // Assert
+        bitset.IsSet(5).Should().BeFalse();
+        bitset.HasAny().Should().BeFalse();
+    }
+
+    [Fact]
+    public void ClearAll_RemovesEverything()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(0);
+        bitset.Set(31);
+        bitset.Set(63);
+
+        // Act
+        bitset.ClearAll();
+
+        // Assert
+        bitset.IsSet(0).Should().BeFalse();
+        bitset.IsSet(31).Should().BeFalse();
+        bitset.IsSet(63).Should().BeFalse();
+        bitset.HasAny().Should().BeFalse();
+        bitset.Count.Should().Be(0);
+        bitset.FindHighest().Should().Be(-1);
+        bitset.FindLowest().Should().Be(-1);
+    }
+
+    [Fact]
+    public void Set_BeyondInitialCapacity_GrowsAutomatically()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(100);
+
+        // Assert
+        bitset.IsSet(100).Should().BeTrue();
+        bitset.HasAny().Should().BeTrue();
+        bitset.Count.Should().Be(1);
+        bitset.FindHighest().Should().Be(100);
+        bitset.FindLowest().Should().Be(100);
+    }
+
+    [Fact]
+    public void MultipleWords_FindHighest_ReturnsCorrectIndex()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(10);   // word 0
+        bitset.Set(70);   // word 1
+        bitset.Set(130);  // word 2
+
+        // Act
+        var highest = bitset.FindHighest();
+        var lowest = bitset.FindLowest();
+
+        // Assert
+        highest.Should().Be(130);
+        lowest.Should().Be(10);
+    }
+
+    [Fact]
+    public void MultipleWords_ClearHighest_UpdatesFindHighest()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(10);
+        bitset.Set(70);
+        bitset.Set(130);
+
+        // Act
+        bitset.Clear(130);
+
+        // Assert
+        bitset.FindHighest().Should().Be(70);
+        bitset.IsSet(130).Should().BeFalse();
+    }
+
+    [Fact]
+    public void MultipleWords_ClearLowest_UpdatesFindLowest()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(10);
+        bitset.Set(70);
+        bitset.Set(130);
+
+        // Act
+        bitset.Clear(10);
+
+        // Assert
+        bitset.FindLowest().Should().Be(70);
+        bitset.IsSet(10).Should().BeFalse();
+    }
+
+    [Fact]
+    public void MultipleWords_ClearAll_ClearsAllWords()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(0);
+        bitset.Set(64);
+        bitset.Set(128);
+        bitset.Set(192);
+
+        // Act
+        bitset.ClearAll();
+
+        // Assert
+        bitset.HasAny().Should().BeFalse();
+        bitset.Count.Should().Be(0);
+        bitset.FindHighest().Should().Be(-1);
+    }
+
+    [Fact]
+    public void WordBoundary_Bit63And64()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(63);  // last bit of word 0
+        bitset.Set(64);  // first bit of word 1
+
+        // Act
+        bitset.Clear(64);
+
+        // Assert
+        bitset.IsSet(63).Should().BeTrue();
+        bitset.IsSet(64).Should().BeFalse();
+        bitset.FindHighest().Should().Be(63);
+        bitset.FindLowest().Should().Be(63);
+    }
+
+    [Fact]
+    public void FindHighest_WithOnlyLowBitsSet()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(200); // force multi-word allocation
+        bitset.Clear(200);
+        bitset.Set(0);
+        bitset.Set(1);
+        bitset.Set(2);
+
+        // Act
+        var highest = bitset.FindHighest();
+        var lowest = bitset.FindLowest();
+
+        // Assert
+        highest.Should().Be(2);
+        lowest.Should().Be(0);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(31)]
+    [InlineData(32)]
+    [InlineData(63)]
+    public void SingleBit_RoundTrips(int index)
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(index);
+
+        // Assert
+        bitset.IsSet(index).Should().BeTrue();
+        bitset.HasAny().Should().BeTrue();
+        bitset.FindHighest().Should().Be(index);
+        bitset.FindLowest().Should().Be(index);
+
+        bitset.Clear(index);
+        bitset.IsSet(index).Should().BeFalse();
+        bitset.HasAny().Should().BeFalse();
+    }
+
+    [Fact]
+    public void SetAndClear_ManyBits_CountStaysConsistent()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        for (var i = 0; i < 100; i++)
+        {
+            bitset.Set(i);
+        }
+
+        // Act
+        for (var i = 0; i < 99; i++)
+        {
+            bitset.Clear(i);
+        }
+
+        // Assert
+        bitset.HasAny().Should().BeTrue();
+        bitset.Count.Should().Be(1);
+        bitset.FindHighest().Should().Be(99);
+        bitset.FindLowest().Should().Be(99);
+        bitset.IsSet(99).Should().BeTrue();
+        bitset.IsSet(0).Should().BeFalse();
+
+        bitset.Clear(99);
+        bitset.HasAny().Should().BeFalse();
+        bitset.Count.Should().Be(0);
+    }
+
+    [Fact]
+    public void IsSet_BeyondCapacity_ReturnsFalse()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        var result = bitset.IsSet(500);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    [Fact]
+    public void Clear_BeyondCapacity_DoesNotThrow()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        var act = () => bitset.Clear(500);
+
+        // Assert
+        act.Should().NotThrow();
+        bitset.HasAny().Should().BeFalse();
+    }
+
+    [Fact]
+    public void Compact_ShrinksThenSetGrowsBack()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(200);
+        bitset.Clear(200);
+
+        // Act
+        bitset.Compact();
+        bitset.Set(200);
+
+        // Assert
+        bitset.IsSet(200).Should().BeTrue();
+        bitset.FindHighest().Should().Be(200);
+    }
+
+    [Fact]
+    public void Compact_RetainsActiveBits()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(5);
+        bitset.Set(200);
+        bitset.Clear(200);
+
+        // Act
+        bitset.Compact();
+
+        // Assert
+        bitset.IsSet(5).Should().BeTrue();
+        bitset.HasAny().Should().BeTrue();
+        bitset.FindHighest().Should().Be(5);
+    }
+
+    [Fact]
+    public void Compact_AllEmpty_ShrinkToMinimum()
+    {
+        // Arrange
+        var bitset = new Bitset();
+        bitset.Set(200);
+        bitset.ClearAll();
+
+        // Act
+        bitset.Compact();
+
+        // Assert
+        bitset.HasAny().Should().BeFalse();
+        bitset.FindHighest().Should().Be(-1);
+    }
+
+    [Fact]
+    public void Count_TracksSetBitsAccurately()
+    {
+        // Arrange
+        var bitset = new Bitset();
+
+        // Act
+        bitset.Set(1);
+        bitset.Set(10);
+        bitset.Set(100);
+
+        // Assert
+        bitset.Count.Should().Be(3);
+
+        // Act (idempotent set)
+        bitset.Set(10);
+
+        // Assert
+        bitset.Count.Should().Be(3, "idempotent Set should not increment");
+
+        // Act (clear one)
+        bitset.Clear(10);
+
+        // Assert
+        bitset.Count.Should().Be(2);
+
+        // Act (clear all)
+        bitset.ClearAll();
+
+        // Assert
+        bitset.Count.Should().Be(0);
+    }
+}
diff --git a/src/DynamicData.Tests/Internal/CacheParentSubscriptionFixture.cs b/src/DynamicData.Tests/Internal/CacheParentSubscriptionFixture.cs
new file mode 100644
index 000000000..5f11b9fc5
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/CacheParentSubscriptionFixture.cs
@@ -0,0 +1,375 @@
+// 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.Linq;
+using System.Reactive.Subjects;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Bogus;
+
+using DynamicData.Internal;
+using DynamicData.Tests.Utilities;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+/// <summary>
+/// Tests for <see cref="CacheParentSubscription{TParent, TKey, TChild, TObserver}"/>
+/// behavioral contracts using a minimal concrete subclass.
+/// </summary>
+public sealed class CacheParentSubscriptionFixture
+{
+    private const int SeedMin = 1;
+    private const int SeedMax = 10000;
+    private const int BatchSizeMin = 2;
+    private const int BatchSizeMax = 8;
+
+    private readonly Randomizer _rand = new(55);
+
+    /// <summary>Test item with a typed key — no string parsing.</summary>
+    private sealed record TestItem(int Key, string Value);
+
+    [Fact]
+    public void ParentOnNext_CalledForEachChangeSet()
+    {
+        var itemCount = _rand.Number(BatchSizeMin, BatchSizeMax);
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer);
+        sub.ExposeCreateParent(source.Connect());
+
+        var items = Enumerable.Range(0, itemCount)
+            .Select(i => new TestItem(_rand.Number(SeedMin, SeedMax) + i * 100, _rand.String2(_rand.Number(3, 10))))
+            .ToList();
+
+        foreach (var item in items)
+            source.AddOrUpdate(item);
+
+        sub.ParentCallCount.Should().Be(items.Count, "ParentOnNext should fire once per changeset");
+        observer.EmitCount.Should().Be(items.Count, "EmitChanges should fire after each parent update");
+    }
+
+    [Fact]
+    public void ChildOnNext_CalledForEachEmission()
+    {
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var childSubjects = new List<Subject<string>>();
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer, key =>
+        {
+            var subj = new Subject<string>();
+            childSubjects.Add(subj);
+            return subj;
+        });
+        sub.ExposeCreateParent(source.Connect());
+
+        var key = _rand.Number(SeedMin, SeedMax);
+        source.AddOrUpdate(new TestItem(key, "parent"));
+
+        childSubjects.Should().HaveCount(1);
+        var childValue = _rand.String2(_rand.Number(5, 15));
+        childSubjects[0].OnNext(childValue);
+
+        sub.ChildCalls.Should().ContainSingle()
+            .Which.Should().Be((childValue, key));
+    }
+
+    [Fact]
+    public void EmitChanges_FiresOnceForBatch()
+    {
+        var batchSize = _rand.Number(BatchSizeMin, BatchSizeMax);
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer);
+        sub.ExposeCreateParent(source.Connect());
+
+        source.Edit(updater =>
+        {
+            for (var i = 0; i < batchSize; i++)
+                updater.AddOrUpdate(new TestItem(i + 1, _rand.String2(_rand.Number(3, 8))));
+        });
+
+        sub.ParentCallCount.Should().Be(1, "single batch = single ParentOnNext");
+        sub.EmitCallCount.Should().Be(1, "single batch = single EmitChanges");
+    }
+
+    [Fact]
+    public void Batching_ChildUpdatesSettleBeforeEmit()
+    {
+        var batchSize = _rand.Number(BatchSizeMin, BatchSizeMax);
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var observer = new TestObserver();
+        var childCount = 0;
+        using var sub = new TestSubscription(observer, key =>
+        {
+            Interlocked.Increment(ref childCount);
+            return new BehaviorSubject<string>($"sync-{key}");
+        });
+        sub.ExposeCreateParent(source.Connect());
+
+        source.Edit(updater =>
+        {
+            for (var i = 0; i < batchSize; i++)
+                updater.AddOrUpdate(new TestItem(i + 1, _rand.String2(_rand.Number(3, 8))));
+        });
+
+        childCount.Should().Be(batchSize, "each item should create a child");
+        sub.EmitCallCount.Should().BeGreaterThanOrEqualTo(1,
+            "EmitChanges fires after parent + children settle");
+    }
+
+    [Fact]
+    public void Completion_RequiresParentAndAllChildren()
+    {
+        using var source = new TestSourceCache<TestItem, int>(x => x.Key);
+        var childSubjects = new List<Subject<string>>();
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer, key =>
+        {
+            var subj = new Subject<string>();
+            childSubjects.Add(subj);
+            return subj;
+        });
+        sub.ExposeCreateParent(source.Connect());
+
+        source.AddOrUpdate(new TestItem(_rand.Number(SeedMin, SeedMax), "item"));
+        childSubjects.Should().HaveCount(1);
+
+        source.Complete();
+        observer.IsCompleted.Should().BeFalse("parent complete but child still active");
+
+        childSubjects[0].OnCompleted();
+        observer.IsCompleted.Should().BeTrue("OnCompleted fires when parent + all children complete");
+    }
+
+    [Fact]
+    public void Completion_ParentOnly_NoChildren()
+    {
+        using var source = new TestSourceCache<TestItem, int>(x => x.Key);
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer);
+        sub.ExposeCreateParent(source.Connect());
+
+        source.Complete();
+        observer.IsCompleted.Should().BeTrue("immediate OnCompleted when no children");
+    }
+
+    [Fact]
+    public void Disposal_StopsAllEmissions()
+    {
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var childSubjects = new List<Subject<string>>();
+        var observer = new TestObserver();
+        var sub = new TestSubscription(observer, key =>
+        {
+            var subj = new Subject<string>();
+            childSubjects.Add(subj);
+            return subj;
+        });
+        sub.ExposeCreateParent(source.Connect());
+
+        source.AddOrUpdate(new TestItem(_rand.Number(SeedMin, SeedMax), "item"));
+        var emitsBefore = observer.EmitCount;
+
+        sub.Dispose();
+
+        source.AddOrUpdate(new TestItem(_rand.Number(SeedMin + SeedMax, SeedMax * 2), "after"));
+        if (childSubjects.Count > 0)
+            childSubjects[0].OnNext("after-dispose");
+
+        observer.EmitCount.Should().Be(emitsBefore, "no emissions after disposal");
+    }
+
+    [Fact]
+    public void Error_Propagates()
+    {
+        using var source = new TestSourceCache<TestItem, int>(x => x.Key);
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(observer);
+        sub.ExposeCreateParent(source.Connect());
+
+        var error = new InvalidOperationException("test error");
+        source.SetError(error);
+
+        observer.Error.Should().BeSameAs(error);
+    }
+
+    [Fact]
+    public void Serialization_ParentAndChildDoNotInterleave()
+    {
+        using var source = new SourceCache<TestItem, int>(x => x.Key);
+        var callLog = new List<string>();
+        var observer = new TestObserver();
+        using var sub = new TestSubscription(
+            observer,
+            key =>
+            {
+                var subj = new Subject<string>();
+                return subj;
+            },
+            onParent: () => { lock (callLog) callLog.Add("P-start"); Thread.Sleep(1); lock (callLog) callLog.Add("P-end"); },
+            onChild: () => { lock (callLog) callLog.Add("C-start"); Thread.Sleep(1); lock (callLog) callLog.Add("C-end"); });
+        sub.ExposeCreateParent(source.Connect());
+
+        source.AddOrUpdate(new TestItem(_rand.Number(SeedMin, SeedMax), "item"));
+
+        // Start/end pairs should not interleave
+        for (var i = 0; i + 1 < callLog.Count; i += 2)
+        {
+            var prefix = callLog[i].Split('-')[0];
+            callLog[i + 1].Should().StartWith(prefix, "operations should not interleave");
+        }
+    }
+
+    /// <summary>
+    /// Proves CPS delivery runs without holding the lock. Two TestSubscription instances
+    /// whose EmitChanges callbacks write into each other's source cache — creating a
+    /// cross-cache cycle. Deadlocks on unfixed code, passes after the fix.
+    /// </summary>
+    [Trait("Category", "ExplicitDeadlock")]
+    [Fact]
+    public async Task DeadlockProof_CrossFeedingSubscriptions()
+    {
+        var iterations = _rand.Number(50, 150);
+
+        using var sourceA = new SourceCache<TestItem, int>(x => x.Key);
+        using var sourceB = new SourceCache<TestItem, int>(x => x.Key);
+
+        // Each TestSubscription's EmitChanges writes into the OTHER source (limited to prevent infinite loops)
+        var observerA = new CrossFeedObserver(sourceB, 100_001, iterations);
+        using var subA = new TestSubscription(observerA);
+        subA.ExposeCreateParent(sourceA.Connect());
+
+        var observerB = new CrossFeedObserver(sourceA, 200_001, iterations);
+        using var subB = new TestSubscription(observerB);
+        subB.ExposeCreateParent(sourceB.Connect());
+
+        using var barrier = new Barrier(2);
+
+        var taskA = Task.Run(() =>
+        {
+            var tRand = new Randomizer(56);
+            barrier.SignalAndWait();
+            for (var i = 0; i < iterations; i++)
+                sourceA.AddOrUpdate(new TestItem(tRand.Number(1, 50_000), tRand.String2(5)));
+        });
+
+        var taskB = Task.Run(() =>
+        {
+            var tRand = new Randomizer(57);
+            barrier.SignalAndWait();
+            for (var i = 0; i < iterations; i++)
+                sourceB.AddOrUpdate(new TestItem(tRand.Number(50_001, 100_000), tRand.String2(5)));
+        });
+
+        var completed = Task.WhenAll(taskA, taskB);
+        var finished = await Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(30)));
+        finished.Should().BeSameAs(completed,
+            "cross-feeding CacheParentSubscriptions should not deadlock");
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // Test Infrastructure
+    // ═══════════════════════════════════════════════════════════════
+
+    /// <summary>Observer that writes into another cache on every emission — creates cross-cache cycle.</summary>
+    private sealed class CrossFeedObserver(SourceCache<TestItem, int> target, int idBase, int maxCrossWrites) : IObserver<IChangeSet<TestItem, int>>
+    {
+        private int _counter;
+
+        public void OnNext(IChangeSet<TestItem, int> value)
+        {
+            // Limit cross-writes to prevent infinite feedback loops
+            if (Interlocked.Increment(ref _counter) <= maxCrossWrites)
+            {
+                target.AddOrUpdate(new TestItem(idBase + _counter, "cross"));
+            }
+        }
+
+        public void OnError(Exception error) { }
+
+        public void OnCompleted() { }
+    }
+
+    /// <summary>
+    /// Minimal concrete CacheParentSubscription for testing.
+    /// </summary>
+    private sealed class TestSubscription : CacheParentSubscription<TestItem, int, string, IChangeSet<TestItem, int>>
+    {
+        private readonly Func<int, IObservable<string>>? _childFactory;
+        private readonly Action? _onParent;
+        private readonly Action? _onChild;
+        private readonly ChangeAwareCache<TestItem, int> _cache = new();
+
+        public int ParentCallCount;
+        public int EmitCallCount;
+        public readonly List<(string Value, int Key)> ChildCalls = [];
+
+        public TestSubscription(
+            IObserver<IChangeSet<TestItem, int>> observer,
+            Func<int, IObservable<string>>? childFactory = null,
+            Action? onParent = null,
+            Action? onChild = null)
+            : base(observer)
+        {
+            _childFactory = childFactory;
+            _onParent = onParent;
+            _onChild = onChild;
+        }
+
+        public void ExposeCreateParent(IObservable<IChangeSet<TestItem, int>> source)
+            => CreateParentSubscription(source);
+
+        protected override void ParentOnNext(IChangeSet<TestItem, int> changes)
+        {
+            Interlocked.Increment(ref ParentCallCount);
+            _onParent?.Invoke();
+            _cache.Clone(changes);
+
+            if (_childFactory is not null)
+            {
+                foreach (var change in (ChangeSet<TestItem, int>)changes)
+                {
+                    if (change.Reason is ChangeReason.Add or ChangeReason.Update)
+                        AddChildSubscription(MakeChildObservable(_childFactory(change.Key)), change.Key);
+                    else if (change.Reason is ChangeReason.Remove)
+                        RemoveChildSubscription(change.Key);
+                }
+            }
+        }
+
+        protected override void ChildOnNext(string child, int parentKey)
+        {
+            _onChild?.Invoke();
+            ChildCalls.Add((child, parentKey));
+            _cache.AddOrUpdate(new TestItem(parentKey, child), parentKey);
+        }
+
+        protected override void EmitChanges(IObserver<IChangeSet<TestItem, int>> observer)
+        {
+            Interlocked.Increment(ref EmitCallCount);
+            var changes = _cache.CaptureChanges();
+            if (changes.Count > 0)
+                observer.OnNext(changes);
+        }
+    }
+
+    /// <summary>Observer that records emissions, completion, and errors.</summary>
+    private sealed class TestObserver : IObserver<IChangeSet<TestItem, int>>
+    {
+        public int EmitCount;
+        public bool IsCompleted;
+        public Exception? Error;
+
+        public void OnNext(IChangeSet<TestItem, int> value) => Interlocked.Increment(ref EmitCount);
+        public void OnError(Exception error) => Error = error;
+        public void OnCompleted() => IsCompleted = true;
+    }
+}
\ No newline at end of file
diff --git a/src/DynamicData.Tests/Internal/DeliveryQueueFixture.cs b/src/DynamicData.Tests/Internal/DeliveryQueueFixture.cs
new file mode 100644
index 000000000..3062e331f
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/DeliveryQueueFixture.cs
@@ -0,0 +1,560 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using DynamicData.Internal;
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+public class DeliveryQueueFixture
+{
+#if NET9_0_OR_GREATER
+    private readonly Lock _gate = new();
+#else
+    private readonly object _gate = new();
+#endif
+
+    /// <summary>Helper observer that captures OnNext items into a list.</summary>
+    private sealed class ListObserver<T> : IObserver<T>
+    {
+        private readonly List<T> _items = new();
+        public IReadOnlyList<T> Items => _items;
+        public Exception? Error { get; private set; }
+        public bool IsCompleted { get; private set; }
+
+        public void OnNext(T value) => _items.Add(value);
+        public void OnError(Exception error) => Error = error;
+        public void OnCompleted() => IsCompleted = true;
+    }
+
+    /// <summary>Thread-safe observer for concurrent tests.</summary>
+    private sealed class ConcurrentObserver<T> : IObserver<T>
+    {
+        private readonly ConcurrentBag<T> _items = new();
+        public ConcurrentBag<T> Items => _items;
+
+        public void OnNext(T value) => _items.Add(value);
+        public void OnError(Exception error) { }
+        public void OnCompleted() { }
+    }
+
+    /// <summary>Thread-safe ordered observer for concurrent tests.</summary>
+    private sealed class ConcurrentQueueObserver<T> : IObserver<T>
+    {
+        private readonly ConcurrentQueue<T> _items = new();
+        public ConcurrentQueue<T> Items => _items;
+
+        public void OnNext(T value) => _items.Enqueue(value);
+        public void OnError(Exception error) { }
+        public void OnCompleted() { }
+    }
+
+    private static void EnqueueAndDeliver<T>(DeliveryQueue<T> queue, T item)
+    {
+        using var scope = queue.AcquireLock();
+        scope.EnqueueNext(item);
+    }
+
+    private static void TriggerDelivery<T>(DeliveryQueue<T> queue)
+    {
+        using var scope = queue.AcquireLock();
+    }
+
+    [Fact]
+    public void EnqueueAndDeliverDeliversItem()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        EnqueueAndDeliver(queue, "A");
+
+        observer.Items.Should().Equal("A");
+    }
+
+    [Fact]
+    public void DeliverDeliversItemsInFifoOrder()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueNext("A");
+            scope.EnqueueNext("B");
+            scope.EnqueueNext("C");
+        }
+
+        observer.Items.Should().Equal("A", "B", "C");
+    }
+
+    [Fact]
+    public void DeliverWithEmptyQueueIsNoOp()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        TriggerDelivery(queue);
+
+        observer.Items.Should().BeEmpty();
+    }
+
+    [Fact]
+    public async Task OnlyOneDelivererAtATime()
+    {
+        var concurrentCount = 0;
+        var maxConcurrent = 0;
+        var deliveryCount = 0;
+        var delivered = new ConcurrentBag<int>();
+        using var firstDeliveryStarted = new ManualResetEventSlim(false);
+        using var allowFirstDeliveryToContinue = new ManualResetEventSlim(false);
+        using var startContenders = new ManualResetEventSlim(false);
+
+        var observer = new BlockingObserver<int>(
+            onNextAction: item =>
+            {
+                var current = Interlocked.Increment(ref concurrentCount);
+                int snapshot;
+                do
+                {
+                    snapshot = maxConcurrent;
+                    if (current <= snapshot) break;
+                }
+                while (Interlocked.CompareExchange(ref maxConcurrent, current, snapshot) != snapshot);
+
+                delivered.Add(item);
+
+                if (Interlocked.Increment(ref deliveryCount) == 1)
+                {
+                    firstDeliveryStarted.Set();
+                    allowFirstDeliveryToContinue.Wait();
+                }
+
+                Thread.SpinWait(1000);
+                Interlocked.Decrement(ref concurrentCount);
+            });
+
+        var queue = new DeliveryQueue<int>(_gate, observer);
+
+        var firstDelivery = Task.Run(() => EnqueueAndDeliver(queue, -1));
+        firstDeliveryStarted.Wait();
+
+        var enqueueTasks = Enumerable.Range(0, 100)
+            .Select(i => Task.Run(() =>
+            {
+                startContenders.Wait();
+                EnqueueAndDeliver(queue, i);
+            }));
+
+        var triggerTasks = Enumerable.Range(0, 4)
+            .Select(_ => Task.Run(() =>
+            {
+                startContenders.Wait();
+                TriggerDelivery(queue);
+            }));
+
+        var tasks = enqueueTasks.Concat(triggerTasks).ToArray();
+        startContenders.Set();
+        allowFirstDeliveryToContinue.Set();
+
+        await Task.WhenAll(tasks.Append(firstDelivery));
+
+        maxConcurrent.Should().Be(1, "only one thread should be delivering at a time");
+        delivered.Should().HaveCount(101);
+    }
+
+    [Fact]
+    public void SecondWriterItemPickedUpByFirstDeliverer()
+    {
+        var observer = new ListObserver<string>();
+        DeliveryQueue<string>? q = null;
+
+        var enqueuingObserver = new DelegateObserver<string>(item =>
+        {
+            observer.OnNext(item);
+            if (observer.Items.Count == 1)
+            {
+                using var scope = q!.AcquireLock();
+                scope.EnqueueNext("B");
+            }
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, enqueuingObserver);
+        q = queue;
+
+        EnqueueAndDeliver(queue, "A");
+
+        observer.Items.Should().Equal("A", "B");
+    }
+
+    [Fact]
+    public void ReentrantEnqueueDoesNotRecurse()
+    {
+        var callDepth = 0;
+        var maxDepth = 0;
+        var delivered = new List<string>();
+        DeliveryQueue<string>? q = null;
+
+        var observer = new DelegateObserver<string>(item =>
+        {
+            callDepth++;
+            if (callDepth > maxDepth) maxDepth = callDepth;
+
+            delivered.Add(item);
+
+            if (item == "A")
+            {
+                using var scope = q!.AcquireLock();
+                scope.EnqueueNext("B");
+            }
+
+            callDepth--;
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, observer);
+        q = queue;
+
+        EnqueueAndDeliver(queue, "A");
+
+        delivered.Should().Equal("A", "B");
+        maxDepth.Should().Be(1, "delivery callback should not recurse");
+    }
+
+    [Fact]
+    public void ExceptionInDeliveryResetsDeliveryToken()
+    {
+        var callCount = 0;
+        var observer = new DelegateObserver<string>(_ =>
+        {
+            if (++callCount == 1)
+                throw new InvalidOperationException("boom");
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        var act = () => EnqueueAndDeliver(queue, "A");
+        act.Should().Throw<InvalidOperationException>();
+
+        EnqueueAndDeliver(queue, "B");
+
+        callCount.Should().Be(2, "delivery should work after exception recovery");
+    }
+
+    [Fact]
+    public void RemainingItemsDeliveredAfterExceptionRecovery()
+    {
+        var delivered = new List<string>();
+        var shouldThrow = true;
+        var observer = new DelegateObserver<string>(item =>
+        {
+            if (shouldThrow && item == "A")
+                throw new InvalidOperationException("boom");
+            delivered.Add(item);
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        var act = () =>
+        {
+            using var scope = queue.AcquireLock();
+            scope.EnqueueNext("A");
+            scope.EnqueueNext("B");
+        };
+
+        act.Should().Throw<InvalidOperationException>();
+
+        shouldThrow = false;
+        TriggerDelivery(queue);
+
+        delivered.Should().Equal("B");
+    }
+
+    [Fact]
+    public void TerminalCompletedStopsDelivery()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueNext("A");
+            scope.EnqueueCompleted();
+            scope.EnqueueNext("B"); // should be ignored after terminal
+        }
+
+        observer.Items.Should().Equal("A");
+        observer.IsCompleted.Should().BeTrue();
+        queue.IsTerminated.Should().BeTrue();
+    }
+
+    [Fact]
+    public void TerminalErrorStopsDelivery()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+        var error = new InvalidOperationException("test");
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueNext("A");
+            scope.EnqueueError(error);
+            scope.EnqueueNext("B"); // should be ignored after terminal
+        }
+
+        observer.Items.Should().Equal("A");
+        observer.Error.Should().BeSameAs(error);
+        queue.IsTerminated.Should().BeTrue();
+    }
+
+    [Fact]
+    public void EnqueueAfterTerminationIsIgnored()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueCompleted();
+        }
+
+        EnqueueAndDeliver(queue, "AFTER");
+
+        observer.Items.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void IsTerminatedIsFalseInitially()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+        queue.IsTerminated.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task ConcurrentEnqueueAllItemsDelivered()
+    {
+        const int threadCount = 8;
+        const int itemsPerThread = 500;
+        var observer = new ConcurrentObserver<int>();
+        var queue = new DeliveryQueue<int>(_gate, observer);
+
+        var tasks = Enumerable.Range(0, threadCount).Select(t => Task.Run(() =>
+        {
+            for (var i = 0; i < itemsPerThread; i++)
+                EnqueueAndDeliver(queue, (t * itemsPerThread) + i);
+        })).ToArray();
+
+        await Task.WhenAll(tasks);
+        TriggerDelivery(queue);
+
+        observer.Items.Count.Should().Be(threadCount * itemsPerThread);
+    }
+
+    [Fact]
+    public async Task ConcurrentEnqueueNoDuplicates()
+    {
+        const int threadCount = 8;
+        const int itemsPerThread = 500;
+        var observer = new ConcurrentObserver<int>();
+        var queue = new DeliveryQueue<int>(_gate, observer);
+
+        var tasks = Enumerable.Range(0, threadCount).Select(t => Task.Run(() =>
+        {
+            for (var i = 0; i < itemsPerThread; i++)
+                EnqueueAndDeliver(queue, (t * itemsPerThread) + i);
+        })).ToArray();
+
+        await Task.WhenAll(tasks);
+        TriggerDelivery(queue);
+
+        observer.Items.Distinct().Count().Should().Be(threadCount * itemsPerThread);
+    }
+
+    [Fact]
+    public async Task ConcurrentEnqueuePreservesPerThreadOrdering()
+    {
+        const int threadCount = 4;
+        const int itemsPerThread = 200;
+        var observer = new ConcurrentQueueObserver<(int Thread, int Seq)>();
+        var queue = new DeliveryQueue<(int Thread, int Seq)>(_gate, observer);
+
+        var tasks = Enumerable.Range(0, threadCount).Select(t => Task.Run(() =>
+        {
+            for (var i = 0; i < itemsPerThread; i++)
+                EnqueueAndDeliver(queue, (t, i));
+        })).ToArray();
+
+        await Task.WhenAll(tasks);
+        TriggerDelivery(queue);
+
+        var itemsByThread = observer.Items.ToArray().GroupBy(x => x.Thread)
+            .ToDictionary(g => g.Key, g => g.Select(x => x.Seq).ToList());
+
+        foreach (var (thread, sequences) in itemsByThread)
+            sequences.Should().BeInAscendingOrder($"items from thread {thread} should preserve enqueue order");
+    }
+
+    /// <summary>Observer that delegates OnNext to an action.</summary>
+    private sealed class DelegateObserver<T>(Action<T> onNextAction) : IObserver<T>
+    {
+        public void OnNext(T value) => onNextAction(value);
+        public void OnError(Exception error) { }
+        public void OnCompleted() { }
+    }
+
+    /// <summary>Observer with blocking capability for concurrency tests.</summary>
+    private sealed class BlockingObserver<T>(Action<T> onNextAction) : IObserver<T>
+    {
+        public void OnNext(T value) => onNextAction(value);
+        public void OnError(Exception error) { }
+        public void OnCompleted() { }
+    }
+
+    [Fact]
+    public void DisposeTerminatesQueue()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        EnqueueAndDeliver(queue, "A");
+        queue.Dispose();
+
+        queue.IsTerminated.Should().BeTrue();
+
+        // Further enqueues should be ignored
+        EnqueueAndDeliver(queue, "B");
+        observer.Items.Should().Equal("A");
+    }
+
+    [Fact]
+    public void DisposeClearsPendingItems()
+    {
+        var observer = new ListObserver<string>();
+        var deliveryCount = 0;
+        DeliveryQueue<string>? q = null;
+
+        var blockingObserver = new DelegateObserver<string>(item =>
+        {
+            observer.OnNext(item);
+            if (++deliveryCount == 1)
+            {
+                // While delivering first item, enqueue more then terminate
+                using (var scope = q!.AcquireLock())
+                {
+                    scope.EnqueueNext("B");
+                    scope.EnqueueNext("C");
+                }
+
+                q!.Dispose(); // re-entrant — should not spin
+            }
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, blockingObserver);
+        q = queue;
+
+        EnqueueAndDeliver(queue, "A");
+
+        // Only "A" should be delivered — "B" and "C" were cleared by Dispose
+        observer.Items.Should().Equal("A");
+        queue.IsTerminated.Should().BeTrue();
+    }
+
+    [Fact]
+    public void DisposeFromDrainThreadDoesNotDeadlock()
+    {
+        var observer = new ListObserver<string>();
+        DeliveryQueue<string>? q = null;
+
+        var terminatingObserver = new DelegateObserver<string>(_ =>
+        {
+            // Called from drain thread — Dispose must detect
+            // re-entrancy via _drainThreadId and skip the spin-wait
+            q!.Dispose();
+        });
+
+        var queue = new DeliveryQueue<string>(_gate, terminatingObserver);
+        q = queue;
+
+        // This should NOT deadlock
+        var completed = Task.Run(() => EnqueueAndDeliver(queue, "A"));
+        var finished = Task.WhenAny(completed, Task.Delay(TimeSpan.FromSeconds(5))).Result;
+        finished.Should().BeSameAs(completed, "Dispose from drain thread should not deadlock");
+    }
+
+    [Fact]
+    public async Task DisposeWaitsForInFlightDelivery()
+    {
+        var observer = new ListObserver<int>();
+        using var deliveryStarted = new ManualResetEventSlim(false);
+        using var allowDeliveryToFinish = new ManualResetEventSlim(false);
+
+        var slowObserver = new DelegateObserver<int>(item =>
+        {
+            observer.OnNext(item);
+            deliveryStarted.Set();
+            allowDeliveryToFinish.Wait();
+        });
+
+        var queue = new DeliveryQueue<int>(_gate, slowObserver);
+
+        // Start delivering — will block in observer
+        var deliverTask = Task.Run(() => EnqueueAndDeliver(queue, 42));
+        deliveryStarted.Wait();
+
+        // Drain thread is blocked in observer callback. Dispose should spin.
+        var terminateTask = Task.Run(() => queue.Dispose());
+
+        // Give terminate a moment to enter spin-wait
+        await Task.Delay(100);
+        terminateTask.IsCompleted.Should().BeFalse("should be spinning waiting for delivery");
+
+        // Release the delivery
+        allowDeliveryToFinish.Set();
+
+        await Task.WhenAll(deliverTask, terminateTask);
+        queue.IsTerminated.Should().BeTrue();
+        observer.Items.Should().Equal(42);
+    }
+
+    [Fact]
+    public void TerminalItemsDeliveredBeforeTermination()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueNext("A");
+            scope.EnqueueNext("B");
+            scope.EnqueueCompleted();
+            scope.EnqueueNext("C"); // should be ignored — after terminal
+        }
+
+        observer.Items.Should().Equal("A", "B");
+        observer.IsCompleted.Should().BeTrue();
+        queue.IsTerminated.Should().BeTrue();
+    }
+
+    [Fact]
+    public void ErrorTerminatesAndClearsPending()
+    {
+        var observer = new ListObserver<string>();
+        var queue = new DeliveryQueue<string>(_gate, observer);
+        var error = new InvalidOperationException("test");
+
+        using (var scope = queue.AcquireLock())
+        {
+            scope.EnqueueNext("A");
+            scope.EnqueueError(error);
+            scope.EnqueueNext("B"); // should be ignored
+        }
+
+        observer.Items.Should().Equal("A");
+        observer.Error.Should().BeSameAs(error);
+        queue.IsTerminated.Should().BeTrue();
+    }
+}
\ No newline at end of file
diff --git a/src/DynamicData.Tests/Internal/KeyedDisposableFixture.cs b/src/DynamicData.Tests/Internal/KeyedDisposableFixture.cs
new file mode 100644
index 000000000..2296564ef
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/KeyedDisposableFixture.cs
@@ -0,0 +1,158 @@
+// 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 DynamicData.Internal;
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+public class KeyedDisposableFixture
+{
+    [Fact]
+    public void AddTracksDisposable()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposed = false;
+        var item = new TestDisposable(() => disposed = true);
+
+        tracker.Add("key", item);
+
+        tracker.ContainsKey("key").Should().BeTrue();
+        disposed.Should().BeFalse();
+    }
+
+    [Fact]
+    public void RemoveDisposesItem()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposed = false;
+        tracker.Add("key", new TestDisposable(() => disposed = true));
+
+        tracker.Remove("key");
+
+        disposed.Should().BeTrue();
+        tracker.ContainsKey("key").Should().BeFalse();
+    }
+
+    [Fact]
+    public void AddWithSameKeyDisposePrevious()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposed1 = false;
+        var disposed2 = false;
+        tracker.Add("key", new TestDisposable(() => disposed1 = true));
+
+        tracker.Add("key", new TestDisposable(() => disposed2 = true));
+
+        disposed1.Should().BeTrue("previous item should be disposed");
+        disposed2.Should().BeFalse("new item should not be disposed");
+    }
+
+    [Fact]
+    public void AddWithSameReferenceDoesNotDispose()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposeCount = 0;
+        var item = new TestDisposable(() => disposeCount++);
+
+        tracker.Add("key", item);
+        tracker.Add("key", item); // same reference
+
+        disposeCount.Should().Be(0, "same reference should not be disposed");
+        tracker.ContainsKey("key").Should().BeTrue();
+    }
+
+    [Fact]
+    public void DisposeDisposesAllItems()
+    {
+        var tracker = new KeyedDisposable<int>();
+        var disposedCount = 0;
+        for (var i = 0; i < 5; i++)
+            tracker.Add(i, new TestDisposable(() => disposedCount++));
+
+        tracker.Dispose();
+
+        disposedCount.Should().Be(5);
+        tracker.IsDisposed.Should().BeTrue();
+    }
+
+    [Fact]
+    public void DisposeIsIdempotent()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposeCount = 0;
+        tracker.Add("key", new TestDisposable(() => disposeCount++));
+
+        tracker.Dispose();
+        tracker.Dispose();
+
+        disposeCount.Should().Be(1);
+    }
+
+    [Fact]
+    public void AddAfterDisposeDisposesImmediately()
+    {
+        var tracker = new KeyedDisposable<string>();
+        tracker.Dispose();
+
+        var disposed = false;
+        tracker.Add("key", new TestDisposable(() => disposed = true));
+
+        disposed.Should().BeTrue("item added after Dispose should be disposed immediately");
+    }
+
+    [Fact]
+    public void DisposeAggregatesExceptions()
+    {
+        var tracker = new KeyedDisposable<int>();
+        tracker.Add(1, new TestDisposable(() => throw new InvalidOperationException("boom1")));
+        tracker.Add(2, new TestDisposable(() => { }));
+        tracker.Add(3, new TestDisposable(() => throw new InvalidOperationException("boom3")));
+
+        var act = () => tracker.Dispose();
+
+        act.Should().Throw<AggregateException>()
+            .Which.InnerExceptions.Should().HaveCount(2);
+        tracker.Count.Should().Be(0, "all items should be cleared even after exceptions");
+    }
+
+    [Fact]
+    public void AddNonDisposableTracksNothing()
+    {
+        var tracker = new KeyedDisposable<string>();
+
+        tracker.Add("key", "not disposable");
+
+        tracker.ContainsKey("key").Should().BeFalse();
+    }
+
+    [Fact]
+    public void AddNonDisposableRemovesPrevious()
+    {
+        var tracker = new KeyedDisposable<string>();
+        var disposed = false;
+        tracker.Add("key", new TestDisposable(() => disposed = true));
+
+        tracker.Add("key", "not disposable");
+
+        disposed.Should().BeTrue("previous disposable should be disposed");
+        tracker.ContainsKey("key").Should().BeFalse();
+    }
+
+    [Fact]
+    public void RemoveNonExistentKeyIsNoOp()
+    {
+        var tracker = new KeyedDisposable<string>();
+        tracker.Remove("nonexistent"); // should not throw
+    }
+
+    private sealed class TestDisposable(Action onDispose) : IDisposable
+    {
+        public void Dispose() => onDispose();
+    }
+}
\ No newline at end of file
diff --git a/src/DynamicData.Tests/Internal/NotificationFixture.cs b/src/DynamicData.Tests/Internal/NotificationFixture.cs
new file mode 100644
index 000000000..d221b0044
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/NotificationFixture.cs
@@ -0,0 +1,142 @@
+// 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.Reactive;
+
+using DynamicData.Internal;
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+public class NotificationFixture
+{
+    [Fact]
+    public void CreateNext_WithReferenceType_DeliversOnNext()
+    {
+        var observer = new RecordingObserver<string>();
+        var n = DynamicData.Internal.Notification<string>.CreateNext("hello");
+
+        n.IsTerminal.Should().BeFalse();
+        n.Accept(observer);
+
+        observer.NextValue.Should().Be("hello");
+        observer.Error.Should().BeNull();
+        observer.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public void CreateError_WithReferenceType_DeliversOnError()
+    {
+        var observer = new RecordingObserver<string>();
+        var error = new Exception("test");
+        var n = DynamicData.Internal.Notification<string>.CreateError(error);
+
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeTrue();
+        n.Accept(observer);
+
+        observer.NextValue.Should().BeNull();
+        observer.Error.Should().BeSameAs(error);
+        observer.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public void CreateCompleted_WithReferenceType_DeliversOnCompleted()
+    {
+        var observer = new RecordingObserver<string>();
+        var n = DynamicData.Internal.Notification<string>.CreateCompleted();
+
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeFalse();
+        n.Accept(observer);
+
+        observer.NextValue.Should().BeNull();
+        observer.Error.Should().BeNull();
+        observer.IsCompleted.Should().BeTrue();
+    }
+
+    [Fact]
+    public void CreateNext_WithValueType_DeliversOnNext()
+    {
+        var observer = new RecordingObserver<Unit>();
+        var n = DynamicData.Internal.Notification<Unit>.CreateNext(Unit.Default);
+
+        n.IsTerminal.Should().BeFalse();
+        n.Accept(observer);
+
+        observer.HasNext.Should().BeTrue();
+        observer.Error.Should().BeNull();
+        observer.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public void CreateError_WithValueType_DeliversOnError()
+    {
+        var observer = new RecordingObserver<Unit>();
+        var error = new Exception("test");
+        var n = DynamicData.Internal.Notification<Unit>.CreateError(error);
+
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeTrue();
+        n.Accept(observer);
+
+        observer.HasNext.Should().BeFalse();
+        observer.Error.Should().BeSameAs(error);
+        observer.IsCompleted.Should().BeFalse();
+    }
+
+    [Fact]
+    public void CreateCompleted_WithValueType_DeliversOnCompleted()
+    {
+        var observer = new RecordingObserver<Unit>();
+        var n = DynamicData.Internal.Notification<Unit>.CreateCompleted();
+
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeFalse();
+        n.Accept(observer);
+
+        observer.HasNext.Should().BeFalse();
+        observer.Error.Should().BeNull();
+        observer.IsCompleted.Should().BeTrue();
+    }
+
+    [Fact]
+    public void DefaultNotification_WithValueType_IsTerminal()
+    {
+        // default(DynamicData.Internal.Notification<Unit>) should behave as OnCompleted
+        var n = default(DynamicData.Internal.Notification<Unit>);
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeFalse();
+
+        var observer = new RecordingObserver<Unit>();
+        n.Accept(observer);
+        observer.IsCompleted.Should().BeTrue();
+    }
+
+    [Fact]
+    public void DefaultNotification_WithReferenceType_IsTerminal()
+    {
+        var n = default(DynamicData.Internal.Notification<string>);
+        n.IsTerminal.Should().BeTrue();
+        n.IsError.Should().BeFalse();
+
+        var observer = new RecordingObserver<string>();
+        n.Accept(observer);
+        observer.IsCompleted.Should().BeTrue();
+    }
+
+    private sealed class RecordingObserver<T> : IObserver<T>
+    {
+        public T? NextValue { get; private set; }
+        public bool HasNext { get; private set; }
+        public Exception? Error { get; private set; }
+        public bool IsCompleted { get; private set; }
+
+        public void OnNext(T value) { NextValue = value; HasNext = true; }
+        public void OnError(Exception error) => Error = error;
+        public void OnCompleted() => IsCompleted = true;
+    }
+}
diff --git a/src/DynamicData.Tests/Internal/SharedDeliveryQueueFixture.cs b/src/DynamicData.Tests/Internal/SharedDeliveryQueueFixture.cs
new file mode 100644
index 000000000..e67444cb6
--- /dev/null
+++ b/src/DynamicData.Tests/Internal/SharedDeliveryQueueFixture.cs
@@ -0,0 +1,187 @@
+// 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.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using DynamicData.Internal;
+using FluentAssertions;
+using Xunit;
+
+namespace DynamicData.Tests.Internal;
+
+public class SharedDeliveryQueueFixture
+{
+#if NET9_0_OR_GREATER
+    private readonly Lock _gate = new();
+#else
+    private readonly object _gate = new();
+#endif
+
+    [Fact]
+    public void SingleSourceDeliversItems()
+    {
+        var queue = new SharedDeliveryQueue(_gate);
+        var delivered = new List<int>();
+        var observer = new TestObserver<int>(delivered.Add);
+        var sub = queue.CreateQueue(observer);
+
+        using (var scope = sub.AcquireLock())
+        {
+            scope.EnqueueNext(1);
+            scope.EnqueueNext(2);
+            scope.EnqueueNext(3);
+        }
+
+        delivered.Should().Equal(1, 2, 3);
+    }
+
+    [Fact]
+    public void MultipleSourcesSerializeDelivery()
+    {
+        var queue = new SharedDeliveryQueue(_gate);
+        var delivered = new List<string>();
+        var obs1 = new TestObserver<int>(i => delivered.Add($"int:{i}"));
+        var obs2 = new TestObserver<string>(s => delivered.Add($"str:{s}"));
+        var sub1 = queue.CreateQueue(obs1);
+        var sub2 = queue.CreateQueue(obs2);
+
+        using (var scope1 = sub1.AcquireLock())
+        {
+            scope1.EnqueueNext(1);
+        }
+
+        using (var scope2 = sub2.AcquireLock())
+        {
+            scope2.EnqueueNext("hello");
+        }
+
+        delivered.Should().Equal("int:1", "str:hello");
+    }
+
+    [Fact]
+    public void ErrorTerminatesAllSubQueues()
+    {
+        var queue = new SharedDeliveryQueue(_gate);
+        var delivered1 = new List<int>();
+        var delivered2 = new List<string>();
+        var obs1 = new TestObserver<int>(delivered1.Add);
+        var obs2 = new TestObserver<string>(delivered2.Add);
+        var sub1 = queue.CreateQueue(obs1);
+        var sub2 = queue.CreateQueue(obs2);
+
+        using (var scope1 = sub1.AcquireLock())
+        {
+            scope1.EnqueueNext(1);
+            scope1.EnqueueError(new InvalidOperationException("boom"));
+        }
+
+        queue.IsTerminated.Should().BeTrue();
+
+        // Further enqueues should be ignored
+        using (var scope2 = sub2.AcquireLock())
+        {
+            scope2.EnqueueNext("ignored");
+        }
+
+        delivered1.Should().Equal(1);
+        obs1.Error.Should().NotBeNull();
+        delivered2.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void CompletionDoesNotTerminateParent()
+    {
+        var queue = new SharedDeliveryQueue(_gate);
+        var delivered1 = new List<int>();
+        var delivered2 = new List<string>();
+        var obs1 = new TestObserver<int>(delivered1.Add);
+        var obs2 = new TestObserver<string>(delivered2.Add);
+        var sub1 = queue.CreateQueue(obs1);
+        var sub2 = queue.CreateQueue(obs2);
+
+        using (var scope1 = sub1.AcquireLock())
+        {
+            scope1.EnqueueNext(1);
+            scope1.EnqueueCompleted();
+        }
+
+        queue.IsTerminated.Should().BeFalse("completion of one sub-queue should not terminate parent");
+        obs1.IsCompleted.Should().BeTrue();
+
+        // Other sub-queue should still work
+        using (var scope2 = sub2.AcquireLock())
+        {
+            scope2.EnqueueNext("still alive");
+        }
+
+        delivered2.Should().Equal("still alive");
+    }
+
+    [Fact]
+    public void DisposeTerminatesAndWaits()
+    {
+        var queue = new SharedDeliveryQueue(_gate);
+        var observer = new TestObserver<int>(_ => { });
+        var sub = queue.CreateQueue(observer);
+
+        using (var scope = sub.AcquireLock())
+        {
+            scope.EnqueueNext(1);
+        }
+
+        queue.Dispose();
+
+        queue.IsTerminated.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task ConcurrentMultiSourceDelivery()
+    {
+        const int threadCount = 4;
+        const int itemsPerThread = 200;
+        var queue = new SharedDeliveryQueue(_gate);
+        var delivered = new ConcurrentBag<string>();
+
+        var subQueues = Enumerable.Range(0, threadCount).Select(t =>
+        {
+            var obs = new TestObserver<int>(i => delivered.Add($"{t}:{i}"));
+            return queue.CreateQueue(obs);
+        }).ToArray();
+
+        var tasks = Enumerable.Range(0, threadCount).Select(t => Task.Run(() =>
+        {
+            for (var i = 0; i < itemsPerThread; i++)
+            {
+                using var scope = subQueues[t].AcquireLock();
+                scope.EnqueueNext(i);
+            }
+        })).ToArray();
+
+        await Task.WhenAll(tasks);
+
+        delivered.Count.Should().Be(threadCount * itemsPerThread);
+
+        // Each thread's items should all be present
+        for (var t = 0; t < threadCount; t++)
+        {
+            var threadItems = delivered.Where(s => s.StartsWith($"{t}:")).Count();
+            threadItems.Should().Be(itemsPerThread);
+        }
+    }
+
+    private sealed class TestObserver<T>(Action<T> onNext) : IObserver<T>
+    {
+        public Exception? Error { get; private set; }
+        public bool IsCompleted { get; private set; }
+
+        public void OnNext(T value) => onNext(value);
+        public void OnError(Exception error) => Error = error;
+        public void OnCompleted() => IsCompleted = true;
+    }
+}
\ No newline at end of file
diff --git a/src/DynamicData/Binding/SortAndBind.cs b/src/DynamicData/Binding/SortAndBind.cs
index 80cddd3e2..0bb5fe208 100644
--- a/src/DynamicData/Binding/SortAndBind.cs
+++ b/src/DynamicData/Binding/SortAndBind.cs
@@ -65,11 +65,11 @@ public SortAndBind(IObservable<IChangeSet<TObject, TKey>> source,
                 comparerChanged = comparerChanged.ObserveOn(scheduler);
             }
 
-            var locker = InternalEx.NewLock();
+            var queue = new SharedDeliveryQueue();
             SortApplicator? sortApplicator = null;
 
             // Create a new sort applicator each time.
-            var latestComparer = comparerChanged.Synchronize(locker)
+            var latestComparer = comparerChanged.SynchronizeSafe(queue)
                 .Subscribe(comparer =>
                 {
                     sortApplicator = new SortApplicator(_cache, target, comparer, options);
@@ -77,7 +77,7 @@ public SortAndBind(IObservable<IChangeSet<TObject, TKey>> source,
                 });
 
             // Listen to changes and apply the sorting
-            var subscriber = source.Synchronize(locker)
+            var subscriber = source.SynchronizeSafe(queue)
                 .Select((changes, index) =>
                 {
                     _cache.Clone(changes);
@@ -89,7 +89,7 @@ public SortAndBind(IObservable<IChangeSet<TObject, TKey>> source,
                 })
                 .SubscribeSafe(observer);
 
-            return new CompositeDisposable(latestComparer, subscriber);
+            return new CompositeDisposable(latestComparer, subscriber, queue);
         });
 
     public IObservable<IChangeSet<TObject, TKey>> Run() => _sorted;
diff --git a/src/DynamicData/Cache/Internal/AsyncDisposeMany.cs b/src/DynamicData/Cache/Internal/AsyncDisposeMany.cs
index a134360c5..8699e1c58 100644
--- a/src/DynamicData/Cache/Internal/AsyncDisposeMany.cs
+++ b/src/DynamicData/Cache/Internal/AsyncDisposeMany.cs
@@ -7,8 +7,6 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
-using DynamicData.Internal;
-
 namespace DynamicData.Cache.Internal;
 
 #if SUPPORTS_ASYNC_DISPOSABLE
@@ -28,23 +26,18 @@ public static IObservable<IChangeSet<TObject, TKey>> Create(
             {
                 var itemsByKey = new Dictionary<TKey, TObject>();
 
-                var synchronizationGate = InternalEx.NewLock();
-
                 var disposals = new Subject<IObservable<Unit>>();
                 var disposalsCompleted = disposals
                     .Merge()
                     .IgnoreElements()
                     .Concat(Observable.Return(Unit.Default))
-                    // If no one subscribes to this stream, disposals won't actually occur, so make sure we have one (and only one) regardless of what the consumer does.
                     .Publish()
                     .AutoConnect(0);
 
-                // Make sure the consumer gets a chance to subscribe BEFORE we actually start processing items, so there's no risk of the consumer missing notifications.
                 disposalsCompletedAccessor.Invoke(disposalsCompleted);
 
                 var sourceSubscription = source
-                    .Synchronize(synchronizationGate)
-                    // Using custom notification handlers instead of .Do() to make sure that we're not disposing items until AFTER we've notified all downstream listeners to remove them from their cached or bound collections.
+                    .SynchronizeSafe()
                     .SubscribeSafe(
                         onNext: upstreamChanges =>
                         {
@@ -70,24 +63,18 @@ public static IObservable<IChangeSet<TObject, TKey>> Create(
                         onError: error =>
                         {
                             downstreamObserver.OnError(error);
-
                             TearDown();
                         },
                         onCompleted: () =>
                         {
                             downstreamObserver.OnCompleted();
-
                             TearDown();
                         });
 
                 return Disposable.Create(() =>
                 {
-                    lock (synchronizationGate)
-                    {
-                        sourceSubscription.Dispose();
-
-                        TearDown();
-                    }
+                    sourceSubscription.Dispose();
+                    TearDown();
                 });
 
                 void TearDown()
@@ -99,7 +86,6 @@ void TearDown()
                             foreach (var item in itemsByKey.Values)
                                 TryDisposeItem(item);
                             disposals.OnCompleted();
-
                             itemsByKey.Clear();
                         }
                         catch (Exception error)
@@ -119,4 +105,4 @@ void TryDisposeItem(TObject item)
             });
     }
 }
-#endif
+#endif
\ No newline at end of file
diff --git a/src/DynamicData/Cache/Internal/AutoRefresh.cs b/src/DynamicData/Cache/Internal/AutoRefresh.cs
index d489a56dc..ee81fe581 100644
--- a/src/DynamicData/Cache/Internal/AutoRefresh.cs
+++ b/src/DynamicData/Cache/Internal/AutoRefresh.cs
@@ -32,9 +32,9 @@ public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChange
                     changes.Buffer(buffer.Value, _scheduler).Where(list => list.Count > 0).Select(items => new ChangeSet<TObject, TKey>(items));
 
                 // publish refreshes and underlying changes
-                var locker = InternalEx.NewLock();
-                var publisher = shared.Synchronize(locker).Merge(refreshChanges.Synchronize(locker)).SubscribeSafe(observer);
+                var queue = new SharedDeliveryQueue();
+                var publisher = shared.SynchronizeSafe(queue).Merge(refreshChanges.SynchronizeSafe(queue)).SubscribeSafe(observer);
 
-                return new CompositeDisposable(publisher, shared.Connect());
+                return new CompositeDisposable(publisher, shared.Connect(), queue);
             });
 }
diff --git a/src/DynamicData/Cache/Internal/BatchIf.cs b/src/DynamicData/Cache/Internal/BatchIf.cs
index 17d5e4a3a..76af20a61 100644
--- a/src/DynamicData/Cache/Internal/BatchIf.cs
+++ b/src/DynamicData/Cache/Internal/BatchIf.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.
 
@@ -23,7 +23,7 @@ public IObservable<ChangeSet<TObject, TKey>> Run() => Observable.Create<ChangeSe
             observer =>
             {
                 var batchedChanges = new List<IChangeSet<TObject, TKey>>();
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
                 var paused = initialPauseState;
                 var timeoutDisposer = new SerialDisposable();
                 var intervalTimerDisposer = new SerialDisposable();
@@ -46,7 +46,7 @@ void ResumeAction()
                 }
 
                 IDisposable IntervalFunction() =>
-                    intervalTimer.Synchronize(locker).Finally(() => paused = false).Subscribe(
+                    intervalTimer.SynchronizeSafe(queue).Finally(() => paused = false).Subscribe(
                         _ =>
                         {
                             paused = false;
@@ -62,7 +62,7 @@ IDisposable IntervalFunction() =>
                     intervalTimerDisposer.Disposable = IntervalFunction();
                 }
 
-                var pausedHandler = _pauseIfTrueSelector.Synchronize(locker).Subscribe(
+                var pausedHandler = _pauseIfTrueSelector.SynchronizeSafe(queue).Subscribe(
                     p =>
                     {
                         paused = p;
@@ -78,7 +78,7 @@ IDisposable IntervalFunction() =>
                         }
                         else if (timeOut.HasValue)
                         {
-                            timeoutDisposer.Disposable = Observable.Timer(timeOut.Value, _scheduler).Synchronize(locker).Subscribe(
+                            timeoutDisposer.Disposable = Observable.Timer(timeOut.Value, _scheduler).SynchronizeSafe(queue).Subscribe(
                                 _ =>
                                 {
                                     paused = false;
@@ -87,7 +87,7 @@ IDisposable IntervalFunction() =>
                         }
                     });
 
-                var publisher = _source.Synchronize(locker).Subscribe(
+                var publisher = _source.SynchronizeSafe(queue).Subscribe(
                     changes =>
                     {
                         batchedChanges.Add(changes);
@@ -99,6 +99,6 @@ IDisposable IntervalFunction() =>
                         }
                     });
 
-                return new CompositeDisposable(publisher, pausedHandler, timeoutDisposer, intervalTimerDisposer);
+                return new CompositeDisposable(publisher, pausedHandler, timeoutDisposer, intervalTimerDisposer, queue);
             });
 }
diff --git a/src/DynamicData/Cache/Internal/DisposeMany.cs b/src/DynamicData/Cache/Internal/DisposeMany.cs
index 7271896c8..fe97f5c0e 100644
--- a/src/DynamicData/Cache/Internal/DisposeMany.cs
+++ b/src/DynamicData/Cache/Internal/DisposeMany.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.
 
@@ -14,14 +14,12 @@ internal sealed class DisposeMany<TObject, TKey>(IObservable<IChangeSet<TObject,
 {
     private readonly IObservable<IChangeSet<TObject, TKey>> _source = source;
 
-    public IObservable<IChangeSet<TObject, TKey>> Run()
-        => Observable.Create<IChangeSet<TObject, TKey>>(observer =>
+    public IObservable<IChangeSet<TObject, TKey>> Run() =>
+        Observable.Create<IChangeSet<TObject, TKey>>(observer =>
         {
-            // Will be locking on cachedItems directly, instead of using an anonymous gate object. This is acceptable, since it's a privately-held object, there's no risk of deadlock from other consumers locking on it.
-            var cachedItems = new Dictionary<TKey, TObject>();
+            var tracked = new KeyedDisposable<TKey>();
 
             var sourceSubscription = _source
-                .Synchronize(cachedItems)
                 .SubscribeSafe(Observer.Create<IChangeSet<TObject, TKey>>(
                     onNext: changeSet =>
                     {
@@ -31,53 +29,19 @@ public IObservable<IChangeSet<TObject, TKey>> Run()
                         {
                             switch (change.Reason)
                             {
-                                case ChangeReason.Update:
-                                    if (change.Previous.HasValue && !EqualityComparer<TObject>.Default.Equals(change.Current, change.Previous.Value))
-                                    {
-                                        (change.Previous.Value as IDisposable)?.Dispose();
-                                    }
-
+                                case ChangeReason.Add or ChangeReason.Update:
+                                    tracked.Add(change.Key, change.Current);
                                     break;
 
                                 case ChangeReason.Remove:
-                                    (change.Current as IDisposable)?.Dispose();
+                                    tracked.Remove(change.Key);
                                     break;
                             }
                         }
-
-                        cachedItems.Clone(changeSet);
-                    },
-                    onError: error =>
-                    {
-                        observer.OnError(error);
-
-                        ProcessFinalization(cachedItems);
                     },
-                    onCompleted: () =>
-                    {
-                        observer.OnCompleted();
+                    onError: observer.OnError,
+                    onCompleted: observer.OnCompleted));
 
-                        ProcessFinalization(cachedItems);
-                    }));
-
-            return Disposable.Create(() =>
-            {
-                sourceSubscription.Dispose();
-
-                lock (cachedItems)
-                {
-                    ProcessFinalization(cachedItems);
-                }
-            });
+            return new CompositeDisposable(sourceSubscription, tracked);
         });
-
-    private static void ProcessFinalization(Dictionary<TKey, TObject> cachedItems)
-    {
-        foreach (var pair in cachedItems)
-        {
-            (pair.Value as IDisposable)?.Dispose();
-        }
-
-        cachedItems.Clear();
-    }
 }
diff --git a/src/DynamicData/Cache/Internal/DynamicCombiner.cs b/src/DynamicData/Cache/Internal/DynamicCombiner.cs
index a5eba2bdd..41c7e3a8d 100644
--- a/src/DynamicData/Cache/Internal/DynamicCombiner.cs
+++ b/src/DynamicData/Cache/Internal/DynamicCombiner.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.
 
@@ -16,19 +16,19 @@ internal sealed class DynamicCombiner<TObject, TKey>(IObservableList<IObservable
     public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChangeSet<TObject, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 // this is the resulting cache which produces all notifications
                 var resultCache = new ChangeAwareCache<TObject, TKey>();
 
                 // Transform to a merge container.
                 // This populates a RefTracker when the original source is subscribed to
-                var sourceLists = _source.Connect().Synchronize(locker).Transform(changeSet => new MergeContainer(changeSet)).AsObservableList();
+                var sourceLists = _source.Connect().SynchronizeSafe(queue).Transform(changeSet => new MergeContainer(changeSet)).AsObservableList();
 
                 var sharedLists = sourceLists.Connect().Publish();
 
                 // merge the items back together
-                var allChanges = sharedLists.MergeMany(mc => mc.Source).Synchronize(locker).Subscribe(
+                var allChanges = sharedLists.MergeMany(mc => mc.Source).SynchronizeSafe(queue).Subscribe(
                     changes =>
                     {
                         // Populate result list and check for changes
@@ -79,7 +79,7 @@ public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChange
                         }
                     }).Subscribe();
 
-                return new CompositeDisposable(sourceLists, allChanges, removedItem, sourceChanged, sharedLists.Connect());
+                return new CompositeDisposable(sourceLists, allChanges, removedItem, sourceChanged, sharedLists.Connect(), queue);
             });
 
     private bool MatchesConstraint(MergeContainer[] sources, TKey key)
diff --git a/src/DynamicData/Cache/Internal/FullJoin.cs b/src/DynamicData/Cache/Internal/FullJoin.cs
index f4e4f5438..46bdb663f 100644
--- a/src/DynamicData/Cache/Internal/FullJoin.cs
+++ b/src/DynamicData/Cache/Internal/FullJoin.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.
 
@@ -26,10 +26,11 @@ public IObservable<IChangeSet<TDestination, TLeftKey>> Run() => Observable.Creat
             observer =>
             {
                 var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue(locker);
 
                 // create local backing stores
-                var leftCache = _left.Synchronize(locker).AsObservableCache(false);
-                var rightCache = _right.Synchronize(locker).ChangeKey(_rightKeySelector).AsObservableCache(false);
+                var leftCache = _left.SynchronizeSafe(queue).AsObservableCache();
+                var rightCache = _right.SynchronizeSafe(queue).ChangeKey(_rightKeySelector).AsObservableCache();
 
                 // joined is the final cache
                 var joinedCache = new ChangeAwareCache<TDestination, TLeftKey>();
@@ -118,7 +119,7 @@ public IObservable<IChangeSet<TDestination, TLeftKey>> Run() => Observable.Creat
 
                 lock (locker)
                 {
-                    return new CompositeDisposable(leftLoader.Merge(rightLoader).SubscribeSafe(observer), leftCache, rightCache);
+                    return new CompositeDisposable(leftLoader.Merge(rightLoader).SubscribeSafe(observer), leftCache, rightCache, queue);
                 }
             });
 }
diff --git a/src/DynamicData/Cache/Internal/GroupOn.cs b/src/DynamicData/Cache/Internal/GroupOn.cs
index 619685afd..fd0936fe7 100644
--- a/src/DynamicData/Cache/Internal/GroupOn.cs
+++ b/src/DynamicData/Cache/Internal/GroupOn.cs
@@ -22,12 +22,12 @@ internal sealed class GroupOn<TObject, TKey, TGroupKey>(IObservable<IChangeSet<T
     public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observable.Create<IGroupChangeSet<TObject, TKey, TGroupKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
                 var grouper = new Grouper(_groupSelectorKey);
 
-                var groups = _source.Finally(observer.OnCompleted).Synchronize(locker).Select(grouper.Update).Where(changes => changes.Count != 0);
+                var groups = _source.SynchronizeSafe(queue).Finally(observer.OnCompleted).Select(grouper.Update).Where(changes => changes.Count != 0);
 
-                var regroup = _regrouper.Synchronize(locker).Select(_ => grouper.Regroup()).Where(changes => changes.Count != 0);
+                var regroup = _regrouper.SynchronizeSafe(queue).Select(_ => grouper.Regroup()).Where(changes => changes.Count != 0);
 
                 var published = groups.Merge(regroup).Publish();
                 var subscriber = published.SubscribeSafe(observer);
@@ -35,13 +35,7 @@ public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observabl
 
                 var connected = published.Connect();
 
-                return Disposable.Create(
-                    () =>
-                    {
-                        connected.Dispose();
-                        disposer.Dispose();
-                        subscriber.Dispose();
-                    });
+                return new CompositeDisposable(connected, disposer, subscriber, queue);
             });
 
     private sealed class Grouper(Func<TObject, TGroupKey> groupSelectorKey)
diff --git a/src/DynamicData/Cache/Internal/GroupOnDynamic.cs b/src/DynamicData/Cache/Internal/GroupOnDynamic.cs
index 815baa34d..0e11bc594 100644
--- a/src/DynamicData/Cache/Internal/GroupOnDynamic.cs
+++ b/src/DynamicData/Cache/Internal/GroupOnDynamic.cs
@@ -5,7 +5,6 @@
 using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using DynamicData.Internal;
 
 namespace DynamicData.Cache.Internal;
 
@@ -17,13 +16,14 @@ internal sealed class GroupOnDynamic<TObject, TKey, TGroupKey>(IObservable<IChan
     public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observable.Create<IGroupChangeSet<TObject, TKey, TGroupKey>>(observer =>
     {
         var dynamicGrouper = new DynamicGrouper<TObject, TKey, TGroupKey>();
+        var queue = new SharedDeliveryQueue();
         var notGrouped = new Cache<TObject, TKey>();
         var hasSelector = false;
 
         // Create shared observables for the 3 inputs
-        var sharedSource = source.Synchronize(dynamicGrouper).Publish();
-        var sharedGroupSelector = selectGroupObservable.DistinctUntilChanged().Synchronize(dynamicGrouper).Publish();
-        var sharedRegrouper = (regrouper ?? Observable.Empty<Unit>()).Synchronize(dynamicGrouper).Publish();
+        var sharedSource = source.SynchronizeSafe(queue).Publish();
+        var sharedGroupSelector = selectGroupObservable.DistinctUntilChanged().SynchronizeSafe(queue).Publish();
+        var sharedRegrouper = (regrouper ?? Observable.Empty<Unit>()).SynchronizeSafe(queue).Publish();
 
         // The first value from the Group Selector should update the Grouper with all the values seen so far
         // Then indicate a selector has been found.  Subsequent values should just update the group selector.
@@ -73,6 +73,7 @@ public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observabl
 
         // Create an observable that completes when all 3 inputs complete so the downstream can be completed as well
         var subOnComplete = Observable.Merge(sharedSource.ToUnit(), sharedGroupSelector.ToUnit(), sharedRegrouper)
+            .IgnoreElements()
             .SubscribeSafe(observer.OnError, observer.OnCompleted);
 
         return new CompositeDisposable(
@@ -83,6 +84,7 @@ public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observabl
             subChanges,
             subGroupSelector,
             subRegrouper,
-            subOnComplete);
+            subOnComplete,
+            queue);
     });
 }
diff --git a/src/DynamicData/Cache/Internal/GroupOnImmutable.cs b/src/DynamicData/Cache/Internal/GroupOnImmutable.cs
index a7a14e3e2..ba33db031 100644
--- a/src/DynamicData/Cache/Internal/GroupOnImmutable.cs
+++ b/src/DynamicData/Cache/Internal/GroupOnImmutable.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 
 namespace DynamicData.Cache.Internal;
@@ -21,14 +22,14 @@ internal sealed class GroupOnImmutable<TObject, TKey, TGroupKey>(IObservable<ICh
     public IObservable<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observable.Create<IImmutableGroupChangeSet<TObject, TKey, TGroupKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
                 var grouper = new Grouper(_groupSelectorKey);
 
-                var groups = _source.Synchronize(locker).Select(grouper.Update).Where(changes => changes.Count != 0);
+                var groups = _source.SynchronizeSafe(queue).Select(grouper.Update).Where(changes => changes.Count != 0);
 
-                var regroup = _regrouper.Synchronize(locker).Select(_ => grouper.Regroup()).Where(changes => changes.Count != 0);
+                var regroup = _regrouper.SynchronizeSafe(queue).Select(_ => grouper.Regroup()).Where(changes => changes.Count != 0);
 
-                return groups.Merge(regroup).SubscribeSafe(observer);
+                return new CompositeDisposable(groups.Merge(regroup).SubscribeSafe(observer), queue);
             });
 
     private sealed class Grouper(Func<TObject, TGroupKey> groupSelectorKey)
diff --git a/src/DynamicData/Cache/Internal/InnerJoin.cs b/src/DynamicData/Cache/Internal/InnerJoin.cs
index ae9858e74..e27c565c6 100644
--- a/src/DynamicData/Cache/Internal/InnerJoin.cs
+++ b/src/DynamicData/Cache/Internal/InnerJoin.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.
 
@@ -26,13 +26,14 @@ internal sealed class InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination
             observer =>
             {
                 var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue(locker);
 
                 // create local backing stores
-                var leftCache = _left.Synchronize(locker).AsObservableCache(false);
+                var leftCache = _left.SynchronizeSafe(queue).AsObservableCache();
 
-                var rightShare = _right.Synchronize(locker).Publish();
-                var rightCache = rightShare.AsObservableCache(false);
-                var rightGrouped = rightShare.GroupWithImmutableState(_rightKeySelector).AsObservableCache(false);
+                var rightShare = _right.SynchronizeSafe(queue).Publish();
+                var rightCache = rightShare.AsObservableCache();
+                var rightGrouped = rightShare.GroupWithImmutableState(_rightKeySelector).AsObservableCache();
 
                 var rightForeignKeysByKey = new Dictionary<TRightKey, TLeftKey>();
 
@@ -157,7 +158,7 @@ internal sealed class InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination
 
                     hasInitialized = true;
 
-                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShare.Connect());
+                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShare.Connect(), queue);
                 }
             });
 }
diff --git a/src/DynamicData/Cache/Internal/LeftJoin.cs b/src/DynamicData/Cache/Internal/LeftJoin.cs
index bcacf8774..f0709cb75 100644
--- a/src/DynamicData/Cache/Internal/LeftJoin.cs
+++ b/src/DynamicData/Cache/Internal/LeftJoin.cs
@@ -26,14 +26,15 @@ public IObservable<IChangeSet<TDestination, TLeftKey>> Run() => Observable.Creat
             observer =>
             {
                 var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue(locker);
 
                 // create local backing stores
-                var leftShare = _left.Synchronize(locker).Publish();
-                var leftCache = leftShare.AsObservableCache(false);
+                var leftShare = _left.SynchronizeSafe(queue).Publish();
+                var leftCache = leftShare.AsObservableCache();
 
-                var rightShare = _right.Synchronize(locker).Publish();
-                var rightCache = rightShare.AsObservableCache(false);
-                var rightForeignCache = rightShare.ChangeKey(_rightKeySelector).AsObservableCache(false);
+                var rightShare = _right.SynchronizeSafe(queue).Publish();
+                var rightCache = rightShare.AsObservableCache();
+                var rightForeignCache = rightShare.ChangeKey(_rightKeySelector).AsObservableCache();
 
                 var rightForeignKeysByKey = new Dictionary<TRightKey, TLeftKey>();
 
@@ -146,7 +147,7 @@ public IObservable<IChangeSet<TDestination, TLeftKey>> Run() => Observable.Creat
 
                     hasInitialized = true;
 
-                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShareConnection, leftShare.Connect());
+                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShareConnection, leftShare.Connect(), queue);
                 }
             });
 }
diff --git a/src/DynamicData/Cache/Internal/MergeChangeSets.cs b/src/DynamicData/Cache/Internal/MergeChangeSets.cs
index 62b942402..ebf4b22f1 100644
--- a/src/DynamicData/Cache/Internal/MergeChangeSets.cs
+++ b/src/DynamicData/Cache/Internal/MergeChangeSets.cs
@@ -1,10 +1,10 @@
-// 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.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using DynamicData.Internal;
 
 namespace DynamicData.Cache.Internal;
 
@@ -23,39 +23,30 @@ public MergeChangeSets(IEnumerable<IObservable<IChangeSet<TObject, TKey>>> sourc
     public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChangeSet<TObject, TKey>>(
         observer =>
         {
-            var locker = InternalEx.NewLock();
+            var queue = new SharedDeliveryQueue();
             var cache = new Cache<ChangeSetCache<TObject, TKey>, int>();
 
             // This is manages all of the changes
             var changeTracker = new ChangeSetMergeTracker<TObject, TKey>(() => cache.Items, comparer, equalityComparer);
 
             // Create a ChangeSet of Caches, synchronize, update the local copy, and merge the sub-observables together.
-            return CreateContainerObservable(source, locker)
-                .Synchronize(locker)
+            return new CompositeDisposable(CreateContainerObservable(source, queue)
+                .SynchronizeSafe(queue)
                 .Do(cache.Clone)
                 .MergeMany(mc => mc.Source.Do(static _ => { }, observer.OnError))
                 .SubscribeSafe(
                     changes => changeTracker.ProcessChangeSet(changes, observer),
                     observer.OnError,
-                    observer.OnCompleted);
+                    observer.OnCompleted), queue);
         });
 
     // Can optimize for the Add case because that's the only one that applies
-#if NET9_0_OR_GREATER
-    private static Change<ChangeSetCache<TObject, TKey>, int> CreateChange(IObservable<IChangeSet<TObject, TKey>> source, int index, Lock locker) =>
-        new(ChangeReason.Add, index, new ChangeSetCache<TObject, TKey>(source.IgnoreSameReferenceUpdate().Synchronize(locker)));
+    private static Change<ChangeSetCache<TObject, TKey>, int> CreateChange(IObservable<IChangeSet<TObject, TKey>> source, int index, SharedDeliveryQueue queue) =>
+        new(ChangeReason.Add, index, new ChangeSetCache<TObject, TKey>(source.IgnoreSameReferenceUpdate().SynchronizeSafe(queue)));
 
     // Create a ChangeSet Observable that produces ChangeSets with a single Add event for each new sub-observable
-    private static IObservable<IChangeSet<ChangeSetCache<TObject, TKey>, int>> CreateContainerObservable(IObservable<IObservable<IChangeSet<TObject, TKey>>> source, Lock locker) =>
-        source.Select((src, index) => new ChangeSet<ChangeSetCache<TObject, TKey>, int>(new[] { CreateChange(src, index, locker) }));
-#else
-    private static Change<ChangeSetCache<TObject, TKey>, int> CreateChange(IObservable<IChangeSet<TObject, TKey>> source, int index, object locker) =>
-        new(ChangeReason.Add, index, new ChangeSetCache<TObject, TKey>(source.IgnoreSameReferenceUpdate().Synchronize(locker)));
-
-    // Create a ChangeSet Observable that produces ChangeSets with a single Add event for each new sub-observable
-    private static IObservable<IChangeSet<ChangeSetCache<TObject, TKey>, int>> CreateContainerObservable(IObservable<IObservable<IChangeSet<TObject, TKey>>> source, object locker) =>
-        source.Select((src, index) => new ChangeSet<ChangeSetCache<TObject, TKey>, int>(new[] { CreateChange(src, index, locker) }));
-#endif
+    private static IObservable<IChangeSet<ChangeSetCache<TObject, TKey>, int>> CreateContainerObservable(IObservable<IObservable<IChangeSet<TObject, TKey>>> source, SharedDeliveryQueue queue) =>
+        source.Select((src, index) => new ChangeSet<ChangeSetCache<TObject, TKey>, int>(new[] { CreateChange(src, index, queue) }));
 
     // Create a ChangeSet Observable with a single event that adds all the values in the enum (and then completes, maybe)
     private static IObservable<IObservable<IChangeSet<TObject, TKey>>> CreateObservable(IEnumerable<IObservable<IChangeSet<TObject, TKey>>> source, bool completable, IScheduler? scheduler = null)
diff --git a/src/DynamicData/Cache/Internal/MergeMany.cs b/src/DynamicData/Cache/Internal/MergeMany.cs
index 0058ffe55..fe2eecc75 100644
--- a/src/DynamicData/Cache/Internal/MergeMany.cs
+++ b/src/DynamicData/Cache/Internal/MergeMany.cs
@@ -1,11 +1,10 @@
-// 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.Reactive.Disposables;
 using System.Reactive.Linq;
-using System.Reactive.Subjects;
-using DynamicData.Internal;
+using System.Runtime.CompilerServices;
 
 namespace DynamicData.Cache.Internal;
 
@@ -34,50 +33,29 @@ public MergeMany(IObservable<IChangeSet<TObject, TKey>> source, Func<TObject, IO
     public IObservable<TDestination> Run() => Observable.Create<TDestination>(
             observer =>
             {
-                var counter = new SubscriptionCounter();
-                var locker = InternalEx.NewLock();
-                var disposable = _source.Concat(counter.DeferCleanup)
-                                                .SubscribeMany((t, key) =>
-                                                {
-                                                    counter.Added();
-                                                    return _observableSelector(t, key).Synchronize(locker).Finally(() => counter.Finally()).Subscribe(observer.OnNext, static _ => { });
-                                                })
-                                                .SubscribeSafe(observer.OnError, observer.OnCompleted);
-
-                return new CompositeDisposable(disposable, counter);
+                var counter = new StrongBox<int>(1);
+                var queue = new DeliveryQueue<TDestination>(observer);
+
+                // Queue first: terminate before subscription disposal to prevent
+                // Finally callbacks from delivering spurious OnCompleted during teardown.
+                return new CompositeDisposable(queue, _source
+                    .Do(static _ => { }, static _ => { }, () => CheckCompleted(counter, queue))
+                    .Concat(Observable.Never<IChangeSet<TObject, TKey>>())
+                    .SubscribeMany((t, key) =>
+                    {
+                        Interlocked.Increment(ref counter.Value);
+                        return _observableSelector(t, key)
+                            .Finally(() => CheckCompleted(counter, queue))
+                            .Subscribe(queue.OnNext, static _ => { });
+                    })
+                    .Subscribe(static _ => { }, observer.OnError));
             });
 
-    private sealed class SubscriptionCounter : IDisposable
+    private static void CheckCompleted(StrongBox<int> counter, DeliveryQueue<TDestination> queue)
     {
-        private readonly Subject<IChangeSet<TObject, TKey>> _subject = new();
-        private int _subscriptionCount = 1;
-
-        public IObservable<IChangeSet<TObject, TKey>> DeferCleanup => Observable.Defer(() =>
-        {
-            CheckCompleted();
-            return _subject.AsObservable();
-        });
-
-        public void Added() => _ = Interlocked.Increment(ref _subscriptionCount);
-
-        public void Finally() => CheckCompleted();
-
-        public void Dispose()
+        if (Interlocked.Decrement(ref counter.Value) == 0 && !queue.IsTerminated)
         {
-            if (Interlocked.Exchange(ref _subscriptionCount, 0) != 0)
-            {
-                _subject.OnCompleted();
-            }
-
-            _subject.Dispose();
-        }
-
-        private void CheckCompleted()
-        {
-            if (Interlocked.Decrement(ref _subscriptionCount) == 0)
-            {
-                _subject.OnCompleted();
-            }
+            queue.OnCompleted();
         }
     }
 }
diff --git a/src/DynamicData/Cache/Internal/OnBeingRemoved.cs b/src/DynamicData/Cache/Internal/OnBeingRemoved.cs
index c66f414db..092306f3d 100644
--- a/src/DynamicData/Cache/Internal/OnBeingRemoved.cs
+++ b/src/DynamicData/Cache/Internal/OnBeingRemoved.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,20 +17,17 @@ internal sealed class OnBeingRemoved<TObject, TKey>(IObservable<IChangeSet<TObje
     public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChangeSet<TObject, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
                 var cache = new Cache<TObject, TKey>();
-                var subscriber = _source.Synchronize(locker).Do(changes => RegisterForRemoval(changes, cache), observer.OnError).SubscribeSafe(observer);
+                var subscriber = _source.SynchronizeSafe()
+                    .Do(changes => RegisterForRemoval(changes, cache))
+                    .SubscribeSafe(observer);
 
                 return Disposable.Create(
                     () =>
                     {
                         subscriber.Dispose();
-
-                        lock (locker)
-                        {
-                            cache.KeyValues.ForEach(kvp => _removeAction(kvp.Value, kvp.Key));
-                            cache.Clear();
-                        }
+                        cache.KeyValues.ForEach(kvp => _removeAction(kvp.Value, kvp.Key));
+                        cache.Clear();
                     });
             });
 
@@ -39,12 +36,9 @@ private void RegisterForRemoval(IChangeSet<TObject, TKey> changes, Cache<TObject
         changes.ForEach(
             change =>
             {
-                switch (change.Reason)
+                if (change.Reason is ChangeReason.Remove)
                 {
-                    case ChangeReason.Remove:
-                        // ReSharper disable once InconsistentlySynchronizedField
-                        _removeAction(change.Current, change.Key);
-                        break;
+                    _removeAction(change.Current, change.Key);
                 }
             });
         cache.Clone(changes);
diff --git a/src/DynamicData/Cache/Internal/Page.cs b/src/DynamicData/Cache/Internal/Page.cs
index f7c5b8755..e41595871 100644
--- a/src/DynamicData/Cache/Internal/Page.cs
+++ b/src/DynamicData/Cache/Internal/Page.cs
@@ -1,7 +1,8 @@
-// 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.Reactive.Disposables;
 using System.Reactive.Linq;
 
 namespace DynamicData.Cache.Internal;
@@ -13,15 +14,15 @@ internal sealed class Page<TObject, TKey>(IObservable<ISortedChangeSet<TObject,
     public IObservable<IPagedChangeSet<TObject, TKey>> Run() => Observable.Create<IPagedChangeSet<TObject, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
                 var paginator = new Paginator();
-                var request = pageRequests.Synchronize(locker).Select(paginator.Paginate);
-                var dataChange = source.Synchronize(locker).Select(paginator.Update);
+                var request = pageRequests.SynchronizeSafe(queue).Select(paginator.Paginate);
+                var dataChange = source.SynchronizeSafe(queue).Select(paginator.Update);
 
-                return request.Merge(dataChange)
+                return new CompositeDisposable(request.Merge(dataChange)
                     .Where(updates => updates is not null)
                     .Select(x => x!)
-                    .SubscribeSafe(observer);
+                    .SubscribeSafe(observer), queue);
             });
 
     private sealed class Paginator
diff --git a/src/DynamicData/Cache/Internal/QueryWhenChanged.cs b/src/DynamicData/Cache/Internal/QueryWhenChanged.cs
index 5dab527ee..01828e85e 100644
--- a/src/DynamicData/Cache/Internal/QueryWhenChanged.cs
+++ b/src/DynamicData/Cache/Internal/QueryWhenChanged.cs
@@ -1,7 +1,8 @@
-// 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.Reactive.Disposables;
 using System.Reactive.Linq;
 
 namespace DynamicData.Cache.Internal;
@@ -31,23 +32,24 @@ public IObservable<IQuery<TObject, TKey>> Run()
                 .Select(cache => new AnonymousQuery<TObject, TKey>(cache!));
         }
 
-        return _source.Publish(
-            shared =>
-            {
-                var locker = InternalEx.NewLock();
-                var state = new Cache<TObject, TKey>();
+        return Observable.Create<IQuery<TObject, TKey>>(observer =>
+        {
+            var queue = new SharedDeliveryQueue();
+            var state = new Cache<TObject, TKey>();
+
+            var shared = _source.Publish();
 
-                var inlineChange = shared.MergeMany(itemChangedTrigger).Synchronize(locker).Select(_ => new AnonymousQuery<TObject, TKey>(state));
+            var inlineChange = shared.MergeMany(itemChangedTrigger).SynchronizeSafe(queue).Select(_ => new AnonymousQuery<TObject, TKey>(state));
 
-                var sourceChanged = shared.Synchronize(locker).Scan(
-                    state,
-                    (cache, changes) =>
-                    {
-                        cache.Clone(changes);
-                        return cache;
-                    }).Select(list => new AnonymousQuery<TObject, TKey>(list));
+            var sourceChanged = shared.SynchronizeSafe(queue).Scan(
+                state,
+                (cache, changes) =>
+                {
+                    cache.Clone(changes);
+                    return cache;
+                }).Select(list => new AnonymousQuery<TObject, TKey>(list));
 
-                return sourceChanged.Merge(inlineChange);
-            });
+            return new CompositeDisposable(sourceChanged.Merge(inlineChange).SubscribeSafe(observer), shared.Connect(), queue);
+        });
     }
 }
diff --git a/src/DynamicData/Cache/Internal/RightJoin.cs b/src/DynamicData/Cache/Internal/RightJoin.cs
index cd4fb87db..85163f75e 100644
--- a/src/DynamicData/Cache/Internal/RightJoin.cs
+++ b/src/DynamicData/Cache/Internal/RightJoin.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.
 
@@ -26,17 +26,18 @@ public IObservable<IChangeSet<TDestination, TRightKey>> Run() => Observable.Crea
             observer =>
             {
                 var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue(locker);
 
                 // create local backing stores
-                var leftCache = _left.Synchronize(locker).AsObservableCache(false);
+                var leftCache = _left.SynchronizeSafe(queue).AsObservableCache();
 
-                var rightShare = _right.Synchronize(locker).Publish();
+                var rightShare = _right.SynchronizeSafe(queue).Publish();
 
-                var rightCache = rightShare.AsObservableCache(false);
+                var rightCache = rightShare.AsObservableCache();
                 var rightForeignCache = rightShare
                     .Transform(static (item, key) => (item, key))
                     .ChangeKey(pair => _rightKeySelector.Invoke(pair.item))
-                    .AsObservableCache(false);
+                    .AsObservableCache();
 
                 var rightForeignKeysByKey = new Dictionary<TRightKey, TLeftKey>();
 
@@ -139,7 +140,7 @@ public IObservable<IChangeSet<TDestination, TRightKey>> Run() => Observable.Crea
 
                     hasInitialized = true;
 
-                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShare.Connect());
+                    return new CompositeDisposable(observerSubscription, leftCache, rightCache, rightShare.Connect(), queue);
                 }
             });
 }
diff --git a/src/DynamicData/Cache/Internal/Sort.cs b/src/DynamicData/Cache/Internal/Sort.cs
index feeb98c7f..11b39035e 100644
--- a/src/DynamicData/Cache/Internal/Sort.cs
+++ b/src/DynamicData/Cache/Internal/Sort.cs
@@ -1,8 +1,9 @@
-// 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.Reactive;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 
 namespace DynamicData.Cache.Internal;
@@ -42,7 +43,7 @@ public IObservable<ISortedChangeSet<TObject, TKey>> Run() => Observable.Create<I
             observer =>
             {
                 var sorter = new Sorter(_sortOptimisations, _comparer, _resetThreshold);
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 // check for nulls so we can prevent a lock when not required
                 if (_comparerChangedObservable is null && _resorter is null)
@@ -50,13 +51,13 @@ public IObservable<ISortedChangeSet<TObject, TKey>> Run() => Observable.Create<I
                     return _source.Select(sorter.Sort).Where(result => result is not null).Select(x => x!).SubscribeSafe(observer);
                 }
 
-                var comparerChanged = (_comparerChangedObservable ?? Observable.Never<IComparer<TObject>>()).Synchronize(locker).Select(sorter.Sort);
+                var comparerChanged = (_comparerChangedObservable ?? Observable.Never<IComparer<TObject>>()).SynchronizeSafe(queue).Select(sorter.Sort);
 
-                var sortAgain = (_resorter ?? Observable.Never<Unit>()).Synchronize(locker).Select(_ => sorter.Sort());
+                var sortAgain = (_resorter ?? Observable.Never<Unit>()).SynchronizeSafe(queue).Select(_ => sorter.Sort());
 
-                var dataChanged = _source.Synchronize(locker).Select(sorter.Sort);
+                var dataChanged = _source.SynchronizeSafe(queue).Select(sorter.Sort);
 
-                return comparerChanged.Merge(dataChanged).Merge(sortAgain).Where(result => result is not null).Select(x => x!).SubscribeSafe(observer);
+                return new CompositeDisposable(comparerChanged.Merge(dataChanged).Merge(sortAgain).Where(result => result is not null).Select(x => x!).SubscribeSafe(observer), queue);
             });
 
     private sealed class Sorter(SortOptimisations optimisations, IComparer<TObject>? comparer = null, int resetThreshold = -1)
diff --git a/src/DynamicData/Cache/Internal/SortAndPage.cs b/src/DynamicData/Cache/Internal/SortAndPage.cs
index 768b5d024..2d612a9b6 100644
--- a/src/DynamicData/Cache/Internal/SortAndPage.cs
+++ b/src/DynamicData/Cache/Internal/SortAndPage.cs
@@ -2,6 +2,7 @@
 // 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.Reactive.Disposables;
 using System.Reactive.Linq;
 using DynamicData.Binding;
 
@@ -43,7 +44,7 @@ public IObservable<IChangeSet<TObject, TKey, PageContext<TObject>>> Run() =>
         Observable.Create<IChangeSet<TObject, TKey, PageContext<TObject>>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 var sortOptions = new SortAndBindOptions
                 {
@@ -62,7 +63,7 @@ public IObservable<IChangeSet<TObject, TKey, PageContext<TObject>>> Run() =>
                 SortedKeyValueApplicator<TObject, TKey>? applicator = null;
 
                 // used to maintain a sorted list of key value pairs
-                var comparerChanged = _comparerChanged.Synchronize(locker)
+                var comparerChanged = _comparerChanged.SynchronizeSafe(queue)
                     .Select(c =>
                     {
                         comparer = c;
@@ -79,7 +80,7 @@ public IObservable<IChangeSet<TObject, TKey, PageContext<TObject>>> Run() =>
                         return ApplyPagedChanges();
                     });
 
-                var paramsChanged = _pageRequests.Synchronize(locker)
+                var paramsChanged = _pageRequests.SynchronizeSafe(queue)
                     .DistinctUntilChanged()
                     // exclude dodgy params
                     .Where(parameters => parameters is { Page: > 0, Size: > 0 })
@@ -94,7 +95,7 @@ public IObservable<IChangeSet<TObject, TKey, PageContext<TObject>>> Run() =>
                         return ApplyPagedChanges();
                     });
 
-                var dataChange = _source.Synchronize(locker)
+                var dataChange = _source.SynchronizeSafe(queue)
                     // we need to ensure each change batch has unique keys only.
                     // Otherwise, calculation of virtualized changes is super complex
                     .EnsureUniqueKeys()
@@ -110,11 +111,11 @@ public IObservable<IChangeSet<TObject, TKey, PageContext<TObject>>> Run() =>
                         return ApplyPagedChanges(changes);
                     });
 
-                return Observable.Merge(
+                return new CompositeDisposable(Observable.Merge(
                         comparerChanged.Skip(1),
                         paramsChanged.Where(changes => changes.Count is not 0),
                         dataChange.Where(changes => changes.Count is not 0))
-                    .SubscribeSafe(observer);
+                    .SubscribeSafe(observer), queue);
 
                 ChangeSet<TObject, TKey, PageContext<TObject>> ApplyPagedChanges(IChangeSet<TObject, TKey>? changeSet = null)
                 {
diff --git a/src/DynamicData/Cache/Internal/SortAndVirtualize.cs b/src/DynamicData/Cache/Internal/SortAndVirtualize.cs
index 1e18a940c..44c6d3dc3 100644
--- a/src/DynamicData/Cache/Internal/SortAndVirtualize.cs
+++ b/src/DynamicData/Cache/Internal/SortAndVirtualize.cs
@@ -2,6 +2,7 @@
 // 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.Reactive.Disposables;
 using System.Reactive.Linq;
 using DynamicData.Binding;
 
@@ -43,7 +44,7 @@ public IObservable<IChangeSet<TObject, TKey, VirtualContext<TObject>>> Run() =>
         Observable.Create<IChangeSet<TObject, TKey, VirtualContext<TObject>>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 var sortOptions = new SortAndBindOptions
                 {
@@ -62,7 +63,7 @@ public IObservable<IChangeSet<TObject, TKey, VirtualContext<TObject>>> Run() =>
                 SortedKeyValueApplicator<TObject, TKey>? applicator = null;
 
                 // used to maintain a sorted list of key value pairs
-                var comparerChanged = _comparerChanged.Synchronize(locker)
+                var comparerChanged = _comparerChanged.SynchronizeSafe(queue)
                     .Select(c =>
                     {
                         comparer = c;
@@ -79,7 +80,7 @@ public IObservable<IChangeSet<TObject, TKey, VirtualContext<TObject>>> Run() =>
                         return ApplyVirtualChanges();
                     });
 
-                var paramsChanged = _virtualRequests.Synchronize(locker)
+                var paramsChanged = _virtualRequests.SynchronizeSafe(queue)
                     .DistinctUntilChanged()
                     // exclude dodgy params
                     .Where(parameters => parameters is { StartIndex: >= 0, Size: > 0 })
@@ -94,7 +95,7 @@ public IObservable<IChangeSet<TObject, TKey, VirtualContext<TObject>>> Run() =>
                         return ApplyVirtualChanges();
                     });
 
-                var dataChange = _source.Synchronize(locker)
+                var dataChange = _source.SynchronizeSafe(queue)
                     // we need to ensure each change batch has unique keys only.
                     // Otherwise, calculation of virtualized changes is super complex
                     .EnsureUniqueKeys()
@@ -110,12 +111,12 @@ public IObservable<IChangeSet<TObject, TKey, VirtualContext<TObject>>> Run() =>
                         return ApplyVirtualChanges(changes);
                     });
 
-                return
+                return new CompositeDisposable(
                     comparerChanged
                         .Merge(paramsChanged)
                         .Merge(dataChange)
                         .Where(changes => changes.Count is not 0)
-                        .SubscribeSafe(observer);
+                        .SubscribeSafe(observer), queue);
 
                 ChangeSet<TObject, TKey, VirtualContext<TObject>> ApplyVirtualChanges(IChangeSet<TObject, TKey>? changeSet = null)
                 {
diff --git a/src/DynamicData/Cache/Internal/SpecifiedGrouper.cs b/src/DynamicData/Cache/Internal/SpecifiedGrouper.cs
index 4cf20cdfc..863f2d6d6 100644
--- a/src/DynamicData/Cache/Internal/SpecifiedGrouper.cs
+++ b/src/DynamicData/Cache/Internal/SpecifiedGrouper.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,13 +21,13 @@ internal sealed class SpecifiedGrouper<TObject, TKey, TGroupKey>(IObservable<ICh
     public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observable.Create<IGroupChangeSet<TObject, TKey, TGroupKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 // create source group cache
-                var sourceGroups = _source.Synchronize(locker).Group(_groupSelector).DisposeMany().AsObservableCache();
+                var sourceGroups = _source.SynchronizeSafe(queue).Group(_groupSelector).DisposeMany().AsObservableCache();
 
                 // create parent groups
-                var parentGroups = _resultGroupSource.Synchronize(locker).Transform(
+                var parentGroups = _resultGroupSource.SynchronizeSafe(queue).Transform(
                     x =>
                     {
                         // if child already has data, populate it.
@@ -62,13 +62,6 @@ public IObservable<IGroupChangeSet<TObject, TKey, TGroupKey>> Run() => Observabl
                         return new GroupChangeSet<TObject, TKey, TGroupKey>(groups);
                     }).SubscribeSafe(observer);
 
-                return Disposable.Create(
-                    () =>
-                    {
-                        notifier.Dispose();
-                        sourceGroups.Dispose();
-                        parentGroups.Dispose();
-                        updatesFromChildren.Dispose();
-                    });
+                return new CompositeDisposable(notifier, sourceGroups, parentGroups, updatesFromChildren, queue);
             });
 }
diff --git a/src/DynamicData/Cache/Internal/Switch.cs b/src/DynamicData/Cache/Internal/Switch.cs
index 77a0c16b1..766f9f14a 100644
--- a/src/DynamicData/Cache/Internal/Switch.cs
+++ b/src/DynamicData/Cache/Internal/Switch.cs
@@ -17,7 +17,7 @@ internal sealed class Switch<TObject, TKey>(IObservable<IObservable<IChangeSet<T
     public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChangeSet<TObject, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
                 var destination = new LockFreeObservableCache<TObject, TKey>();
 
@@ -25,10 +25,10 @@ public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChange
 
                 var populator = Observable.Switch(
                         _sources
-                            .Synchronize(locker)
+                            .SynchronizeSafe(queue)
                             .Do(onNext: _ => destination.Clear(),
                                 onError: error => errors.OnError(error)))
-                    .Synchronize(locker)
+                    .SynchronizeSafe(queue)
                     .Do(onNext: static _ => { },
                         onError: error => errors.OnError(error))
                     .PopulateInto(destination);
@@ -40,6 +40,7 @@ public IObservable<IChangeSet<TObject, TKey>> Run() => Observable.Create<IChange
                     destination
                         .Connect()
                         .Merge(errors)
-                        .SubscribeSafe(observer));
+                        .SubscribeSafe(observer),
+                    queue);
             });
 }
diff --git a/src/DynamicData/Cache/Internal/TransformAsync.cs b/src/DynamicData/Cache/Internal/TransformAsync.cs
index 344adc621..73b6f62a9 100644
--- a/src/DynamicData/Cache/Internal/TransformAsync.cs
+++ b/src/DynamicData/Cache/Internal/TransformAsync.cs
@@ -2,6 +2,7 @@
 // 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.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
 
@@ -27,11 +28,13 @@ public IObservable<IChangeSet<TDestination, TKey>> Run() =>
 
             if (forceTransform is not null)
             {
-                var locker = InternalEx.NewLock();
-                var forced = forceTransform.Synchronize(locker)
+                var queue = new SharedDeliveryQueue();
+                var forced = forceTransform.SynchronizeSafe(queue)
                     .Select(shouldTransform => DoTransform(cache, shouldTransform)).Concat();
 
-                transformer = transformer.Synchronize(locker).Merge(forced);
+                transformer = transformer.SynchronizeSafe(queue).Merge(forced);
+
+                return new CompositeDisposable(transformer.SubscribeSafe(observer), queue);
             }
 
             return transformer.SubscribeSafe(observer);
diff --git a/src/DynamicData/Cache/Internal/TransformMany.cs b/src/DynamicData/Cache/Internal/TransformMany.cs
index 76aa2b57c..f38853c08 100644
--- a/src/DynamicData/Cache/Internal/TransformMany.cs
+++ b/src/DynamicData/Cache/Internal/TransformMany.cs
@@ -117,10 +117,10 @@ private IObservable<IChangeSet<TDestination, TDestinationKey>> CreateWithChangeS
                             changes);
                     }).Publish();
 
-                var outerLock = new object();
-                var initial = transformed.Synchronize(outerLock).Select(changes => new ChangeSet<TDestination, TDestinationKey>(new DestinationEnumerator(changes)));
+                var queue = new SharedDeliveryQueue();
+                var initial = transformed.SynchronizeSafe(queue).Select(changes => new ChangeSet<TDestination, TDestinationKey>(new DestinationEnumerator(changes)));
 
-                var subsequent = transformed.MergeMany(x => x.Changes).Synchronize(outerLock);
+                var subsequent = transformed.MergeMany(x => x.Changes).SynchronizeSafe(queue);
 
                 var allChanges = initial.Merge(subsequent).Select(
                     changes =>
@@ -129,7 +129,7 @@ private IObservable<IChangeSet<TDestination, TDestinationKey>> CreateWithChangeS
                         return result.CaptureChanges();
                     });
 
-                return new CompositeDisposable(allChanges.SubscribeSafe(observer), transformed.Connect());
+                return new CompositeDisposable(allChanges.SubscribeSafe(observer), transformed.Connect(), queue);
             });
     }
 
diff --git a/src/DynamicData/Cache/Internal/TransformWithForcedTransform.cs b/src/DynamicData/Cache/Internal/TransformWithForcedTransform.cs
index 58e3f3ef9..c7c95aa66 100644
--- a/src/DynamicData/Cache/Internal/TransformWithForcedTransform.cs
+++ b/src/DynamicData/Cache/Internal/TransformWithForcedTransform.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.
 
@@ -15,22 +15,22 @@ internal sealed class TransformWithForcedTransform<TDestination, TSource, TKey>(
     public IObservable<IChangeSet<TDestination, TKey>> Run() => Observable.Create<IChangeSet<TDestination, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
-                var shared = source.Synchronize(locker).Publish();
+                var queue = new SharedDeliveryQueue();
+                var shared = source.SynchronizeSafe(queue).Publish();
 
                 // capture all items so we can apply a forced transform
                 var cache = new Cache<TSource, TKey>();
                 var cacheLoader = shared.Subscribe(changes => cache.Clone(changes));
 
                 // create change set of items where force refresh is applied
-                var refresher = forceTransform.Synchronize(locker).Select(selector => CaptureChanges(cache, selector)).Select(changes => new ChangeSet<TSource, TKey>(changes)).NotEmpty();
+                var refresher = forceTransform.SynchronizeSafe(queue).Select(selector => CaptureChanges(cache, selector)).Select(changes => new ChangeSet<TSource, TKey>(changes)).NotEmpty();
 
                 var sourceAndRefreshes = shared.Merge(refresher);
 
                 // do raw transform
                 var transform = new Transform<TDestination, TSource, TKey>(sourceAndRefreshes, transformFactory, exceptionCallback, true).Run();
 
-                return new CompositeDisposable(cacheLoader, transform.SubscribeSafe(observer), shared.Connect());
+                return new CompositeDisposable(cacheLoader, transform.SubscribeSafe(observer), shared.Connect(), queue);
             });
 
     private static IEnumerable<Change<TSource, TKey>> CaptureChanges(Cache<TSource, TKey> cache, Func<TSource, TKey, bool> shouldTransform) =>
diff --git a/src/DynamicData/Cache/Internal/TreeBuilder.cs b/src/DynamicData/Cache/Internal/TreeBuilder.cs
index 3c393c4bf..bf379ef99 100644
--- a/src/DynamicData/Cache/Internal/TreeBuilder.cs
+++ b/src/DynamicData/Cache/Internal/TreeBuilder.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.
 
@@ -24,16 +24,16 @@ internal sealed class TreeBuilder<TObject, TKey>(IObservable<IChangeSet<TObject,
     public IObservable<IChangeSet<Node<TObject, TKey>, TKey>> Run() => Observable.Create<IChangeSet<Node<TObject, TKey>, TKey>>(
             observer =>
             {
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
                 var reFilterObservable = new BehaviorSubject<Unit>(Unit.Default);
 
-                var allData = _source.Synchronize(locker).AsObservableCache();
+                var allData = _source.SynchronizeSafe(queue).AsObservableCache();
 
                 // for each object we need a node which provides
                 // a structure to set the parent and children
-                var allNodes = allData.Connect().Synchronize(locker).Transform((t, v) => new Node<TObject, TKey>(t, v)).AsObservableCache();
+                var allNodes = allData.Connect().SynchronizeSafe(queue).Transform((t, v) => new Node<TObject, TKey>(t, v)).AsObservableCache();
 
-                var groupedByPivot = allNodes.Connect().Synchronize(locker).Group(x => _pivotOn(x.Item)).AsObservableCache();
+                var groupedByPivot = allNodes.Connect().SynchronizeSafe(queue).Group(x => _pivotOn(x.Item)).AsObservableCache();
 
                 void UpdateChildren(Node<TObject, TKey> parentNode)
                 {
@@ -197,18 +197,9 @@ void UpdateChildren(Node<TObject, TKey> parentNode)
                         reFilterObservable.OnNext(Unit.Default);
                     }).DisposeMany().Subscribe();
 
-                var filter = _predicateChanged.Synchronize(locker).CombineLatest(reFilterObservable, (predicate, _) => predicate);
+                var filter = _predicateChanged.SynchronizeSafe(queue).CombineLatest(reFilterObservable, (predicate, _) => predicate);
                 var result = allNodes.Connect().Filter(filter).SubscribeSafe(observer);
 
-                return Disposable.Create(
-                    () =>
-                    {
-                        result.Dispose();
-                        parentSetter.Dispose();
-                        allData.Dispose();
-                        allNodes.Dispose();
-                        groupedByPivot.Dispose();
-                        reFilterObservable.OnCompleted();
-                    });
+                return new CompositeDisposable(result, parentSetter, allData, allNodes, groupedByPivot, Disposable.Create(() => reFilterObservable.OnCompleted()), queue);
             });
 }
diff --git a/src/DynamicData/Cache/Internal/Virtualise.cs b/src/DynamicData/Cache/Internal/Virtualise.cs
index 724682ab1..9a5fefbcc 100644
--- a/src/DynamicData/Cache/Internal/Virtualise.cs
+++ b/src/DynamicData/Cache/Internal/Virtualise.cs
@@ -2,6 +2,7 @@
 // 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.Reactive.Disposables;
 using System.Reactive.Linq;
 
 namespace DynamicData.Cache.Internal;
@@ -18,11 +19,11 @@ public IObservable<IVirtualChangeSet<TObject, TKey>> Run() => Observable.Create<
             observer =>
             {
                 var virtualiser = new Virtualiser();
-                var locker = InternalEx.NewLock();
+                var queue = new SharedDeliveryQueue();
 
-                var request = _virtualRequests.Synchronize(locker).Select(virtualiser.Virtualise).Where(x => x is not null).Select(x => x!);
-                var dataChange = _source.Synchronize(locker).Select(virtualiser.Update).Where(x => x is not null).Select(x => x!);
-                return request.Merge(dataChange).Where(updates => updates is not null).SubscribeSafe(observer);
+                var request = _virtualRequests.SynchronizeSafe(queue).Select(virtualiser.Virtualise).Where(x => x is not null).Select(x => x!);
+                var dataChange = _source.SynchronizeSafe(queue).Select(virtualiser.Update).Where(x => x is not null).Select(x => x!);
+                return new CompositeDisposable(request.Merge(dataChange).Where(updates => updates is not null).SubscribeSafe(observer), queue);
             });
 
     private sealed class Virtualiser(VirtualRequest? request = null)
diff --git a/src/DynamicData/Cache/ObservableCache.cs b/src/DynamicData/Cache/ObservableCache.cs
index e56bab14f..5cbeca988 100644
--- a/src/DynamicData/Cache/ObservableCache.cs
+++ b/src/DynamicData/Cache/ObservableCache.cs
@@ -6,6 +6,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
+using System.Threading;
 using DynamicData.Binding;
 using DynamicData.Cache;
 using DynamicData.Cache.Internal;
@@ -38,69 +39,52 @@ internal sealed class ObservableCache<TObject, TKey> : IObservableCache<TObject,
 
     private readonly ReaderWriter<TObject, TKey> _readerWriter;
 
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Terminated via NotifyCompleted in _cleanUp")]
+    private readonly DeliveryQueue<CacheUpdate> _notifications;
+
     private int _editLevel; // The level of recursion in editing.
 
+    private long _currentVersion; // Monotonic counter incremented under lock for each enqueued change notification.
+
+    private long _currentDeliveryVersion; // Version of the item currently being delivered. Set before _changes.OnNext.
+
     public ObservableCache(IObservable<IChangeSet<TObject, TKey>> source)
     {
-        _suspensionTracker = new(() => new SuspensionTracker(_changes.OnNext, InvokeCountNext));
         _readerWriter = new ReaderWriter<TObject, TKey>();
+        _notifications = new DeliveryQueue<CacheUpdate>(_locker, new CacheUpdateObserver(this));
+        _suspensionTracker = new(() => new SuspensionTracker());
 
-        var loader = source.Synchronize(_locker).Finally(
-            () =>
-            {
-                _changes.OnCompleted();
-                _changesPreview.OnCompleted();
-            }).Subscribe(
+        var loader = source.Subscribe(
             changeSet =>
             {
+                using var notifications = _notifications.AcquireLock();
+
                 var previewHandler = _changesPreview.HasObservers ? (Action<ChangeSet<TObject, TKey>>)InvokePreview : null;
                 var changes = _readerWriter.Write(changeSet, previewHandler, _changes.HasObservers);
-                InvokeNext(changes);
+
+                if (changes is not null)
+                {
+                    notifications.EnqueueNext(new CacheUpdate(changes, _readerWriter.Count, ++_currentVersion));
+                }
             },
-            ex =>
-            {
-                _changesPreview.OnError(ex);
-                _changes.OnError(ex);
-            });
+            NotifyError,
+            NotifyCompleted);
 
         _cleanUp = Disposable.Create(
             () =>
             {
                 loader.Dispose();
-                _changes.OnCompleted();
-                _changesPreview.OnCompleted();
-                if (_suspensionTracker.IsValueCreated)
-                {
-                    _suspensionTracker.Value.Dispose();
-                }
-
-                if (_countChanged.IsValueCreated)
-                {
-                    _countChanged.Value.OnCompleted();
-                }
+                NotifyCompleted();
             });
     }
 
     public ObservableCache(Func<TObject, TKey>? keySelector = null)
     {
-        _suspensionTracker = new(() => new SuspensionTracker(_changes.OnNext, InvokeCountNext));
         _readerWriter = new ReaderWriter<TObject, TKey>(keySelector);
+        _notifications = new DeliveryQueue<CacheUpdate>(_locker, new CacheUpdateObserver(this));
+        _suspensionTracker = new(() => new SuspensionTracker());
 
-        _cleanUp = Disposable.Create(
-            () =>
-            {
-                _changes.OnCompleted();
-                _changesPreview.OnCompleted();
-                if (_suspensionTracker.IsValueCreated)
-                {
-                    _suspensionTracker.Value.Dispose();
-                }
-
-                if (_countChanged.IsValueCreated)
-                {
-                    _countChanged.Value.OnCompleted();
-                }
-            });
+        _cleanUp = Disposable.Create(NotifyCompleted);
     }
 
     public int Count => _readerWriter.Count;
@@ -109,11 +93,15 @@ public ObservableCache(Func<TObject, TKey>? keySelector = null)
         Observable.Create<int>(
             observer =>
             {
-                lock (_locker)
-                {
-                    var source = _countChanged.Value.StartWith(_readerWriter.Count).DistinctUntilChanged();
-                    return source.SubscribeSafe(observer);
-                }
+                using var readLock = _notifications.AcquireReadLock();
+
+                var snapshotVersion = _currentVersion;
+                var countChanged = readLock.HasPending
+                    ? _countChanged.Value.SkipWhile(_ => Volatile.Read(ref _currentDeliveryVersion) <= snapshotVersion)
+                    : _countChanged.Value;
+
+                var source = countChanged.StartWith(_readerWriter.Count).DistinctUntilChanged();
+                return source.SubscribeSafe(observer);
             });
 
     public IReadOnlyList<TObject> Items => _readerWriter.Items;
@@ -188,27 +176,26 @@ internal void UpdateFromIntermediate(Action<ICacheUpdater<TObject, TKey>> update
     {
         updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
 
-        lock (_locker)
-        {
-            ChangeSet<TObject, TKey>? changes = null;
+        using var notifications = _notifications.AcquireLock();
 
-            _editLevel++;
-            if (_editLevel == 1)
-            {
-                var previewHandler = _changesPreview.HasObservers ? (Action<ChangeSet<TObject, TKey>>)InvokePreview : null;
-                changes = _readerWriter.Write(updateAction, previewHandler, _changes.HasObservers);
-            }
-            else
-            {
-                _readerWriter.WriteNested(updateAction);
-            }
+        ChangeSet<TObject, TKey>? changes = null;
+
+        _editLevel++;
+        if (_editLevel == 1)
+        {
+            var previewHandler = _changesPreview.HasObservers ? (Action<ChangeSet<TObject, TKey>>)InvokePreview : null;
+            changes = _readerWriter.Write(updateAction, previewHandler, _changes.HasObservers);
+        }
+        else
+        {
+            _readerWriter.WriteNested(updateAction);
+        }
 
-            _editLevel--;
+        _editLevel--;
 
-            if (changes is not null && _editLevel == 0)
-            {
-                InvokeNext(changes);
-            }
+        if (changes is not null && _editLevel == 0)
+        {
+            notifications.EnqueueNext(new CacheUpdate(changes, _readerWriter.Count, ++_currentVersion));
         }
     }
 
@@ -216,27 +203,26 @@ internal void UpdateFromSource(Action<ISourceUpdater<TObject, TKey>> updateActio
     {
         updateAction.ThrowArgumentNullExceptionIfNull(nameof(updateAction));
 
-        lock (_locker)
-        {
-            ChangeSet<TObject, TKey>? changes = null;
+        using var notifications = _notifications.AcquireLock();
 
-            _editLevel++;
-            if (_editLevel == 1)
-            {
-                var previewHandler = _changesPreview.HasObservers ? (Action<ChangeSet<TObject, TKey>>)InvokePreview : null;
-                changes = _readerWriter.Write(updateAction, previewHandler, _changes.HasObservers);
-            }
-            else
-            {
-                _readerWriter.WriteNested(updateAction);
-            }
+        ChangeSet<TObject, TKey>? changes = null;
+
+        _editLevel++;
+        if (_editLevel == 1)
+        {
+            var previewHandler = _changesPreview.HasObservers ? (Action<ChangeSet<TObject, TKey>>)InvokePreview : null;
+            changes = _readerWriter.Write(updateAction, previewHandler, _changes.HasObservers);
+        }
+        else
+        {
+            _readerWriter.WriteNested(updateAction);
+        }
 
-            _editLevel--;
+        _editLevel--;
 
-            if (changes is not null && _editLevel == 0)
-            {
-                InvokeNext(changes);
-            }
+        if (changes is not null && _editLevel == 0)
+        {
+            notifications.EnqueueNext(new CacheUpdate(changes, _readerWriter.Count, ++_currentVersion));
         }
     }
 
@@ -244,123 +230,231 @@ private IObservable<IChangeSet<TObject, TKey>> CreateConnectObservable(Func<TObj
         Observable.Create<IChangeSet<TObject, TKey>>(
             observer =>
             {
-                lock (_locker)
-                {
-                    var initial = InternalEx.Return(() => (IChangeSet<TObject, TKey>)GetInitialUpdates(predicate));
-                    var changes = initial.Concat(_changes);
+                using var readLock = _notifications.AcquireReadLock();
 
-                    if (predicate != null)
-                    {
-                        changes = changes.Filter(predicate, suppressEmptyChangeSets);
-                    }
-                    else if (suppressEmptyChangeSets)
-                    {
-                        changes = changes.NotEmpty();
-                    }
+                var initial = InternalEx.Return(() => (IChangeSet<TObject, TKey>)GetInitialUpdates(predicate));
+
+                // The current snapshot may contain changes that have been made but the notifications
+                // have yet to be delivered.  We need to filter those out to avoid delivering an update
+                // that has already been applied (but detect this possibility and skip filtering unless absolutely needed)
+                var snapshotVersion = _currentVersion;
+                var changes = readLock.HasPending
+                    ? _changes.SkipWhile(_ => Volatile.Read(ref _currentDeliveryVersion) <= snapshotVersion)
+                    : (IObservable<IChangeSet<TObject, TKey>>)_changes;
 
-                    return changes.SubscribeSafe(observer);
+                changes = initial.Concat(changes);
+
+                if (predicate != null)
+                {
+                    changes = changes.Filter(predicate, suppressEmptyChangeSets);
                 }
+                else if (suppressEmptyChangeSets)
+                {
+                    changes = changes.NotEmpty();
+                }
+
+                return changes.SubscribeSafe(observer);
             });
 
     private IObservable<Change<TObject, TKey>> CreateWatchObservable(TKey key) =>
         Observable.Create<Change<TObject, TKey>>(
             observer =>
             {
-                lock (_locker)
+                using var readLock = _notifications.AcquireReadLock();
+
+                var initial = _readerWriter.Lookup(key);
+                if (initial.HasValue)
                 {
-                    var initial = _readerWriter.Lookup(key);
-                    if (initial.HasValue)
-                    {
-                        observer.OnNext(new Change<TObject, TKey>(ChangeReason.Add, key, initial.Value));
-                    }
+                    observer.OnNext(new Change<TObject, TKey>(ChangeReason.Add, key, initial.Value));
+                }
+
+                // The current snapshot may contain changes that have been made but the notifications
+                // have yet to be delivered.  We need to filter those out to avoid delivering an update
+                // that has already been applied (but detect this possibility and skip filtering unless absolutely needed)
+                var snapshotVersion = _currentVersion;
+                var changes = readLock.HasPending
+                    ? _changes.SkipWhile(_ => Volatile.Read(ref _currentDeliveryVersion) <= snapshotVersion)
+                    : _changes;
 
-                    return _changes.Finally(observer.OnCompleted).Subscribe(
-                        changes =>
+                return changes.Finally(observer.OnCompleted).Subscribe(
+                    changes =>
+                    {
+                        foreach (var change in changes)
                         {
-                            foreach (var change in changes.ToConcreteType())
+                            var match = EqualityComparer<TKey>.Default.Equals(change.Key, key);
+                            if (match)
                             {
-                                var match = EqualityComparer<TKey>.Default.Equals(change.Key, key);
-                                if (match)
-                                {
-                                    observer.OnNext(change);
-                                }
+                                observer.OnNext(change);
                             }
-                        });
-                }
+                        }
+                    });
             });
 
-    private void InvokeNext(ChangeSet<TObject, TKey> changes)
+    /// <summary>
+    /// Delivers a preview notification synchronously under _locker. Preview is
+    /// called by ReaderWriter during a write, between two data swaps, so it MUST
+    /// fire under the lock with the pre-write state visible to subscribers.
+    /// </summary>
+    private void InvokePreview(ChangeSet<TObject, TKey> changes)
     {
-        lock (_locker)
+        if (changes.Count != 0 && !_notifications.IsTerminated)
         {
-            // If Notifications are not suspended
-            if (!_suspensionTracker.IsValueCreated || !_suspensionTracker.Value.AreNotificationsSuspended)
-            {
-                // Emit the changes
-                _changes.OnNext(changes);
-            }
-            else
-            {
-                // Don't emit the changes, but add them to the list
-                _suspensionTracker.Value.EnqueueChanges(changes);
-            }
+            _changesPreview.OnNext(changes);
+        }
+    }
 
-            // If CountChanges are not suspended
-            if (!_suspensionTracker.IsValueCreated || !_suspensionTracker.Value.IsCountSuspended)
-            {
-                InvokeCountNext();
-            }
+    private void NotifyCompleted()
+    {
+        using var notifications = _notifications.AcquireLock();
+        notifications.EnqueueCompleted();
+    }
+
+    private void NotifyError(Exception ex)
+    {
+        using var notifications = _notifications.AcquireLock();
+        notifications.EnqueueError(ex);
+    }
+
+    /// <summary>
+    /// Delivers a single notification to subscribers. This method is the delivery
+    /// callback for <see cref="_notifications"/> and must never be called directly.
+    /// It is invoked by the <see cref="DeliveryQueue{TItem}"/> after releasing the
+    /// lock, which guarantees that no lock is held when subscriber code runs. The
+    /// queue's single-deliverer token ensures this method is never called concurrently,
+    /// preserving the Rx serialization contract across all subjects.
+    /// Returns true to continue delivery, or false for terminal items (OnCompleted/OnError)
+    /// which causes the queue to self-terminate.
+    /// </summary>
+    private void ResumeCount()
+    {
+        using var notifications = _notifications.AcquireLock();
+        Debug.Assert(_suspensionTracker.IsValueCreated, "Should not be Resuming Count without Suspend Count instance");
+
+        if (_suspensionTracker.Value.ResumeCount() && _countChanged.IsValueCreated)
+        {
+            notifications.EnqueueNext(new CacheUpdate(null, _readerWriter.Count));
         }
     }
 
-    private void InvokePreview(ChangeSet<TObject, TKey> changes)
+    private void ResumeNotifications()
     {
-        lock (_locker)
+        bool emitResume;
+
+        using (var notifications = _notifications.AcquireLock())
         {
-            if (changes.Count != 0)
+            Debug.Assert(_suspensionTracker.IsValueCreated, "Should not be Resuming Notifications without Suspend Notifications instance");
+
+            (var changes, emitResume) = _suspensionTracker.Value.ResumeNotifications();
+            if (changes is not null)
             {
-                _changesPreview.OnNext(changes);
+                notifications.EnqueueNext(new CacheUpdate(changes, _readerWriter.Count, ++_currentVersion));
             }
         }
+
+        // Emit the resume signal after releasing the delivery scope so that
+        // accumulated changes are delivered first
+        if (emitResume)
+        {
+            using var readLock = _notifications.AcquireReadLock();
+            _suspensionTracker.Value.EmitResumeNotification();
+        }
     }
 
-    private void InvokeCountNext()
+    /// <summary>
+    /// The notification payload for cache delivery. Null Changes = count-only notification.
+    /// </summary>
+    private readonly record struct CacheUpdate(ChangeSet<TObject, TKey>? Changes, int Count, long Version = 0);
+
+    /// <summary>
+    /// Observer that dispatches <see cref="CacheUpdate"/> items to the cache's
+    /// downstream subjects. Used as the delivery target for <see cref="_notifications"/>.
+    /// </summary>
+    private sealed class CacheUpdateObserver(ObservableCache<TObject, TKey> cache) : IObserver<CacheUpdate>
     {
-        lock (_locker)
+        public void OnNext(CacheUpdate value)
         {
-            if (_countChanged.IsValueCreated)
+            if (value.Changes is not null)
             {
-                _countChanged.Value.OnNext(_readerWriter.Count);
+                Volatile.Write(ref cache._currentDeliveryVersion, value.Version);
+                EmitChanges(value.Changes);
             }
+
+            EmitCount(value.Count);
         }
-    }
 
-    private void ResumeCount()
-    {
-        lock (_locker)
+        public void OnError(Exception error)
         {
-            Debug.Assert(_suspensionTracker.IsValueCreated, "Should not be Resuming Count without Suspend Count instance");
-            _suspensionTracker.Value.ResumeCount();
+            cache._changesPreview.OnError(error);
+            cache._changes.OnError(error);
+
+            if (cache._countChanged.IsValueCreated)
+            {
+                cache._countChanged.Value.OnError(error);
+            }
+
+            if (cache._suspensionTracker.IsValueCreated)
+            {
+                cache._suspensionTracker.Value.Dispose();
+            }
         }
-    }
 
-    private void ResumeNotifications()
-    {
-        lock (_locker)
+        public void OnCompleted()
+        {
+            cache._changes.OnCompleted();
+            cache._changesPreview.OnCompleted();
+
+            if (cache._countChanged.IsValueCreated)
+            {
+                cache._countChanged.Value.OnCompleted();
+            }
+
+            if (cache._suspensionTracker.IsValueCreated)
+            {
+                cache._suspensionTracker.Value.Dispose();
+            }
+        }
+
+        private void EmitChanges(ChangeSet<TObject, TKey> changes)
         {
-            Debug.Assert(_suspensionTracker.IsValueCreated, "Should not be Resuming Notifications without Suspend Count instance");
-            _suspensionTracker.Value.ResumeNotifications();
+            if (cache._suspensionTracker.IsValueCreated)
+            {
+                lock (cache._locker)
+                {
+                    if (cache._suspensionTracker.Value.AreNotificationsSuspended)
+                    {
+                        cache._suspensionTracker.Value.EnqueueChanges(changes);
+                        return;
+                    }
+                }
+            }
+
+            cache._changes.OnNext(changes);
+        }
+
+        private void EmitCount(int count)
+        {
+            if (cache._suspensionTracker.IsValueCreated)
+            {
+                lock (cache._locker)
+                {
+                    if (cache._suspensionTracker.Value.IsCountSuspended)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            if (cache._countChanged.IsValueCreated)
+            {
+                cache._countChanged.Value.OnNext(count);
+            }
         }
     }
 
-    private sealed class SuspensionTracker(Action<ChangeSet<TObject, TKey>> onResumeNotifications, Action onResumeCount) : IDisposable
+    private sealed class SuspensionTracker : IDisposable
     {
         private readonly BehaviorSubject<bool> _areNotificationsSuspended = new(false);
 
-        private readonly Action<ChangeSet<TObject, TKey>> _onResumeNotifications = onResumeNotifications;
-
-        private readonly Action _onResumeCount = onResumeCount;
-
         private List<Change<TObject, TKey>> _pendingChanges = [];
 
         private int _countSuspendCount;
@@ -392,30 +486,29 @@ public void SuspendNotifications()
 
         public void SuspendCount() => ++_countSuspendCount;
 
-        public void ResumeNotifications()
+        public bool ResumeCount() => --_countSuspendCount == 0;
+
+        public (ChangeSet<TObject, TKey>? Changes, bool EmitResume) ResumeNotifications()
         {
             if (--_notifySuspendCount == 0 && !_areNotificationsSuspended.IsDisposed)
             {
-                // Fire pending changes to existing subscribers
+                ChangeSet<TObject, TKey>? changes = null;
+
                 if (_pendingChanges.Count > 0)
                 {
-                    _onResumeNotifications(new ChangeSet<TObject, TKey>(_pendingChanges));
-                    _pendingChanges.Clear();
+                    var changesToDeliver = _pendingChanges;
+                    _pendingChanges = [];
+                    changes = new ChangeSet<TObject, TKey>(changesToDeliver);
                 }
 
-                // Tell deferred subscribers they can continue
-                _areNotificationsSuspended.OnNext(false);
+                return (changes, true);
             }
-        }
 
-        public void ResumeCount()
-        {
-            if (--_countSuspendCount == 0)
-            {
-                _onResumeCount();
-            }
+            return (null, false);
         }
 
+        public void EmitResumeNotification() => _areNotificationsSuspended.OnNext(false);
+
         public void Dispose()
         {
             _areNotificationsSuspended.OnCompleted();
diff --git a/src/DynamicData/Cache/ObservableCacheEx.cs b/src/DynamicData/Cache/ObservableCacheEx.cs
index e532d15d1..a401e2386 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>
@@ -642,15 +643,12 @@ public static IObservable<IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this IO
 
         return Observable.Create<IChangeSet<TObject, TKey>>(
             observer =>
-            {
-                var locker = InternalEx.NewLock();
-                return source.Synchronize(locker).Select(
+                source.SynchronizeSafe(InternalEx.NewLock()).Select(
                     changes =>
                     {
                         updater.Adapt(changes, destination);
                         return changes;
-                    }).SubscribeSafe(observer);
-            });
+                    }).SubscribeSafe(observer));
     }
 
     /// <summary>
@@ -770,15 +768,12 @@ public static IObservable<ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(t
 
         return Observable.Create<ISortedChangeSet<TObject, TKey>>(
             observer =>
-            {
-                var locker = InternalEx.NewLock();
-                return source.Synchronize(locker).Select(
+                source.SynchronizeSafe(InternalEx.NewLock()).Select(
                     changes =>
                     {
                         updater.Adapt(changes, destination);
                         return changes;
-                    }).SubscribeSafe(observer);
-            });
+                    }).SubscribeSafe(observer));
     }
 
     /// <summary>
@@ -5232,13 +5227,15 @@ public static IObservable<Optional<TObject>> ToObservableOptional<TObject, TKey>
     {
         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 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/DynamicData.csproj b/src/DynamicData/DynamicData.csproj
index b7e7b212b..1ec234b35 100644
--- a/src/DynamicData/DynamicData.csproj
+++ b/src/DynamicData/DynamicData.csproj
@@ -12,6 +12,7 @@
 
   <ItemGroup>
     <Using Include="DynamicData.Kernel" />
+    <Using Include="DynamicData.Internal" />
   </ItemGroup>
 
   <PropertyGroup>
diff --git a/src/DynamicData/Internal/Bitset.cs b/src/DynamicData/Internal/Bitset.cs
new file mode 100644
index 000000000..d28e4a669
--- /dev/null
+++ b/src/DynamicData/Internal/Bitset.cs
@@ -0,0 +1,242 @@
+// 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.
+
+#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+#endif
+using System.Runtime.CompilerServices;
+
+namespace DynamicData.Internal;
+
+/// <summary>
+/// <para>
+/// A compact bitset backed by a <see langword="long"/>[] array that tracks active slots
+/// (e.g., sub-queues with pending items). Provides O(1) set/clear operations and fast
+/// highest/lowest-bit lookup via hardware intrinsics (LZCNT/TZCNT) for LIFO/FIFO iteration.
+/// </para>
+/// <para>
+/// Each <see langword="long"/> holds 64 bits. A slot index maps to a word and bit position:
+/// <c>word = index / 64</c>, <c>bit = index % 64</c>. The backing array grows automatically
+/// via <see cref="EnsureCapacity"/> but never shrinks. Callers that need compaction should
+/// create a new instance.
+/// </para>
+/// </summary>
+internal struct Bitset
+{
+    private const int BitsPerWord = 64;
+    private const int WordShift = 6;
+    private const int BitMask = BitsPerWord - 1;
+
+    private long[] _words;
+
+    /// <summary>Initializes a new instance of the <see cref="Bitset"/> struct with capacity for 64 slots.</summary>
+    public Bitset() => _words = [0];
+
+    /// <summary>Gets the number of bits currently set.</summary>
+    public int Count { get; private set; }
+
+    /// <summary>Sets the bit at <paramref name="index"/>, marking the slot as active.</summary>
+    /// <param name="index">The zero-based slot index.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(int index)
+    {
+        EnsureCapacity(index);
+        ref var word = ref _words[index >> WordShift];
+        var mask = 1L << (index & BitMask);
+        if ((word & mask) == 0)
+        {
+            word |= mask;
+            Count++;
+        }
+    }
+
+    /// <summary>Clears the bit at <paramref name="index"/>, marking the slot as inactive.</summary>
+    /// <param name="index">The zero-based slot index.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(int index)
+    {
+        if ((index >> WordShift) >= _words.Length)
+        {
+            return;
+        }
+
+        ref var word = ref _words[index >> WordShift];
+        var mask = 1L << (index & BitMask);
+        if ((word & mask) != 0)
+        {
+            word &= ~mask;
+            Count--;
+        }
+    }
+
+    /// <summary>Returns <see langword="true"/> if the bit at <paramref name="index"/> is set.</summary>
+    /// <param name="index">The zero-based slot index.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool IsSet(int index)
+    {
+        var wordIndex = index >> WordShift;
+        if (wordIndex >= _words.Length)
+        {
+            return false;
+        }
+
+        return (_words[wordIndex] & (1L << (index & BitMask))) != 0;
+    }
+
+    /// <summary>
+    /// <para>
+    /// Finds the highest set bit (for LIFO iteration) and returns its index,
+    /// or -1 if no bits are set.
+    /// </para>
+    /// <para>
+    /// Scans words from highest to lowest. Within each word, the leading zero count
+    /// intrinsic (LZCNT on x86, CLZ on ARM) locates the most significant set bit
+    /// in a single CPU instruction.
+    /// </para>
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int FindHighest()
+    {
+        var words = _words;
+        if (words.Length == 1)
+        {
+            var w0 = words[0];
+            if (w0 == 0) return -1;
+#if NETCOREAPP3_0_OR_GREATER
+            return 63 - BitOperations.LeadingZeroCount((ulong)w0);
+#else
+            return HighestSetBit(w0);
+#endif
+        }
+
+        for (var w = words.Length - 1; w >= 0; w--)
+        {
+            var word = words[w];
+            if (word != 0)
+            {
+#if NETCOREAPP3_0_OR_GREATER
+                var bitIndex = 63 - BitOperations.LeadingZeroCount((ulong)word);
+#else
+                var bitIndex = HighestSetBit(word);
+#endif
+                return (w << WordShift) | bitIndex;
+            }
+        }
+
+        return -1;
+    }
+
+    /// <summary>
+    /// <para>
+    /// Finds the lowest set bit (for FIFO iteration) and returns its index,
+    /// or -1 if no bits are set.
+    /// </para>
+    /// <para>
+    /// Scans words from lowest to highest. Within each word, the trailing zero count
+    /// intrinsic (TZCNT on x86, CTZ on ARM) locates the least significant set bit
+    /// in a single CPU instruction.
+    /// </para>
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int FindLowest()
+    {
+        var words = _words;
+        for (var w = 0; w < words.Length; w++)
+        {
+            var word = words[w];
+            if (word != 0)
+            {
+#if NETCOREAPP3_0_OR_GREATER
+                var bitIndex = BitOperations.TrailingZeroCount((ulong)word);
+#else
+                var bitIndex = LowestSetBit(word);
+#endif
+                return (w << WordShift) | bitIndex;
+            }
+        }
+
+        return -1;
+    }
+
+    /// <summary>Returns <see langword="true"/> if any bit is set.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool HasAny() => Count > 0;
+
+    /// <summary>Clears all bits in every word.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll()
+    {
+        if (_words.Length == 1)
+        {
+            _words[0] = 0;
+        }
+        else
+        {
+            Array.Clear(_words, 0, _words.Length);
+        }
+
+        Count = 0;
+    }
+
+    /// <summary>Grows the backing array if needed so that <paramref name="index"/> is addressable. Called implicitly by <see cref="Set"/>.</summary>
+    /// <param name="index">The zero-based slot index that must be representable.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void EnsureCapacity(int index)
+    {
+        var wordIndex = index >> WordShift;
+        if (wordIndex >= _words.Length)
+        {
+            Array.Resize(ref _words, wordIndex + 1);
+        }
+    }
+
+    /// <summary>
+    /// Shrinks the backing array to the minimum size needed to represent all set bits.
+    /// Reclaims memory from words that are entirely zero at the end of the array.
+    /// Always retains at least one word.
+    /// </summary>
+    public void Compact()
+    {
+        var needed = 1;
+        for (var w = _words.Length - 1; w >= 1; w--)
+        {
+            if (_words[w] != 0)
+            {
+                needed = w + 1;
+                break;
+            }
+        }
+
+        if (needed < _words.Length)
+        {
+            Array.Resize(ref _words, needed);
+        }
+    }
+
+#if !NETCOREAPP3_0_OR_GREATER
+    private static int HighestSetBit(long value)
+    {
+        var bit = 0;
+        for (var v = (ulong)value; v > 1; v >>= 1)
+        {
+            bit++;
+        }
+
+        return bit;
+    }
+
+    private static int LowestSetBit(long value)
+    {
+        var bit = 0;
+        var v = (ulong)value;
+        while ((v & 1) == 0)
+        {
+            v >>= 1;
+            bit++;
+        }
+
+        return bit;
+    }
+#endif
+}
diff --git a/src/DynamicData/Internal/CacheParentSubscription.cs b/src/DynamicData/Internal/CacheParentSubscription.cs
index 95e63daf0..3a33143df 100644
--- a/src/DynamicData/Internal/CacheParentSubscription.cs
+++ b/src/DynamicData/Internal/CacheParentSubscription.cs
@@ -11,32 +11,41 @@ namespace DynamicData.Internal;
 /// <summary>
 /// Base class for subscriptions that need to manage child subscriptions and emit updates
 /// when either the parent or child gets a new value.
+/// Uses a <see cref="SharedDeliveryQueue"/> for serialization and lock-free delivery.
+/// Same-thread reentrant delivery preserves child-during-parent ordering.
+/// OnDrainComplete calls EmitChanges after the outermost delivery, outside the lock.
 /// </summary>
 /// <typeparam name="TParent">Type of the Parent ChangeSet.</typeparam>
 /// <typeparam name="TKey">Type for the Parent ChangeSet Key.</typeparam>
 /// <typeparam name="TChild">Type for the Child Subscriptions.</typeparam>
 /// <typeparam name="TObserver">Type for the Final Observable.</typeparam>
-/// <param name="observer">Observer to use for emitting events.</param>
-internal abstract class CacheParentSubscription<TParent, TKey, TChild, TObserver>(IObserver<TObserver> observer) : IDisposable
+internal abstract class CacheParentSubscription<TParent, TKey, TChild, TObserver> : IDisposable
     where TParent : notnull
     where TKey : notnull
     where TChild : notnull
 {
-#if NET9_0_OR_GREATER
-    private readonly Lock _synchronize = new();
-#else
-    private readonly object _synchronize = new();
-#endif
     private readonly KeyedDisposable<TKey> _childSubscriptions = new();
     private readonly SingleAssignmentDisposable _parentSubscription = new();
-    private readonly IObserver<TObserver> _observer = observer;
-    private int _subscriptionCounter = 1;
-    private int _updateCounter;
+    private readonly SharedDeliveryQueue _queue;
+    private readonly IObserver<TObserver> _observer;
+    private int _subscriptionCounter = 1; // Starts at 1 for the parent subscription
+    private bool _isCompleted;
+    private bool _hasTerminated;
     private bool _disposedValue;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CacheParentSubscription{TParent, TKey, TChild, TObserver}"/> class.
+    /// </summary>
+    /// <param name="observer">Observer to use for emitting events.</param>
+    protected CacheParentSubscription(IObserver<TObserver> observer)
+    {
+        _observer = observer;
+        _queue = new SharedDeliveryQueue(onDrainComplete: OnDrainComplete);
+    }
+
+    /// <inheritdoc/>
     public void Dispose()
     {
-        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
         Dispose(disposing: true);
         GC.SuppressFinalize(this);
     }
@@ -49,7 +58,7 @@ public void Dispose()
 
     protected void AddChildSubscription(IObservable<TChild> observable, TKey parentKey)
     {
-        // Add a new subscription.  Do first so cleanup of existing subs doesn't trigger OnCompleted.
+        // Add a new subscription. Do first so cleanup of existing subs doesn't trigger OnCompleted.
         Interlocked.Increment(ref _subscriptionCounter);
 
         // Create a container for the Disposable and add to the KeyedDisposable
@@ -58,16 +67,18 @@ protected void AddChildSubscription(IObservable<TChild> observable, TKey parentK
         // Create the subscription
         // Will Dispose immediately if OnCompleted fires upon subscription because OnCompleted disposes the container
         // Remove the child subscription if it completes because its not needed anymore
+        //
+        // THREADING INVARIANT: Finally(CheckCompleted) fires on completion, error, AND disposal,
+        // ensuring the subscription counter always decrements. The onCompleted callback only fires
+        // on normal completion (not disposal), so RemoveChildSubscription is NOT called when the
+        // parent disposes child subscriptions during Dispose(). This asymmetry is intentional:
+        // disposal cleanup is handled by KeyedDisposable, not by individual completion callbacks.
         disposableContainer.Disposable = observable
             .Finally(CheckCompleted)
             .SubscribeSafe(
-                val =>
-                {
-                    ChildOnNext(val, parentKey);
-                    ExitUpdate();
-                },
-                _observer.OnError,
-                () => RemoveChildSubscription(parentKey));
+                onNext: val => ChildOnNext(val, parentKey),
+                onError: TerminalError,
+                onCompleted: () => RemoveChildSubscription(parentKey));
     }
 
     protected void RemoveChildSubscription(TKey parentKey) => _childSubscriptions.Remove(parentKey);
@@ -75,16 +86,11 @@ protected void AddChildSubscription(IObservable<TChild> observable, TKey parentK
     protected void CreateParentSubscription(IObservable<IChangeSet<TParent, TKey>> source) =>
         _parentSubscription.Disposable =
             source
-                .Synchronize(_synchronize)
-                .Do(_ => EnterUpdate())
+                .SynchronizeSafe(_queue)
                 .SubscribeSafe(
-                    changes =>
-                    {
-                        ParentOnNext(changes);
-                        ExitUpdate();
-                    },
-                    _observer.OnError,
-                    CheckCompleted);
+                    onNext: ParentOnNext,
+                    onError: TerminalError,
+                    onCompleted: CheckCompleted);
 
     protected virtual void Dispose(bool disposing)
     {
@@ -92,41 +98,46 @@ protected virtual void Dispose(bool disposing)
         {
             if (disposing)
             {
-                lock (_synchronize)
-                {
-                    _parentSubscription.Dispose();
-                    _childSubscriptions.Dispose();
-                }
+                _queue.Dispose();
+                _parentSubscription.Dispose();
+                _childSubscriptions.Dispose();
             }
+
             _disposedValue = true;
         }
     }
 
-    // This must be called by the derived class on anything passed to AddChildSubscription
-    // Manual step so that the derived class has full control on where it is called
+    /// <summary>
+    /// Wraps a child observable through the shared delivery queue for serialization.
+    /// Must be called by derived classes on observables passed to <see cref="AddChildSubscription"/>.
+    /// Same-thread reentrant delivery ensures child items are delivered inline during
+    /// parent processing, preserving the original Synchronize(lock) ordering semantics.
+    /// </summary>
     protected IObservable<T> MakeChildObservable<T>(IObservable<T> observable) =>
-        observable
-            .Synchronize(_synchronize)
-            .Do(_ => EnterUpdate())
-        ;
-
-    private void EnterUpdate() => Interlocked.Increment(ref _updateCounter);
+        observable.SynchronizeSafe(_queue);
 
-    private void ExitUpdate()
+    private void OnDrainComplete()
     {
-        if (Interlocked.Decrement(ref _updateCounter) == 0)
+        EmitChanges(_observer);
+
+        if (Volatile.Read(ref _isCompleted) && !_hasTerminated)
         {
-            EmitChanges(_observer);
+            _hasTerminated = true;
+            _observer.OnCompleted();
         }
+    }
 
-        Debug.Assert(_updateCounter >= 0, "Should never be negative");
+    private void TerminalError(Exception error)
+    {
+        _hasTerminated = true;
+        _observer.OnError(error);
     }
 
     private void CheckCompleted()
     {
         if (Interlocked.Decrement(ref _subscriptionCounter) == 0)
         {
-            _observer.OnCompleted();
+            Volatile.Write(ref _isCompleted, true);
         }
 
         Debug.Assert(_subscriptionCounter >= 0, "Should never be negative");
diff --git a/src/DynamicData/Internal/DeliveryQueue.cs b/src/DynamicData/Internal/DeliveryQueue.cs
new file mode 100644
index 000000000..74a688f25
--- /dev/null
+++ b/src/DynamicData/Internal/DeliveryQueue.cs
@@ -0,0 +1,281 @@
+// 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.Internal;
+
+/// <summary>
+/// A queue that serializes item delivery outside a caller-owned lock.
+/// Internally stores <see cref="Notification{T}"/> values. Delivery
+/// is dispatched to an <see cref="IObserver{T}"/> outside the lock.
+/// </summary>
+/// <typeparam name="T">The value type delivered via OnNext.</typeparam>
+internal sealed class DeliveryQueue<T> : IObserver<T>, IDisposable
+{
+    private readonly Queue<Notification<T>> _queue = new(1);
+
+#if NET9_0_OR_GREATER
+    private readonly Lock _gate;
+#else
+    private readonly object _gate;
+#endif
+
+    private readonly IObserver<T> _observer;
+    private int _drainThreadId = -1;
+    private volatile bool _isTerminated;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DeliveryQueue{T}"/> class with its own internal lock.
+    /// </summary>
+    /// <param name="observer">The observer that receives delivered items.</param>
+    public DeliveryQueue(IObserver<T> observer)
+    {
+#if NET9_0_OR_GREATER
+        _gate = new Lock();
+#else
+        _gate = new object();
+#endif
+        _observer = observer;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DeliveryQueue{T}"/> class.
+    /// </summary>
+    /// <param name="gate">The lock shared with the caller.</param>
+    /// <param name="observer">The observer that receives delivered items.</param>
+#if NET9_0_OR_GREATER
+    public DeliveryQueue(Lock gate, IObserver<T> observer)
+#else
+    public DeliveryQueue(object gate, IObserver<T> observer)
+#endif
+    {
+        _gate = gate;
+        _observer = observer;
+    }
+
+    /// <summary>
+    /// Gets whether this queue has been terminated. Safe to read from any thread.
+    /// </summary>
+    public bool IsTerminated => _isTerminated;
+
+    /// <summary>
+    /// Terminates the queue (rejecting further enqueues) and blocks until
+    /// any in-flight delivery has completed. After this returns, no more
+    /// observer callbacks will fire. Safe to call from within a delivery
+    /// callback (skips the spin-wait if the calling thread is the deliverer).
+    /// </summary>
+    private void EnsureDeliveryComplete()
+    {
+        using (AcquireReadLock())
+        {
+            _isTerminated = true;
+            _queue.Clear();
+
+            // If we're being called from within the drain loop (e.g., downstream
+            // disposed during OnNext), the current thread IS the deliverer.
+            // The drain loop will see _isTerminated and exit after we return.
+            if (_drainThreadId == Environment.CurrentManagedThreadId)
+                return;
+        }
+
+        SpinWait spinner = default;
+        while (Volatile.Read(ref _drainThreadId) != -1)
+            spinner.SpinOnce();
+    }
+
+    /// <inheritdoc/>
+    public void Dispose() => EnsureDeliveryComplete();
+
+    /// <summary>
+    /// Acquires the gate and returns a scoped access for enqueueing notifications.
+    /// Disposing releases the gate and triggers delivery if needed.
+    /// </summary>
+    public ScopedAccess AcquireLock() => new(this);
+
+    /// <summary>
+    /// Acquires the gate for read-only inspection. Does not trigger delivery on dispose.
+    /// </summary>
+    public ReadOnlyScopedAccess AcquireReadLock() => new(this);
+
+    /// <summary>Enqueues an OnNext notification via the lock, then drains.</summary>
+    public void OnNext(T value)
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueNext(value);
+    }
+
+    /// <summary>Enqueues an OnError notification via the lock, then drains.</summary>
+    public void OnError(Exception error)
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueError(error);
+    }
+
+    /// <summary>Enqueues an OnCompleted notification via the lock, then drains.</summary>
+    public void OnCompleted()
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueCompleted();
+    }
+
+#if NET9_0_OR_GREATER
+    private void EnterLock() => _gate.Enter();
+
+    private void ExitLock() => _gate.Exit();
+#else
+    private void EnterLock() => Monitor.Enter(_gate);
+
+    private void ExitLock() => Monitor.Exit(_gate);
+#endif
+
+    private void EnqueueNotification(Notification<T> item)
+    {
+        if (_isTerminated)
+        {
+            return;
+        }
+
+        _queue.Enqueue(item);
+    }
+
+    private void ExitLockAndDeliver()
+    {
+        var shouldDeliver = TryStartDelivery();
+        ExitLock();
+
+        if (shouldDeliver)
+        {
+            DeliverAll();
+        }
+
+        bool TryStartDelivery()
+        {
+            if (_drainThreadId != -1 || _queue.Count == 0)
+            {
+                return false;
+            }
+
+            _drainThreadId = Environment.CurrentManagedThreadId;
+            return true;
+        }
+
+        void DeliverAll()
+        {
+            try
+            {
+                while (true)
+                {
+                    Notification<T> notification;
+
+                    using (AcquireReadLock())
+                    {
+                        if (_queue.Count == 0 || _isTerminated)
+                        {
+                            _drainThreadId = -1;
+                            return;
+                        }
+
+                        notification = _queue.Dequeue();
+
+                        // Mark terminated BEFORE delivery so concurrent code
+                        // (e.g., InvokePreview) sees the terminal state immediately.
+                        if (notification.IsTerminal)
+                        {
+                            _isTerminated = true;
+                            _queue.Clear();
+                        }
+                    }
+
+                    // Deliver outside the lock
+                    notification.Accept(_observer);
+
+                    if (notification.IsTerminal)
+                    {
+                        using (AcquireReadLock())
+                        {
+                            _drainThreadId = -1;
+                        }
+
+                        return;
+                    }
+                }
+            }
+            catch
+            {
+                using (AcquireReadLock())
+                {
+                    _drainThreadId = -1;
+                }
+
+                throw;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Scoped access for enqueueing notifications under the gate lock.
+    /// </summary>
+    public ref struct ScopedAccess
+    {
+        private DeliveryQueue<T>? _owner;
+
+        internal ScopedAccess(DeliveryQueue<T> owner)
+        {
+            _owner = owner;
+            owner.EnterLock();
+        }
+
+        /// <summary>Enqueues an OnNext notification.</summary>
+        public readonly void EnqueueNext(T value) => _owner?.EnqueueNotification(Notification<T>.CreateNext(value));
+
+        /// <summary>Enqueues an OnError notification (terminal).</summary>
+        public readonly void EnqueueError(Exception error) => _owner?.EnqueueNotification(Notification<T>.CreateError(error));
+
+        /// <summary>Enqueues an OnCompleted notification (terminal).</summary>
+        public readonly void EnqueueCompleted() => _owner?.EnqueueNotification(Notification<T>.CreateCompleted());
+
+        /// <summary>Releases the gate lock and delivers pending items.</summary>
+        public void Dispose()
+        {
+            var owner = _owner;
+            if (owner is null)
+            {
+                return;
+            }
+
+            _owner = null;
+            owner.ExitLockAndDeliver();
+        }
+    }
+
+    /// <summary>
+    /// Read-only scoped access. Disposing releases the gate without triggering delivery.
+    /// </summary>
+    public ref struct ReadOnlyScopedAccess
+    {
+        private DeliveryQueue<T>? _owner;
+
+        internal ReadOnlyScopedAccess(DeliveryQueue<T> owner)
+        {
+            _owner = owner;
+            owner.EnterLock();
+        }
+
+        /// <summary>Gets whether there are notifications pending delivery.</summary>
+        public readonly bool HasPending =>
+            _owner is not null && (_owner._queue.Count > 0 || _owner._drainThreadId != -1);
+
+        /// <summary>Releases the gate lock.</summary>
+        public void Dispose()
+        {
+            var owner = _owner;
+            if (owner is null)
+            {
+                return;
+            }
+
+            _owner = null;
+            owner.ExitLock();
+        }
+    }
+}
diff --git a/src/DynamicData/Internal/KeyedDisposable.cs b/src/DynamicData/Internal/KeyedDisposable.cs
index 80d90fdff..4e2ab2951 100644
--- a/src/DynamicData/Internal/KeyedDisposable.cs
+++ b/src/DynamicData/Internal/KeyedDisposable.cs
@@ -8,73 +8,150 @@ namespace DynamicData.Internal;
 /// Manages Disposables by Key:
 /// 1) Adding a disposable with the same key will dispose/replace the previous one.
 /// 2) Adding when the container is Disposed will Dispose it immediately.
+/// Thread-safe: all operations are internally synchronized.
 /// </summary>
 /// <typeparam name="TKey">Type to use for the Key.</typeparam>
 internal sealed class KeyedDisposable<TKey> : IDisposable
     where TKey : notnull
 {
     private readonly Dictionary<TKey, IDisposable> _disposables = [];
-    private bool _disposedValue;
 
-    public int Count => _disposables.Count;
+#if NET9_0_OR_GREATER
+    private readonly Lock _gate = new();
+#else
+    private readonly object _gate = new();
+#endif
 
-    public IEnumerable<TKey> Keys => _disposables.Keys;
+    private bool _disposedValue;
 
-    public bool ContainsKey(TKey key) => _disposables.ContainsKey(key);
+    public int Count
+    {
+        get
+        {
+            lock (_gate)
+                return _disposables.Count;
+        }
+    }
 
-    public bool IsDisposed => _disposedValue;
+    public IEnumerable<TKey> Keys
+    {
+        get
+        {
+            lock (_gate)
+                return _disposables.Keys.ToArray();
+        }
+    }
 
-    public TDisposable Add<TDisposable>(TKey key, TDisposable disposable)
-        where TDisposable : IDisposable
+    public bool ContainsKey(TKey key)
     {
-        disposable.ThrowArgumentNullExceptionIfNull(nameof(disposable));
+        lock (_gate)
+            return _disposables.ContainsKey(key);
+    }
 
-        if (!_disposedValue)
+    public bool IsDisposed
+    {
+        get
         {
-            Remove(key);
-            _disposables.Add(key, disposable);
+            lock (_gate)
+                return _disposedValue;
+        }
+    }
+
+    /// <summary>
+    /// Tracks an item by key. If the item implements <see cref="IDisposable"/>,
+    /// it replaces any existing entry (disposing the previous one if different).
+    /// If the item is NOT disposable, any existing entry for the key is removed
+    /// and disposed.
+    /// </summary>
+    public TItem Add<TItem>(TKey key, TItem item)
+        where TItem : notnull
+    {
+        if (item is IDisposable disposable)
+        {
+            IDisposable? toDispose = null;
+
+            lock (_gate)
+            {
+                if (!_disposedValue)
+                {
+                    if (_disposables.TryGetValue(key, out var existing))
+                    {
+                        if (ReferenceEquals(existing, disposable))
+                        {
+                            return item;
+                        }
+
+                        _disposables[key] = disposable;
+                        toDispose = existing;
+                    }
+                    else
+                    {
+                        _disposables[key] = disposable;
+                    }
+                }
+                else
+                {
+                    toDispose = disposable;
+                }
+            }
+
+            toDispose?.Dispose();
         }
         else
         {
-            disposable.Dispose();
+            Remove(key);
         }
 
-        return disposable;
+        return item;
     }
 
     public void Remove(TKey key)
     {
-#if NET6_0_OR_GREATER
-        if (_disposables.Remove(key, out var disposable))
+        IDisposable? toDispose;
+        lock (_gate)
         {
-            disposable.Dispose();
-        }
+#if NET6_0_OR_GREATER
+            if (!_disposables.Remove(key, out toDispose))
+                return;
 #else
-        if (_disposables.TryGetValue(key, out var disposable))
-        {
-            disposable.Dispose();
+            if (!_disposables.TryGetValue(key, out toDispose))
+                return;
             _disposables.Remove(key);
-        }
 #endif
-    }
+        }
 
-    public void Dispose()
-    {
-        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
-        Dispose(disposing: true);
-        GC.SuppressFinalize(this);
+        toDispose.Dispose();
     }
 
-    private void Dispose(bool disposing)
+    public void Dispose()
     {
-        if (!_disposedValue)
+        Dictionary<TKey, IDisposable>? snapshot;
+        lock (_gate)
         {
+            if (_disposedValue)
+                return;
+
             _disposedValue = true;
-            if (disposing)
+            snapshot = new Dictionary<TKey, IDisposable>(_disposables);
+            _disposables.Clear();
+        }
+
+        List<Exception>? errors = null;
+        foreach (var d in snapshot.Values)
+        {
+            try
             {
-                _disposables.Values.ForEach(d => d.Dispose());
-                _disposables.Clear();
+                d.Dispose();
             }
+            catch (Exception ex)
+            {
+                (errors ??= []).Add(ex);
+            }
+        }
+
+        if (errors is { Count: > 0 })
+        {
+            throw new AggregateException(errors);
         }
     }
 }
diff --git a/src/DynamicData/Internal/Notification.cs b/src/DynamicData/Internal/Notification.cs
new file mode 100644
index 000000000..9e3eaf4a0
--- /dev/null
+++ b/src/DynamicData/Internal/Notification.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 DynamicData.Kernel;
+
+namespace DynamicData.Internal;
+
+/// <summary>
+/// A lightweight notification struct for delivery queues. Discriminates
+/// OnNext, OnError, and OnCompleted using <see cref="Optional{T}.HasValue"/>
+/// and the error field, avoiding null discrimination on <c>T?</c> which
+/// is broken for value types in generic struct fields on .NET 9.
+/// </summary>
+internal readonly struct Notification<T>
+{
+    private readonly Optional<T> _value;
+    private readonly Exception? _error;
+
+    private Notification(Optional<T> value, Exception? error)
+    {
+        _value = value;
+        _error = error;
+    }
+
+    /// <summary>Creates an OnNext notification.</summary>
+    public static Notification<T> CreateNext(T value) => new(value, null);
+
+    /// <summary>Creates an OnError notification (terminal).</summary>
+    public static Notification<T> CreateError(Exception error)
+    {
+        error.ThrowArgumentNullExceptionIfNull(nameof(error));
+        return new(Optional.None<T>(), error);
+    }
+
+    /// <summary>Creates an OnCompleted notification (terminal).</summary>
+    public static Notification<T> CreateCompleted() => new(Optional.None<T>(), null);
+
+    /// <summary>Gets whether this is an OnError notification.</summary>
+    public bool IsError => _error is not null;
+
+    /// <summary>Gets whether this is a terminal notification (OnError or OnCompleted).</summary>
+    public bool IsTerminal => !_value.HasValue;
+
+    /// <summary>Delivers this notification to the specified observer.</summary>
+    public void Accept(IObserver<T> observer)
+    {
+        if (_value.HasValue)
+        {
+            observer.OnNext(_value.Value);
+        }
+        else if (_error is not null)
+        {
+            observer.OnError(_error);
+        }
+        else
+        {
+            observer.OnCompleted();
+        }
+    }
+}
diff --git a/src/DynamicData/Internal/SharedDeliveryQueue.cs b/src/DynamicData/Internal/SharedDeliveryQueue.cs
new file mode 100644
index 000000000..6eab28894
--- /dev/null
+++ b/src/DynamicData/Internal/SharedDeliveryQueue.cs
@@ -0,0 +1,565 @@
+// 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.Runtime.CompilerServices;
+
+namespace DynamicData.Internal;
+
+/// <summary>
+/// A type-erased delivery queue that serializes delivery across multiple sources
+/// with different item types. Each source gets a typed <see cref="DeliverySubQueue{T}"/>
+/// via <see cref="CreateQueue{T}"/>. A single drain loop delivers items from all
+/// sub-queues outside the lock, one item per iteration. An <see cref="Bitset"/>
+/// tracks which sub-queues have pending items, replacing O(N) scans with O(1) lookups.
+/// </summary>
+internal sealed class SharedDeliveryQueue : IDisposable
+{
+    private readonly List<DrainableBase> _sources = [];
+    private readonly Action? _onDrainComplete;
+
+#if NET9_0_OR_GREATER
+    private readonly Lock _gate;
+#else
+    private readonly object _gate;
+#endif
+
+    private Bitset _activeBits = new();
+    private int _deadCount;
+    private int _drainThreadId = -1;
+    private volatile bool _isTerminated;
+
+    /// <summary>Initializes a new instance of the <see cref="SharedDeliveryQueue"/> class with its own internal lock.</summary>
+    public SharedDeliveryQueue()
+        : this(onDrainComplete: null)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SharedDeliveryQueue"/> class with its own internal lock
+    /// and a callback that fires outside the lock after each drain cycle completes.
+    /// </summary>
+    public SharedDeliveryQueue(Action? onDrainComplete)
+    {
+#if NET9_0_OR_GREATER
+        _gate = new Lock();
+#else
+        _gate = new object();
+#endif
+        _onDrainComplete = onDrainComplete;
+    }
+
+#if NET9_0_OR_GREATER
+    /// <summary>Initializes a new instance of the <see cref="SharedDeliveryQueue"/> class with a caller-provided lock.</summary>
+    public SharedDeliveryQueue(Lock gate) => _gate = gate;
+#else
+    /// <summary>Initializes a new instance of the <see cref="SharedDeliveryQueue"/> class with a caller-provided lock.</summary>
+    public SharedDeliveryQueue(object gate) => _gate = gate;
+#endif
+
+    /// <summary>Gets whether this queue has been terminated.</summary>
+    public bool IsTerminated
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _isTerminated;
+    }
+
+    /// <summary>
+    /// Terminates the queue (rejecting further enqueues) and blocks until
+    /// any in-flight delivery has completed. After this returns, no more
+    /// observer callbacks will fire. Safe to call from within a delivery
+    /// callback (skips the spin-wait if the calling thread is the deliverer).
+    /// </summary>
+    private void EnsureDeliveryComplete()
+    {
+        EnterLock();
+
+        _isTerminated = true;
+        _activeBits.ClearAll();
+
+        foreach (var s in _sources)
+        {
+            s.Clear();
+        }
+
+        if (_drainThreadId == Environment.CurrentManagedThreadId)
+        {
+            ExitLock();
+            return;
+        }
+
+        ExitLock();
+
+        SpinWait spinner = default;
+        while (Volatile.Read(ref _drainThreadId) != -1)
+            spinner.SpinOnce();
+    }
+
+    /// <summary>Disposes the queue by calling <see cref="EnsureDeliveryComplete"/>.</summary>
+    public void Dispose() => EnsureDeliveryComplete();
+
+    /// <summary>Creates a typed sub-queue bound to the specified observer.</summary>
+    public DeliverySubQueue<T> CreateQueue<T>(IObserver<T> observer)
+    {
+        EnterLock();
+        try
+        {
+            var index = _sources.Count;
+            var queue = new DeliverySubQueue<T>(this, observer, index);
+            _sources.Add(queue);
+
+            return queue;
+        }
+        finally
+        {
+            ExitLock();
+        }
+    }
+
+    /// <summary>Acquires the gate for read-only inspection. Does not trigger delivery on dispose.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ReadOnlyScopedAccess AcquireReadLock() => new(this);
+
+    /// <summary>Called by a sub-queue when it is disposed. Clears its active bit and tracks dead slots.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void NotifyQueueRemoved(int index)
+    {
+        _activeBits.Clear(index);
+        _deadCount++;
+    }
+
+    /// <summary>Sets the active bit for a sub-queue when an item is enqueued.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void SetActive(int index) => _activeBits.Set(index);
+
+#if NET9_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void EnterLock() => _gate.Enter();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void ExitLock() => _gate.Exit();
+#else
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void EnterLock() => Monitor.Enter(_gate);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void ExitLock() => Monitor.Exit(_gate);
+#endif
+
+    internal void ExitLockAndDrain()
+    {
+        var currentThreadId = Environment.CurrentManagedThreadId;
+
+        // Same-thread reentrant: if we're already draining on this thread,
+        // deliver newly enqueued items inline. This preserves the same delivery
+        // order as Synchronize(lock): child items emitted synchronously during
+        // parent delivery are delivered immediately, not deferred.
+        if (_drainThreadId == currentThreadId)
+        {
+            ExitLock();
+            DrainPending();
+            return;
+        }
+
+        var shouldDrain = false;
+        if (_drainThreadId == -1 && !_isTerminated && _activeBits.HasAny())
+        {
+            _drainThreadId = currentThreadId;
+            shouldDrain = true;
+        }
+
+        ExitLock();
+
+        if (shouldDrain)
+        {
+            DrainAll();
+        }
+    }
+
+    private void DrainAll()
+    {
+        try
+        {
+            while (true)
+            {
+                if (!DrainPending())
+                {
+                    EnterLock();
+                    try
+                    {
+                        _drainThreadId = -1;
+                        CompactIfNeeded();
+                    }
+                    finally
+                    {
+                        ExitLock();
+                    }
+
+                    return;
+                }
+
+                if (_onDrainComplete is not null)
+                {
+                    _onDrainComplete();
+                }
+
+                // Atomically check for pending items and release drain ownership
+                // if empty. This closes the TOCTOU window: if we checked and released
+                // in separate lock scopes, Thread B could enqueue between them,
+                // see _drainThreadId != -1, and rely on us to drain, but we'd exit
+                // without draining Thread B's item.
+                EnterLock();
+
+                if (_activeBits.HasAny() && !_isTerminated)
+                {
+                    // Items arrived during _onDrainComplete. Loop back to drain them.
+                    ExitLock();
+                    continue;
+                }
+
+                try
+                {
+                    _drainThreadId = -1;
+                    CompactIfNeeded();
+                }
+                finally
+                {
+                    ExitLock();
+                }
+
+                return;
+            }
+        }
+        catch
+        {
+            EnterLock();
+            _drainThreadId = -1;
+            ExitLock();
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Delivers all pending items from all sub-queues, one at a time.
+    /// Sub-queues are found via the active bitset using LZCNT (highest-index first
+    /// for LIFO ordering). When one sub-queue's delivery can dispose another
+    /// (parent disposing a child), the child must drain first to prevent pending
+    /// child notifications from being silently lost. Newer sub-queues are always
+    /// children of older ones, so LIFO provides this guarantee.
+    /// </summary>
+    /// <returns>True if completed normally; false if an error terminated the queue.</returns>
+    private bool DrainPending()
+    {
+        while (true)
+        {
+            EnterLock();
+
+            if (_isTerminated)
+            {
+                ExitLock();
+                return false;
+            }
+
+            var sourceIndex = _activeBits.FindHighest();
+            if (sourceIndex < 0)
+            {
+                ExitLock();
+                return true;
+            }
+
+            var active = _sources[sourceIndex];
+            var isError = active.StageNext();
+
+            // If sub-queue is now empty, clear its active bit immediately.
+            if (!active.HasItems)
+            {
+                _activeBits.Clear(sourceIndex);
+            }
+
+            ExitLock();
+
+            active.DeliverStaged();
+
+            if (isError)
+            {
+                EnterLock();
+                _isTerminated = true;
+                _activeBits.ClearAll();
+                foreach (var s in _sources)
+                {
+                    s.Clear();
+                }
+
+                ExitLock();
+                return false;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Compacts the source list when dead slots exceed 50% of capacity.
+    /// Rebuilds indices and the bitset atomically. Must be called under lock.
+    /// </summary>
+    private void CompactIfNeeded()
+    {
+        if (_deadCount == 0 || _deadCount <= _sources.Count / 2)
+        {
+            return;
+        }
+
+        _deadCount = 0;
+        _activeBits.ClearAll();
+
+        var writeIndex = 0;
+        for (var readIndex = 0; readIndex < _sources.Count; readIndex++)
+        {
+            var source = _sources[readIndex];
+            if (!source.IsRemoved)
+            {
+                source.Index = writeIndex;
+                _sources[writeIndex] = source;
+
+                if (source.HasItems)
+                {
+                    SetActive(writeIndex);
+                }
+
+                writeIndex++;
+            }
+        }
+
+        // Remove trailing dead entries
+        if (writeIndex < _sources.Count)
+        {
+            _sources.RemoveRange(writeIndex, _sources.Count - writeIndex);
+        }
+
+        _activeBits.Compact();
+    }
+
+    /// <summary>Read-only scoped access. Disposing releases the gate without triggering delivery.</summary>
+    public ref struct ReadOnlyScopedAccess
+    {
+        private SharedDeliveryQueue? _owner;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal ReadOnlyScopedAccess(SharedDeliveryQueue owner)
+        {
+            _owner = owner;
+            owner.EnterLock();
+        }
+
+        /// <summary>Gets whether any sub-queue has pending items.</summary>
+        public readonly bool HasPending
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if (_owner is null)
+                {
+                    return false;
+                }
+
+                return _owner._drainThreadId != -1 || _owner._activeBits.HasAny();
+            }
+        }
+
+        /// <summary>Releases the gate lock.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            var owner = _owner;
+            if (owner is null)
+            {
+                return;
+            }
+
+            _owner = null;
+            owner.ExitLock();
+        }
+    }
+}
+
+/// <summary>Base class for typed sub-queues. Enables devirtualization in the drain loop.</summary>
+internal abstract class DrainableBase
+{
+    /// <summary>Gets whether this sub-queue has items.</summary>
+    internal abstract bool HasItems { get; }
+
+    /// <summary>Gets whether this sub-queue has been removed and should be skipped/compacted.</summary>
+    internal abstract bool IsRemoved { get; }
+
+    /// <summary>Gets or sets the stable index in the parent's source list.</summary>
+    internal abstract int Index { get; set; }
+
+    /// <summary>Dequeues the next item into staging. Returns true if error (terminal).</summary>
+    /// <returns>True if the staged item is an error notification.</returns>
+    internal abstract bool StageNext();
+
+    /// <summary>Delivers the staged item to the observer.</summary>
+    internal abstract void DeliverStaged();
+
+    /// <summary>Clears all pending items.</summary>
+    internal abstract void Clear();
+}
+
+/// <summary>
+/// A typed sub-queue. All enqueue access goes through <see cref="ScopedAccess"/>
+/// which acquires the parent's lock.
+/// </summary>
+internal sealed class DeliverySubQueue<T> : DrainableBase, IObserver<T>, IDisposable
+{
+    private readonly Queue<Notification<T>> _items = new(1);
+    private readonly SharedDeliveryQueue _parent;
+    private readonly IObserver<T> _observer;
+    private Notification<T> _staged;
+    private int _index;
+    private bool _isRemoved;
+
+    internal DeliverySubQueue(SharedDeliveryQueue parent, IObserver<T> observer, int index)
+    {
+        _parent = parent;
+        _observer = observer;
+        _index = index;
+    }
+
+    /// <inheritdoc/>
+    internal override bool HasItems
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => !_isRemoved && _items.Count > 0;
+    }
+
+    /// <inheritdoc/>
+    internal override bool IsRemoved
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _isRemoved;
+    }
+
+    /// <inheritdoc/>
+    internal override int Index
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _index;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        set => _index = value;
+    }
+
+    /// <summary>Acquires the parent gate. Disposing releases the lock and triggers drain.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ScopedAccess AcquireLock() => new(this);
+
+    /// <summary>Enqueues an OnNext notification via the lock, then drains.</summary>
+    public void OnNext(T value)
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueNext(value);
+    }
+
+    /// <summary>Enqueues an OnError notification via the lock, then drains.</summary>
+    public void OnError(Exception error)
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueError(error);
+    }
+
+    /// <summary>Enqueues an OnCompleted notification via the lock, then drains.</summary>
+    public void OnCompleted()
+    {
+        using var scope = AcquireLock();
+        scope.EnqueueCompleted();
+    }
+
+    /// <summary>
+    /// Marks this sub-queue as removed under the parent lock, clearing pending items
+    /// and notifying the parent for GC compaction. Idempotent.
+    /// </summary>
+    public void Dispose()
+    {
+        _parent.EnterLock();
+        try
+        {
+            if (_isRemoved)
+            {
+                return;
+            }
+
+            _isRemoved = true;
+            _items.Clear();
+            _parent.NotifyQueueRemoved(_index);
+        }
+        finally
+        {
+            _parent.ExitLock();
+        }
+    }
+
+    /// <inheritdoc/>
+    internal override bool StageNext()
+    {
+        _staged = _items.Dequeue();
+        return _staged.IsError;
+    }
+
+    /// <inheritdoc/>
+    internal override void DeliverStaged()
+    {
+        _staged.Accept(_observer);
+        _staged = default;
+    }
+
+    /// <inheritdoc/>
+    internal override void Clear() => _items.Clear();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void EnqueueItem(Notification<T> item)
+    {
+        if (_parent.IsTerminated || _isRemoved)
+        {
+            return;
+        }
+
+        _items.Enqueue(item);
+        _parent.SetActive(_index);
+    }
+
+    /// <summary>Scoped access for enqueueing items. Acquires the parent's gate lock.</summary>
+    public ref struct ScopedAccess
+    {
+        private DeliverySubQueue<T>? _owner;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal ScopedAccess(DeliverySubQueue<T> owner)
+        {
+            _owner = owner;
+            owner._parent.EnterLock();
+        }
+
+        /// <summary>Enqueues an OnNext item.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly void EnqueueNext(T item) => _owner?.EnqueueItem(Notification<T>.CreateNext(item));
+
+        /// <summary>Enqueues a terminal error.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly void EnqueueError(Exception error) => _owner?.EnqueueItem(Notification<T>.CreateError(error));
+
+        /// <summary>Enqueues a terminal completion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly void EnqueueCompleted() => _owner?.EnqueueItem(Notification<T>.CreateCompleted());
+
+        /// <summary>Releases the parent gate lock and delivers pending items.</summary>
+        public void Dispose()
+        {
+            var owner = _owner;
+            if (owner is null)
+            {
+                return;
+            }
+
+            _owner = null;
+            owner._parent.ExitLockAndDrain();
+        }
+    }
+}
diff --git a/src/DynamicData/Internal/SynchronizeSafeExtensions.cs b/src/DynamicData/Internal/SynchronizeSafeExtensions.cs
new file mode 100644
index 000000000..ace8ed4a1
--- /dev/null
+++ b/src/DynamicData/Internal/SynchronizeSafeExtensions.cs
@@ -0,0 +1,81 @@
+// 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.Reactive.Disposables;
+using System.Reactive.Linq;
+
+namespace DynamicData.Internal;
+
+/// <summary>
+/// Provides SynchronizeSafe extension methods, drop-in replacements
+/// for <c>Synchronize(lock)</c> that release the lock before downstream delivery.
+/// </summary>
+/// <remarks>
+/// <para><strong>Disposal ordering matters.</strong> <c>CompositeDisposable</c> disposes in
+/// declaration order. The queue and the source subscription have different roles:</para>
+/// <list type="bullet">
+///   <item>
+///     <term>Subscription-first (gate and SDQ overloads)</term>
+///     <description>The queue is the <c>IObserver</c> that the source sends notifications to.
+///     Disposing the subscription first allows any final terminal notification (OnCompleted/OnError
+///     triggered by Rx's disposal cascade or a <c>Finally</c> operator) to flow through the
+///     still-active queue. The queue is disposed last as cleanup.</description>
+///   </item>
+///   <item>
+///     <term>Queue-first (parameterless overload)</term>
+///     <description>Used by operators with teardown side effects (DisposeMany, OnBeingRemoved).
+///     The queue is terminated first via <see cref="DeliveryQueue{T}.Dispose"/>, which ensures
+///     all in-flight deliveries complete before the subscription is disposed and teardown logic
+///     (e.g., disposing removed items) runs. Terminal notifications are not needed because
+///     the subscriber is explicitly tearing down.</description>
+///   </item>
+/// </list>
+/// </remarks>
+internal static class SynchronizeSafeExtensions
+{
+    /// <summary>
+    /// Synchronizes the source observable through a <see cref="SharedDeliveryQueue"/>.
+    /// Use when multiple sources of different types share a gate.
+    /// </summary>
+    public static IObservable<T> SynchronizeSafe<T>(this IObservable<T> source, SharedDeliveryQueue queue) =>
+        Observable.Create<T>(observer =>
+        {
+            var subQueue = queue.CreateQueue(observer);
+
+            // Subscription first: terminal notifications flow through the still-active sub-queue
+            return new CompositeDisposable(source.SubscribeSafe(subQueue), subQueue);
+        });
+
+    /// <summary>
+    /// Synchronizes the source observable through an implicitly created <see cref="DeliveryQueue{T}"/>.
+    /// Drop-in replacement for <c>Synchronize(locker)</c>.
+    /// </summary>
+#if NET9_0_OR_GREATER
+    public static IObservable<T> SynchronizeSafe<T>(this IObservable<T> source, Lock gate) =>
+#else
+    public static IObservable<T> SynchronizeSafe<T>(this IObservable<T> source, object gate) =>
+#endif
+        Observable.Create<T>(observer =>
+        {
+            var queue = new DeliveryQueue<T>(gate, observer);
+
+            // Subscription first: terminal notifications flow through the still-active queue
+            return new CompositeDisposable(source.SubscribeSafe(queue), queue);
+        });
+
+    /// <summary>
+    /// Synchronizes the source observable through an implicitly created <see cref="DeliveryQueue{T}"/>
+    /// with automatic delivery completion on dispose. The queue is terminated and drained
+    /// before the source subscription is disposed, ensuring all in-flight notifications
+    /// are delivered before teardown.
+    /// </summary>
+    public static IObservable<T> SynchronizeSafe<T>(this IObservable<T> source) =>
+        Observable.Create<T>(observer =>
+        {
+            var queue = new DeliveryQueue<T>(observer);
+
+            // Queue first: ensures in-flight deliveries complete before teardown side effects run
+            return new CompositeDisposable(queue, source.SubscribeSafe(queue));
+        });
+}