From 9a5fe6bdf59d5d8feeedb2f24d9f5c9c87c9df19 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 17:55:57 +1000
Subject: [PATCH 01/11] chore: Update benchmarks and fix tests

---
 src/Polyfills/ArgumentExceptionHelper.cs      |   5 +-
 .../ArgumentOutOfRangeExceptionHelper.cs      |   4 +-
 .../ObjectDisposedExceptionHelper.cs          |   5 +-
 src/Polyfills/TaskCompletionSource.cs         |   6 +-
 .../InvalidOperationExceptionHelper.cs        |  33 +--
 .../Internal/ScheduledDrainState.cs           |  29 +-
 .../Internal/SequencerPeriodicExtensions.cs   |   9 +-
 .../ObservableSubscriptionExtensions.cs       |  14 +-
 .../Operators/AsSignalObservable.cs           |   8 +-
 .../Operators/BufferUntilIdleObservable.cs    |   5 +-
 .../Operators/ConflateObservable.cs           |  23 +-
 .../Operators/DebounceImmediateObservable.cs  |   2 +-
 .../Operators/DebounceUntilObservable.cs      |   5 +-
 .../Operators/DetectStaleObservable.cs        |  11 +-
 .../Operators/ForEachObservable.cs            |   7 +-
 .../Operators/FromArrayObservable.cs          |   7 +-
 .../Operators/HeartbeatObservable.cs          |   4 +-
 .../Operators/ObserveOnIfObservable.cs        |   2 +-
 .../Operators/ObserveOnObservable.cs          |   9 +-
 .../Operators/RetryBackoffPolicy.cs           |   5 +-
 .../Operators/RetryWithDelayObservable.cs     |   6 +-
 .../Operators/RunAllObservable.cs             |  24 +-
 .../Operators/ScheduleConfig.cs               |   4 +-
 .../Operators/ScheduledSourceObservable.cs    |  30 +--
 .../Operators/ScheduledValueObservable.cs     |  21 +-
 .../Operators/SyncTimerObservable.cs          |  37 +--
 .../Operators/ThrottleDistinctObservable.cs   |  16 +-
 .../Operators/ThrottleObservable.cs           |   9 +-
 .../Operators/ThrottleUntilTrueObservable.cs  |  11 +-
 .../Operators/UsingActionObservable.cs        |   9 +-
 .../Operators/UsingFuncObservable.cs          |   8 +-
 .../Operators/WhileObservable.cs              |   9 +-
 .../ReactiveExtensions.cs                     |  20 +-
 src/Primitives.Shared/Advanced/AfterSignal.cs |   6 +-
 .../Advanced/AfterSubscription.cs             |   4 +-
 .../Advanced/AsyncSubscriptionLifetime.cs     |   6 +-
 .../Advanced/AutoShareSignal{T}.cs            |   7 +-
 .../Advanced/BufferSignal{T}.cs               |   4 +-
 .../Advanced/CatchSignal{T}.cs                |  77 +++---
 .../Advanced/CollectSignal{T}.cs              |   4 +-
 .../Advanced/CollectWitness{T}.cs             |  10 +-
 .../Advanced/CreateSafeSignal{T}.cs           |  31 +--
 .../Advanced/CreateSignal{T,TState}.cs        |  62 ++---
 .../Advanced/CreateSignal{T}.cs               |  32 +--
 .../Advanced/CreateSink{T}.cs                 |   9 +-
 .../Advanced/DeferSignal{T}.cs                |  26 +-
 .../Advanced/EmitIfQuietSignal{T}.cs          |   4 +-
 .../Advanced/EmitIfQuietWitness{T}.cs         |  10 +-
 .../Advanced/EmptySignal{T}.cs                |  26 +-
 src/Primitives.Shared/Advanced/EverySignal.cs |  24 +-
 .../Advanced/ExpireCoordinator{T}.cs          |  44 ++-
 .../Advanced/ExpireSignal{T}.cs               |   6 +-
 .../Advanced/FinallySignal{T}.cs              |  60 ++---
 .../Advanced/FromAsyncSubscription{T}.cs      |  10 +-
 ...Signal{TEventHandler,TCallback,TResult}.cs |   6 +-
 .../Advanced/GuardedWitness{T}.cs             |   7 +-
 .../Advanced/ImmutableReturnRxVoidSignal.cs   |  22 +-
 .../Advanced/IsEmptySignal{T}.cs              |   9 +-
 .../Advanced/IsEmptyWitness{T}.cs             |   2 +-
 .../Advanced/LoopSignal{T}.cs                 |  23 +-
 .../MapIndexedSignal{TSource,TResult}.cs      |   2 +-
 .../Advanced/MergeCoordinator{T}.cs           |   4 +-
 .../Advanced/MergeSignal{T}.cs                |   2 +-
 .../Advanced/RecoverSignal{T,TException}.cs   |   6 +-
 .../Advanced/RepeatSourceCoordinator{T}.cs    |   2 +-
 .../Advanced/RepeatSourceWitness{T}.cs        |   2 +-
 .../Advanced/ResumeSignal{T}.cs               |   5 +-
 .../Advanced/ReturnSignal{T}.cs               |  30 +--
 .../Advanced/ScheduledEnumerableSignal{T}.cs  |   6 +-
 .../Advanced/SequenceSignal.cs                |   4 +-
 .../Advanced/SparkWitness.cs                  |   2 +-
 src/Primitives.Shared/Advanced/StartSignal.cs |   4 +-
 .../Advanced/StartSignal{T}.cs                |   4 +-
 .../Advanced/SubscriptionScheduling.cs        |  13 +-
 .../SwitchMapSignal{TSource,TResult}.cs       |   4 +-
 .../Advanced/SwitchWitness{T}.cs              |  10 +-
 .../Advanced/SynchronizeObjectSignal{T}.cs    |   2 +-
 .../Advanced/TaskAnyWitness{T}.cs             |   4 +-
 .../Advanced/TaskChainCoordinatorState.cs     |   6 +-
 .../Advanced/TaskChainSignal{T}.cs            |   2 +-
 .../Advanced/TaskCountWitness{T}.cs           |   4 +-
 .../Advanced/ThrowSignal{T}.cs                |  32 +--
 .../Advanced/TimeIntervalWitness.cs           |   2 +-
 src/Primitives.Shared/Advanced/TimerSlot.cs   |   8 +-
 .../Advanced/UnsparkWitness.cs                |   2 +-
 .../Advanced/WitnessLifetime.cs               |   6 +-
 .../Advanced/WitnessOnSignal{T}.cs            |  73 +++--
 .../Concurrency/SequencerWorkItem.cs          |   2 +-
 .../Concurrency/SequencerWorkItemDisposal.cs  |   6 +-
 .../ConnectableSignalRxNameExtensions.cs      |   8 +-
 src/Primitives.Shared/Core/Spark.cs           |   6 +-
 .../Core/SparkCompositeFormats.cs             |   5 +-
 src/Primitives.Shared/Core/Spark{T}.cs        |  20 +-
 src/Primitives.Shared/Handle.cs               |   3 +-
 src/Primitives.Shared/LinqExtensions.cs       |  42 ++-
 .../SignalOperatorMixins.BlendUnique.cs       |  13 +-
 .../SignalOperatorMixins.BufferSignals.cs     |   6 +-
 ...SignalOperatorMixins.ChooseSwitchSelect.cs |   5 +-
 .../SignalOperatorMixins.CollectionSignals.cs |  16 +-
 ...lOperatorMixins.CombineLatest.WideArity.cs |  14 +-
 .../SignalOperatorMixins.CombineLatest.cs     |  26 +-
 .../SignalOperatorMixins.Coordinators.cs      |  21 +-
 .../SignalOperatorMixins.SchedulerSignals.cs  |  10 +-
 .../SignalOperatorMixins.StatefulSignals.cs   |  38 +--
 .../SignalOperatorMixins.Switch.cs            |   2 +-
 ...alOperatorMixins.SyncLatest.MultiSource.cs |   4 +-
 ...gnalOperatorMixins.SyncLatest.WideArity.cs |  14 +-
 src/Primitives.Shared/SignalOperatorMixins.cs |  13 +-
 ...alOperatorParityMixins.AggregateHelpers.cs |  14 +-
 ...OperatorParityMixins.AwaitableTerminals.cs |   8 +-
 ...atorParityMixins.BooleanTerminalHelpers.cs |   4 +-
 .../SignalOperatorParityMixins.FlatMap.cs     |  13 +-
 .../SignalOperatorParityMixins.ForkJoin.cs    |   2 +-
 .../SignalOperatorParityMixins.Helpers.cs     |  22 +-
 .../SignalOperatorParityMixins.Probe.cs       |  14 +-
 ...ixins.RxNames.CombineLatest.Collections.cs |   7 +-
 ...rityMixins.RxNames.CombineLatest.Tuples.cs |   2 +-
 ...yMixins.RxNames.CombineLatest.WideArity.cs |  20 +-
 ...ratorParityMixins.RxNames.CombineLatest.cs |   4 +-
 ...ratorParityMixins.RxNames.SubscribeSafe.cs |  20 +-
 .../SignalOperatorParityMixins.RxNames.cs     |  18 +-
 .../SignalOperatorParityMixins.cs             |  18 +-
 .../Signals/PrioritySemaphoreSignal{T}.cs     |  15 +-
 .../Signals/ReplaySignal{T}.cs                | 129 ++++-----
 .../Signals/ScheduledSignal{T}.cs             |  20 +-
 .../Signals/SignalExtensions{Create}.cs       |   6 +-
 .../Signals/SignalExtensions{FromTask}.cs     |  44 ++-
 .../Signals/SignalExtensions{GetAwaiter}.cs   |  10 +-
 .../Signals/SignalExtensions{Recover}.cs      |   6 +-
 .../Signals/Signal{Collect}.cs                |   6 +-
 .../Signals/Signal{Create}.cs                 |  98 +++----
 src/Primitives.Shared/Signals/Signal{Emit}.cs |  40 +--
 .../Signals/Signal{Factories}.cs              | 145 +++++-----
 src/Primitives.Shared/Signals/Signal{Fail}.cs |  56 ++--
 .../Signals/Signal{FromTask}.cs               | 125 ++++-----
 .../Signals/Signal{GetAwaiter}.cs             |  38 +--
 src/Primitives.Shared/Signals/Signal{None}.cs |  43 ++-
 .../Signals/Signal{RxAliases}.cs              |  15 +-
 .../Signals/Signal{Silent}.cs                 |  17 +-
 .../Signals/Signal{Subjects}.cs               |   3 +-
 src/Primitives.Shared/Signals/TaskSignal.cs   |  48 ++--
 .../Signals/TaskSignal{T}.cs                  |  56 ++--
 .../Signals/TaskTerminalCompletion{T}.cs      |  19 +-
 .../Advanced/AsyncSerialGate.cs               |  24 +-
 .../Advanced/BackgroundJobSignal{T}.cs        |   7 +-
 .../Advanced/CallbackWitnessAsync.cs          |   3 +-
 .../Advanced/FlatMapCoordinator{TResult}.cs   |  44 +--
 .../Advanced/ForwardingWitnessAsync.cs        |   5 +-
 .../Advanced/IReentrantAsyncDisposable.cs     |   7 +-
 .../Advanced/IntervalSignal.cs                |   6 +-
 .../Advanced/IntervalSubscription.cs          |   3 +-
 .../Advanced/LeadSubscription{T}.cs           |   6 +-
 .../Advanced/PooledDelaySource.cs             |  44 +--
 .../Advanced/SingleElementWitness.cs          |  12 +-
 .../Advanced/StartSignal{TResult}.cs          |   4 +-
 .../Advanced/StartSubscription{TResult}.cs    |   4 +-
 ...T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult}.cs |   5 +-
 ...2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult}.cs |   5 +-
 ...,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult}.cs |   5 +-
 ...T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult}.cs |   5 +-
 ...6,T7,T8,T9,T10,T11,T12,T13,T14,TResult}.cs |   5 +-
 ...,T8,T9,T10,T11,T12,T13,T14,T15,TResult}.cs |   5 +-
 ...T9,T10,T11,T12,T13,T14,T15,T16,TResult}.cs |   5 +-
 .../SyncLatest2Coordinator{T1,T2,TResult}.cs  |   5 +-
 ...yncLatest3Coordinator{T1,T2,T3,TResult}.cs |   5 +-
 ...Latest4Coordinator{T1,T2,T3,T4,TResult}.cs |   5 +-
 ...est5Coordinator{T1,T2,T3,T4,T5,TResult}.cs |   5 +-
 ...6Coordinator{T1,T2,T3,T4,T5,T6,TResult}.cs |   5 +-
 ...ordinator{T1,T2,T3,T4,T5,T6,T7,TResult}.cs |   5 +-
 ...inator{T1,T2,T3,T4,T5,T6,T7,T8,TResult}.cs |   5 +-
 ...tor{T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult}.cs |   5 +-
 .../Advanced/SyncLatestCoordinatorBase.cs     |  28 +-
 ...tEnumerableCoordinator{TSource,TResult}.cs |  10 +-
 .../Advanced/SyncLatestIndexedWitness.cs      |  14 +-
 .../Advanced/SyncLatestLifecycle.cs           |  18 +-
 .../Advanced/TakeUntilLifecycle.cs            |  23 +-
 .../Advanced/TakeUntilSourceWitness.cs        |   6 +-
 .../Advanced/TaskResultCompletionSource.cs    |   2 +-
 .../Advanced/TaskResultWitnessAsyncBase.cs    |   4 +-
 .../Advanced/TaskSignalSubscription{T}.cs     |  40 ++-
 .../ConcurrencyRaceHelpers.cs                 |  26 +-
 .../ConcurrentWitnessCallsException.cs        |   8 +-
 .../ConnectableSignalAsync.cs                 |  27 +-
 .../ConnectableSignalAsyncHelper.cs           |   5 +-
 .../ConnectableSignalAsyncState{T}.cs         |  13 +-
 .../Disposables/DisposableAsync.cs            |  23 +-
 .../Disposables/DisposableAsyncSlot.cs        |  16 +-
 .../Disposables/MultipleDisposableAsync.cs    |  55 ++--
 .../SingleAssignmentDisposableAsync.cs        |  55 ++--
 .../SingleReplaceableDisposableAsync.cs       |  29 +-
 .../Helpers/DisposalHelper.cs                 |   4 +-
 .../Helpers/FireAndForgetHelper.cs            |   9 +-
 .../Helpers/SubscriptionHelper.cs             |   5 +-
 .../IObservableAsync.cs                       |  14 +-
 .../IObserverAsync.cs                         |  25 +-
 .../Mixins/DisposableAsyncExtensions.cs       |  17 +-
 .../Mixins/SignalExtensions.cs                |  27 +-
 .../Observables/Create.cs                     |  20 +-
 .../Observables/Defer.cs                      |  33 +--
 .../Observables/Empty.cs                      |  17 +-
 .../Observables/FromAsync.cs                  |  13 +-
 .../Observables/Interval.cs                   |  18 +-
 .../Observables/Never.cs                      |   9 +-
 .../Observables/Range.cs                      |  11 +-
 .../Observables/Return.cs                     |  17 +-
 .../Observables/Throw.cs                      |  15 +-
 .../Observables/Timer.cs                      |   4 +-
 .../Observables/ToAsyncSignal.cs              |  32 +--
 .../Operators/AnyAllAsync.cs                  |   9 +-
 .../Operators/Blend.cs                        |  76 ++----
 .../Operators/Cast.cs                         |  13 +-
 .../Operators/Chain.cs                        |  17 +-
 .../Operators/ChainEnumerableSignal{T}.cs     |  21 +-
 .../Operators/ChainSignalSourcesSignal{T}.cs  |  13 +-
 .../Operators/CompletionSignalDelegate.cs     |   4 +-
 .../Operators/ContainsAsync.cs                |   3 -
 .../Operators/CountAsync.cs                   |   3 -
 .../Operators/Distinct.cs                     |  24 +-
 .../Operators/Expire.cs                       |  70 +++--
 .../Operators/FirstAsync.cs                   |  11 +-
 .../Operators/FirstOrDefaultAsync.cs          |   4 -
 .../Operators/FlatMap.cs                      |   7 +-
 .../Operators/Fold.cs                         |  18 +-
 .../Operators/ForEachAsync.cs                 |  19 +-
 .../Operators/GroupBy.cs                      |  19 +-
 .../Operators/GroupedAsyncSignal.cs           |   4 +-
 .../Operators/Keep.cs                         |  24 +-
 .../Operators/KeepType.cs                     |  10 +-
 .../Operators/LastAsync.cs                    |  13 +-
 .../Operators/LastOrDefaultAsync.cs           |   3 -
 .../Operators/Lead.cs                         |   8 +-
 .../Operators/LongCountAsync.cs               |   3 -
 .../Operators/Map.cs                          |  25 +-
 .../Operators/Multicast.cs                    |  61 ++---
 .../Operators/OnDispose.cs                    |  18 +-
 .../Operators/OnErrorResumeAsFailure.cs       |   8 +-
 .../Operators/Pair.cs                         |  21 +-
 .../Operators/ParityHelpers.FilterFusions.cs  |  42 +--
 .../ParityHelpers.OperatorFusions.cs          |  85 ++----
 .../Operators/ParityHelpers.Partition.cs      |  34 +--
 .../Operators/ParityHelpers.Start.cs          |   5 +-
 .../Operators/ParityHelpers.cs                |  11 +-
 .../Operators/Reattempt.cs                    |   2 -
 .../Operators/Recover.cs                      |  26 +-
 .../Operators/ReduceAsync.cs                  |  15 +-
 .../Operators/RefCount.cs                     |  13 +-
 .../Operators/Shift.cs                        |   9 +-
 .../SignalAsyncExtensions.Catch.Rx.cs         |   5 +-
 ...AsyncExtensions.DistinctUntilChanged.Rx.cs |   8 +-
 .../SignalAsyncExtensions.Timeout.Rx.cs       |  20 +-
 .../Operators/SingleAsync.cs                  |  22 +-
 .../Operators/SingleOrDefaultAsync.cs         |  21 +-
 .../Operators/Skip.cs                         |   7 +-
 .../Operators/SkipWhile.cs                    |  15 +-
 .../Operators/StartWith.cs                    |  12 +-
 .../Operators/SubscribeAsync.cs               |  21 +-
 .../Operators/SwitchTo.cs                     |   3 -
 .../Operators/SwitchToSignal.cs               |   8 +-
 .../Operators/SyncLatest10.cs                 |   6 +-
 .../Operators/SyncLatest11.cs                 |   6 +-
 .../Operators/SyncLatest12.cs                 |   6 +-
 .../Operators/SyncLatest13.cs                 |   6 +-
 .../Operators/SyncLatest14.cs                 |   6 +-
 .../Operators/SyncLatest15.cs                 |   6 +-
 .../Operators/SyncLatest16.cs                 |   6 +-
 .../Operators/SyncLatest8.cs                  |   6 +-
 .../Operators/SyncLatest9.cs                  |   6 +-
 .../Operators/SyncLatestEnumerable.cs         |  16 +-
 .../Operators/Take.cs                         |  12 +-
 .../Operators/TakeUntil.PredicateSignals.cs   |   6 +-
 .../Operators/TakeUntil.cs                    |  32 +--
 .../Operators/TakeUntilOptions.cs             |   6 +-
 .../Operators/TakeWhile.cs                    |  11 +-
 .../Operators/Tap.cs                          |   3 -
 .../UnhandledExceptionHandler.cs              |  26 +-
 .../WitnessAsync.cs                           | 208 ++++++---------
 .../Advanced/AggregateWitness.cs              |   7 +-
 .../Advanced/AllPredicateWitness.cs           |   2 +-
 .../Advanced/AnyPredicateWitness.cs           |   2 +-
 .../Advanced/AnyWitness.cs                    |   2 +-
 .../Advanced/AppendDelegateWitness.cs         |   2 +-
 .../Advanced/AppendWitness.cs                 |   4 +-
 .../Advanced/AsyncEnumerableSignal{T}.cs      |  24 +-
 .../Advanced/BufferWitness.cs                 |  14 +-
 .../Advanced/CallbackWitness.cs               |   1 -
 .../Advanced/CollectArrayWitness.cs           |   2 +-
 .../Advanced/CollectListWitness.cs            |   2 +-
 .../Advanced/ContainsWitness.cs               |   2 +-
 .../Advanced/DefaultIfEmptyWitness.cs         |   4 +-
 .../Advanced/DisposedMarker.cs                |   2 +-
 .../Advanced/DisposedWitness{T}.cs            |   2 +-
 .../Advanced/DistinctByCountAggregator.cs     |   4 +-
 .../Advanced/DistinctByLongCountAggregator.cs |   4 +-
 .../Advanced/DistinctByWitness.cs             |   4 +-
 .../Advanced/DistinctWitness.cs               |   6 +-
 .../Advanced/EmptyWitness{T}.cs               |  10 +-
 .../Advanced/FoldWitness.cs                   |   2 +-
 .../Advanced/FromEnumerableSignal{T}.cs       |  28 +-
 .../Advanced/IAggregator.cs                   |   6 +-
 .../Advanced/IInlineSignal{T}.cs              |  14 +-
 .../Advanced/IRequireCurrentThread.cs         |  10 +-
 .../Advanced/IgnoreValuesWitness.cs           |   2 +-
 .../Advanced/ImmediateReturnSignal{T}.cs      |  27 +-
 .../Advanced/ImmediateThrowSignal{T}.cs       |  25 +-
 .../Advanced/ImmutableEmptySignal{T}.cs       |  28 +-
 .../Advanced/ImmutableNeverSignal{T}.cs       |  17 +-
 .../Advanced/ImmutableReturnFalseSignal.cs    |  25 +-
 .../Advanced/ImmutableReturnInt32Signal.cs    |  39 ++-
 .../Advanced/ImmutableReturnTrueSignal.cs     |  25 +-
 .../Advanced/KeepNotNullWitness.cs            |   2 +-
 .../Advanced/KeepTypeWitness.cs               |   2 +-
 .../Advanced/RangeConcatSignal.cs             |   2 +-
 .../Advanced/RangeSignal.cs                   |  28 +-
 .../Advanced/RangeZipSignal{TResult}.cs       |  32 +--
 .../Advanced/ReduceWitness.cs                 |   2 +-
 .../Advanced/RepeatSignal{T}.cs               |  34 +--
 .../Advanced/SinkSubscription.cs              |   9 +-
 .../Advanced/SinkTerminal.cs                  |  13 +-
 .../Advanced/SkipWhileWitness.cs              |   4 +-
 .../Advanced/SkipWitness.cs                   |   2 +-
 .../Advanced/StatefulWitness.cs               |   1 -
 .../Advanced/SubscriptionSlots.cs             |   2 +-
 .../Advanced/SynchronizeWitness.cs            |   9 +-
 .../Advanced/TakeWhileWitness.cs              |   2 +-
 .../Advanced/TakeWitness.cs                   |   2 +-
 .../Advanced/TapWitness.cs                    |   2 +-
 .../Advanced/UnfoldSignal{TState,TResult}.cs  |  22 +-
 .../Advanced/UniqueByWitness.cs               |   6 +-
 .../Advanced/UniqueWitness.cs                 |   6 +-
 .../Advanced/UseSignal{TResource,T}.cs        |  21 +-
 .../Advanced/Witness.cs                       |   4 +-
 .../Concurrency/ScheduledItem.cs              |  54 +---
 .../Concurrency/SequencerQueue.cs             |   8 +-
 .../ConnectableSignal{T}.cs                   |   6 +-
 .../ExceptionExtensions.cs                    |   2 +-
 src/ReactiveUI.Primitives.Core/Optional.cs    |  28 +-
 src/ReactiveUI.Primitives.Core/Result.cs      |  29 +-
 .../ActivationExtensionsEmitter.cs            |   4 +-
 .../CodeGeneration/ActivationSource.cs        |  18 +-
 .../CodeGeneration/GeneratedNames.cs          |  12 +-
 .../CodeGeneration/InstanceWrapperEmitter.cs  |   4 -
 .../CodeGeneration/PooledStringBuilder.cs     |  17 +-
 .../CodeGeneration/SourceFileWriter.cs        |   5 +-
 .../CodeGeneration/StaticEventsEmitter.cs     |   3 +-
 .../Constants.cs                              |   7 +-
 .../EventGenerator.cs                         |  31 +--
 .../GeneratorStepNames.cs                     |   6 +-
 .../Concurrency/WasmScheduler.cs              |  53 ++--
 .../Advanced/DispatchSequencerState.cs        |  25 +-
 .../Concurrency/CurrentThreadSequencer.cs     |  14 +-
 .../Concurrency/ImmediateSequencer.cs         |   2 +-
 .../Concurrency/Sequencer.Simple.cs           |  11 +-
 .../Concurrency/SequencerExtensions.cs        |  63 +----
 .../SynchronizationContextSequencer.cs        |   3 +-
 .../Concurrency/SynchronizedSequencerQueue.cs |   5 +-
 .../Concurrency/TaskPoolSequencer.cs          |   5 +-
 .../Concurrency/ThreadPoolSequencer.cs        |  38 ++-
 .../AsyncPrimitiveContractTests.cs            |  21 +-
 .../AsyncRenameCoverageTests.cs               |   4 +-
 .../CombiningOperatorTests.Blend.cs           |  59 ++--
 .../ConcurrentSignalBaseTests.cs              |  20 +-
 .../CustomTaskScheduler.cs                    |  38 +++
 .../DisposableTests.cs                        |  15 +-
 .../ErrorHandlingOperatorTests.cs             |  10 +-
 .../FactorySignalTests.cs                     |  47 ++--
 .../NewThreadTaskScheduler.cs                 |  33 ---
 .../ObserverAsyncDisposeTests.cs              |  45 ++--
 .../ParityHelpersOperatorFusionsTests.cs      |  23 +-
 ...keUntilOperatorTests.CompletionDelegate.cs |  85 +++---
 .../TimeBasedOperatorTests.cs                 |  22 +-
 .../AvaloniaSchedulerTests.cs                 |  54 ++--
 .../Operators/DropIfBusyObservableTests.cs    |  31 +--
 .../OperatorAfterTerminalGuardTests.cs        |  36 +--
 .../Operators/ScanWithInitialTests.cs         |  64 ++---
 .../SelectAsyncConcurrentObservableTests.cs   |  33 ++-
 .../SelectAsyncSequentialObservableTests.cs   |  33 ++-
 .../SelectLatestAsyncObservableTests.cs       |  51 ++--
 .../SubscribeAsyncObservableTests.cs          |  51 ++--
 .../SynchronizeAsyncObservableTests.cs        |   5 -
 .../ThrottleUntilTrueObservableTests.cs       |  92 ++++---
 .../Operators/WhileObservableTests.cs         |  83 +++---
 .../ReactiveExtensionsPortedTests.cs          |   3 +-
 .../ReactiveExtensionsTests.Misc.cs           |  42 ++-
 .../ReactiveExtensionsTests.Scheduling.cs     |  16 +-
 .../ReactiveExtensionsTests.SelectAsync.cs    |  15 +-
 .../ReactiveExtensionsTests.Synchronize.cs    | 137 ++++------
 .../ReactiveExtensionsTests.Throttle.cs       |  57 ++--
 .../MauiDispatcherSequencerTests.cs           |  11 +-
 .../WasmSchedulerTests.cs                     | 251 +++++++-----------
 .../Common/AwaitableWitness.cs                |  93 +++++++
 .../Common/CancellationTokenExtensions.cs     |  27 ++
 .../RxNamesTests.cs                           |  77 +++---
 .../SignalAliasCoverageTests.cs               |   8 +-
 .../SignalFactoriesTests.Behavior.cs          |  22 +-
 .../SignalFactoriesTests.Composition.cs       |   6 +-
 .../SignalFactoriesTests.DefaultSequencer.cs  |  36 ++-
 .../SignalFactoriesTests.Scheduling.cs        |   6 +-
 .../SignalFactoriesTests.cs                   |  66 +++--
 .../SignalOperatorMixinsTests.cs              |  21 +-
 399 files changed, 3238 insertions(+), 4390 deletions(-)
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/NewThreadTaskScheduler.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs

diff --git a/src/Polyfills/ArgumentExceptionHelper.cs b/src/Polyfills/ArgumentExceptionHelper.cs
index d7df3bde..d154c660 100644
--- a/src/Polyfills/ArgumentExceptionHelper.cs
+++ b/src/Polyfills/ArgumentExceptionHelper.cs
@@ -8,9 +8,8 @@
 namespace ReactiveUI.Primitives.Internal;
 
 /// <summary>
-/// Polyfill for <c>ArgumentNullException.ThrowIfNull</c> on target frameworks (net462-net481) that predate it.
-/// On net8.0 and later this type is not compiled; consuming projects alias the <c>ArgumentExceptionHelper</c>
-/// identifier directly to <see cref="ArgumentNullException"/> so the call sites bind to the BCL method.
+/// Polyfill for <c>ArgumentNullException.ThrowIfNull</c> on net462-net481; net8.0 and later compile no copy of this
+/// type and alias the <c>ArgumentExceptionHelper</c> identifier to <see cref="ArgumentNullException"/> instead.
 /// </summary>
 [ExcludeFromCodeCoverage]
 internal static class ArgumentExceptionHelper
diff --git a/src/Polyfills/ArgumentOutOfRangeExceptionHelper.cs b/src/Polyfills/ArgumentOutOfRangeExceptionHelper.cs
index 65a5d9c1..825fc1e9 100644
--- a/src/Polyfills/ArgumentOutOfRangeExceptionHelper.cs
+++ b/src/Polyfills/ArgumentOutOfRangeExceptionHelper.cs
@@ -70,9 +70,7 @@ internal static void ThrowIfLessThan(
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "A type-specialized polyfill overload. The bounds-check body is identical to the int overload only "
-            + "because the guard shape is the same; the two operate on different value types (int vs TimeSpan) and "
-            + "cannot forward to one another. This mirrors the BCL's per-type ThrowIfLessThan overloads.")]
+            "The int and TimeSpan overloads guard different value types and cannot forward to one another.")]
     internal static void ThrowIfLessThan(
         TimeSpan value,
         TimeSpan other,
diff --git a/src/Polyfills/ObjectDisposedExceptionHelper.cs b/src/Polyfills/ObjectDisposedExceptionHelper.cs
index 8867323b..c74b6361 100644
--- a/src/Polyfills/ObjectDisposedExceptionHelper.cs
+++ b/src/Polyfills/ObjectDisposedExceptionHelper.cs
@@ -7,9 +7,8 @@
 namespace ReactiveUI.Primitives.Internal;
 
 /// <summary>
-/// Polyfill for <c>ObjectDisposedException.ThrowIf</c> on target frameworks (net462-net481) that predate it.
-/// On net8.0 and later this type is not compiled; consuming projects alias the <c>ObjectDisposedExceptionHelper</c>
-/// identifier directly to <see cref="ObjectDisposedException"/> so the call sites bind to the BCL method.
+/// Polyfill for <c>ObjectDisposedException.ThrowIf</c> on net462-net481; net8.0 and later compile no copy of this
+/// type and alias the <c>ObjectDisposedExceptionHelper</c> identifier to <see cref="ObjectDisposedException"/> instead.
 /// </summary>
 [ExcludeFromCodeCoverage]
 internal static class ObjectDisposedExceptionHelper
diff --git a/src/Polyfills/TaskCompletionSource.cs b/src/Polyfills/TaskCompletionSource.cs
index b5b10cc2..615dcae8 100644
--- a/src/Polyfills/TaskCompletionSource.cs
+++ b/src/Polyfills/TaskCompletionSource.cs
@@ -19,7 +19,7 @@ internal sealed class TaskCompletionSource
 
     /// <summary>Initializes a new instance of the <see cref="TaskCompletionSource"/> class.</summary>
     [SuppressMessage("Concurrency", "PSH1302", Justification =
-        "BCL-parity polyfill; must match the framework ctor's TaskCreationOptions.None default, not force async continuations.")]
+        "Matches the framework constructor's TaskCreationOptions.None default.")]
     public TaskCompletionSource() => _inner = new();
 
     /// <summary>Transitions the underlying task to the <see cref="TaskStatus.RanToCompletion"/> state.</summary>
@@ -47,9 +47,7 @@ internal sealed class TaskCompletionSource
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "Distinct BCL-parity surface members with different contracts and return types: SetCanceled is void and "
-            + "TrySetCanceled returns bool. They share the same backing call here but must track the framework surface "
-            + "independently, so they are deliberately kept as separate members rather than one forwarding to the other.")]
+            "SetCanceled returns void and TrySetCanceled returns bool; each tracks its own framework contract.")]
     internal bool TrySetCanceled() => _inner.TrySetCanceled();
 
     /// <summary>Attempts to transition the underlying task to the <see cref="TaskStatus.Canceled"/> state for the specified token.</summary>
diff --git a/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs b/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
index 235386f3..11581b65 100644
--- a/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
+++ b/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
@@ -8,23 +8,16 @@
 namespace ReactiveUI.Primitives.Extensions;
 
 /// <summary>
-/// Provides helper methods for throwing <see cref="InvalidOperationException"/> when
-/// constructor-supplied state on an operator is missing at the time it is consumed.
-/// The thrown message is composed of the captured member name and the caller member
-/// (typically <c>Subscribe</c> or the enclosing type), so call sites just pass the
-/// field being validated.
+/// Throws <see cref="InvalidOperationException"/> when constructor-supplied operator state is missing at the
+/// point it is consumed, naming the captured member and the calling member in the message.
 /// </summary>
 [ExcludeFromCodeCoverage]
 internal static class InvalidOperationExceptionHelper
 {
-    /// <summary>
-    /// Throws an <see cref="InvalidOperationException"/> if <paramref name="argument"/> is null.
-    /// The exception message is composed from the captured argument expression and the
-    /// caller member, e.g. <c>"'source' was not supplied to 'Subscribe'."</c>.
-    /// </summary>
+    /// <summary>Throws <see cref="InvalidOperationException"/> when <paramref name="argument"/> is null.</summary>
     /// <param name="argument">The reference type field to validate as non-null.</param>
-    /// <param name="memberName">The validated member's name, captured from the <paramref name="argument"/> expression via <see cref="CallerArgumentExpressionAttribute"/>.</param>
-    /// <param name="operation">The void-throwing caller's name, captured via <see cref="CallerMemberNameAttribute"/>.</param>
+    /// <param name="memberName">The validated member's name, captured from the <paramref name="argument"/> expression.</param>
+    /// <param name="operation">The calling member's name.</param>
     /// <exception cref="InvalidOperationException"><paramref name="argument"/> is <see langword="null"/>.</exception>
     internal static void ThrowIfNull(
         [NotNull] object? argument,
@@ -42,13 +35,13 @@ internal static void ThrowIfNull(
     }
 
     /// <summary>
-    /// Validates an argument and returns it if it is not null, otherwise throws an <see cref="InvalidOperationException"/>.
-    /// Designed for use in primary constructor initializers.
+    /// Returns <paramref name="argument"/> when non-null and otherwise throws, shaped for use in a primary
+    /// constructor initializer.
     /// </summary>
     /// <typeparam name="T">The type of the argument.</typeparam>
     /// <param name="argument">The argument to validate.</param>
-    /// <param name="memberName">The validated reference-type argument's name, captured from the <paramref name="argument"/> expression via <see cref="CallerArgumentExpressionAttribute"/>.</param>
-    /// <param name="operation">The reference-type-checking caller's name, captured via <see cref="CallerMemberNameAttribute"/>.</param>
+    /// <param name="memberName">The validated argument's name, captured from the <paramref name="argument"/> expression.</param>
+    /// <param name="operation">The calling member's name.</param>
     /// <returns>The non-null argument.</returns>
     /// <exception cref="InvalidOperationException"><paramref name="argument"/> is <see langword="null"/>.</exception>
     internal static T Check<T>(
@@ -68,12 +61,12 @@ internal static T Check<T>(
     }
 
     /// <summary>
-    /// Validates a string argument and returns it if it is not null or empty, otherwise throws an <see cref="InvalidOperationException"/>.
-    /// Designed for use in primary constructor initializers.
+    /// Returns <paramref name="argument"/> when it is neither null nor empty and otherwise throws, shaped for use
+    /// in a primary constructor initializer.
     /// </summary>
     /// <param name="argument">The argument to validate.</param>
-    /// <param name="memberName">The validated string argument's name, captured from the <paramref name="argument"/> expression via <see cref="CallerArgumentExpressionAttribute"/>.</param>
-    /// <param name="operation">The string-checking caller's name, captured via <see cref="CallerMemberNameAttribute"/>.</param>
+    /// <param name="memberName">The validated argument's name, captured from the <paramref name="argument"/> expression.</param>
+    /// <param name="operation">The calling member's name.</param>
     /// <returns>The non-null, non-empty argument.</returns>
     /// <exception cref="InvalidOperationException"><paramref name="argument"/> is <see langword="null"/> or empty.</exception>
     internal static string Check(
diff --git a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
index 89c6ef95..7271810a 100644
--- a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
+++ b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
@@ -12,14 +12,10 @@ namespace ReactiveUI.Primitives.Extensions.Internal;
 #endif
 
 /// <summary>
-/// Shared queue-and-single-drain marshaller used by the synchronous scheduler-marshalling operator
-/// sinks (<c>ObserveOn</c>, <c>Conflate</c>). Each of those sinks previously hand-rolled the same gate,
-/// FIFO queue, drain-in-flight flag, terminal flag, enqueue-and-schedule logic, and dequeue loop on top
-/// of identical fields; this helper centralises that machinery so the per-sink class only carries the
-/// operator-specific notification handling. Notifications are enqueued and a single drain pass is
-/// scheduled per burst (rather than one scheduled action per item), and the drain callback carries no
-/// captures — the sink is passed through as an <see cref="IDrainTarget"/>. Sinks compose one instance
-/// and forward to it; there is no base class and no per-item virtual dispatch.
+/// Queue-and-single-drain marshaller composed by the synchronous scheduler-marshalling operator sinks
+/// (<c>ObserveOn</c>, <c>Conflate</c>): notifications are enqueued under the sink's gate and one drain pass is
+/// scheduled per burst rather than one scheduled action per item. The drain callback is capture-free, taking
+/// the sink through as an <see cref="IDrainTarget"/>.
 /// </summary>
 /// <typeparam name="T">The element type carried by <see cref="DrainNotificationKind.Next"/> notifications.</typeparam>
 /// <param name="scheduler">The scheduler each drain pass runs on.</param>
@@ -42,8 +38,7 @@ internal sealed class ScheduledDrainState<T>(ISequencer scheduler, IDrainTarget
     /// <summary>Set to <see langword="true"/> once a terminal notification has been delivered or the sink disposed.</summary>
     private bool _done;
 
-    /// <summary>Gets a value indicating whether the sink has reached a terminal state. Read inside
-    /// the sink's gate by callers that need to short-circuit once terminated.</summary>
+    /// <summary>Gets a value indicating whether the sink has reached a terminal state; read it inside the sink's gate.</summary>
     internal bool Done => _done;
 
     /// <summary>Enqueues an OnNext notification and schedules a drain pass if one isn't already running.</summary>
@@ -60,7 +55,7 @@ internal sealed class ScheduledDrainState<T>(ISequencer scheduler, IDrainTarget
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void EnqueueCompleted() => Enqueue(new(DrainNotificationKind.Completed, default!, null));
 
-    /// <summary>Records the upstream subscription, or disposes it immediately if the sink is already done.</summary>
+    /// <summary>Records the upstream subscription, or disposes it immediately when the sink has terminated.</summary>
     /// <param name="subscription">The upstream subscription handle.</param>
     internal void Attach(IDisposable subscription)
     {
@@ -109,9 +104,8 @@ internal void Terminate()
     /// the still-queued notifications are abandoned because <see cref="TryDequeue"/> checks the done flag first.</summary>
     internal void MarkDoneLocked() => _done = true;
 
-    /// <summary>Begins disposal under the gate: marks the sink done, clears the queue, and detaches
-    /// the upstream subscription — returned to the caller so it is disposed outside the gate. Returns
-    /// <see langword="null"/> when already disposed.</summary>
+    /// <summary>Begins disposal under the gate, returning the upstream subscription so the caller disposes it
+    /// outside the gate, or <see langword="null"/> when the sink has terminated.</summary>
     /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
     internal IDisposable? BeginDispose()
     {
@@ -121,10 +115,9 @@ internal void Terminate()
         }
     }
 
-    /// <summary>Marks the sink done, clears the queue, and detaches the upstream subscription, returning it for
-    /// disposal outside the gate. Caller must hold the gate and have confirmed <see cref="Done"/> is
-    /// <see langword="false"/>. Lets a composing sink dispose its own scheduled-work slot atomically with the
-    /// done transition under the same lock.</summary>
+    /// <summary>Marks the sink done, clears the queue, and returns the upstream subscription for disposal outside
+    /// the gate. Caller must hold the gate and have confirmed <see cref="Done"/> is <see langword="false"/>, which
+    /// lets it retire its own scheduled-work slot atomically with the done transition.</summary>
     /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
     internal IDisposable? BeginDisposeLocked()
     {
diff --git a/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs b/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
index 6af78f2c..e355ba5c 100644
--- a/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
+++ b/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Internal;
 namespace ReactiveUI.Primitives.Extensions.Internal;
 #endif
 
-/// <summary>Periodic scheduling helpers used by migrated extension operators.</summary>
+/// <summary>Periodic scheduling helpers for <see cref="ISequencer"/>.</summary>
 internal static class SequencerPeriodicExtensions
 {
     /// <summary>Periodic scheduling helpers for a sequencer.</summary>
@@ -67,10 +67,7 @@ private static PeriodicSubscription<TState> SchedulePeriodic<TState>(
         return subscription;
     }
 
-    /// <summary>
-    /// Disposable state for one periodic schedule. Internal (rather than private) so coverage tests can
-    /// drive <see cref="Tick"/> directly instead of via reflection.
-    /// </summary>
+    /// <summary>Disposable state for one periodic schedule, re-arming itself after each tick until disposed.</summary>
     /// <typeparam name="TState">The state type.</typeparam>
     /// <param name="scheduler">The scheduler used for each tick.</param>
     /// <param name="state">The state passed to each tick.</param>
@@ -127,7 +124,7 @@ internal void ScheduleNext(TimeSpan dueTime)
             });
         }
 
-        /// <summary>Runs a tick and schedules the next one when still active.</summary>
+        /// <summary>Runs one tick and schedules the next, unless disposed.</summary>
         internal void Tick()
         {
             if (Volatile.Read(ref _disposed) != 0)
diff --git a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
index 1165906c..48ea0223 100644
--- a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
@@ -12,9 +12,8 @@ namespace ReactiveUI.Primitives.Extensions;
 #endif
 
 /// <summary>
-/// Provides extension methods for subscribing to and handling reactive sequences
-/// in a synchronous or blocking manner. These methods offer utility functions
-/// to retrieve emitted values, handle completion, and capture errors from observables.
+/// Provides extension methods that subscribe to a sequence and block the calling thread until it produces a
+/// value or terminates, returning the emitted value or the captured error.
 /// </summary>
 public static class ObservableSubscriptionExtensions
 {
@@ -240,8 +239,8 @@ private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer
     }
 
     /// <summary>
-    /// Subscribes to the specified <paramref name="source"/> observable using the provided <paramref name="scheduler"/>.
-    /// If a scheduler is specified, the subscription is scheduled; otherwise, the subscription occurs immediately.
+    /// Subscribes <paramref name="observer"/> to <paramref name="source"/> on <paramref name="scheduler"/>, or
+    /// inline when no scheduler is supplied.
     /// </summary>
     /// <typeparam name="T">The type of the elements in <paramref name="source"/>.</typeparam>
     /// <param name="source">The observable to subscribe to.</param>
@@ -360,9 +359,8 @@ private sealed class BlockingValueWitness<T>(ManualResetEventSlim done) : IObser
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "This blocking witness treats completion and error identically: either terminal signal releases the "
-                + "gate. OnError and OnCompleted are distinct IObserver<T> channels that share this by design, not a "
-                + "copy that was meant to differ.")]
+                "Completion and error are distinct IObserver<T> channels that deliberately share one action: "
+                + "releasing the gate.")]
         public void OnCompleted() => done.Set();
     }
 
diff --git a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
index a9826886..25ad98c5 100644
--- a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
@@ -11,10 +11,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Projection operator that emits <see cref="RxVoid.Default"/> for every source
-/// element. Replaces the <c>source.Select(_ =&gt; RxVoid.Default)</c> pattern,
-/// avoiding the per-subscription closure allocation that the projection lambda
-/// would otherwise capture.
+/// Projection operator that emits <see cref="RxVoid.Default"/> for every source element without allocating a
+/// projection closure.
 /// </summary>
 /// <typeparam name="T">The element type of the source observable (ignored).</typeparam>
 /// <param name="source">The source observable whose values are ignored.</param>
@@ -28,7 +26,7 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
         return source.Subscribe(new AsSignalWitness(observer));
     }
 
-    /// <summary>Forwarding observer that replaces every <see cref="OnNext"/> value with <see cref="RxVoid.Default"/>. Error and completion signals pass through unchanged.</summary>
+    /// <summary>Forwards every source value as <see cref="RxVoid.Default"/>, passing error and completion through unchanged.</summary>
     /// <param name="downstream">The downstream observer.</param>
     private sealed class AsSignalWitness(IObserver<RxVoid> downstream) : IObserver<T>
     {
diff --git a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
index 524306f5..42a334d3 100644
--- a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
@@ -35,10 +35,7 @@ public IDisposable Subscribe(IObserver<IList<T>> observer)
         return new DisposableBag(subscription, sink);
     }
 
-    /// <summary>
-    /// Sink that manages the buffer and idle timer. Composes <see cref="TimerSinkState{T}"/> for
-    /// the shared gate / timer / done-flag plumbing so this class only carries the buffer logic.
-    /// </summary>
+    /// <summary>Sink that accumulates elements and emits the buffer once the idle timer elapses.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="idleTime">The idle time period.</param>
     /// <param name="scheduler">The scheduler.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
index 0421684d..3960cbf3 100644
--- a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
@@ -34,11 +34,9 @@ public IDisposable Subscribe(IObserver<T> observer)
     }
 
     /// <summary>
-    /// Single observer that combines two previously-distinct concerns into one allocation:
-    /// (1) marshals upstream notifications onto the scheduler thread — delegated to the shared
-    /// <see cref="ScheduledDrainState{T}"/> FIFO queue and scheduled drain — and (2) applies the conflate
-    /// time-window throttle to each <see cref="DrainNotificationKind.Next"/> notification. End-user-observable
-    /// semantics are unchanged from the prior two-observer implementation.
+    /// Single observer that both marshals upstream notifications onto the scheduler thread, through the
+    /// <see cref="ScheduledDrainState{T}"/> queue and scheduled drain, and applies the conflate time-window
+    /// throttle to each <see cref="DrainNotificationKind.Next"/> notification.
     /// </summary>
     internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
     {
@@ -149,10 +147,8 @@ void IDrainTarget.Drain()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void AttachSourceSubscription(IDisposable subscription) => _state.Attach(subscription);
 
-        /// <summary>Applies the throttle-window decision to a dequeued value and either emits inline or
-        /// schedules a deferred emission. The emission bodies live in covered helpers; only this
-        /// race-guarded shell (whose already-done early-out is reachable only when a concurrent dispose
-        /// flips the flag between the drain dequeue and this gate acquisition) is excluded.</summary>
+        /// <summary>Applies the throttle-window decision to a dequeued value, emitting it inline or scheduling a
+        /// deferred emission at the end of the window.</summary>
         /// <param name="value">The value to forward.</param>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         private void ProcessNext(T value)
@@ -162,6 +158,7 @@ private void ProcessNext(T value)
 
             lock (_gate)
             {
+                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
@@ -228,13 +225,12 @@ private void EmitInline(T value)
 
         /// <summary>Forwards an error to downstream and terminates the sink.</summary>
         /// <param name="error">The error to forward.</param>
-        /// <remarks>The already-terminated early-out is reachable only when a concurrent dispose flips the
-        /// flag between the drain dequeue and this gate acquisition; excluded as race-only.</remarks>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         private void ForwardError(Exception error)
         {
             lock (_gate)
             {
+                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
@@ -247,14 +243,13 @@ private void ForwardError(Exception error)
             _downstream.OnError(error);
         }
 
-        /// <summary>Forwards completion, deferring if a throttled emission is still scheduled.</summary>
-        /// <remarks>The already-terminated early-out is reachable only when a concurrent dispose flips the
-        /// flag between the drain dequeue and this gate acquisition; excluded as race-only.</remarks>
+        /// <summary>Forwards completion, deferring it when a throttled emission is scheduled.</summary>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         private void ForwardCompleted()
         {
             lock (_gate)
             {
+                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
index cbd0270a..63703687 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
@@ -32,7 +32,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DisposableBag(subscription, sink);
     }
 
-    /// <summary>Sink for the debounce immediate observable.</summary>
+    /// <summary>Sink that forwards the first value inline and debounces every later value by the due time.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="dueTime">The debounce duration.</param>
     /// <param name="scheduler">The scheduler to use for timing.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
index 266b6170..e92e72d6 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
@@ -35,10 +35,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DisposableBag(subscription, sink);
     }
 
-    /// <summary>
-    /// Sink for the debounce-until observable. Composes <see cref="TimerSinkState{T}"/> for the
-    /// shared gate / timer / done-flag plumbing so this class only carries the OnNext logic.
-    /// </summary>
+    /// <summary>Sink that forwards a value inline when the condition holds and otherwise after the debounce window.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="debounce">The debounce duration.</param>
     /// <param name="condition">The condition.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
index 60a46e1b..bb69cb0d 100644
--- a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
@@ -34,10 +34,7 @@ public IDisposable Subscribe(IObserver<Stale<T>> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Sink that manages staleness detection. Composes <see cref="TimerSinkState{T}"/> for the
-    /// shared gate / timer / done-flag plumbing so this class only carries the OnNext / schedule logic.
-    /// </summary>
+    /// <summary>Sink that re-arms the staleness timer on each upstream value and emits a stale marker when the window elapses.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="stalenessPeriod">The staleness period.</param>
     /// <param name="scheduler">The scheduler.</param>
@@ -52,7 +49,7 @@ private sealed class DetectStaleSink(
         /// <summary>Shared timer / done-flag plumbing.</summary>
         private readonly TimerSinkState<Stale<T>> _state = new(downstream);
 
-        /// <summary>Upstream subscription handle, set once via <see cref="AttachSourceSubscription"/> so the sink can tear it down on dispose without a wrapper bag.</summary>
+        /// <summary>Upstream subscription handle, set once via <see cref="AttachSourceSubscription"/> and disposed with the sink.</summary>
         private IDisposable? _sourceSubscription;
 
         /// <summary>Records the upstream subscription for disposal.</summary>
@@ -119,9 +116,7 @@ public void Dispose()
             Interlocked.Exchange(ref _sourceSubscription, null)?.Dispose();
         }
 
-        /// <summary>Schedules the staleness notification. Uses the state-carrying scheduler
-        /// overload with a static lambda so no per-reschedule closure capturing <c>this</c> is
-        /// allocated (the timer re-arms on every upstream emission).</summary>
+        /// <summary>Arms the staleness timer, which re-arms on every upstream emission without allocating a per-arm closure.</summary>
         private void ScheduleStale() =>
             _state.Timer.Disposable =
                 scheduler.Schedule(this, stalenessPeriod, static (_, self) => self.OnStaleTimer());
diff --git a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
index 3c8570bd..529016f3 100644
--- a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
@@ -11,11 +11,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Flattening operator that subscribes to an upstream sequence of
-/// <see cref="IEnumerable{T}"/> batches and emits each contained element
-/// individually. Replaces the
-/// <c>Observable.Create&lt;T&gt;(o =&gt; source.ObserveOnSafe(s).Subscribe(v =&gt; o.FastForEach(v)))</c>
-/// pattern with a single operator + observer pair.
+/// Flattening operator that subscribes to an upstream sequence of <see cref="IEnumerable{T}"/> batches and emits
+/// each contained element individually.
 /// </summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source observable of enumerables.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
index e37f7674..b8a06fde 100644
--- a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
@@ -11,11 +11,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Factory operator that emits each element of an <see cref="IEnumerable{T}"/>
-/// to a single subscriber, then completes. The emission can optionally be
-/// marshalled through a scheduler. Replaces the
-/// <c>Observable.Create&lt;T&gt;(o =&gt; scheduler.ScheduleSafe(() =&gt; o.FastForEach(source)))</c>
-/// pattern with a dedicated <see cref="IObservable{T}"/> implementation.
+/// Factory operator that emits each element of an <see cref="IEnumerable{T}"/> to a single subscriber and then
+/// completes, optionally marshalling the emission through a scheduler.
 /// </summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source enumerable whose elements are pumped on subscription.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs b/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
index e9027274..3c73db56 100644
--- a/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
@@ -34,7 +34,7 @@ public IDisposable Subscribe(IObserver<Heartbeat<T>> observer)
         return sink;
     }
 
-    /// <summary>The sink for the heartbeat operator.</summary>
+    /// <summary>Sink that forwards upstream values and emits a heartbeat whenever the period elapses without one.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="heartbeatPeriod">The period between heartbeats.</param>
     /// <param name="scheduler">The scheduler to run the heartbeat timer on.</param>
@@ -49,7 +49,7 @@ private sealed class HeartbeatSink(
         /// <summary>The subscription to the periodic heartbeat timer.</summary>
         private readonly MutableDisposable _timerSubscription = new();
 
-        /// <summary>Upstream subscription handle; set once via <see cref="AttachSourceSubscription"/> so the sink can tear it down in <see cref="Dispose"/> without needing a wrapper bag.</summary>
+        /// <summary>Upstream subscription handle, set once via <see cref="AttachSourceSubscription"/> and torn down in <see cref="Dispose"/>.</summary>
         private IDisposable? _sourceSubscription;
 
         /// <summary>Whether the sink has completed or been disposed.</summary>
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
index 270dcb71..574dc407 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
@@ -46,7 +46,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DisposableBag(sourceSub, conditionSub, sink);
     }
 
-    /// <summary>Sinks the source observable and conditionally observes on different schedulers.</summary>
+    /// <summary>Sink that forwards each value on whichever scheduler the latest condition value selects.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="trueScheduler">The scheduler to use when condition is true.</param>
     /// <param name="falseScheduler">The scheduler to use when condition is false.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
index 610a58c3..f17f3740 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
@@ -11,12 +11,9 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Marshals every source notification onto the supplied <see cref="ISequencer"/>, preserving order.
-/// Replaces the <c>System.Reactive.Linq.Observable.ObserveOn</c> delegation behind the sync
-/// <c>ObserveOnSafe</c> / <c>ObserveOnIf</c> helpers with our own queue-and-single-drain marshaller:
-/// notifications are enqueued and a single drain pass is scheduled per burst (rather than one
-/// scheduled action per item). The shared queue / gate / drain machinery lives in
-/// <see cref="ScheduledDrainState{T}"/>; this sink only carries the forward-everything drain handling.
+/// Marshals every source notification onto the supplied <see cref="ISequencer"/>, preserving order: notifications
+/// are enqueued in <see cref="ScheduledDrainState{T}"/> and one drain pass is scheduled per burst rather than one
+/// scheduled action per item.
 /// </summary>
 /// <typeparam name="T">The element type of the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
index 9171802f..2e67051b 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
@@ -9,9 +9,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Bundled retry configuration for <see cref="RetryWithBackoffObservable{T}"/>: retry count,
-/// delay schedule, scheduler, and an optional error sink. A <see langword="readonly record struct"/>
-/// so it stays allocation-free and keeps the constructors that consume it to a short parameter list.
+/// Bundled retry configuration for <see cref="RetryWithBackoffObservable{T}"/>: retry count, delay schedule,
+/// scheduler, and an optional error sink.
 /// </summary>
 /// <param name="MaxRetries">Maximum number of retries.</param>
 /// <param name="InitialDelay">Delay before the first retry.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryWithDelayObservable.cs b/src/Primitives.Extensions.Shared/Operators/RetryWithDelayObservable.cs
index 9592b8fb..30f2c0ff 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryWithDelayObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryWithDelayObservable.cs
@@ -16,10 +16,12 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="source">The source observable.</param>
 /// <param name="retryCount">The maximum number of retries.</param>
 /// <param name="delaySelector">A function to select the delay for each retry attempt.</param>
+/// <param name="sequencer">The sequencer timing retry delays; <c>null</c> uses the default sequencer.</param>
 internal sealed class RetryWithDelayObservable<T>(
     IObservable<T> source,
     int retryCount,
-    Func<int, TimeSpan> delaySelector) : IObservable<T>
+    Func<int, TimeSpan> delaySelector,
+    ISequencer? sequencer = null) : IObservable<T>
 {
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<T> observer)
@@ -28,7 +30,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(delaySelector);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        RetryWithDelaySink sink = new(observer, source, retryCount, delaySelector, Sequencer.Default);
+        RetryWithDelaySink sink = new(observer, source, retryCount, delaySelector, sequencer ?? Sequencer.Default);
         sink.Run();
         return sink;
     }
diff --git a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
index e687c2a7..05d4b096 100644
--- a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
@@ -17,12 +17,6 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// Errors from any observable propagate to the downstream observer.
 /// </summary>
 /// <param name="sources">The list of one-shot observables to run in order.</param>
-/// <remarks>
-/// Replaces patterns like <c>sources.Concat().LastOrDefaultAsync()</c> with a single
-/// operator that subscribes sequentially. Uses an iterative loop with a sync-completion
-/// flag to avoid stack overflow when sources complete synchronously during
-/// <c>Subscribe</c>.
-/// </remarks>
 internal sealed class RunAllObservable(IReadOnlyList<IObservable<RxVoid>> sources) : IObservable<RxVoid>
 {
     /// <inheritdoc/>
@@ -43,10 +37,9 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
     }
 
     /// <summary>
-    /// Stateful observer that walks the source list sequentially. The sink subscribes itself
-    /// directly to each source — its own <see cref="IObserver{RxVoid}.OnCompleted"/> sets a
-    /// per-iteration flag the surrounding loop reads to decide whether to advance. This
-    /// replaces the previous probe-observer-per-iteration allocation pattern.
+    /// Stateful observer that walks the source list sequentially: the sink subscribes itself to each source, and its
+    /// own <see cref="IObserver{RxVoid}.OnCompleted"/> sets a per-iteration flag the surrounding loop reads to
+    /// decide whether to advance.
     /// </summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="sources">The source list to walk.</param>
@@ -66,10 +59,9 @@ private sealed class Sink(
         /// <summary>Guards against re-entrant <see cref="RunNext"/> calls.</summary>
         private bool _looping;
 
-        /// <summary>Per-iteration latch (0 = pending, 1 = terminated). Set by <see cref="OnCompleted"/>
-        /// when a source terminates synchronously during <c>Subscribe</c>; read by the surrounding
-        /// loop in <see cref="RunNext"/>. Accessed via <see cref="Volatile"/> so it crosses the
-        /// method boundary safely without needing a separate probe-observer allocation per iteration.</summary>
+        /// <summary>Per-iteration latch (0 = pending, 1 = terminated), set by <see cref="OnCompleted"/> when a source
+        /// terminates synchronously during <c>Subscribe</c> and read by the surrounding loop in
+        /// <see cref="RunNext"/>.</summary>
         private int _iterationTerminated;
 
         /// <inheritdoc/>
@@ -146,12 +138,10 @@ internal void RunNext()
         }
 
         /// <summary>Emits the terminal <see cref="RxVoid"/> and completes once all sources have run.</summary>
-        /// <remarks>The already-done early-out is only reachable when a concurrent dispose latches between the
-        /// loop exit and this call; this small completion shell is excluded from coverage as race-only while the
-        /// trampoline loop in <see cref="RunNext"/> stays covered.</remarks>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         private void CompleteRun()
         {
+            // Race-only: a concurrent dispose can latch the done flag between the loop exit and this call.
             if (Interlocked.Exchange(ref _done, 1) != 0)
             {
                 return;
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs b/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
index 28b7181a..fa93ee26 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
@@ -10,9 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
 /// Bundled scheduling configuration shared by <see cref="ScheduledValueObservable{T}"/> and
-/// <see cref="ScheduledSourceObservable{T}"/>. Carrying these parameters as a single readonly record
-/// struct keeps observable/observer constructor parameter counts low, avoids SA1117-style parameter
-/// soup, and lets the compiler copy the configuration into capture-free scheduler lambdas.
+/// <see cref="ScheduledSourceObservable{T}"/>, copied by value into capture-free scheduler lambdas.
 /// </summary>
 /// <typeparam name="T">The element type emitted by the configured observable.</typeparam>
 /// <param name="Scheduler">The scheduler on which each emission is dispatched.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
index 7de6946b..8d8832d7 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
@@ -11,21 +11,14 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Source-driven scheduled observable. Subscribes to an upstream
-/// <see cref="IObservable{T}"/> and, for every emitted value, schedules a
-/// callback on the supplied <see cref="ISequencer"/> that applies an optional
-/// <see cref="Action{T}"/> side-effect and/or <see cref="Func{T,T}"/> transform
-/// before forwarding the value to the downstream observer. Replaces the
-/// <c>Observable.Create&lt;T&gt;(o =&gt; source.Subscribe(v =&gt; scheduler.Schedule(...)))</c>
-/// family of source-driven <c>Schedule</c> overloads.
+/// Source-driven scheduled observable: for every upstream value, schedules a callback on the supplied
+/// <see cref="ISequencer"/> that applies an optional <see cref="Action{T}"/> side-effect and/or
+/// <see cref="Func{T,T}"/> transform before forwarding the value downstream.
 /// </summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <remarks>
-/// To match the original <c>source.Subscribe(Action&lt;T&gt;)</c> semantics, this
-/// operator only forwards <see cref="IObserver{T}.OnNext"/>. Source errors and
-/// completion are intentionally not propagated to the downstream observer; that
-/// preserves the historical behaviour of <c>Observable.Create</c> + a
-/// next-only subscription.
+/// Only <see cref="IObserver{T}.OnNext"/> is forwarded: source errors and completion never reach the downstream
+/// observer, so a subscriber sees no terminal notification.
 /// </remarks>
 internal sealed class ScheduledSourceObservable<T> : IObservable<T>
 {
@@ -56,11 +49,8 @@ public IDisposable Subscribe(IObserver<T> observer)
     }
 
     /// <summary>
-    /// Carries the per-emission state into the scheduled callback so the
-    /// scheduler lambda does not capture any fields. A <see langword="readonly"/>
-    /// <see langword="record"/> <see langword="struct"/> so it rides inside the
-    /// scheduler's work item by value rather than as a separate per-emission heap
-    /// allocation.
+    /// Carries the per-emission state by value into the scheduled callback so the scheduler lambda captures
+    /// nothing.
     /// </summary>
     /// <param name="Observer">The downstream observer.</param>
     /// <param name="Value">The value to emit.</param>
@@ -129,15 +119,13 @@ public void OnNext(T value)
         /// <inheritdoc/>
         public void OnError(Exception error)
         {
-            // Intentionally not forwarded: original Observable.Create + Subscribe(Action<T>)
-            // pattern silently dropped source errors. Preserving that behaviour.
+            // Not forwarded: this operator is next-only by contract.
         }
 
         /// <inheritdoc/>
         public void OnCompleted()
         {
-            // Intentionally not forwarded: original Observable.Create + Subscribe(Action<T>)
-            // pattern silently dropped completion. Preserving that behaviour.
+            // Not forwarded: this operator is next-only by contract.
         }
     }
 }
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs b/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
index 4d9dc857..d5a61fa6 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
@@ -11,16 +11,15 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Single-value scheduled observable. On subscription, schedules a callback on
-/// the supplied <see cref="ISequencer"/> that applies an optional
-/// <see cref="Action{T}"/> side-effect and/or an optional <see cref="Func{T,T}"/>
-/// transform to the captured value, calls <see cref="IObserver{T}.OnNext"/>
-/// once, then <see cref="IObserver{T}.OnCompleted"/>. Replaces the
-/// <c>Observable.Create&lt;T&gt;(o =&gt; scheduler.Schedule[Safe](due, () =&gt; o.OnNext(...)))</c>
-/// family of single-value <c>Schedule</c> overloads with one dedicated type
-/// that captures only the fields each overload actually uses.
+/// Single-value scheduled observable: on subscription, schedules a callback on the supplied
+/// <see cref="ISequencer"/> that applies an optional <see cref="Action{T}"/> side-effect and/or an optional
+/// <see cref="Func{T,T}"/> transform to the captured value and calls <see cref="IObserver{T}.OnNext"/> once.
 /// </summary>
 /// <typeparam name="T">The value type emitted to the downstream observer.</typeparam>
+/// <remarks>
+/// The sequence never completes on its own: no terminal notification is sent, so the subscriber ends it by
+/// disposing the subscription.
+/// </remarks>
 internal sealed class ScheduledValueObservable<T> : IObservable<T>
 {
     /// <summary>The value to emit.</summary>
@@ -121,13 +120,9 @@ private sealed class EmitState(
         Func<T, T>? transform,
         Action<T>? action)
     {
-        /// <summary>Applies the optional side-effect and transform, then emits the value followed by completion to the captured observer.</summary>
+        /// <summary>Applies the optional side-effect and transform, then emits the value to the captured observer.</summary>
         public void Emit()
         {
-            // Preserves the original Observable.Create-based semantics: the
-            // scheduled callback only emits OnNext. The sequence completes
-            // when downstream subscribers dispose; we do not auto-call
-            // OnCompleted here.
             try
             {
                 action?.Invoke(value);
diff --git a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
index e683b50a..fe782db6 100644
--- a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
@@ -12,12 +12,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Optimized operator that shares a single timer per <c>(TimeSpan, ISequencer)</c> key.
-/// Replaces the manual <c>ConcurrentDictionary&lt;..., Lazy&lt;SharedTimer&gt;&gt;</c> shape with a stateful
-/// <c>ConcurrentDictionary.GetOrAdd</c> overload that doesn't allocate a
-/// <see cref="Lazy{T}"/> or its factory delegate on the hot path.
-/// </summary>
+/// <summary>Caches and shares one running timer per <c>(TimeSpan, ISequencer)</c> key.</summary>
 internal static class SyncTimerObservable
 {
     /// <summary>The timer cache, keyed by <c>(TimeSpan, ISequencer)</c>.</summary>
@@ -40,9 +35,8 @@ internal static IObservable<DateTime> Get(TimeSpan timeSpan, ISequencer schedule
     }
 
     /// <summary>
-    /// A manual implementation of a connectable timer that minimizes allocations and unrolls Rx chains.
-    /// Tick uses a swap-on-write <see cref="IObserver{DateTime}"/> array so the read path is allocation-free
-    /// and lock-free; subscribe / unsubscribe takes the gate and publishes a fresh array.
+    /// Connectable timer that fans each tick out to its observers: the tick path reads a swap-on-write observer
+    /// array lock-free, while subscribe and unsubscribe take the gate and publish a fresh array.
     /// </summary>
     /// <param name="timeSpan">The period.</param>
     /// <param name="scheduler">The scheduler.</param>
@@ -55,9 +49,8 @@ private sealed class SharedTimer(TimeSpan timeSpan, ISequencer scheduler) : IObs
         private readonly Lock _gate = new();
 
         /// <summary>
-        /// Snapshot of currently active observers. Replaced (not mutated) on subscribe / unsubscribe under
-        /// <see cref="_gate"/>. The tick path reads this via <c>Volatile.Read</c> with no lock and no
-        /// allocation.
+        /// Snapshot of active observers, replaced rather than mutated on subscribe and unsubscribe under
+        /// <see cref="_gate"/> so the tick path can read it without the lock.
         /// </summary>
         private IObserver<DateTime>[] _observers = _emptyObservers;
 
@@ -87,9 +80,7 @@ public IDisposable Subscribe(IObserver<DateTime> observer)
             return new TimerSubscription(this, observer);
         }
 
-        /// <summary>Ticks every currently-subscribed observer with the scheduler's current time.
-        /// The empty-array short-circuit lives in <see cref="ObserverArrayHelpers.Broadcast{T}"/>
-        /// (excluded from coverage) so this hot path stays branchless on the steady state.</summary>
+        /// <summary>Ticks every currently-subscribed observer with the scheduler's current time.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void Tick() =>
             ObserverArrayHelpers.Broadcast(Volatile.Read(ref _observers), scheduler.Now.DateTime);
@@ -100,29 +91,21 @@ private void Remove(IObserver<DateTime> observer)
         {
             lock (_gate)
             {
-                // TimerSubscription.Dispose's Interlocked guard ensures Remove is called at most
-                // once per subscription, and each subscription's observer was placed in _observers
-                // under this same lock before the disposable was returned — so RemoveOrNull always
-                // locates the observer by construction.
+                // Never null: Dispose's Interlocked guard admits one Remove per subscription, and the
+                // observer was added under this same lock before the disposable was handed out.
                 var updated = ObserverArrayHelpers.RemoveOrNull(_observers, observer, _emptyObservers)!;
 
                 Volatile.Write(ref _observers, updated);
                 if (ReferenceEquals(updated, _emptyObservers))
                 {
-                    // Subscribe sets _timerSubscription on first add, before the disposable is
-                    // returned; if we reach the "all observers gone" branch, at least one Subscribe
-                    // ran, so _timerSubscription is non-null by construction.
+                    // Never null: reaching an empty set means Subscribe ran, which arms the timer.
                     _timerSubscription!.Dispose();
                     _timerSubscription = null;
                 }
             }
         }
 
-        /// <summary>
-        /// Per-subscribe disposable. Holding <c>(parent, observer)</c> as fields instead of capturing them in
-        /// a lambda removes the per-subscribe closure allocation that <see cref="ActionDisposable"/> would
-        /// have required.
-        /// </summary>
+        /// <summary>Per-subscribe disposable that detaches its observer from the owning timer exactly once.</summary>
         /// <param name="parent">The owning timer.</param>
         /// <param name="observer">The observer to remove on dispose.</param>
         private sealed class TimerSubscription(SharedTimer parent, IObserver<DateTime> observer) : IDisposable
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
index 673cfe60..6a4fcecf 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
@@ -27,18 +27,13 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        // Implementation of .DistinctUntilChanged().Throttle(throttle, scheduler).DistinctUntilChanged()
-        // But fused into a single sink to avoid multiple operator allocations and observer chains.
+        // Equivalent to DistinctUntilChanged().Throttle(throttle, scheduler).DistinctUntilChanged(), fused into one sink.
         ThrottleDistinctSink sink = new(observer, throttle, scheduler);
         var subscription = source.Subscribe(sink);
         return new DisposableBag(subscription, sink);
     }
 
-    /// <summary>
-    /// Sink that implements the throttle distinct logic. Composes <see cref="TimerSinkState{T}"/>
-    /// for the shared gate / timer / done-flag plumbing so this class only carries the throttle
-    /// and distinct-value tracking.
-    /// </summary>
+    /// <summary>Sink that emits the latest value once the throttle window elapses, skipping it when it equals the last emitted value.</summary>
     /// <param name="downstream">The observer to forward elements to.</param>
     /// <param name="throttle">The throttle duration.</param>
     /// <param name="scheduler">The scheduler to use for timing.</param>
@@ -115,17 +110,14 @@ public void Dispose()
             }
         }
 
-        /// <summary>Emits the last received value if it differs from the last emitted value.
-        /// Marked <c>[ExcludeFromCodeCoverage]</c> because the in-lock
-        /// race-loser branch (sink done or no buffered value) is only reachable when the
-        /// scheduled callback fires concurrently with Dispose / OnCompleted, which the
-        /// single-threaded test harness cannot trigger.</summary>
+        /// <summary>Emits the last received value when it differs from the last emitted value.</summary>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         private void Emit()
         {
             T? toEmit;
             lock (_gate)
             {
+                // Race-only: reachable when this scheduled callback overlaps Dispose or a terminal notification.
                 if (_state.Done || !_hasLastReceived)
                 {
                     return;
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
index 317ac0fc..c54836b6 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
@@ -145,12 +145,8 @@ public void Dispose()
         }
 
         /// <summary>
-        /// Emits the buffered value if it is still current (i.e. no newer
-        /// <see cref="OnNext"/> arrived after this emission was scheduled).
-        /// Marked <c>[ExcludeFromCodeCoverage]</c> because the in-lock
-        /// race-loser branch (sink done, emission superseded, value already drained) is only
-        /// reachable when the scheduled callback fires concurrently with Dispose / OnCompleted,
-        /// which the single-threaded test harness cannot trigger.
+        /// Emits the buffered value when it is still current, meaning no newer <see cref="OnNext"/> arrived after
+        /// this emission was scheduled.
         /// </summary>
         /// <param name="id">The emission id this callback was scheduled for.</param>
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -159,6 +155,7 @@ private void Emit(long id)
             T value;
             lock (_gate)
             {
+                // Race-only: reachable when this scheduled callback overlaps Dispose or a terminal notification.
                 if (_done || id != _emissionId || !_hasValue)
                 {
                     return;
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleUntilTrueObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleUntilTrueObservable.cs
index 0d344b82..04946c35 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleUntilTrueObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleUntilTrueObservable.cs
@@ -15,10 +15,12 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="source">The source observable.</param>
 /// <param name="throttle">The throttle duration.</param>
 /// <param name="predicate">The predicate to determine if an element should be emitted immediately or throttled.</param>
+/// <param name="sequencer">The sequencer timing throttled emissions; <c>null</c> uses the default sequencer.</param>
 internal sealed class ThrottleUntilTrueObservable<T>(
     IObservable<T> source,
     TimeSpan throttle,
-    Func<T, bool> predicate) : IObservable<T>
+    Func<T, bool> predicate,
+    ISequencer? sequencer = null) : IObservable<T>
 {
     /// <summary>The source observable.</summary>
     private readonly IObservable<T> _source = InvalidOperationExceptionHelper.Check(source);
@@ -29,17 +31,20 @@ internal sealed class ThrottleUntilTrueObservable<T>(
     /// <summary>The predicate to determine if an element should be emitted immediately or throttled.</summary>
     private readonly Func<T, bool> _predicate = InvalidOperationExceptionHelper.Check(predicate);
 
+    /// <summary>The sequencer timing throttled emissions.</summary>
+    private readonly ISequencer _sequencer = sequencer ?? Sequencer.Default;
+
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        ThrottleUntilTrueSink sink = new(observer, _throttle, _predicate, Sequencer.Default);
+        ThrottleUntilTrueSink sink = new(observer, _throttle, _predicate, _sequencer);
         var subscription = _source.Subscribe(sink);
         return new DisposableBag(subscription, sink);
     }
 
-    /// <summary>Sinks the source observable and throttles elements until a predicate is true.</summary>
+    /// <summary>Sink that forwards a value inline when the predicate holds and otherwise after the throttle window.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="throttle">The throttle duration.</param>
     /// <param name="predicate">The predicate.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs b/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
index b1a3b22d..cdc2e1e2 100644
--- a/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
@@ -11,11 +11,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Resource-bound factory observable that runs an optional
-/// <see cref="Action{T}"/> against a captured <see cref="IDisposable"/>
-/// resource, emits <see cref="RxVoid.Default"/>, completes, and finally disposes
-/// the resource. Replaces the legacy
-/// <c>Observable.Using(() =&gt; obj, id =&gt; Observable.Start(...))</c> pattern.
+/// Resource-bound factory observable that runs an optional <see cref="Action{T}"/> against a captured
+/// <see cref="IDisposable"/> resource, emits <see cref="RxVoid.Default"/>, completes, and disposes the resource.
 /// </summary>
 /// <typeparam name="T">The disposable resource type.</typeparam>
 /// <param name="resource">The resource to use during the operation and dispose at the end.</param>
@@ -55,7 +52,7 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
         "Design",
         "SST1429:Handle, rethrow, or narrow this catch; an empty catch of the base exception hides failures",
         Justification =
-            "A secondary dispose failure during error handling is intentionally swallowed so the primary exception sent to the observer wins; this assembly has no unhandled-exception sink.")]
+            "A secondary dispose failure is swallowed so the primary exception reaching the observer wins.")]
     private static void Run(IObserver<RxVoid> observer, T resource, Action<T>? action)
     {
         try
diff --git a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
index 768da676..14755c3c 100644
--- a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
@@ -11,10 +11,8 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Resource-bound factory observable that runs a <see cref="Func{T, TResult}"/>
-/// against a captured <see cref="IDisposable"/> resource, emits the result,
-/// completes, and finally disposes the resource. Replaces the legacy
-/// <c>Observable.Using(() =&gt; obj, id =&gt; Observable.Start(() =&gt; func(id)))</c> pattern.
+/// Resource-bound factory observable that runs a <see cref="Func{T, TResult}"/> against a captured
+/// <see cref="IDisposable"/> resource, emits the result, completes, and disposes the resource.
 /// </summary>
 /// <typeparam name="T">The disposable resource type.</typeparam>
 /// <typeparam name="TResult">The result type emitted to the downstream observer.</typeparam>
@@ -59,7 +57,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         "Design",
         "SST1429:Handle, rethrow, or narrow this catch; an empty catch of the base exception hides failures",
         Justification =
-            "A secondary dispose failure during error handling is intentionally swallowed so the primary exception sent to the observer wins; this assembly has no unhandled-exception sink.")]
+            "A secondary dispose failure is swallowed so the primary exception reaching the observer wins.")]
     private static void Run(IObserver<TResult> observer, T resource, Func<T, TResult> function)
     {
         TResult result;
diff --git a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
index ae87e75b..214ce2d9 100644
--- a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
@@ -12,12 +12,9 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
 /// <summary>
-/// Loops the supplied <see cref="Action"/> on the supplied
-/// <see cref="ISequencer"/> (or inline when no scheduler is provided), emitting
-/// <see cref="RxVoid.Default"/> after each iteration, for as long as
-/// <paramref name="condition"/> returns <c>true</c>. Replaces the legacy
-/// <c>Observable.While(condition, Observable.Start(action, scheduler))</c>
-/// pattern.
+/// Loops the supplied <see cref="Action"/> on the supplied <see cref="ISequencer"/>, or inline when no scheduler is
+/// provided, emitting <see cref="RxVoid.Default"/> after each iteration for as long as
+/// <paramref name="condition"/> returns <c>true</c>.
 /// </summary>
 /// <param name="condition">The loop predicate. Evaluated before each iteration.</param>
 /// <param name="action">The action to invoke per iteration.</param>
diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
index 7ad51784..33feaa0b 100644
--- a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
@@ -20,7 +20,7 @@ namespace ReactiveUI.Primitives.Extensions;
 [SuppressMessage(
     "Roslynator",
     "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-    Justification = "Existing API")]
+    Justification = "The SubscribeAsync overloads are named for the asynchronous handler they invoke and return a subscription handle rather than a task.")]
 public static partial class ReactiveExtensions
 {
     /// <summary>Default match timeout for regex filters created from string patterns.</summary>
@@ -42,16 +42,16 @@ public IObservable<RxVoid> Start(ISequencer? scheduler) =>
     /// <param name="condition">Condition to evaluate.</param>
     extension(Func<bool> condition)
     {
-        /// <summary>While construct.</summary>
+        /// <summary>Runs the action inline, emitting <see cref="RxVoid.Default"/> after each iteration for as long as the condition holds.</summary>
         /// <param name="action">Action to execute.</param>
         /// <returns>Observable representing the loop.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<RxVoid> While(Action action) =>
             While(condition, action, null);
 
-        /// <summary>While construct.</summary>
+        /// <summary>Runs the action on the scheduler, emitting <see cref="RxVoid.Default"/> after each iteration for as long as the condition holds.</summary>
         /// <param name="action">Action to execute.</param>
-        /// <param name="scheduler">Scheduler.</param>
+        /// <param name="scheduler">Scheduler each iteration runs on; <c>null</c> runs inline.</param>
         /// <returns>Observable representing the loop.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<RxVoid> While(Action action, ISequencer? scheduler) =>
@@ -62,13 +62,13 @@ public IObservable<RxVoid> While(Action action, ISequencer? scheduler) =>
     /// <param name="sources">The sources.</param>
     extension(IEnumerable<IObservable<bool>> sources)
     {
-        /// <summary>Latest values of each sequence are all false.</summary>
+        /// <summary>Combines the latest value of every source and reports whether they are all false.</summary>
         /// <returns>A sequence that emits true when all latest booleans are false.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<bool> CombineLatestValuesAreAllFalse() =>
             new BooleanReduceObservable(sources, false);
 
-        /// <summary>Latest values of each sequence are all true.</summary>
+        /// <summary>Combines the latest value of every source and reports whether they are all true.</summary>
         /// <returns>A sequence that emits true when all latest booleans are true.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<bool> CombineLatestValuesAreAllTrue() =>
@@ -415,7 +415,7 @@ public IObservable<T> SwitchIfEmpty(IObservable<T> fallback) =>
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The name describes the asynchronous handler this overload invokes; it returns a subscription handle rather than a task.")]
         public IDisposable SubscribeAsync(Func<T, ValueTask> onNext) =>
             new SubscribeAsyncObservable<T>(source, onNext, null, null);
 
@@ -429,7 +429,7 @@ public IDisposable SubscribeAsync(Func<T, ValueTask> onNext) =>
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The name describes the asynchronous handler this overload invokes; it returns a subscription handle rather than a task.")]
         public IDisposable SubscribeAsync(Func<T, ValueTask> onNext, Action onCompleted) =>
             new SubscribeAsyncObservable<T>(source, onNext, null, onCompleted);
 
@@ -443,7 +443,7 @@ public IDisposable SubscribeAsync(Func<T, ValueTask> onNext, Action onCompleted)
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The name describes the asynchronous handler this overload invokes; it returns a subscription handle rather than a task.")]
         public IDisposable SubscribeAsync(Func<T, ValueTask> onNext, Action<Exception> onError) =>
             new SubscribeAsyncObservable<T>(source, onNext, onError, null);
 
@@ -458,7 +458,7 @@ public IDisposable SubscribeAsync(Func<T, ValueTask> onNext, Action<Exception> o
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The name describes the asynchronous handler this overload invokes; it returns a subscription handle rather than a task.")]
         public IDisposable SubscribeAsync(
             Func<T, ValueTask> onNext,
             Action<Exception> onError,
diff --git a/src/Primitives.Shared/Advanced/AfterSignal.cs b/src/Primitives.Shared/Advanced/AfterSignal.cs
index 65f681a6..20ef9072 100644
--- a/src/Primitives.Shared/Advanced/AfterSignal.cs
+++ b/src/Primitives.Shared/Advanced/AfterSignal.cs
@@ -20,12 +20,12 @@ public sealed class AfterSignal : IRequireCurrentThread<long>
     /// <summary>The recurring period after the first tick, when this is a periodic timer.</summary>
     private readonly TimeSpan? _period;
 
-    /// <summary>The sequencer used to schedule the tick.</summary>
+    /// <summary>The sequencer that schedules the tick.</summary>
     private readonly ISequencer _scheduler;
 
     /// <summary>Initializes a new instance of the <see cref="AfterSignal"/> class.</summary>
     /// <param name="dueTime">The delay before the single tick.</param>
-    /// <param name="scheduler">The sequencer used to schedule the tick.</param>
+    /// <param name="scheduler">The sequencer that schedules the tick.</param>
     public AfterSignal(TimeSpan dueTime, ISequencer scheduler)
     {
         _dueTime = dueTime;
@@ -35,7 +35,7 @@ public AfterSignal(TimeSpan dueTime, ISequencer scheduler)
     /// <summary>Initializes a new instance of the <see cref="AfterSignal"/> class.</summary>
     /// <param name="dueTime">The delay before the first tick.</param>
     /// <param name="period">The period between subsequent ticks.</param>
-    /// <param name="scheduler">The sequencer used to schedule ticks.</param>
+    /// <param name="scheduler">The sequencer that schedules ticks.</param>
     public AfterSignal(TimeSpan dueTime, TimeSpan period, ISequencer scheduler)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(period, TimeSpan.Zero);
diff --git a/src/Primitives.Shared/Advanced/AfterSubscription.cs b/src/Primitives.Shared/Advanced/AfterSubscription.cs
index 1b789c87..533b2aab 100644
--- a/src/Primitives.Shared/Advanced/AfterSubscription.cs
+++ b/src/Primitives.Shared/Advanced/AfterSubscription.cs
@@ -16,7 +16,7 @@ public sealed class AfterSubscription : IDisposable
 {
     /// <summary>Initializes a new instance of the <see cref="AfterSubscription"/> class.</summary>
     /// <param name="observer">The downstream observer.</param>
-    /// <param name="scheduler">The scheduler used to emit ticks.</param>
+    /// <param name="scheduler">The scheduler that emits ticks.</param>
     /// <param name="dueTime">The delay before the first tick.</param>
     /// <param name="period">The period between subsequent ticks, or <see langword="null"/> for one-shot timers.</param>
     public AfterSubscription(IObserver<long> observer, ISequencer scheduler, TimeSpan dueTime, TimeSpan? period)
@@ -30,7 +30,7 @@ public AfterSubscription(IObserver<long> observer, ISequencer scheduler, TimeSpa
     /// <summary>Gets the downstream observer.</summary>
     private IObserver<long> Observer { get; }
 
-    /// <summary>Gets the scheduler used to emit ticks.</summary>
+    /// <summary>Gets the scheduler that emits ticks.</summary>
     private ISequencer Scheduler { get; }
 
     /// <summary>Gets the delay before the first tick.</summary>
diff --git a/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
index 76b8e231..020b85ba 100644
--- a/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
+++ b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
@@ -47,7 +47,7 @@ public sealed class AsyncSubscriptionLifetime : IDisposable
     public void SetSubscription(IDisposable? disposable) =>
         _subscription.Create(disposable ?? EmptyDisposable.Instance);
 
-    /// <summary>Marks asynchronous setup complete and releases the cancellation source when still owned here.</summary>
+    /// <summary>Marks asynchronous setup complete and releases the cancellation source while it is owned here.</summary>
     public void Complete() => _ = TryComplete();
 
     /// <inheritdoc/>
@@ -71,7 +71,7 @@ public void Dispose()
         _cts.Dispose();
     }
 
-    /// <summary>Attempts to mark asynchronous setup complete and release the cancellation source when still owned here.</summary>
+    /// <summary>Attempts to mark asynchronous setup complete and release the cancellation source while it is owned here.</summary>
     /// <returns><see langword="true"/> when this call completed the lifetime.</returns>
     internal bool TryComplete()
     {
@@ -100,7 +100,7 @@ private static void CancelIgnoringDisposed(CancellationTokenSource cts)
         }
         catch (ObjectDisposedException)
         {
-            // Completion can release the CTS concurrently; disposal still continues with the inner subscription.
+            // Completion can release the CTS concurrently; disposal continues with the inner subscription.
         }
     }
 }
diff --git a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
index c461fe9f..a2a3e03c 100644
--- a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
@@ -95,10 +95,9 @@ internal void Release(IDisposable subscription)
     /// <summary>Connects the source outside <see cref="_gate"/> and publishes or drops the connection.</summary>
     /// <param name="subscription">The inner source subscription owned by the connecting observer.</param>
     /// <remarks>
-    /// Connecting runs outside the lock so a synchronous source cannot drive user callbacks while the
-    /// gate is held. A re-entrant or concurrent <see cref="Release"/> can drop the subscriber count to
-    /// zero before the connection is published; in that case the freshly returned connection is orphaned
-    /// and is disposed here rather than stored.
+    /// Connecting runs outside the lock so a synchronous source cannot drive user callbacks while the gate is
+    /// held, which lets a re-entrant or concurrent <see cref="Release"/> drain the subscriber count before the
+    /// connection is published.
     /// </remarks>
     private void ConnectOutsideGate(IDisposable subscription)
     {
diff --git a/src/Primitives.Shared/Advanced/BufferSignal{T}.cs b/src/Primitives.Shared/Advanced/BufferSignal{T}.cs
index a8a5117b..80e958b1 100644
--- a/src/Primitives.Shared/Advanced/BufferSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/BufferSignal{T}.cs
@@ -16,7 +16,7 @@ public sealed class BufferSignal<T> : IObservable<IList<T>>
     /// <summary>Initializes a new instance of the <see cref="BufferSignal{T}"/> class.</summary>
     /// <param name="source">The source observable.</param>
     /// <param name="timeSpan">The buffer window duration.</param>
-    /// <param name="sequencer">The sequencer used to schedule buffer flushes.</param>
+    /// <param name="sequencer">The sequencer that schedules buffer flushes.</param>
     /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="sequencer"/> is <see langword="null"/>.</exception>
     public BufferSignal(IObservable<T> source, TimeSpan timeSpan, ISequencer sequencer)
     {
@@ -31,7 +31,7 @@ public BufferSignal(IObservable<T> source, TimeSpan timeSpan, ISequencer sequenc
     /// <summary>Gets the buffer window duration.</summary>
     private TimeSpan Window { get; }
 
-    /// <summary>Gets the sequencer used to schedule buffer flushes.</summary>
+    /// <summary>Gets the sequencer that schedules buffer flushes.</summary>
     private ISequencer Scheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/CatchSignal{T}.cs b/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
index 5be0be31..66e650ed 100644
--- a/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
@@ -10,75 +10,74 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the CatchSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Subscribes to each source in turn, moving to the next one whenever a source errors.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 internal sealed class CatchSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sources tried in order.</summary>
     private readonly IEnumerable<IObservable<T>> _sources;
 
     /// <summary>Initializes a new instance of the <see cref="CatchSignal{T}"/> class.</summary>
-    /// <param name="sources">The sources value.</param>
+    /// <param name="sources">The sources to try in order.</param>
     public CatchSignal(IEnumerable<IObservable<T>> sources) => _sources = sources;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription runs on the calling thread.</summary>
+    /// <returns>Always <see langword="true"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => true;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the observer and starts walking the sources.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that tears the walk down.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, true, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Creates the handler that walks the sources and starts it.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable that tears the walk down.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel) =>
         new Catch(this, observer, cancel).Run();
 
-    /// <summary>Represents the Catch class.</summary>
+    /// <summary>Walks the source sequence, advancing on each error and forwarding the last error if none succeed.</summary>
     private sealed class Catch : IObserver<T>, IDisposable
     {
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The signal supplying the sources.</summary>
         private readonly CatchSignal<T> _parent;
 
-        /// <summary>Stores the downstream observer.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer;
 
-        /// <summary>Executes the new operation.</summary>
-        /// <returns>The result.</returns>
+        /// <summary>Serializes advancing the enumerator against teardown.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Stores the upstream subscription.</summary>
+        /// <summary>The outer subscription handle released on teardown.</summary>
         private IDisposable? _cancel;
 
         /// <summary>Disposed latch; 0 when alive, 1 once disposed.</summary>
         private int _disposed;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>Set under <see cref="_gate"/> once teardown ran, so no further source is subscribed.</summary>
         private bool _isDisposed;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The enumerator over the sources.</summary>
         private IEnumerator<IObservable<T>>? _e;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The slot holding the current source subscription.</summary>
         private SingleReplaceableDisposable? _subscription;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The error raised by the most recent source.</summary>
         private Exception? _lastException;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The recursive continuation that advances to the next source.</summary>
         private Action? _nextSelf;
 
         /// <summary>Initializes a new instance of the <see cref="Catch"/> class.</summary>
-        /// <param name="parent">The parent value.</param>
-        /// <param name="observer">The observer value.</param>
-        /// <param name="cancel">The cancel value.</param>
+        /// <param name="parent">The signal supplying the sources.</param>
+        /// <param name="observer">The downstream observer.</param>
+        /// <param name="cancel">The outer subscription handle.</param>
         /// <exception cref="ArgumentNullException"><paramref name="cancel"/> is <see langword="null"/>.</exception>
         public Catch(CatchSignal<T> parent, IObserver<T> observer, IDisposable cancel)
         {
@@ -87,8 +86,8 @@ public Catch(CatchSignal<T> parent, IObserver<T> observer, IDisposable cancel)
             _parent = parent;
         }
 
-        /// <summary>Executes the Run operation.</summary>
-        /// <returns>The result.</returns>
+        /// <summary>Starts the walk on the immediate sequencer.</summary>
+        /// <returns>The disposable that releases the enumerator and the current source subscription.</returns>
         public MultipleDisposable Run()
         {
             _isDisposed = false;
@@ -108,20 +107,20 @@ public MultipleDisposable Run()
             }));
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
-        /// <param name="value">The value.</param>
+        /// <summary>Forwards a value downstream.</summary>
+        /// <param name="value">The value to forward.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(T value) => _observer.OnNext(value);
 
-        /// <summary>Executes the OnError operation.</summary>
-        /// <param name="error">The error value.</param>
+        /// <summary>Records the error and advances to the next source instead of terminating.</summary>
+        /// <param name="error">The error raised by the current source.</param>
         public void OnError(Exception error)
         {
             _lastException = error;
             _nextSelf!();
         }
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Completes downstream and tears the walk down.</summary>
         public void OnCompleted()
         {
             try
@@ -134,7 +133,7 @@ public void OnCompleted()
             }
         }
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Releases the enumerator, the current source subscription and the outer handle.</summary>
         public void Dispose()
         {
             _e?.Dispose();
@@ -144,8 +143,8 @@ public void Dispose()
             _ = WitnessTeardown.Dispose(ref _disposed, ref _cancel);
         }
 
-        /// <summary>Executes the RecursiveRun operation.</summary>
-        /// <param name="self">The self value.</param>
+        /// <summary>Subscribes to the next source, or terminates once the sequence is exhausted.</summary>
+        /// <param name="self">The continuation that re-enters this method for the following source.</param>
         private void RecursiveRun(Action self)
         {
             lock (_gate)
@@ -172,7 +171,7 @@ private void RecursiveRun(Action self)
             }
         }
 
-        /// <summary>Advances the handler sequence to the next source. Call while holding the gate.</summary>
+        /// <summary>Advances the enumerator to the next source. Call while holding <see cref="_gate"/>.</summary>
         /// <param name="next">The next source, or <see langword="null"/> once the sequence is exhausted.</param>
         /// <param name="error">The exception the sequence raised, when it raised one.</param>
         /// <returns><see langword="true"/> when the sequence advanced without raising.</returns>
@@ -203,7 +202,7 @@ private bool TryMoveToNextSource(out IObservable<T>? next, out Exception? error)
             }
         }
 
-        /// <summary>Forwards an error downstream and tears the handler down.</summary>
+        /// <summary>Forwards an error downstream and tears the walk down.</summary>
         /// <param name="error">The error to forward.</param>
         private void FailAndDispose(Exception error)
         {
diff --git a/src/Primitives.Shared/Advanced/CollectSignal{T}.cs b/src/Primitives.Shared/Advanced/CollectSignal{T}.cs
index 7d157de7..f5594754 100644
--- a/src/Primitives.Shared/Advanced/CollectSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CollectSignal{T}.cs
@@ -16,7 +16,7 @@ public sealed class CollectSignal<T> : IObservable<IList<T>>
     /// <summary>Initializes a new instance of the <see cref="CollectSignal{T}"/> class.</summary>
     /// <param name="source">The source observable.</param>
     /// <param name="timeSpan">The buffer window duration.</param>
-    /// <param name="sequencer">The sequencer used to schedule buffer flushes.</param>
+    /// <param name="sequencer">The sequencer that schedules buffer flushes.</param>
     /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="sequencer"/> is <see langword="null"/>.</exception>
     public CollectSignal(IObservable<T> source, TimeSpan timeSpan, ISequencer sequencer)
     {
@@ -31,7 +31,7 @@ public CollectSignal(IObservable<T> source, TimeSpan timeSpan, ISequencer sequen
     /// <summary>Gets the buffer window duration.</summary>
     private TimeSpan TimeSpan { get; }
 
-    /// <summary>Gets the sequencer used to schedule buffer flushes.</summary>
+    /// <summary>Gets the sequencer that schedules buffer flushes.</summary>
     private ISequencer Sequencer { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/CollectWitness{T}.cs b/src/Primitives.Shared/Advanced/CollectWitness{T}.cs
index 0c688716..eaaf6a54 100644
--- a/src/Primitives.Shared/Advanced/CollectWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/CollectWitness{T}.cs
@@ -18,7 +18,7 @@ public sealed class CollectWitness<T> : IObserver<T>, IDisposable
     /// <summary>Serializes access to buffered values and terminal state.</summary>
     private readonly Lock _gate = new();
 
-    /// <summary>Whether a flush has already been scheduled for the current window.</summary>
+    /// <summary>Whether a flush is scheduled for the current window.</summary>
     private bool _flushScheduled;
 
     /// <summary>Whether the source has terminated.</summary>
@@ -33,7 +33,7 @@ public CollectWitness(IObserver<IList<T>> observer) =>
     /// <summary>Initializes a new instance of the <see cref="CollectWitness{T}"/> class.</summary>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="timeSpan">The buffer window duration.</param>
-    /// <param name="sequencer">The sequencer used to schedule flushes.</param>
+    /// <param name="sequencer">The sequencer that schedules flushes.</param>
     /// <exception cref="ArgumentNullException"><paramref name="observer"/> or <paramref name="sequencer"/> is <see langword="null"/>.</exception>
     public CollectWitness(IObserver<IList<T>> observer, TimeSpan timeSpan, ISequencer sequencer)
     {
@@ -48,7 +48,7 @@ public CollectWitness(IObserver<IList<T>> observer, TimeSpan timeSpan, ISequence
     /// <summary>Gets the buffer window duration.</summary>
     private TimeSpan TimeSpan { get; }
 
-    /// <summary>Gets the sequencer used to schedule flushes.</summary>
+    /// <summary>Gets the sequencer that schedules flushes.</summary>
     private ISequencer? Sequencer { get; }
 
     /// <summary>Gets the source subscription and scheduled flushes.</summary>
@@ -132,7 +132,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => Disposables.Add(subscription);
 
-    /// <summary>Flushes the current window if it still has buffered values.</summary>
+    /// <summary>Flushes the current window when it holds buffered values.</summary>
     private void Flush()
     {
         var batch = TakeScheduledBatch();
@@ -177,7 +177,7 @@ private bool TryRecord(T value)
         }
     }
 
-    /// <summary>Marks the observer as stopped if it has not already stopped.</summary>
+    /// <summary>Transitions the observer to the stopped state.</summary>
     /// <returns><see langword="true"/> when this call stopped the observer.</returns>
     private bool TryMarkStopped()
     {
diff --git a/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs b/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
index 6fea332c..0fc3c76d 100644
--- a/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
@@ -10,37 +10,38 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the CreateSafeSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Creates a signal from a subscribe delegate whose sink releases the subscription when a downstream
+/// <c>OnNext</c> throws.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 internal sealed class CreateSafeSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The delegate invoked for each subscription.</summary>
     private readonly Func<IObserver<T>, IDisposable> _subscribe;
 
     /// <summary>Whether subscription must be dispatched through the current-thread sequencer.</summary>
     private readonly bool _isRequiredSubscribeOnCurrentThread;
 
     /// <summary>Initializes a new instance of the <see cref="CreateSafeSignal{T}"/> class.</summary>
-    /// <param name="subscribe">The subscribe value.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
     public CreateSafeSignal(Func<IObserver<T>, IDisposable> subscribe) => _subscribe = subscribe;
 
     /// <summary>Initializes a new instance of the <see cref="CreateSafeSignal{T}"/> class.</summary>
-    /// <param name="subscribe">The subscribe value.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">The isRequiredSubscribeOnCurrentThread value.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
     public CreateSafeSignal(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
     {
         _subscribe = subscribe;
         _isRequiredSubscribeOnCurrentThread = isRequiredSubscribeOnCurrentThread;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports whether subscription must be dispatched through the current-thread sequencer.</summary>
+    /// <returns><see langword="true"/> when current-thread dispatch is required.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _isRequiredSubscribeOnCurrentThread;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with a sink wrapping the observer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that releases the subscription.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -55,10 +56,10 @@ public IDisposable Subscribe(IObserver<T> observer)
         return sink;
     }
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with a sink that owns <paramref name="cancel"/>.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable returned by the subscribe delegate.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         CreateSink<T> sink = new(observer, cancel, true);
diff --git a/src/Primitives.Shared/Advanced/CreateSignal{T,TState}.cs b/src/Primitives.Shared/Advanced/CreateSignal{T,TState}.cs
index d7c276b7..b67b18fb 100644
--- a/src/Primitives.Shared/Advanced/CreateSignal{T,TState}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSignal{T,TState}.cs
@@ -10,23 +10,23 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the CreateSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
-/// <typeparam name="TState">The TState type.</typeparam>
+/// <summary>Creates a signal from a subscribe delegate that receives a caller-supplied state value.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <typeparam name="TState">The state type handed to the subscribe delegate.</typeparam>
 internal sealed class CreateSignal<T, TState> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The state handed to the subscribe delegate.</summary>
     private readonly TState _state;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The delegate invoked for each subscription.</summary>
     private readonly Func<TState, IObserver<T>, IDisposable> _subscribe;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether subscription must be dispatched through the current-thread sequencer.</summary>
     private readonly bool _currentThreadRequired;
 
     /// <summary>Initializes a new instance of the <see cref="CreateSignal{T,TState}"/> class.</summary>
-    /// <param name="state">The state value.</param>
-    /// <param name="subscribe">The subscribe value.</param>
+    /// <param name="state">The state handed to the subscribe delegate.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
     public CreateSignal(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)
     {
         _state = state;
@@ -34,9 +34,9 @@ public CreateSignal(TState state, Func<TState, IObserver<T>, IDisposable> subscr
     }
 
     /// <summary>Initializes a new instance of the <see cref="CreateSignal{T,TState}"/> class.</summary>
-    /// <param name="state">The state value.</param>
-    /// <param name="subscribe">The subscribe value.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">The isRequiredSubscribeOnCurrentThread value.</param>
+    /// <param name="state">The state handed to the subscribe delegate.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
     public CreateSignal(
         TState state,
         Func<TState, IObserver<T>, IDisposable> subscribe,
@@ -47,43 +47,43 @@ public CreateSignal(
         _currentThreadRequired = isRequiredSubscribeOnCurrentThread;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports whether subscription must be dispatched through the current-thread sequencer.</summary>
+    /// <returns><see langword="true"/> when current-thread dispatch is required.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _currentThreadRequired;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with the state and a wrapper around the observer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that releases the subscription.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, _currentThreadRequired, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with a wrapper that owns <paramref name="cancel"/>.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable returned by the subscribe delegate.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new Create(observer, cancel);
         return _subscribe(_state, observer) ?? EmptyDisposable.Instance;
     }
 
-    /// <summary>Represents the Create class.</summary>
+    /// <summary>Forwards notifications downstream and releases the subscription on termination.</summary>
     private sealed class Create : IObserver<T>, IDisposable
     {
-        /// <summary>Stores the downstream observer.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer;
 
-        /// <summary>Stores the upstream subscription.</summary>
+        /// <summary>The outer subscription handle released on teardown.</summary>
         private IDisposable? _cancel;
 
         /// <summary>Disposed latch; 0 when alive, 1 once disposed.</summary>
         private int _disposed;
 
         /// <summary>Initializes a new instance of the <see cref="Create"/> class.</summary>
-        /// <param name="observer">The observer value.</param>
-        /// <param name="cancel">The cancel value.</param>
+        /// <param name="observer">The downstream observer.</param>
+        /// <param name="cancel">The outer subscription handle.</param>
         /// <exception cref="ArgumentNullException"><paramref name="cancel"/> is <see langword="null"/>.</exception>
         public Create(IObserver<T> observer, IDisposable cancel)
         {
@@ -91,13 +91,13 @@ public Create(IObserver<T> observer, IDisposable cancel)
             _observer = observer;
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
-        /// <param name="value">The value.</param>
+        /// <summary>Forwards a value downstream.</summary>
+        /// <param name="value">The value to forward.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(T value) => _observer.OnNext(value);
 
-        /// <summary>Executes the OnError operation.</summary>
-        /// <param name="error">The error value.</param>
+        /// <summary>Forwards the error downstream and releases the subscription.</summary>
+        /// <param name="error">The error to forward.</param>
         public void OnError(Exception error)
         {
             try
@@ -110,7 +110,7 @@ public void OnError(Exception error)
             }
         }
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Completes downstream and releases the subscription.</summary>
         public void OnCompleted()
         {
             try
@@ -123,7 +123,7 @@ public void OnCompleted()
             }
         }
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Releases the outer subscription handle once.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose() => WitnessTeardown.Dispose(ref _disposed, ref _cancel);
     }
diff --git a/src/Primitives.Shared/Advanced/CreateSignal{T}.cs b/src/Primitives.Shared/Advanced/CreateSignal{T}.cs
index 6b6f49d9..cd12bbe7 100644
--- a/src/Primitives.Shared/Advanced/CreateSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSignal{T}.cs
@@ -10,37 +10,37 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the CreateSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Creates a signal from a caller-supplied subscribe delegate.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 internal sealed class CreateSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The delegate invoked for each subscription.</summary>
     private readonly Func<IObserver<T>, IDisposable> _subscribe;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether subscription must be dispatched through the current-thread sequencer.</summary>
     private readonly bool _currentThreadRequired;
 
     /// <summary>Initializes a new instance of the <see cref="CreateSignal{T}"/> class.</summary>
-    /// <param name="subscribe">The subscribe value.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
     public CreateSignal(Func<IObserver<T>, IDisposable> subscribe) => _subscribe = subscribe;
 
     /// <summary>Initializes a new instance of the <see cref="CreateSignal{T}"/> class.</summary>
-    /// <param name="subscribe">The subscribe value.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">The isRequiredSubscribeOnCurrentThread value.</param>
+    /// <param name="subscribe">The delegate invoked for each subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
     public CreateSignal(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
     {
         _subscribe = subscribe;
         _currentThreadRequired = isRequiredSubscribeOnCurrentThread;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports whether subscription must be dispatched through the current-thread sequencer.</summary>
+    /// <returns><see langword="true"/> when current-thread dispatch is required.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _currentThreadRequired;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with a sink wrapping the observer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that releases the subscription.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -55,10 +55,10 @@ public IDisposable Subscribe(IObserver<T> observer)
         return sink;
     }
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the subscribe delegate with a sink that owns <paramref name="cancel"/>.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable returned by the subscribe delegate.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         CreateSink<T> sink = new(observer, cancel, false);
diff --git a/src/Primitives.Shared/Advanced/CreateSink{T}.cs b/src/Primitives.Shared/Advanced/CreateSink{T}.cs
index 21ebdf29..234c4735 100644
--- a/src/Primitives.Shared/Advanced/CreateSink{T}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSink{T}.cs
@@ -11,10 +11,9 @@ namespace ReactiveUI.Primitives.Advanced;
 #endif
 
 /// <summary>
-/// The observer handed to create-style subscription factories: forwards until terminated, owns the factory's
-/// cancel resource, and optionally releases it when a downstream <c>OnNext</c> throws (the safe-create contract).
-/// The shared sink behind <see cref="CreateSignal{T}"/> and <see cref="CreateSafeSignal{T}"/>, usable by any
-/// implementation that hands an observer to a caller-supplied subscribe delegate.
+/// The observer handed to create-style subscription factories. It forwards notifications until terminated and owns
+/// the cancel resource the factory returns; when constructed with <c>disposeOnNextThrow</c> it also releases that
+/// resource before rethrowing if a downstream <c>OnNext</c> throws.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("CreateSink: Stopped = {_stopped}, Observer = {_observer}")]
@@ -60,7 +59,7 @@ public CreateSink(IObserver<T> observer, IDisposable cancel, bool disposeOnNextT
         _disposeOnNextThrow = disposeOnNextThrow;
     }
 
-    /// <summary>Assigns the cancellation resource, releasing it immediately when already stopped.</summary>
+    /// <summary>Assigns the cancellation resource, releasing it immediately when the sink has stopped.</summary>
     /// <param name="cancel">Cancellation resource.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetCancel(IDisposable cancel) =>
diff --git a/src/Primitives.Shared/Advanced/DeferSignal{T}.cs b/src/Primitives.Shared/Advanced/DeferSignal{T}.cs
index 91db3726..b0dec20d 100644
--- a/src/Primitives.Shared/Advanced/DeferSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/DeferSignal{T}.cs
@@ -10,33 +10,33 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the DeferSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Invokes a factory per subscription and subscribes the observer to the observable it returns.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 internal sealed class DeferSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The factory invoked for each subscription.</summary>
     private readonly Func<IObservable<T>> _observableFactory;
 
     /// <summary>Initializes a new instance of the <see cref="DeferSignal{T}"/> class.</summary>
-    /// <param name="observableFactory">The observableFactory value.</param>
+    /// <param name="observableFactory">The factory invoked for each subscription.</param>
     public DeferSignal(Func<IObservable<T>> observableFactory) => _observableFactory = observableFactory;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription needs no current-thread dispatch.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the observer to the observable produced for this subscription.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that releases the subscription.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, false, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes the factory and subscribes, turning a factory throw into an error notification.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The subscription to the produced observable.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
diff --git a/src/Primitives.Shared/Advanced/EmitIfQuietSignal{T}.cs b/src/Primitives.Shared/Advanced/EmitIfQuietSignal{T}.cs
index 7d313418..3b037e8a 100644
--- a/src/Primitives.Shared/Advanced/EmitIfQuietSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/EmitIfQuietSignal{T}.cs
@@ -16,7 +16,7 @@ public sealed class EmitIfQuietSignal<T> : IObservable<T>
     /// <summary>Initializes a new instance of the <see cref="EmitIfQuietSignal{T}"/> class.</summary>
     /// <param name="source">The source observable.</param>
     /// <param name="dueTime">The quiet period before emitting the latest value.</param>
-    /// <param name="sequencer">The sequencer used to schedule delayed emissions.</param>
+    /// <param name="sequencer">The sequencer that schedules delayed emissions.</param>
     /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="sequencer"/> is <see langword="null"/>.</exception>
     public EmitIfQuietSignal(IObservable<T> source, TimeSpan dueTime, ISequencer sequencer)
     {
@@ -31,7 +31,7 @@ public EmitIfQuietSignal(IObservable<T> source, TimeSpan dueTime, ISequencer seq
     /// <summary>Gets the quiet period before emitting the latest value.</summary>
     private TimeSpan DueTime { get; }
 
-    /// <summary>Gets the sequencer used to schedule delayed emissions.</summary>
+    /// <summary>Gets the sequencer that schedules delayed emissions.</summary>
     private ISequencer Sequencer { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/EmitIfQuietWitness{T}.cs b/src/Primitives.Shared/Advanced/EmitIfQuietWitness{T}.cs
index 0aa0e3e9..2db5c71f 100644
--- a/src/Primitives.Shared/Advanced/EmitIfQuietWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/EmitIfQuietWitness{T}.cs
@@ -21,7 +21,7 @@ public sealed class EmitIfQuietWitness<T> : IObserver<T>, IDisposable
     /// <summary>The latest observed value.</summary>
     private T? _latest;
 
-    /// <summary>Monotonic version used to suppress obsolete scheduled emissions.</summary>
+    /// <summary>Monotonic version that suppresses obsolete scheduled emissions.</summary>
     private long _version;
 
     /// <summary>Whether a latest value is pending emission.</summary>
@@ -33,7 +33,7 @@ public sealed class EmitIfQuietWitness<T> : IObserver<T>, IDisposable
     /// <summary>Initializes a new instance of the <see cref="EmitIfQuietWitness{T}"/> class.</summary>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="dueTime">The quiet period before emitting the latest value.</param>
-    /// <param name="sequencer">The sequencer used to schedule delayed emissions.</param>
+    /// <param name="sequencer">The sequencer that schedules delayed emissions.</param>
     /// <exception cref="ArgumentNullException"><paramref name="observer"/> or <paramref name="sequencer"/> is <see langword="null"/>.</exception>
     public EmitIfQuietWitness(IObserver<T> observer, TimeSpan dueTime, ISequencer sequencer)
     {
@@ -48,7 +48,7 @@ public EmitIfQuietWitness(IObserver<T> observer, TimeSpan dueTime, ISequencer se
     /// <summary>Gets the quiet period before emitting the latest value.</summary>
     private TimeSpan DueTime { get; }
 
-    /// <summary>Gets the sequencer used to schedule delayed emissions.</summary>
+    /// <summary>Gets the sequencer that schedules delayed emissions.</summary>
     private ISequencer Sequencer { get; }
 
     /// <summary>Gets the source subscription and scheduled delayed emissions.</summary>
@@ -125,7 +125,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Emits the latest value if the scheduled version is still current.</summary>
+    /// <summary>Emits the latest value when the scheduled version is the current one.</summary>
     /// <param name="scheduledVersion">The version captured when the emission was scheduled.</param>
     private void EmitIfLatest(long scheduledVersion)
     {
@@ -158,7 +158,7 @@ private bool TryRecord(T value, out long currentVersion)
         }
     }
 
-    /// <summary>Marks the observer as stopped if it has not already stopped.</summary>
+    /// <summary>Transitions the observer to the stopped state.</summary>
     /// <returns><see langword="true"/> when this call stopped the observer.</returns>
     private bool TryMarkStopped()
     {
diff --git a/src/Primitives.Shared/Advanced/EmptySignal{T}.cs b/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
index 8451a01f..bf749610 100644
--- a/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
@@ -10,34 +10,34 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the EmptySignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Completes without emitting a value, delivering completion on the supplied sequencer.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("EmptySignal: Scheduler = {_scheduler}")]
 public sealed class EmptySignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer that delivers completion.</summary>
     private readonly ISequencer _scheduler;
 
     /// <summary>Initializes a new instance of the <see cref="EmptySignal{T}"/> class.</summary>
-    /// <param name="scheduler">The scheduler value.</param>
+    /// <param name="scheduler">The sequencer that delivers completion.</param>
     public EmptySignal(ISequencer scheduler) => _scheduler = scheduler;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription needs no current-thread dispatch.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the observer and arranges its completion.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that cancels a completion not yet delivered.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, false, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Completes the observer inline on the immediate sequencer, otherwise schedules the completion.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable that cancels a scheduled completion.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
diff --git a/src/Primitives.Shared/Advanced/EverySignal.cs b/src/Primitives.Shared/Advanced/EverySignal.cs
index cb313d55..458ea6ca 100644
--- a/src/Primitives.Shared/Advanced/EverySignal.cs
+++ b/src/Primitives.Shared/Advanced/EverySignal.cs
@@ -10,19 +10,16 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Dedicated signal for the interval timer factory (<c>Every</c>), replacing the self-referencing
-/// <c>CreateSafe</c> closure with a coordinator that reschedules itself through a method group.
-/// </summary>
+/// <summary>Emits an incrementing tick at a fixed interval for the <c>Every</c> factory.</summary>
 /// <param name="period">The interval between ticks.</param>
-/// <param name="scheduler">The sequencer used to schedule ticks.</param>
+/// <param name="scheduler">The sequencer that schedules ticks.</param>
 [System.Diagnostics.DebuggerDisplay("EverySignal: Period = {_period}, Scheduler = {_scheduler}")]
 public sealed class EverySignal(TimeSpan period, ISequencer scheduler) : IRequireCurrentThread<long>
 {
     /// <summary>The interval between ticks.</summary>
     private readonly TimeSpan _period = period;
 
-    /// <summary>The sequencer used to schedule ticks.</summary>
+    /// <summary>The sequencer that schedules ticks.</summary>
     private readonly ISequencer _scheduler = scheduler;
 
     /// <inheritdoc/>
@@ -50,13 +47,13 @@ public IDisposable Subscribe(IObserver<long> observer)
         return subscription;
     }
 
-    /// <summary>Reschedules the recurring tick without a captured closure.</summary>
+    /// <summary>Emits each tick and re-arms the schedule for the following one.</summary>
     private sealed class EveryCoordinator : IDisposable
     {
         /// <summary>The downstream observer.</summary>
         private readonly IObserver<long> _observer;
 
-        /// <summary>The sequencer used to schedule ticks.</summary>
+        /// <summary>The sequencer that schedules ticks.</summary>
         private readonly ISequencer _scheduler;
 
         /// <summary>The interval between ticks.</summary>
@@ -73,7 +70,7 @@ private sealed class EveryCoordinator : IDisposable
 
         /// <summary>Initializes a new instance of the <see cref="EveryCoordinator"/> class.</summary>
         /// <param name="observer">The downstream observer.</param>
-        /// <param name="scheduler">The sequencer used to schedule ticks.</param>
+        /// <param name="scheduler">The sequencer that schedules ticks.</param>
         /// <param name="period">The interval between ticks.</param>
         internal EveryCoordinator(IObserver<long> observer, ISequencer scheduler, TimeSpan period)
         {
@@ -100,14 +97,9 @@ internal EveryCoordinator Run()
         private void ScheduleNext() => TimerSlot.Arm(_slot, _scheduler, _period, _tickAction);
 
         /// <summary>Emits the current tick and reschedules unless cancelled.</summary>
-        /// <remarks>
-        /// Disposal is tested before the emit as well as after it. A cancelled subscription must not deliver another
-        /// value, and the sequencer's own cancellation check happens before the item is invoked, not before the
-        /// observer is called. The second test covers an observer that disposes the subscription from inside
-        /// <see cref="IObserver{T}.OnNext"/>, which must stop the recurring schedule rather than re-arm it.
-        /// </remarks>
         private void Tick()
         {
+            // The sequencer checks cancellation before invoking this item, not before the observer is called.
             if (_slot.IsDisposed)
             {
                 return;
@@ -116,6 +108,8 @@ private void Tick()
             var tick = _tick;
             _tick++;
             _observer.OnNext(tick);
+
+            // An observer that disposes from inside OnNext must stop the schedule rather than re-arm it.
             if (_slot.IsDisposed)
             {
                 return;
diff --git a/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs b/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
index 2aba4628..f96303f0 100644
--- a/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
@@ -22,7 +22,7 @@ public sealed class ExpireCoordinator<T> : IObserver<T>, IDisposable
     /// <summary>The timeout period.</summary>
     private readonly TimeSpan _dueTime;
 
-    /// <summary>The sequencer used to schedule the timeout.</summary>
+    /// <summary>The sequencer that schedules the timeout.</summary>
     private readonly ISequencer _sequencer;
 
     /// <summary>The downstream observer.</summary>
@@ -32,35 +32,33 @@ public sealed class ExpireCoordinator<T> : IObserver<T>, IDisposable
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Usage",
         "CA2213:Disposable fields should be disposed",
-        Justification =
-            "Disposed via the thread-safe Interlocked.Exchange teardown in Dispose; CA2213 does not recognize disposal of a field through Interlocked.Exchange.")]
+        Justification = "Disposed through Interlocked.Exchange in Dispose.")]
     private IDisposable? _subscription;
 
     /// <summary>The active timeout timer.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Usage",
         "CA2213:Disposable fields should be disposed",
-        Justification =
-            "Disposed via the thread-safe Interlocked.Exchange teardown in Dispose; CA2213 does not recognize disposal of a field through Interlocked.Exchange.")]
+        Justification = "Disposed through Interlocked.Exchange in Dispose.")]
     private IDisposable? _timer;
 
     /// <summary>A value indicating whether the timeout or source has terminated.</summary>
     private int _done;
 
-    /// <summary>Monotonic version used to suppress timeouts superseded by a newer value.</summary>
+    /// <summary>Monotonic version that suppresses timeouts superseded by a newer value.</summary>
     private long _epoch;
 
     /// <summary>
-    /// The instant, on the sequencer's own clock, at which the current inactivity window closes. Read and written
-    /// under <see cref="_gate"/>. Starts at <see cref="DateTimeOffset.MaxValue"/> so a window that has not been
-    /// published yet can never expire a value.
+    /// The instant on the sequencer's clock at which the current inactivity window closes, read and written under
+    /// <see cref="_gate"/>. It starts at <see cref="DateTimeOffset.MaxValue"/> so an unpublished window never
+    /// expires a value.
     /// </summary>
     private DateTimeOffset _deadline = DateTimeOffset.MaxValue;
 
     /// <summary>Initializes a new instance of the <see cref="ExpireCoordinator{T}"/> class.</summary>
     /// <param name="source">The source observable.</param>
     /// <param name="dueTime">The timeout period.</param>
-    /// <param name="sequencer">The sequencer used to schedule the timeout.</param>
+    /// <param name="sequencer">The sequencer that schedules the timeout.</param>
     /// <param name="observer">The downstream observer.</param>
     public ExpireCoordinator(IObservable<T> source, TimeSpan dueTime, ISequencer sequencer, IObserver<T> observer)
     {
@@ -140,11 +138,9 @@ public void OnError(Exception error)
 
     /// <inheritdoc/>
     /// <remarks>
-    /// A value is on time only when it arrives before the current inactivity window closes, which is a question for
-    /// the sequencer's clock — not for whether the armed timer has run yet. The timer is dispatched by the sequencer,
-    /// and a thread-pool sequencer whose pool is saturated can dispatch it arbitrarily late while a source on another
-    /// thread keeps producing. Forwarding a value in that gap would deliver a value the operator has already promised
-    /// to time out, so a value that arrives after its deadline expires the sequence here instead.
+    /// A value is on time only when it arrives before the inactivity window closes on the sequencer's clock, not
+    /// merely before the armed timer has run. A value that arrives past its deadline — which a saturated thread-pool
+    /// sequencer can allow — terminates the sequence with <see cref="TimeoutException"/> instead of being forwarded.
     /// </remarks>
     public void OnNext(T value)
     {
@@ -204,10 +200,10 @@ public ExpireCoordinator<T> Run()
     }
 
     /// <summary>Schedules a fresh inactivity timer for the given epoch and discards the in-flight one.</summary>
-    /// <param name="epoch">The version this timer must still match to fire.</param>
-    /// <remarks>Scheduled outside the gate to avoid reentrant <see cref="Lock"/> acquisition on a synchronous
-    /// sequencer; the publish is re-checked under the gate so a timer never survives a terminal notification, and
-    /// so a superseded arm cannot publish its older deadline and timer over a newer value's.</remarks>
+    /// <param name="epoch">The version this timer must match to fire.</param>
+    /// <remarks>Scheduling happens outside the gate so a synchronous sequencer cannot re-enter <see cref="Lock"/>.
+    /// The publish is re-checked under the gate, so neither a terminal notification nor a newer value's window can be
+    /// overwritten by a superseded arm.</remarks>
     private void ArmTimer(long epoch)
     {
         var deadline = Deadline();
@@ -232,13 +228,11 @@ private void ArmTimer(long epoch)
         previous?.Dispose();
     }
 
-    /// <summary>Computes the instant the inactivity window opened now would close at.</summary>
+    /// <summary>Computes the closing instant of an inactivity window opened at the current time.</summary>
     /// <returns>The deadline on the sequencer's clock, saturated instead of overflowing.</returns>
     /// <remarks>
-    /// A due time that normalizes to zero is scheduled as immediate work rather than timed work, so it has no clock
-    /// window: the timeout is ordered by the sequencer's queue, and a synchronous value that arrives before the queue
-    /// drains still wins. That branch mirrors the scheduling extension's own zero-due-time path, keeping the deadline
-    /// in lockstep with how the timer was actually scheduled. Only a positive due time opens a window on the clock.
+    /// A due time that normalizes to zero is queued as immediate work, so it opens no clock window and a synchronous
+    /// value arriving before the queue drains wins; only a positive due time yields a real deadline.
     /// </remarks>
     private DateTimeOffset Deadline()
     {
@@ -252,7 +246,7 @@ private DateTimeOffset Deadline()
         return DateTimeOffset.MaxValue - now <= dueTime ? DateTimeOffset.MaxValue : now + dueTime;
     }
 
-    /// <summary>Emits the timeout error when the firing timer is still current.</summary>
+    /// <summary>Emits the timeout error when the firing timer is the current one.</summary>
     /// <param name="epoch">The version captured when the firing timer was armed.</param>
     /// <returns>An empty disposable.</returns>
     private EmptyDisposable EmitTimeout(long epoch)
diff --git a/src/Primitives.Shared/Advanced/ExpireSignal{T}.cs b/src/Primitives.Shared/Advanced/ExpireSignal{T}.cs
index 9011b5c1..a4c31459 100644
--- a/src/Primitives.Shared/Advanced/ExpireSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ExpireSignal{T}.cs
@@ -8,7 +8,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Timeout signal with a direct subscription path.</summary>
+/// <summary>Terminates with a <see cref="TimeoutException"/> when the source stays quiet longer than the timeout period.</summary>
 /// <typeparam name="T">The source value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ExpireSignal: DueTime = {_dueTime}, Source = {_source}")]
 public sealed class ExpireSignal<T> : IRequireCurrentThread<T>
@@ -19,13 +19,13 @@ public sealed class ExpireSignal<T> : IRequireCurrentThread<T>
     /// <summary>The timeout period.</summary>
     private readonly TimeSpan _dueTime;
 
-    /// <summary>The sequencer used to schedule the timeout.</summary>
+    /// <summary>The sequencer that schedules the timeout.</summary>
     private readonly ISequencer _sequencer;
 
     /// <summary>Initializes a new instance of the <see cref="ExpireSignal{T}"/> class.</summary>
     /// <param name="source">The source observable.</param>
     /// <param name="dueTime">The timeout period.</param>
-    /// <param name="sequencer">The sequencer used to schedule the timeout.</param>
+    /// <param name="sequencer">The sequencer that schedules the timeout.</param>
     public ExpireSignal(IObservable<T> source, TimeSpan dueTime, ISequencer sequencer)
     {
         ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/Primitives.Shared/Advanced/FinallySignal{T}.cs b/src/Primitives.Shared/Advanced/FinallySignal{T}.cs
index 8e739889..7a339c83 100644
--- a/src/Primitives.Shared/Advanced/FinallySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/FinallySignal{T}.cs
@@ -10,58 +10,58 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the FinallySignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
-/// <param name="source">The source value.</param>
-/// <param name="finallyAction">The finallyAction value.</param>
+/// <summary>Runs an action once the subscription ends, whether it terminated or was disposed.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="finallyAction">The action run when the subscription ends.</param>
 [System.Diagnostics.DebuggerDisplay("FinallySignal: Source = {_source}")]
 public sealed class FinallySignal<T>(IObservable<T> source, Action finallyAction) : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The source observable.</summary>
     private readonly IObservable<T> _source = source;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The action run when the subscription ends.</summary>
     private readonly Action _finallyAction = finallyAction;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription runs on the calling thread.</summary>
+    /// <returns>Always <see langword="true"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => true;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the observer and attaches the end-of-subscription action.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that releases the subscription and runs the action.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, true, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Creates the handler that forwards notifications and owns the end-of-subscription action.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable that releases the subscription and runs the action.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel) =>
         new Finally(this, observer, cancel).Run();
 
-    /// <summary>Represents the Finally class.</summary>
+    /// <summary>Forwards notifications downstream and pairs the subscription with the end-of-subscription action.</summary>
     private sealed class Finally : IObserver<T>, IDisposable
     {
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The signal supplying the source and the action.</summary>
         private readonly FinallySignal<T> _parent;
 
-        /// <summary>Stores the downstream observer.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer;
 
-        /// <summary>Stores the upstream subscription.</summary>
+        /// <summary>The outer subscription handle released on teardown.</summary>
         private IDisposable? _cancel;
 
         /// <summary>Disposed latch; 0 when alive, 1 once disposed.</summary>
         private int _disposed;
 
         /// <summary>Initializes a new instance of the <see cref="Finally"/> class.</summary>
-        /// <param name="parent">The parent value.</param>
-        /// <param name="observer">The observer value.</param>
-        /// <param name="cancel">The cancel value.</param>
+        /// <param name="parent">The signal supplying the source and the action.</param>
+        /// <param name="observer">The downstream observer.</param>
+        /// <param name="cancel">The outer subscription handle.</param>
         /// <exception cref="ArgumentNullException"><paramref name="cancel"/> is <see langword="null"/>.</exception>
         public Finally(FinallySignal<T> parent, IObserver<T> observer, IDisposable cancel)
         {
@@ -70,8 +70,8 @@ public Finally(FinallySignal<T> parent, IObserver<T> observer, IDisposable cance
             _parent = parent;
         }
 
-        /// <summary>Executes the Run operation.</summary>
-        /// <returns>The result.</returns>
+        /// <summary>Subscribes to the source, running the action immediately if subscription throws.</summary>
+        /// <returns>The disposable that releases the source subscription and then runs the action.</returns>
         public MultipleDisposable Run()
         {
             IDisposable subscription;
@@ -88,13 +88,13 @@ public MultipleDisposable Run()
             return new(subscription, new ActionDisposable(() => _parent._finallyAction()));
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
-        /// <param name="value">The value.</param>
+        /// <summary>Forwards a value downstream.</summary>
+        /// <param name="value">The value to forward.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(T value) => _observer.OnNext(value);
 
-        /// <summary>Executes the OnError operation.</summary>
-        /// <param name="error">The error value.</param>
+        /// <summary>Forwards the error downstream and releases the subscription.</summary>
+        /// <param name="error">The error to forward.</param>
         public void OnError(Exception error)
         {
             try
@@ -107,7 +107,7 @@ public void OnError(Exception error)
             }
         }
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Completes downstream and releases the subscription.</summary>
         public void OnCompleted()
         {
             try
@@ -120,7 +120,7 @@ public void OnCompleted()
             }
         }
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Releases the outer subscription handle once.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose() => WitnessTeardown.Dispose(ref _disposed, ref _cancel);
     }
diff --git a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
index 615fd62e..8bf1e500 100644
--- a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
+++ b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
@@ -110,7 +110,7 @@ internal IDisposable Start()
         return this;
     }
 
-    /// <summary>Forwards a task that has already reached a terminal state.</summary>
+    /// <summary>Forwards a task that has reached a terminal state.</summary>
     /// <param name="task">The task to observe.</param>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="lifetime">The subscription lifetime.</param>
@@ -120,7 +120,7 @@ internal IDisposable Start()
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification = "Synchronous read is limited to the already-completed task fast path.")]
+        Justification = "Synchronous read is limited to a task in a terminal state.")]
     private static bool TryCompleteSynchronously(
         Task<T> task,
         IObserver<T> observer,
@@ -145,7 +145,7 @@ private static bool TryCompleteSynchronously(
             : task.IsFaulted && FaultSynchronously(task, observer, lifetime, externalCancellation, linkedSource);
     }
 
-    /// <summary>Forwards an already-successful task result.</summary>
+    /// <summary>Forwards a successful task result.</summary>
     /// <param name="value">The task result.</param>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="lifetime">The subscription lifetime.</param>
@@ -171,7 +171,7 @@ private static bool CompleteSynchronously(
         return true;
     }
 
-    /// <summary>Forwards an already-canceled task result.</summary>
+    /// <summary>Forwards a canceled task result.</summary>
     /// <param name="task">The task to observe.</param>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="lifetime">The subscription lifetime.</param>
@@ -202,7 +202,7 @@ private static bool CancelSynchronously(
         return true;
     }
 
-    /// <summary>Forwards an already-faulted task result.</summary>
+    /// <summary>Forwards a faulted task result.</summary>
     /// <param name="task">The task to observe.</param>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="lifetime">The subscription lifetime.</param>
diff --git a/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs b/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
index 7f78774d..fb04d930 100644
--- a/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
@@ -9,9 +9,9 @@ namespace ReactiveUI.Primitives.Advanced;
 #endif
 
 /// <summary>
-/// Bridges an event whose handler is built by a caller-supplied conversion, so the handler can do
-/// synchronous work inside the event before the notification is published downstream. Supplying the
-/// conversion removes the need to derive a delegate reflectively, keeping the bridge trim- and AOT-safe.
+/// Bridges an event whose handler is built by a caller-supplied conversion, letting the handler do synchronous work
+/// inside the event before the notification is published downstream. The conversion replaces reflective delegate
+/// creation, so the bridge is trim- and AOT-safe.
 /// </summary>
 /// <typeparam name="TEventHandler">The delegate type used by the event.</typeparam>
 /// <typeparam name="TCallback">The notification callback type handed to the conversion.</typeparam>
diff --git a/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs b/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
index 80542e27..0f283e61 100644
--- a/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
@@ -12,17 +12,16 @@ namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
 /// Forwarding observer that releases its upstream cancel resource when the sequence terminates or a downstream
-/// <c>OnNext</c> throws. The shared guard behind the scheduled factory signals (Empty, Return, Throw, Defer),
-/// usable by any signal implementation that needs terminate-and-release semantics around a downstream observer.
+/// <c>OnNext</c> throws, rethrowing the latter after release.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("GuardedWitness: Disposed = {_disposed}, Observer = {_observer}")]
 public sealed class GuardedWitness<T> : IObserver<T>, IDisposable
 {
-    /// <summary>Stores the downstream observer.</summary>
+    /// <summary>The downstream observer.</summary>
     private readonly IObserver<T> _observer;
 
-    /// <summary>Stores the upstream subscription.</summary>
+    /// <summary>The upstream cancel resource released on termination.</summary>
     private IDisposable? _cancel;
 
     /// <summary>Disposed latch; 0 when alive, 1 once disposed.</summary>
diff --git a/src/Primitives.Shared/Advanced/ImmutableReturnRxVoidSignal.cs b/src/Primitives.Shared/Advanced/ImmutableReturnRxVoidSignal.cs
index fc74becb..2f08e582 100644
--- a/src/Primitives.Shared/Advanced/ImmutableReturnRxVoidSignal.cs
+++ b/src/Primitives.Shared/Advanced/ImmutableReturnRxVoidSignal.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>An allocation-free observable that emits a single value and then completes; the concrete singleton backing for the RxVoid emit path.</summary>
+/// <summary>Emits <see cref="RxVoid.Default"/> inline and completes, without allocating a subscription.</summary>
 public sealed class ImmutableReturnRxVoidSignal : IRequireCurrentThread<RxVoid>, IInlineSignal<RxVoid>
 {
     /// <summary>The shared singleton instance.</summary>
@@ -21,14 +21,14 @@ private ImmutableReturnRxVoidSignal()
     {
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription needs no current-thread dispatch.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits <see cref="RxVoid.Default"/> and completes before returning.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>An empty disposable; the sequence has ended and there is nothing to cancel.</returns>
     public IDisposable Subscribe(IObserver<RxVoid> observer)
     {
         observer.OnNext(RxVoid.Default);
@@ -36,11 +36,11 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with <see cref="RxVoid.Default"/> and then <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">The value callback.</param>
+    /// <param name="onError">The error callback, which is never invoked.</param>
+    /// <param name="onCompleted">The completion callback.</param>
+    /// <returns>An empty disposable; the sequence has ended and there is nothing to cancel.</returns>
     public IDisposable Subscribe(Action<RxVoid> onNext, Action<Exception> onError, Action onCompleted)
     {
         onNext(RxVoid.Default);
diff --git a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
index 27fe3ebe..4ebd7d17 100644
--- a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
@@ -48,11 +48,10 @@ public IDisposable Subscribe(IObserver<bool> observer)
             return EmptyDisposable.Instance;
         }
 
-        // The first value settles this operator, so it must be able to dispose the source as soon as one arrives.
-        // A current-thread source runs its work on the trampoline of whichever call enters it first; if that call is
-        // the source's own Subscribe, the source drains the trampoline before the sink is handed the subscription,
-        // and an endless source therefore never stops. Entering the trampoline here means the source only queues its
-        // first tick and returns, so the sink owns the subscription before that tick is delivered.
+        // The first value settles this operator, so the sink must own the subscription before any value arrives. A
+        // current-thread source drains the trampoline inside whichever call enters it first, so letting the source's
+        // own Subscribe enter it would deliver values before the sink holds the subscription, and an endless source
+        // would never stop. Entering the trampoline here leaves the source only able to queue its first tick.
         if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
         {
             return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/Advanced/IsEmptyWitness{T}.cs b/src/Primitives.Shared/Advanced/IsEmptyWitness{T}.cs
index e844fb89..640df4ca 100644
--- a/src/Primitives.Shared/Advanced/IsEmptyWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/IsEmptyWitness{T}.cs
@@ -15,7 +15,7 @@ namespace ReactiveUI.Primitives.Advanced;
 [System.Diagnostics.DebuggerDisplay("IsEmptyWitness: Stopped = {_stopped}, Subscription = {Subscription}")]
 public sealed class IsEmptyWitness<T> : IObserver<T>, IDisposable
 {
-    /// <summary>Stores the stopped flag for interlocked/ref helper calls.</summary>
+    /// <summary>Non-zero once the result has been emitted or the sink disposed.</summary>
     private int _stopped;
 
     /// <summary>Initializes a new instance of the <see cref="IsEmptyWitness{T}"/> class.</summary>
diff --git a/src/Primitives.Shared/Advanced/LoopSignal{T}.cs b/src/Primitives.Shared/Advanced/LoopSignal{T}.cs
index 23c50a2d..4fadc5f8 100644
--- a/src/Primitives.Shared/Advanced/LoopSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/LoopSignal{T}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents an infinite repetition signal.</summary>
+/// <summary>Emits the same value endlessly until the subscription is disposed.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("LoopSignal: Value = {Value}")]
 public sealed class LoopSignal<T> : IRequireCurrentThread<T>
@@ -29,14 +29,14 @@ public LoopSignal(T value)
     /// <summary>Gets the repeated value.</summary>
     internal T Value { get; }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription runs on the current-thread sequencer.</summary>
+    /// <returns>Always <see langword="true"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _currentThreadRequired;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the observer and starts the endless emission loop.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The disposable that stops the loop.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, _currentThreadRequired, SubscribeCore);
@@ -47,16 +47,15 @@ public IDisposable Subscribe(IObserver<T> observer) =>
     private static bool IsDisposed(IDisposable disposable) =>
         disposable is IsDisposed state && state.IsDisposed;
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Schedules the recursive emission loop, which stops as soon as the handle is disposed.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The outer subscription handle.</param>
+    /// <returns>The disposable that cancels the scheduled loop.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Allocations",
         "PSH1011",
-        Justification =
-            "No state-taking recursive Schedule overload exists; needs new scheduling API or a rule exclusion.")]
+        Justification = "No state-taking recursive Schedule overload exists.")]
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel) =>
         Sequencer.CurrentThread.Schedule(self =>
         {
diff --git a/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs
index 1b2362dd..182c2070 100644
--- a/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Indexed map signal.</summary>
+/// <summary>Projects each source value together with its zero-based position in the sequence.</summary>
 /// <typeparam name="TSource">The source value type.</typeparam>
 /// <typeparam name="TResult">The projected value type.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
index 407d1e5a..2b8b016b 100644
--- a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
@@ -85,8 +85,8 @@ public void OnSource(IObservable<T>? source)
         }
 
         // A source is free to signal completion more than once. Latch per inner so a repeat cannot decrement
-        // the active count a second time - that would drop the count on behalf of a sibling that is still
-        // running and complete the merge early, losing everything the sibling had left to produce.
+        // the active count on behalf of a running sibling, which would complete the merge early and drop
+        // everything that sibling had left to produce.
         var completed = 0;
         Subscriptions.Add(source.Subscribe(
             OnInnerNext,
diff --git a/src/Primitives.Shared/Advanced/MergeSignal{T}.cs b/src/Primitives.Shared/Advanced/MergeSignal{T}.cs
index b2c94a23..27c3eb03 100644
--- a/src/Primitives.Shared/Advanced/MergeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/MergeSignal{T}.cs
@@ -8,7 +8,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Concrete signal for Rx-named merge overloads.</summary>
+/// <summary>Merges concurrent sources into one sequence, optionally bounding the active subscription count.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("MergeSignal: Sources = {Sources}, MaxConcurrent = {MaxConcurrent}")]
 public sealed class MergeSignal<T> : IObservable<T>
diff --git a/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs b/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
index 8d5f6f3f..52b55198 100644
--- a/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
+++ b/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
@@ -11,9 +11,9 @@ namespace ReactiveUI.Primitives.Advanced;
 #endif
 
 /// <summary>
-/// Dedicated cold signal for <c>Recover</c>/<c>Resume</c> (catch a typed error and switch to a
-/// handler-selected sequence). Replaces the witness-framework subject with a lightweight sink that
-/// holds its source and fallback subscriptions in two interlocked slots, with no composite disposable.
+/// Cold signal that mirrors the source and, on an error of type <typeparamref name="TException"/>, switches to
+/// the sequence the handler selects for it. Any other error, and an error thrown by the handler itself, is
+/// forwarded downstream unchanged.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <typeparam name="TException">The handled exception type.</typeparam>
diff --git a/src/Primitives.Shared/Advanced/RepeatSourceCoordinator{T}.cs b/src/Primitives.Shared/Advanced/RepeatSourceCoordinator{T}.cs
index a52696e0..07353aed 100644
--- a/src/Primitives.Shared/Advanced/RepeatSourceCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/RepeatSourceCoordinator{T}.cs
@@ -25,7 +25,7 @@ public sealed class RepeatSourceCoordinator<T> : IDisposable
     /// <summary>The active source subscription or queued resubscription.</summary>
     private readonly SingleReplaceableDisposable _active = new();
 
-    /// <summary>Guards synchronous completion while a subscription is still being assigned.</summary>
+    /// <summary>Guards completion raised synchronously while a subscription is being assigned.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>The remaining number of finite subscriptions.</summary>
diff --git a/src/Primitives.Shared/Advanced/RepeatSourceWitness{T}.cs b/src/Primitives.Shared/Advanced/RepeatSourceWitness{T}.cs
index 3e0f1725..2725a093 100644
--- a/src/Primitives.Shared/Advanced/RepeatSourceWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/RepeatSourceWitness{T}.cs
@@ -19,7 +19,7 @@ public sealed class RepeatSourceWitness<T> : IObserver<T>
     /// <summary>The source subscription generation.</summary>
     private readonly int _generation;
 
-    /// <summary>Tracks whether this source subscription has already terminated.</summary>
+    /// <summary>Latches to <c>1</c> once this source subscription has terminated.</summary>
     private int _terminated;
 
     /// <summary>Initializes a new instance of the <see cref="RepeatSourceWitness{T}"/> class.</summary>
diff --git a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
index d3e9f7d9..3ce907c8 100644
--- a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
@@ -11,9 +11,8 @@ namespace ReactiveUI.Primitives.Advanced;
 #endif
 
 /// <summary>
-/// Dedicated cold signal for <c>Resume</c> (continue with a fixed fallback sequence after any error). Holds the
-/// fallback observable directly so no per-subscription closure is allocated, mirroring the slot-based subscription
-/// management of <see cref="RecoverSignal{T, TException}"/>.
+/// Cold signal that mirrors the source and, when it produces any error, subscribes the fallback sequence in its
+/// place. The error is not forwarded downstream.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs b/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
index 13658ac5..5ea4ccb1 100644
--- a/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
@@ -10,23 +10,23 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>An observable that emits a single value then completes on the supplied scheduler; the concrete backing for the scheduled emit path.</summary>
+/// <summary>Emits a single value and then completes, on the supplied sequencer.</summary>
 /// <typeparam name="T">The emitted value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ReturnSignal: Value = {_value}, Scheduler = {_scheduler}")]
 public sealed class ReturnSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The value to emit.</summary>
     private readonly T _value;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer that emits the value and completion.</summary>
     private readonly ISequencer _scheduler;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether subscription must be dispatched through the current-thread sequencer.</summary>
     private readonly bool _currentThreadRequired;
 
     /// <summary>Initializes a new instance of the <see cref="ReturnSignal{T}"/> class.</summary>
-    /// <param name="value">The value.</param>
-    /// <param name="scheduler">The scheduler value.</param>
+    /// <param name="value">The value to emit.</param>
+    /// <param name="scheduler">The sequencer that emits the value and completion.</param>
     public ReturnSignal(T value, ISequencer scheduler)
     {
         _value = value;
@@ -34,22 +34,22 @@ public ReturnSignal(T value, ISequencer scheduler)
         _currentThreadRequired = scheduler == Sequencer.CurrentThread;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Gets whether subscription has to be dispatched through the current-thread sequencer.</summary>
+    /// <returns><see langword="true"/> when the supplied sequencer is the current-thread sequencer.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _currentThreadRequired;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes an observer that receives the value followed by completion.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>A disposable that cancels the emission when it has not run yet.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, _currentThreadRequired, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the value and completion inline for the immediate sequencer, otherwise on the sequencer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle the guard checks before forwarding.</param>
+    /// <returns>The disposable that cancels the scheduled emission.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
diff --git a/src/Primitives.Shared/Advanced/ScheduledEnumerableSignal{T}.cs b/src/Primitives.Shared/Advanced/ScheduledEnumerableSignal{T}.cs
index 94fc4418..c13b942d 100644
--- a/src/Primitives.Shared/Advanced/ScheduledEnumerableSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ScheduledEnumerableSignal{T}.cs
@@ -8,14 +8,14 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Scheduled enumerable-backed signal used by observable conversion overloads.</summary>
+/// <summary>Emits the values of an enumerable on the supplied sequencer, then completes.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ScheduledEnumerableSignal: Values = {Values}, Scheduler = {Scheduler}")]
 public sealed class ScheduledEnumerableSignal<T> : IObservable<T>
 {
     /// <summary>Initializes a new instance of the <see cref="ScheduledEnumerableSignal{T}"/> class.</summary>
     /// <param name="values">The values to emit.</param>
-    /// <param name="scheduler">The scheduler used to enumerate and emit the values.</param>
+    /// <param name="scheduler">The sequencer that enumerates and emits the values.</param>
     public ScheduledEnumerableSignal(IEnumerable<T> values, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(values);
@@ -29,7 +29,7 @@ public ScheduledEnumerableSignal(IEnumerable<T> values, ISequencer scheduler)
     /// <summary>Gets the values to emit.</summary>
     private IEnumerable<T> Values { get; }
 
-    /// <summary>Gets the scheduler used to enumerate and emit the values.</summary>
+    /// <summary>Gets the sequencer that enumerates and emits the values.</summary>
     private ISequencer Scheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/SequenceSignal.cs b/src/Primitives.Shared/Advanced/SequenceSignal.cs
index f75ef73c..899143a4 100644
--- a/src/Primitives.Shared/Advanced/SequenceSignal.cs
+++ b/src/Primitives.Shared/Advanced/SequenceSignal.cs
@@ -15,7 +15,7 @@ public sealed class SequenceSignal : IRequireCurrentThread<int>
     /// <summary>Initializes a new instance of the <see cref="SequenceSignal"/> class.</summary>
     /// <param name="start">The first value to emit.</param>
     /// <param name="count">The number of values to emit.</param>
-    /// <param name="scheduler">The scheduler used to emit values.</param>
+    /// <param name="scheduler">The sequencer that emits the values.</param>
     public SequenceSignal(int start, int count, ISequencer scheduler)
     {
         Start = start;
@@ -29,7 +29,7 @@ public SequenceSignal(int start, int count, ISequencer scheduler)
     /// <summary>Gets the number of values to emit.</summary>
     private int Count { get; }
 
-    /// <summary>Gets the scheduler used to emit values.</summary>
+    /// <summary>Gets the sequencer that emits the values.</summary>
     private ISequencer Scheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/SparkWitness.cs b/src/Primitives.Shared/Advanced/SparkWitness.cs
index dfff98cd..dbbb1c34 100644
--- a/src/Primitives.Shared/Advanced/SparkWitness.cs
+++ b/src/Primitives.Shared/Advanced/SparkWitness.cs
@@ -37,7 +37,7 @@ public sealed class SparkWitness<T> : IObserver<T>, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, Spark.CreateOnCompleted<T>(), this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when the slot is occupied.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/Primitives.Shared/Advanced/StartSignal.cs b/src/Primitives.Shared/Advanced/StartSignal.cs
index 5a70166b..a6d89a1d 100644
--- a/src/Primitives.Shared/Advanced/StartSignal.cs
+++ b/src/Primitives.Shared/Advanced/StartSignal.cs
@@ -14,7 +14,7 @@ public sealed class StartSignal : IRequireCurrentThread<RxVoid>
 {
     /// <summary>Initializes a new instance of the <see cref="StartSignal"/> class.</summary>
     /// <param name="action">The action to run.</param>
-    /// <param name="scheduler">The scheduler used to run the action.</param>
+    /// <param name="scheduler">The sequencer that runs the action.</param>
     public StartSignal(Action action, ISequencer scheduler)
     {
         Action = action;
@@ -24,7 +24,7 @@ public StartSignal(Action action, ISequencer scheduler)
     /// <summary>Gets the action to run.</summary>
     private Action Action { get; }
 
-    /// <summary>Gets the scheduler used to run the action.</summary>
+    /// <summary>Gets the sequencer that runs the action.</summary>
     private ISequencer Scheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/StartSignal{T}.cs b/src/Primitives.Shared/Advanced/StartSignal{T}.cs
index 3280e555..e1f4141d 100644
--- a/src/Primitives.Shared/Advanced/StartSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/StartSignal{T}.cs
@@ -15,7 +15,7 @@ public sealed class StartSignal<T> : IRequireCurrentThread<T>
 {
     /// <summary>Initializes a new instance of the <see cref="StartSignal{T}"/> class.</summary>
     /// <param name="function">The function to run.</param>
-    /// <param name="scheduler">The scheduler used to run the function.</param>
+    /// <param name="scheduler">The sequencer that runs the function.</param>
     public StartSignal(Func<T> function, ISequencer scheduler)
     {
         Function = function;
@@ -25,7 +25,7 @@ public StartSignal(Func<T> function, ISequencer scheduler)
     /// <summary>Gets the function to run.</summary>
     private Func<T> Function { get; }
 
-    /// <summary>Gets the scheduler used to run the function.</summary>
+    /// <summary>Gets the sequencer that runs the function.</summary>
     private ISequencer Scheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
index 19f4d726..5e70b6d2 100644
--- a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
+++ b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
@@ -9,16 +9,13 @@ namespace ReactiveUI.Primitives.Advanced;
 #endif
 
 /// <summary>
-/// Shared subscription-time scheduling for advanced signals. A cold signal that must observe the
-/// current-thread sequencer cannot simply subscribe inline: when the current-thread sequencer is already
-/// draining work, the subscription has to be queued behind it so the emissions arrive in trampoline order.
-/// The two shapes below capture that dance once so each signal keeps only its own <c>Run</c> body.
+/// Subscription-time scheduling shared by advanced signals: a signal that observes the current-thread
+/// sequencer has to queue behind it while it is draining work, so emissions arrive in trampoline order.
 /// </summary>
 internal static class SubscriptionScheduling
 {
     /// <summary>
-    /// Subscribes immediately when the current-thread sequencer is idle, otherwise queues the subscription
-    /// on it and hands back a placeholder that is filled in once the subscription actually runs.
+    /// Subscribes inline when the current-thread sequencer is idle, otherwise queues the subscription on it.
     /// </summary>
     /// <typeparam name="TState">The type of the state passed to the subscribe callback.</typeparam>
     /// <param name="state">The state carried to <paramref name="subscribe"/>.</param>
@@ -44,13 +41,13 @@ internal static IDisposable OnCurrentThread<TState>(TState state, Func<TState, I
 
     /// <summary>
     /// Runs <paramref name="run"/> on <paramref name="sequencer"/>: inline for the immediate sequencer, and
-    /// queued behind the current-thread sequencer when that one is the target and is already draining work.
+    /// queued behind the current-thread sequencer when that one is the target and is draining work.
     /// </summary>
     /// <typeparam name="TState">The type of the state passed to the scheduled work.</typeparam>
     /// <param name="sequencer">The sequencer that runs the work.</param>
     /// <param name="state">The state carried to <paramref name="run"/>.</param>
     /// <param name="run">The work to run, which emits to the downstream observer.</param>
-    /// <returns>The disposable used to cancel the scheduled work (best effort).</returns>
+    /// <returns>A disposable that cancels the scheduled work, best effort.</returns>
     internal static IDisposable RunOn<TState>(ISequencer sequencer, TState state, Action<TState> run)
     {
         if (sequencer == Sequencer.Immediate)
diff --git a/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
index c9a4101c..27a9b1aa 100644
--- a/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
@@ -14,8 +14,8 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TResult">The element type of the projected inner observables.</typeparam>
 /// <remarks>
-/// Fuses the projection into the switch: one object and one observer hop, where a projection followed by a
-/// separate switch costs two of each and an intermediate sequence of observables.
+/// The projection is fused into the switch, so it costs one object and one observer hop instead of the two of
+/// each, plus an intermediate sequence of observables, that a separate projection and switch cost.
 /// </remarks>
 [System.Diagnostics.DebuggerDisplay("SwitchMapSignal: Source = {_source}, SkipNullSources = {_skipNullSources}")]
 public sealed class SwitchMapSignal<TSource, TResult> : IObservable<TResult>
diff --git a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
index c10b1e46..d4c5b23f 100644
--- a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
@@ -80,12 +80,10 @@ private void OnSource(IObservable<T> source)
             error => OnError(current, error),
             () => OnCompleted(current));
 
-        // Subscribing can push a value downstream synchronously, and a downstream handler is free to feed the
-        // outer source again. That re-enters OnSource, installs a newer generation, and only then returns here.
-        // Installing unconditionally at that point would replace the newer subscription with this stale one and
-        // dispose it, leaving a subscription whose notifications are all filtered out by version - the sequence
-        // would then never produce another value nor complete. Only the generation that is still current may
-        // occupy the slot; a superseded one disposes itself, outside the gate.
+        // Subscribing can push a value downstream synchronously, and that handler is free to feed the outer
+        // source again, re-entering OnSource and installing a newer generation before this call returns. Only
+        // the current generation may occupy the slot: installing a superseded subscription would dispose the
+        // newer one and leave a sequence whose notifications are all filtered out by version.
         var superseded = false;
         lock (_gate)
         {
diff --git a/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs b/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs
index 7629a5ae..dcdaaa7b 100644
--- a/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs
@@ -8,7 +8,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Object-gated <c>Synchronize</c> compatibility signal.</summary>
+/// <summary>Serializes source notifications behind a caller-supplied object gate.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="gate">The gate shared across subscriptions and other synchronized sequences.</param>
diff --git a/src/Primitives.Shared/Advanced/TaskAnyWitness{T}.cs b/src/Primitives.Shared/Advanced/TaskAnyWitness{T}.cs
index e79de285..a4eb58d0 100644
--- a/src/Primitives.Shared/Advanced/TaskAnyWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/TaskAnyWitness{T}.cs
@@ -34,12 +34,12 @@ public sealed class TaskAnyWitness<T> : IObserver<T>, IDisposable
     private int _stopped;
 
     /// <summary>Initializes a new instance of the <see cref="TaskAnyWitness{T}"/> class.</summary>
-    /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
+    /// <param name="cancellationToken">The token that cancels the task and disposes the subscription.</param>
     public TaskAnyWitness(CancellationToken cancellationToken) => _cancellationToken = cancellationToken;
 
     /// <summary>Initializes a new instance of the <see cref="TaskAnyWitness{T}"/> class.</summary>
     /// <param name="predicate">The predicate.</param>
-    /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
+    /// <param name="cancellationToken">The token that cancels the task and disposes the subscription.</param>
     public TaskAnyWitness(Func<T, bool> predicate, CancellationToken cancellationToken)
     {
         ArgumentExceptionHelper.ThrowIfNull(predicate);
diff --git a/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs b/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs
index 51d7fe5f..fbb0c385 100644
--- a/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs
+++ b/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs
@@ -11,11 +11,11 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <summary>State transitions for <see cref="TaskChainCoordinator{T}"/>.</summary>
 internal static class TaskChainCoordinatorState
 {
-    /// <summary>Marks the active inner source complete and drains when the coordinator has not already stopped.</summary>
+    /// <summary>Marks the active inner source complete and drains the coordinator unless it has stopped.</summary>
     /// <typeparam name="T">The task result type.</typeparam>
     /// <param name="gate">The coordinator state gate.</param>
-    /// <param name="done">A value indicating whether a terminal notification has already been emitted.</param>
-    /// <param name="active">A value indicating whether an inner source is active.</param>
+    /// <param name="done">Whether a terminal notification has been emitted.</param>
+    /// <param name="active">Whether an inner source is active.</param>
     /// <param name="coordinator">The coordinator to drain.</param>
     internal static void OnInnerCompleted<T>(
         Lock gate,
diff --git a/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs b/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs
index 0f4072a8..457c5511 100644
--- a/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs
@@ -8,7 +8,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Task-source <c>Chain</c>/<c>Concat</c> signal.</summary>
+/// <summary>Emits the results of an observable sequence of tasks, one task at a time in source order.</summary>
 /// <typeparam name="T">The task result type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("TaskChainSignal: Sources = {_sources}")]
 public sealed class TaskChainSignal<T> : IObservable<T>
diff --git a/src/Primitives.Shared/Advanced/TaskCountWitness{T}.cs b/src/Primitives.Shared/Advanced/TaskCountWitness{T}.cs
index 1a1e2026..93ccae4d 100644
--- a/src/Primitives.Shared/Advanced/TaskCountWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/TaskCountWitness{T}.cs
@@ -37,12 +37,12 @@ public sealed class TaskCountWitness<T> : IObserver<T>, IDisposable
     private int _stopped;
 
     /// <summary>Initializes a new instance of the <see cref="TaskCountWitness{T}"/> class.</summary>
-    /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
+    /// <param name="cancellationToken">The token that cancels the task and disposes the subscription.</param>
     public TaskCountWitness(CancellationToken cancellationToken) => _cancellationToken = cancellationToken;
 
     /// <summary>Initializes a new instance of the <see cref="TaskCountWitness{T}"/> class.</summary>
     /// <param name="predicate">The predicate.</param>
-    /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
+    /// <param name="cancellationToken">The token that cancels the task and disposes the subscription.</param>
     public TaskCountWitness(Func<T, bool> predicate, CancellationToken cancellationToken)
     {
         ArgumentExceptionHelper.ThrowIfNull(predicate);
diff --git a/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs b/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
index bec0659c..f1d49f1d 100644
--- a/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
@@ -10,23 +10,23 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the ThrowSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Emits a single error on the supplied sequencer without producing any value.</summary>
+/// <typeparam name="T">The value type the sequence would have carried.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ThrowSignal: Error = {_error}, Scheduler = {_scheduler}")]
 public sealed class ThrowSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The error to emit.</summary>
     private readonly Exception _error;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer that emits the error.</summary>
     private readonly ISequencer _scheduler;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether subscription must be dispatched through the current-thread sequencer.</summary>
     private readonly bool _currentThreadRequired;
 
     /// <summary>Initializes a new instance of the <see cref="ThrowSignal{T}"/> class.</summary>
-    /// <param name="error">The error value.</param>
-    /// <param name="scheduler">The scheduler value.</param>
+    /// <param name="error">The error to emit.</param>
+    /// <param name="scheduler">The sequencer that emits the error.</param>
     public ThrowSignal(Exception error, ISequencer scheduler)
     {
         _error = error;
@@ -34,14 +34,14 @@ public ThrowSignal(Exception error, ISequencer scheduler)
         _currentThreadRequired = scheduler == Sequencer.CurrentThread;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Gets whether subscription has to be dispatched through the current-thread sequencer.</summary>
+    /// <returns><see langword="true"/> when the supplied sequencer is the current-thread sequencer.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => _currentThreadRequired;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes an observer that receives the error.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>A disposable that cancels the emission when it has not run yet.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, _currentThreadRequired, SubscribeCore);
@@ -56,10 +56,10 @@ private static EmptyDisposable SignalError((IObserver<T> Observer, Exception Err
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the error inline for the immediate sequencer, otherwise on the sequencer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle the guard checks before forwarding.</param>
+    /// <returns>The disposable that cancels the scheduled emission.</returns>
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
diff --git a/src/Primitives.Shared/Advanced/TimeIntervalWitness.cs b/src/Primitives.Shared/Advanced/TimeIntervalWitness.cs
index 432f64de..6dcf2c01 100644
--- a/src/Primitives.Shared/Advanced/TimeIntervalWitness.cs
+++ b/src/Primitives.Shared/Advanced/TimeIntervalWitness.cs
@@ -58,7 +58,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when the slot is occupied.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/Primitives.Shared/Advanced/TimerSlot.cs b/src/Primitives.Shared/Advanced/TimerSlot.cs
index 8f8e7abf..c0a1a04e 100644
--- a/src/Primitives.Shared/Advanced/TimerSlot.cs
+++ b/src/Primitives.Shared/Advanced/TimerSlot.cs
@@ -18,11 +18,9 @@ public static class TimerSlot
     /// <param name="tick">The timer callback.</param>
     /// <exception cref="ArgumentNullException">An argument is <see langword="null"/>.</exception>
     /// <remarks>
-    /// A sequencer may run <paramref name="tick"/> before its own <c>Schedule</c> returns, and that callback
-    /// may arm its successor. Assigning the returned handle straight into <paramref name="slot"/> would then
-    /// replace - and so cancel - the successor rather than the timer that has already fired. Reserving the
-    /// slot first means the late assignment lands in a reservation the successor has already superseded, and
-    /// the already-fired handle is disposed instead.
+    /// A sequencer may run <paramref name="tick"/> before its own <c>Schedule</c> returns, and that callback may
+    /// arm its successor. Reserving <paramref name="slot"/> first sends the late handle into a superseded
+    /// reservation, so the fired timer is disposed instead of the successor being cancelled.
     /// </remarks>
     public static void Arm(SingleReplaceableDisposable slot, ISequencer sequencer, TimeSpan delay, Action tick)
     {
diff --git a/src/Primitives.Shared/Advanced/UnsparkWitness.cs b/src/Primitives.Shared/Advanced/UnsparkWitness.cs
index 76f5b440..64cbfa80 100644
--- a/src/Primitives.Shared/Advanced/UnsparkWitness.cs
+++ b/src/Primitives.Shared/Advanced/UnsparkWitness.cs
@@ -37,7 +37,7 @@ public sealed class UnsparkWitness<T> : IObserver<Spark<T>>, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when the slot is occupied.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/Primitives.Shared/Advanced/WitnessLifetime.cs b/src/Primitives.Shared/Advanced/WitnessLifetime.cs
index 128c2836..92e6a27b 100644
--- a/src/Primitives.Shared/Advanced/WitnessLifetime.cs
+++ b/src/Primitives.Shared/Advanced/WitnessLifetime.cs
@@ -34,7 +34,7 @@ internal static void Dispose(ref IDisposable? cancelSlot, ref int stopped)
     /// <returns><see langword="true"/> when the sink has stopped.</returns>
     internal static bool IsStopped(ref int stopped) => Volatile.Read(ref stopped) != 0;
 
-    /// <summary>Assigns the upstream subscription and disposes it when the sink has already stopped.</summary>
+    /// <summary>Assigns the upstream subscription, disposing it when the sink has stopped.</summary>
     /// <param name="stopped">The stopped flag.</param>
     /// <param name="slot">The upstream subscription slot.</param>
     /// <param name="subscription">The upstream subscription.</param>
@@ -89,7 +89,7 @@ internal static void Error<T>(
         observer.OnError(terminalError);
     }
 
-    /// <summary>Assigns the cancellation resource or disposes it when the witness already stopped.</summary>
+    /// <summary>Assigns the cancellation resource, disposing it when the witness has stopped.</summary>
     /// <param name="cancelSlot">The slot that owns the cancellation resource.</param>
     /// <param name="stopped">The stopped flag.</param>
     /// <param name="cancel">The cancellation resource to assign.</param>
@@ -111,7 +111,7 @@ internal static void SetCancel(ref IDisposable? cancelSlot, ref int stopped, IDi
         Interlocked.Exchange(ref cancelSlot, null)?.Dispose();
     }
 
-    /// <summary>Forwards a value when the witness is still active.</summary>
+    /// <summary>Forwards a value while the witness is active.</summary>
     /// <typeparam name="TOwner">The witness owner type.</typeparam>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="stopped">The stopped flag.</param>
diff --git a/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs b/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
index 82fb2652..eea0ab6e 100644
--- a/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
@@ -10,63 +10,60 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Represents the WitnessOnSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
-/// <param name="source">The source value.</param>
-/// <param name="scheduler">The scheduler value.</param>
+/// <summary>Re-dispatches source notifications onto a sequencer, preserving their order.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="scheduler">The sequencer that dispatches the notifications.</param>
 internal sealed class WitnessOnSignal<T>(IObservable<T> source, ISequencer scheduler) : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The source observable.</summary>
     private readonly IObservable<T> _source = source;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer that dispatches the notifications.</summary>
     private readonly ISequencer _scheduler = scheduler;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Reports that subscription is dispatched through the current-thread sequencer.</summary>
+    /// <returns>Always <see langword="true"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => true;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes an observer through the current-thread sequencer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The subscription.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         SignalSubscription.Subscribe(observer, true, SubscribeCore);
 
-    /// <summary>Executes the SubscribeCore operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Builds the dispatching sink and subscribes it to the source.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle owned by the subscription helper.</param>
+    /// <returns>The source subscription together with the sink.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel) =>
         new WitnessOn(this, observer, cancel).Run();
 
-    /// <summary>Represents the WitnessOn class.</summary>
-    /// <param name="parent">The parent value.</param>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="cancel">The cancel value.</param>
+    /// <summary>Queues source notifications and drains them on the sequencer.</summary>
+    /// <param name="parent">The owning signal.</param>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle released on teardown.</param>
     private sealed class WitnessOn(WitnessOnSignal<T> parent, IObserver<T> observer, IDisposable cancel) : IObserver<T>, IWorkItem, IsDisposed
     {
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The owning signal.</summary>
         private readonly WitnessOnSignal<T> _parent = parent;
 
-        /// <summary>Stores the downstream observer.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer = observer;
 
         /// <summary>Synchronization gate guarding the queued actions and scheduling state.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>
-        /// Queued notifications awaiting dispatch on the scheduler. Stored as a value type so
-        /// queueing a notification does not allocate a <see cref="Spark{T}"/> per OnNext.
-        /// </summary>
+        /// <summary>Notifications awaiting dispatch on the sequencer.</summary>
         private readonly Queue<Notification> _actions = new();
 
         /// <summary>Upstream subscription disposed on teardown.</summary>
         private IDisposable? _cancel = cancel;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>Whether the sink has been torn down.</summary>
         private bool _isDisposed;
 
         /// <summary>Tracks whether a drain has been scheduled.</summary>
@@ -84,8 +81,8 @@ public bool IsDisposed
             }
         }
 
-        /// <summary>Executes the Run operation.</summary>
-        /// <returns>The result.</returns>
+        /// <summary>Subscribes to the source.</summary>
+        /// <returns>The source subscription together with this sink.</returns>
         public MultipleDisposable Run()
         {
             _isDisposed = false;
@@ -95,17 +92,17 @@ public MultipleDisposable Run()
             return new(sourceDisposable, this);
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
-        /// <param name="value">The value.</param>
+        /// <summary>Queues a value for dispatch.</summary>
+        /// <param name="value">The value to queue.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(T value) => QueueAction(Notification.OnNext(value));
 
-        /// <summary>Executes the OnError operation.</summary>
-        /// <param name="error">The error value.</param>
+        /// <summary>Queues an error for dispatch.</summary>
+        /// <param name="error">The error to queue.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnError(Exception error) => QueueAction(Notification.OnError(error));
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Queues completion for dispatch.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted() => QueueAction(Notification.OnCompleted());
 
@@ -143,7 +140,7 @@ public void Execute()
             }
         }
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Clears the queue and releases the upstream subscription, once.</summary>
         public void Dispose()
         {
             IDisposable? cancel;
@@ -163,8 +160,8 @@ public void Dispose()
             cancel?.Dispose();
         }
 
-        /// <summary>Executes the QueueAction operation.</summary>
-        /// <param name="data">The data value.</param>
+        /// <summary>Queues a notification and schedules a drain when one is not pending.</summary>
+        /// <param name="data">The notification to queue.</param>
         private void QueueAction(in Notification data)
         {
             lock (_gate)
@@ -186,8 +183,8 @@ private void QueueAction(in Notification data)
             _parent._scheduler.Schedule(this);
         }
 
-        /// <summary>Executes the Dispatch operation.</summary>
-        /// <param name="action">The action value.</param>
+        /// <summary>Forwards one notification to the downstream observer.</summary>
+        /// <param name="action">The notification to forward.</param>
         private void Dispatch(in Notification action)
         {
             switch (action.Kind)
diff --git a/src/Primitives.Shared/Concurrency/SequencerWorkItem.cs b/src/Primitives.Shared/Concurrency/SequencerWorkItem.cs
index 0ca3d771..f0764be0 100644
--- a/src/Primitives.Shared/Concurrency/SequencerWorkItem.cs
+++ b/src/Primitives.Shared/Concurrency/SequencerWorkItem.cs
@@ -29,7 +29,7 @@ internal sealed class SequencerWorkItem<TSequencer, TState>(TSequencer sequencer
     /// <summary>Disposable returned by the scheduled action after it starts.</summary>
     private IDisposable? _disposable;
 
-    /// <summary>Tracks cancellation.</summary>
+    /// <summary>Non-zero once the work item has been cancelled.</summary>
     private int _isDisposed;
 
     /// <summary>Cancels the work item.</summary>
diff --git a/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs b/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
index 4ba9d210..b7a8c76f 100644
--- a/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
+++ b/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
@@ -15,10 +15,8 @@ internal static class SequencerWorkItemDisposal
     /// <param name="slot">The disposable slot shared with the work item's disposal.</param>
     /// <param name="disposable">The disposable returned by the scheduled action.</param>
     /// <remarks>
-    /// Disposal swaps a non-null sentinel into the slot, so a non-null exchange result means disposal already
-    /// owns (or will own) the slot and the freshly produced disposable must be released here. A null result
-    /// means this caller published first and disposal releases the slot later. This keeps the in-flight dispose
-    /// race correct with a single compare-exchange instead of a re-check loop.
+    /// Disposal swaps a non-null sentinel into the slot, so a non-null exchange result means disposal owns the
+    /// slot and this caller must release the disposable it produced.
     /// </remarks>
     internal static void Publish(ref IDisposable? slot, IDisposable disposable)
     {
diff --git a/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs b/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
index e9a6065e..2454e531 100644
--- a/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
+++ b/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
@@ -10,11 +10,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// The System.Reactive names for the hot-sharing operators, so code written against Rx reads unchanged here.
-/// Each one builds its hub directly rather than forwarding to its Primitives-named twin in
-/// <see cref="ConnectableSignalExtensions"/>, so an alias costs nothing at the call site.
-/// </summary>
+/// <summary>System.Reactive names for the hot-sharing operators, so code written against Rx compiles unchanged.</summary>
 public static class ConnectableSignalRxNameExtensions
 {
     /// <summary>Reference-counting operators for a connectable signal source.</summary>
@@ -51,7 +47,7 @@ public ConnectableSignal<T> Publish()
         [SuppressMessage(
             "Design",
             "SST2318:Members should not have identical bodies",
-            Justification = "Share and Publish are the same operator under two names callers expect; forwarding one to the other would only add a hop.")]
+            Justification = "Share and Publish are the same operator under two names callers expect.")]
         public ConnectableSignal<T> Share()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/Primitives.Shared/Core/Spark.cs b/src/Primitives.Shared/Core/Spark.cs
index 9551e62e..d5b49df2 100644
--- a/src/Primitives.Shared/Core/Spark.cs
+++ b/src/Primitives.Shared/Core/Spark.cs
@@ -34,8 +34,7 @@ public static class Spark
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static Spark<T> CreateOnError<T>(Exception error)
     {
         ArgumentExceptionHelper.ThrowIfNull(error);
@@ -53,7 +52,6 @@ public static Spark<T> CreateOnError<T>(Exception error)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static Spark<T> CreateOnCompleted<T>() => Spark<T>.OnCompleted();
 }
diff --git a/src/Primitives.Shared/Core/SparkCompositeFormats.cs b/src/Primitives.Shared/Core/SparkCompositeFormats.cs
index 744088cd..bb1b5b6a 100644
--- a/src/Primitives.Shared/Core/SparkCompositeFormats.cs
+++ b/src/Primitives.Shared/Core/SparkCompositeFormats.cs
@@ -12,9 +12,8 @@ namespace ReactiveUI.Primitives.Core;
 
 /// <summary>Holds the parsed composite formats <see cref="Spark{T}"/> renders with.</summary>
 /// <remarks>
-/// The formats sit on a non-generic type on purpose. A static field inside <see cref="Spark{T}"/> is
-/// a field of each closed generic, so the format would be parsed once per <c>T</c>; one shared instance
-/// serves every one of them.
+/// A static field in <see cref="Spark{T}"/> is a distinct field per closed generic, so the formats live on a
+/// non-generic type to be parsed once for every <c>T</c>.
 /// </remarks>
 internal static class SparkCompositeFormats
 {
diff --git a/src/Primitives.Shared/Core/Spark{T}.cs b/src/Primitives.Shared/Core/Spark{T}.cs
index a63b8be7..366358bc 100644
--- a/src/Primitives.Shared/Core/Spark{T}.cs
+++ b/src/Primitives.Shared/Core/Spark{T}.cs
@@ -13,9 +13,8 @@ namespace ReactiveUI.Primitives.Core;
 #endif
 
 /// <summary>
-/// Represents a spark to an observer. This is a by-value type: materializing a sequence allocates
-/// no per-notification heap object, mirroring the value-type notification used by other modern
-/// reactive libraries.
+/// Represents a spark to an observer. Being a value type, materializing a sequence allocates no
+/// per-notification heap object.
 /// </summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
 [Serializable]
@@ -46,7 +45,7 @@ private Spark(SparkKind kind, T value, Exception? exception)
     /// <summary>Gets a value indicating whether the spark carries a value.</summary>
     public bool HasValue => Kind == SparkKind.OnNext;
 
-    /// <summary>Gets the exception of an OnError spark or returns null.</summary>
+    /// <summary>Gets the exception carried by an OnError spark, or <see langword="null"/> for any other kind.</summary>
     public Exception Exception => _exception!;
 
     /// <summary>Gets the kind of Spark that is represented.</summary>
@@ -57,13 +56,12 @@ private Spark(SparkKind kind, T value, Exception? exception)
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Determines whether the current Spark&lt;T&gt; object has the same observer message payload as a specified Spark&lt;T&gt; value.</summary>
-    /// <param name="other">An object to compare to the current Spark&lt;T&gt; object.</param>
-    /// <returns>true if both Spark&lt;T&gt; objects have the same observer message payload; otherwise, false.</returns>
-    /// <remarks>
-    /// Equality of Spark&lt;T&gt; objects is based on the equality of the observer message payload they represent,
-    /// including the Spark Kind and the Value or Exception (if any).
-    /// </remarks>
+    /// <summary>
+    /// Determines whether both sparks carry the same observer message payload: the same <see cref="Kind"/> and,
+    /// for OnNext and OnError, the same value or exception.
+    /// </summary>
+    /// <param name="other">The spark to compare with this one.</param>
+    /// <returns>true if both sparks carry the same payload; otherwise, false.</returns>
     public bool Equals(Spark<T> other) => Kind == other.Kind && Kind switch
     {
         SparkKind.OnNext => EqualityComparer<T>.Default.Equals(Value, other.Value),
diff --git a/src/Primitives.Shared/Handle.cs b/src/Primitives.Shared/Handle.cs
index dc2d8e41..a3c22c7a 100644
--- a/src/Primitives.Shared/Handle.cs
+++ b/src/Primitives.Shared/Handle.cs
@@ -27,8 +27,7 @@ internal static class Handle
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "No argument carries the element type, so it can only come from an explicit type argument.")]
     internal static IObservable<TSource> CatchIgnore<TSource>(Exception ex) =>
         Signal.None<TSource>();
 }
diff --git a/src/Primitives.Shared/LinqExtensions.cs b/src/Primitives.Shared/LinqExtensions.cs
index cfc1b884..469c1e9e 100644
--- a/src/Primitives.Shared/LinqExtensions.cs
+++ b/src/Primitives.Shared/LinqExtensions.cs
@@ -15,14 +15,14 @@ public static partial class LinqExtensions
     /// <param name="disposable">The disposable.</param>
     extension(IDisposable disposable)
     {
-        /// <summary>Disposes the with.</summary>
-        /// <returns>A SingleDisposable.</returns>
+        /// <summary>Wraps the disposable so that disposing the wrapper disposes it exactly once.</summary>
+        /// <returns>A <see cref="SingleDisposable"/> that owns this disposable.</returns>
         public SingleDisposable DisposeWith() =>
             new(disposable);
 
-        /// <summary>Disposes the with.</summary>
-        /// <param name="action">The action.</param>
-        /// <returns>A SingleDisposable.</returns>
+        /// <summary>Wraps the disposable and runs an action just before it is disposed.</summary>
+        /// <param name="action">The action to run on disposal, or <see langword="null"/> to run nothing extra.</param>
+        /// <returns>A <see cref="SingleDisposable"/> that owns this disposable and first invokes <paramref name="action"/>.</returns>
         public SingleDisposable DisposeWith(Action? action) =>
             new(disposable, action);
     }
@@ -32,11 +32,11 @@ public SingleDisposable DisposeWith(Action? action) =>
     /// <param name="source">The source.</param>
     extension<TSource>(IObservable<TSource> source)
     {
-        /// <summary>Buffers the specified count.</summary>
-        /// <param name="count">The count of each buffer.</param>
-        /// <returns>An Signals sequence of buffers.</returns>
-        /// <exception cref="ArgumentExceptionHelper">source.</exception>
-        /// <exception cref="ArgumentOutOfRangeExceptionHelper">count.</exception>
+        /// <summary>Groups the source values into consecutive, non-overlapping buffers of a fixed size.</summary>
+        /// <param name="count">The number of values in each buffer.</param>
+        /// <returns>An observable sequence of buffers; the final buffer is shorter when the source ends mid-window.</returns>
+        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeExceptionHelper"><paramref name="count"/> is zero or negative.</exception>
         public IObservable<IList<TSource>> Buffer(int count)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -46,16 +46,12 @@ public IObservable<IList<TSource>> Buffer(int count)
             return new BufferCountSignal<TSource>(source, count, 0);
         }
 
-        /// <summary>Buffers the specified count then skips the specified count, then repeats.</summary>
-        /// <param name="count">Length of each buffer before being skipped.</param>
-        /// <param name="skip">Number of elements to skip between creation of consecutive buffers.</param>
-        /// <returns>An Signals sequence of buffers taking the count then skipping the skipped value, the sequecnce is then repeated.</returns>
-        /// <exception cref="ArgumentExceptionHelper">source.</exception>
-        /// <exception cref="ArgumentOutOfRangeExceptionHelper">
-        /// count
-        /// or
-        /// skip.
-        /// </exception>
+        /// <summary>Groups values into fixed-size buffers, opening a new buffer every <paramref name="skip"/> values.</summary>
+        /// <param name="count">The number of values in each buffer.</param>
+        /// <param name="skip">The number of values between the starts of consecutive buffers; a value below <paramref name="count"/> makes buffers overlap.</param>
+        /// <returns>An observable sequence of buffers, each opened <paramref name="skip"/> values after the one before it.</returns>
+        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeExceptionHelper"><paramref name="count"/> or <paramref name="skip"/> is zero or negative.</exception>
         public IObservable<IList<TSource>> Buffer(int count, int skip)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -74,9 +70,9 @@ public IObservable<IList<TSource>> Buffer(int count, int skip)
     extension<T>(T disposable)
         where T : IDisposable
     {
-        /// <summary>Disposes the IDisposable with the disposables instance.</summary>
-        /// <param name="disposables">The disposables.</param>
-        /// <returns>The original disposable.</returns>
+        /// <summary>Adds the disposable to a composite that will dispose it.</summary>
+        /// <param name="disposables">The composite taking ownership of the disposable.</param>
+        /// <returns>The same disposable, so the call can be chained onto its creation.</returns>
         public T DisposeWith(MultipleDisposable disposables)
         {
             ArgumentExceptionHelper.ThrowIfNull(disposables);
diff --git a/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs b/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
index ba566d8c..6cb93de3 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
@@ -12,14 +12,13 @@ namespace ReactiveUI.Primitives;
 
 /// <summary>
 /// Fused <c>Blend</c> + <c>Unique</c> operator: concurrently merges a fixed set of sources and forwards a value
-/// only when it differs from the previously forwarded one. Folding the merge and distinct-until-changed into a
-/// single sink avoids the extra subscription hop and allocation of <c>sources.Blend().Unique()</c>.
+/// only when it differs from the last forwarded one, through one sink instead of two.
 /// </summary>
 public static partial class LinqExtensions
 {
     /// <summary>
-    /// Concurrently merges the supplied sources and forwards only values that differ from the previously
-    /// forwarded value, using the default equality comparer. Errors are forwarded from the first failing source;
+    /// Concurrently merges the supplied sources and forwards only values that differ from the last forwarded
+    /// value, using the default equality comparer. Errors are forwarded from the first failing source;
     /// completion is signalled once every source has completed.
     /// </summary>
     /// <typeparam name="T">The element type.</typeparam>
@@ -30,8 +29,8 @@ public static IObservable<T> BlendUnique<T>(params IObservable<T>[] sources) =>
         BlendUnique(sources, null);
 
     /// <summary>
-    /// Concurrently merges the supplied sources and forwards only values that differ from the previously
-    /// forwarded value, using the supplied comparer (or the default when <see langword="null"/>).
+    /// Concurrently merges the supplied sources and forwards only values that differ from the last forwarded
+    /// value, using the supplied comparer (or the default when <see langword="null"/>).
     /// </summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="sources">The sources to merge.</param>
@@ -134,7 +133,7 @@ public void Run(IObservable<T>[] sources)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose() => _pocket.Dispose();
 
-        /// <summary>Forwards a value when it differs from the previously forwarded one.</summary>
+        /// <summary>Forwards a value when it differs from the last forwarded one.</summary>
         /// <param name="value">The merged value.</param>
         private void Forward(T value)
         {
diff --git a/src/Primitives.Shared/SignalOperatorMixins.BufferSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.BufferSignals.cs
index 21c35e74..b8ff0be4 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.BufferSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.BufferSignals.cs
@@ -8,11 +8,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Dedicated cold signal/sink for <c>Buffer</c>. Each subscription gets its own lightweight sink
-/// (no broadcaster, no eager subscription); windows are buffered into a single array of the known
-/// window size and emitted directly, with only a partial trailing window copied to an exact size.
-/// </summary>
+/// <summary>Implementation types for the count-based buffering overloads.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>Dedicated cold signal for <c>Buffer</c>.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
index 2be7bd1c..61df4a34 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Fused projection operators: <c>Choose</c> (filter + map in one sink), <c>SwitchMap</c> (map-to-inner +
-/// switch-to-latest in one sink) and <c>SwitchSelect</c> (the same, skipping null source values).
-/// </summary>
+/// <summary>Fused projection operators that combine filtering or switching with a projection in one sink.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>Fused projection operators for an observable source sequence.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
index 9f9fd21d..857f3512 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
@@ -8,11 +8,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Dedicated signals/sinks for the terminal collection operators (CollectList, CollectArray) and
-/// their eager range-backed fast paths, replacing the per-subscription
-/// <c>Signal.CreateSafe(observer =&gt; ...)</c> closures with parameter-holding signals.
-/// </summary>
+/// <summary>Signals backing the terminal collection operators and their eager range fast paths.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>Dedicated signal for <c>CollectList</c>.</summary>
@@ -61,10 +57,6 @@ public IDisposable Subscribe(IObserver<T[]> observer)
 
     /// <summary>Eager range-backed signal for <c>CollectList</c> (no per-value subscription).</summary>
     /// <typeparam name="T">The result element type, which is always <see cref="int"/>.</typeparam>
-    /// <remarks><see cref="RangeSignal"/> is sealed and implements only <see cref="IObservable{T}"/> of
-    /// <see cref="int"/>. Covariance does not apply to a value-type argument, so an
-    /// <see cref="IObservable{T}"/> can only hold a range when <typeparamref name="T"/> is exactly
-    /// <see cref="int"/> — which is what every construction site asserts.</remarks>
     private sealed class RangeListSignal<T> : IObservable<IList<T>>
     {
         /// <summary>The source range.</summary>
@@ -85,6 +77,7 @@ public IDisposable Subscribe(IObserver<IList<T>> observer)
                 values.Add(_range.Start + i);
             }
 
+            // A value-type argument is not covariant, so this cast holds only because every call site fixes T to int.
             observer.OnNext((IList<T>)(object)values);
             observer.OnCompleted();
             return EmptyDisposable.Instance;
@@ -93,10 +86,6 @@ public IDisposable Subscribe(IObserver<IList<T>> observer)
 
     /// <summary>Eager range-backed signal for <c>CollectArray</c> (no per-value subscription).</summary>
     /// <typeparam name="T">The result element type, which is always <see cref="int"/>.</typeparam>
-    /// <remarks><see cref="RangeSignal"/> is sealed and implements only <see cref="IObservable{T}"/> of
-    /// <see cref="int"/>. Covariance does not apply to a value-type argument, so an
-    /// <see cref="IObservable{T}"/> can only hold a range when <typeparamref name="T"/> is exactly
-    /// <see cref="int"/> — which is what every construction site asserts.</remarks>
     private sealed class RangeArraySignal<T> : IObservable<T[]>
     {
         /// <summary>The source range.</summary>
@@ -117,6 +106,7 @@ public IDisposable Subscribe(IObserver<T[]> observer)
                 values[i] = _range.Start + i;
             }
 
+            // A value-type argument is not covariant, so this cast holds only because every call site fixes T to int.
             observer.OnNext((T[])(object)values);
             observer.OnCompleted();
             return EmptyDisposable.Instance;
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.WideArity.cs b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.WideArity.cs
index c464a254..79ff4dd2 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.WideArity.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.WideArity.cs
@@ -44,7 +44,7 @@ private sealed partial class CombineLatestSignal<TResult>
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -112,7 +112,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -185,7 +185,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -263,7 +263,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -346,7 +346,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult>
             Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(
                 IObservable<T1> source,
@@ -435,7 +435,7 @@ internal static CombineLatestSignal<TResult>
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -528,7 +528,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(
             IObservable<T1> source,
             IObservable<T2> source2,
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
index 3f85fe5c..af954501 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
@@ -25,8 +25,7 @@ private abstract class CombineLatestSlot
     /// <summary>Observable implementation for generated multi-source combine-latest overloads.</summary>
     /// <typeparam name="TResult">The projected result type.</typeparam>
     /// <param name="connect">
-    /// Creates one typed slot per source against a fresh coordinator and returns the projection that reads
-    /// them. Running per subscription is what keeps every latest value in a field of its own source's type.
+    /// Creates one typed slot per source against a fresh coordinator and returns the projection that reads them.
     /// </param>
     private sealed partial class CombineLatestSignal<TResult>(
         Func<CombineLatestCoordinator<TResult>, Func<TResult>> connect) : IObservable<TResult>
@@ -202,7 +201,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -255,7 +254,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -313,7 +312,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
             IObservable<T1> source,
             IObservable<T2> source2,
@@ -350,10 +349,7 @@ internal static CombineLatestSignal<TResult> Create<T1, T2, T3, T4, T5, T6, T7,
             });
     }
 
-    /// <summary>
-    /// Holds the latest value of one source in a field of that source's own type, and observes the source
-    /// directly so a subscription costs one object per source rather than a closure and a delegate per callback.
-    /// </summary>
+    /// <summary>Holds the latest value of one source in a field of that source's own type and observes it directly.</summary>
     /// <typeparam name="TResult">The projected result type.</typeparam>
     /// <typeparam name="T">The source element type.</typeparam>
     /// <param name="coordinator">The coordinator that serializes this slot against its siblings.</param>
@@ -411,21 +407,20 @@ private sealed class CombineLatestCoordinator<TResult> : IDisposable
 
         /// <summary>
         /// One flag per source twice over: the first half records whether a source has produced a value, the
-        /// second whether it has completed. A single array keeps both counters' state in one allocation and
-        /// stays correct for the collection overloads, whose source count has no upper bound.
+        /// second whether it has completed.
         /// </summary>
         private bool[] _flags = [];
 
         /// <summary>The projection over this subscription's slots.</summary>
         private Func<TResult> _project = null!;
 
-        /// <summary>The number of sources still waiting for their first value.</summary>
+        /// <summary>The number of sources yet to produce their first value.</summary>
         private int _missingValues;
 
         /// <summary>The number of sources that have not completed.</summary>
         private int _remainingCompletions;
 
-        /// <summary>Whether a terminal notification has already been forwarded.</summary>
+        /// <summary>Whether a terminal notification has been forwarded.</summary>
         private bool _completed;
 
         /// <summary>Initializes a new instance of the <see cref="CombineLatestCoordinator{TResult}"/> class.</summary>
@@ -450,12 +445,9 @@ internal CombineLatestSlot<TResult, T> Attach<T>(IObservable<T> source)
         /// <summary>Subscribes to every attached source and returns this coordinator as the subscription.</summary>
         /// <param name="project">The projection over the slots created by <see cref="Attach{T}"/>.</param>
         /// <returns>This coordinator.</returns>
-        /// <remarks>
-        /// The projection is installed before the first subscription, so a source that produces a value inside
-        /// its own subscribe call still finds somewhere to project into.
-        /// </remarks>
         internal CombineLatestCoordinator<TResult> Run(Func<TResult> project)
         {
+            // Installed before the first subscribe, so a source that emits inside its own Subscribe has a target.
             _project = project;
             _flags = new bool[_slots.Count * FlagsPerSource];
             _missingValues = _slots.Count;
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
index 8b707e3f..c1a27d67 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
@@ -14,9 +14,7 @@ namespace ReactiveUI.Primitives;
 public static partial class LinqExtensions
 {
     /// <summary>
-    /// Range-specialized WithLatest (Latch): emits each left range value paired with the right
-    /// range's final value. A dedicated signal avoids the closure, delegate, CreateSafe wrapper,
-    /// and safe-guard sink that <c>Signal.CreateSafe(observer =&gt; ...)</c> would allocate.
+    /// Range-specialized WithLatest (Latch): emits each left range value paired with the right range's final value.
     /// </summary>
     /// <typeparam name="TResult">The result value type.</typeparam>
     /// <param name="left">The left source range.</param>
@@ -49,7 +47,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         }
     }
 
-    /// <summary>Dedicated signal for <c>Race</c>; runs the coordinator without a Create closure.</summary>
+    /// <summary>Dedicated signal for <c>Race</c>, handing each subscription to a coordinator.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     private sealed class RaceSignal<T> : IObservable<T>
     {
@@ -69,7 +67,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Dedicated signal for <c>Zip</c>; runs the coordinator without a Create closure.</summary>
+    /// <summary>Dedicated signal for <c>Zip</c>, holding the two sources and the projection.</summary>
     /// <typeparam name="TLeft">The left value type.</typeparam>
     /// <typeparam name="TRight">The right value type.</typeparam>
     /// <typeparam name="TResult">The result value type.</typeparam>
@@ -96,7 +94,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         }
     }
 
-    /// <summary>Dedicated signal for <c>CombineLatest</c>; runs the coordinator without a Create closure.</summary>
+    /// <summary>Dedicated signal for the two-source <c>CombineLatest</c> path.</summary>
     /// <typeparam name="TLeft">The left value type.</typeparam>
     /// <typeparam name="TRight">The right value type.</typeparam>
     /// <typeparam name="TResult">The result value type.</typeparam>
@@ -484,9 +482,8 @@ private void OnRightCompleted()
         }
 
         /// <summary>
-        /// Emits all currently available pairs. The gate is held across the projection and the
-        /// downstream callbacks so left and right threads cannot interleave emissions (the Rx
-        /// serialization contract) and completion is delivered at most once.
+        /// Emits every pair the queues can form. The gate is held across the projection and the downstream
+        /// callbacks, so the left and right threads cannot interleave emissions.
         /// </summary>
         private void Drain()
         {
@@ -562,11 +559,7 @@ internal MultipleDisposable Run(IObservable<TLeft> left, IObservable<TRight> rig
                 left.Subscribe(OnLeftNext, _observer.OnError, OnLeftCompleted),
                 right.Subscribe(OnRightNext, _observer.OnError, OnRightCompleted));
 
-        /// <summary>
-        /// Handles a left value. The gate is held across the projection and the downstream
-        /// callback so left and right threads cannot interleave emissions (the Rx serialization
-        /// contract).
-        /// </summary>
+        /// <summary>Handles a left value, holding the gate across the projection so emissions cannot interleave.</summary>
         /// <param name="value">The left value.</param>
         private void OnLeftNext(TLeft value)
         {
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
index 6a86bbd3..05594380 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
@@ -11,10 +11,8 @@ namespace ReactiveUI.Primitives;
 #endif
 
 /// <summary>
-/// Dedicated signals for the scheduler/time operators, replacing the per-subscription
-/// <c>Signal.Create(observer =&gt; ...)</c> closures. The current-thread variants follow the
-/// <c>ExpireSignal</c>/<c>ProbeSignal</c> pattern: implement <see cref="IRequireCurrentThread{T}"/>
-/// and schedule the subscription onto the current-thread sequencer when required.
+/// Signals for the scheduler and time operators. The current-thread variants implement
+/// <see cref="IRequireCurrentThread{T}"/> and schedule their subscription onto the current-thread sequencer.
 /// </summary>
 public static partial class LinqExtensions
 {
@@ -153,7 +151,7 @@ private sealed class ShiftCoordinator<T>(IObservable<T> source, TimeSpan dueTime
         /// <summary>A value indicating whether a timer or drain is active.</summary>
         private bool _timerActive;
 
-        /// <summary>A value indicating whether the source has already signaled terminal notification.</summary>
+        /// <summary>A value indicating whether the source has signaled a terminal notification.</summary>
         private bool _sourceStopped;
 
         /// <summary>A value indicating whether a terminal notification has been delivered.</summary>
@@ -348,7 +346,7 @@ private bool Deliver(DelayedNotification notification)
         /// <summary>A delayed source notification.</summary>
         private sealed class DelayedNotification
         {
-            /// <summary>Initializes a new instance of the <see cref="DelayedNotification"/> struct.</summary>
+            /// <summary>Initializes a new instance of the <see cref="DelayedNotification"/> class.</summary>
             /// <param name="kind">The notification kind.</param>
             /// <param name="value">The notification value.</param>
             /// <param name="error">The notification error.</param>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
index 8a2041a1..8f5b7a35 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
@@ -10,12 +10,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Dedicated <see cref="IObservable{T}"/> implementations for the stateful single-source operators.
-/// Building through these instead of <c>Signal.CreateSafe(observer =&gt; ...)</c> removes the
-/// per-subscription closure, delegate, CreateSafe wrapper, and safe-guard sink, leaving only the
-/// signal object at chain-build time and the operator sink at subscribe time.
-/// </summary>
+/// <summary><see cref="IObservable{T}"/> implementations for the stateful single-source operators.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>Dedicated signal for <c>Take</c>.</summary>
@@ -41,13 +36,9 @@ public IDisposable Subscribe(IObserver<T> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // A current-thread source runs its work on the trampoline of whichever call enters it first.
-            // If that call is the source's own Subscribe, the source drains the trampoline before this
-            // operator can hand the upstream subscription to its sink, so an endless source (an interval
-            // timer, a repeating loop) never learns that the count was reached and the drain never ends.
-            // Entering the trampoline here instead means the source's Subscribe only queues its work and
-            // returns, the sink owns the upstream subscription before the first value is delivered, and
-            // reaching the count disposes the source and empties the queue.
+            // A current-thread source drains the trampoline inside whichever call enters it first. When that call
+            // is the source's own Subscribe, the sink does not hold the upstream subscription yet, so an endless
+            // source never learns the count was reached. Entering the trampoline here leaves Subscribe queueing only.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -75,7 +66,7 @@ private TakeWitness<T> SubscribeCore(IObserver<T> observer)
         }
     }
 
-    /// <summary>Dedicated signal for <c>TakeUntil</c> that holds its sources without a per-subscription closure.</summary>
+    /// <summary>Dedicated signal for <c>TakeUntil</c>, holding both the source and the stop arm.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <typeparam name="TOther">The cancellation value type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -93,11 +84,9 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // Either arm can be a current-thread source, and whichever this operator subscribes first would run its
-            // work on the trampoline of that very call — draining it before the coordinator has been handed the
-            // subscription it needs in order to stop. An endless source therefore never learns the stop arm fired.
-            // Entering the trampoline here instead means both arms only queue their work and return, the coordinator
-            // owns both subscriptions before the first notification is delivered, and stopping disposes them.
+            // Either arm can be a current-thread source, and whichever is subscribed first drains the trampoline
+            // inside that call, before the coordinator holds the subscription it needs in order to stop. Entering
+            // the trampoline here leaves both arms queueing only, so the coordinator owns both subscriptions first.
             if ((!CurrentThreadRequirement.IsRequired(_source) && !CurrentThreadRequirement.IsRequired(_other))
                 || !CurrentThreadSequencer.IsScheduleRequired)
             {
@@ -115,7 +104,7 @@ public IDisposable Subscribe(IObserver<T> observer)
             return subscription;
         }
 
-        /// <summary>Subscribes the stop arm and, unless it has already fired, the source.</summary>
+        /// <summary>Subscribes the stop arm and, unless it has fired, the source.</summary>
         /// <param name="observer">The downstream observer.</param>
         /// <returns>The coordinator that owns both subscriptions.</returns>
         private TakeUntilCoordinator SubscribeCore(IObserver<T> observer)
@@ -325,7 +314,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
 
         /// <summary>Creates the duplicate-tracking set, pre-sized when the source has a known element count.</summary>
-        /// <returns>The set used to track already-observed values.</returns>
+        /// <returns>The set that tracks the values seen so far.</returns>
         private HashSet<T> CreateSeen() =>
 #if NET8_0_OR_GREATER
             (_source is RangeSignal range ? range.Count : 0) switch
@@ -469,10 +458,9 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // A current-thread source drains its trampoline inside its own Subscribe, so the sink would not own the
-            // upstream subscription until that drain ended — and on an endless source it never does, because the sink
-            // cannot dispose a subscription it has not been handed. Entering the trampoline here first means the
-            // source only queues its work, and the failing predicate can stop it.
+            // A current-thread source drains its trampoline inside its own Subscribe, so on an endless source the sink
+            // never receives the upstream subscription it would have to dispose. Entering the trampoline here leaves
+            // the source queueing only, so a failing predicate can stop it.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
index cc541eb2..6457b889 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives;
 /// <summary>The Switch operator: subscribes to the most recent inner sequence and drops the previous one.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Dedicated signal for <c>SwitchTo</c>; runs the coordinator without a Create closure.</summary>
+    /// <summary>Dedicated signal for <c>SwitchTo</c> that hands each subscription to a coordinator.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     private sealed class SwitchSignal<T> : IObservable<T>
     {
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
index e4bb79a2..7d486880 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
@@ -238,7 +238,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, TResult>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -298,7 +298,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
index b33cc90b..c5ff8289 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
@@ -47,7 +47,7 @@ public static partial class LinqExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -117,7 +117,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TRes
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -192,7 +192,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -272,7 +272,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -357,7 +357,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -447,7 +447,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -542,7 +542,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
diff --git a/src/Primitives.Shared/SignalOperatorMixins.cs b/src/Primitives.Shared/SignalOperatorMixins.cs
index 3bc5a7a1..eafa2030 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.cs
@@ -308,7 +308,7 @@ public IObservable<T> Skip(int count)
             return new SkipSignal<T>(source, count);
         }
 
-        /// <summary>Suppresses values that have already been observed.</summary>
+        /// <summary>Suppresses every value that matches one seen earlier in the sequence.</summary>
         /// <returns>A sequence containing the first occurrence of each source value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> Distinct()
@@ -318,7 +318,7 @@ public IObservable<T> Distinct()
             return new DistinctSignal<T>(source, null);
         }
 
-        /// <summary>Suppresses values that have already been observed using the supplied comparer.</summary>
+        /// <summary>Suppresses every value that the supplied comparer matches to one seen earlier.</summary>
         /// <param name="comparer">The comparer used to identify duplicate values.</param>
         /// <returns>A sequence containing the first occurrence of each source value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
@@ -634,8 +634,7 @@ public IObservable<T> Chain()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification =
-                "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+            Justification = "No argument carries the result type, so it can only come from an explicit type argument.")]
         public IObservable<TResult> KeepType<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -650,8 +649,7 @@ public IObservable<TResult> KeepType<TResult>()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification =
-                "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+            Justification = "No argument carries the result type, so it can only come from an explicit type argument.")]
         public IObservable<TResult> CastTo<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -671,8 +669,7 @@ public IObservable<TResult> CastTo<TResult>()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Concurrency",
             "PSH1315:A blocking wait on an awaitable that may not be done",
-            Justification =
-                "Synchronous read of an already-completed (RanToCompletion) task preserves the existing allocation-free fast path; await is invalid in this synchronous factory.")]
+            Justification = "The read is guarded by a RanToCompletion check, so the task is done.")]
         public IObservable<T> ToSignal()
         {
             ArgumentExceptionHelper.ThrowIfNull(task);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
index 09c0e5c5..a7b60465 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
@@ -25,7 +25,7 @@ private interface ICountSource
         IDisposable SubscribeLongCount(IObserver<long> observer);
     }
 
-    /// <summary>Distinct-by operator implemented without delegate observer wrappers.</summary>
+    /// <summary>Forwards the first source value for each distinct key.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <typeparam name="TKey">The key type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -115,7 +115,7 @@ private static int CountDistinctRange(
         }
     }
 
-    /// <summary>Count operator implemented without fold composition.</summary>
+    /// <summary>Emits the number of source values once the source completes.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     private sealed class CountSignal<T> : IRequireCurrentThread<int>
     {
@@ -153,7 +153,7 @@ public IDisposable Subscribe(IObserver<int> observer)
         }
     }
 
-    /// <summary>Predicate count operator implemented without fold composition.</summary>
+    /// <summary>Emits the number of source values that match a predicate.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="predicate">The predicate.</param>
@@ -213,7 +213,7 @@ private static void EmitCountRange(RangeSignal range, Func<T, bool> predicate, I
         }
     }
 
-    /// <summary>Long-count operator implemented without fold composition.</summary>
+    /// <summary>Emits the number of source values as a 64-bit count.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     private sealed class LongCountSignal<T> : IRequireCurrentThread<long>
     {
@@ -251,7 +251,7 @@ public IDisposable Subscribe(IObserver<long> observer)
         }
     }
 
-    /// <summary>Predicate long-count operator implemented without fold composition.</summary>
+    /// <summary>Emits the number of matching source values as a 64-bit count.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="predicate">The predicate.</param>
@@ -311,7 +311,7 @@ private static void EmitLongCountRange(RangeSignal range, Func<T, bool> predicat
         }
     }
 
-    /// <summary>Any operator implemented without predicate composition.</summary>
+    /// <summary>Emits whether the source produced any value.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     private sealed class AnySignal<T> : IRequireCurrentThread<bool>
     {
@@ -368,7 +368,7 @@ private AnyWitness<T> SubscribeCore(IObserver<bool> observer)
         }
     }
 
-    /// <summary>Predicate any operator implemented without delegate observer wrappers.</summary>
+    /// <summary>Emits whether any source value matches a predicate.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="predicate">The predicate.</param>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs b/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
index a7cde36d..24910d2c 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
@@ -66,8 +66,8 @@ public Task<T> FirstOrDefaultAsync(T defaultValue)
         /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
         /// <returns>A task that completes with the first source value, or <see langword="default"/> when the source is empty.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
-        /// <remarks>Deprioritized so calls like <c>FirstOrDefaultAsync(default!)</c> keep binding to the
-        /// <c>FirstOrDefaultAsync(T)</c> overload they compiled against before this overload existed.</remarks>
+        /// <remarks>Deprioritized, so a call like <c>FirstOrDefaultAsync(default!)</c> binds to the
+        /// <c>FirstOrDefaultAsync(T)</c> overload rather than this one.</remarks>
         [OverloadResolutionPriority(-1)]
         public Task<T> FirstOrDefaultAsync(CancellationToken cancellationToken)
         {
@@ -141,8 +141,8 @@ public Task<T> LastOrDefaultAsync(T defaultValue)
         /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
         /// <returns>A task that completes with the final source value, or <see langword="default"/> when the source is empty.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
-        /// <remarks>Deprioritized so calls like <c>LastOrDefaultAsync(default!)</c> keep binding to the
-        /// <c>LastOrDefaultAsync(T)</c> overload they compiled against before this overload existed.</remarks>
+        /// <remarks>Deprioritized, so a call like <c>LastOrDefaultAsync(default!)</c> binds to the
+        /// <c>LastOrDefaultAsync(T)</c> overload rather than this one.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [OverloadResolutionPriority(-1)]
         public Task<T> LastOrDefaultAsync(CancellationToken cancellationToken) =>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
index da97c8ec..0e786046 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives;
 /// <summary>Private helper types for boolean terminal parity operators.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Predicate all operator implemented without delegate observer wrappers.</summary>
+    /// <summary>Emits whether every source value matches a predicate.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="predicate">The predicate.</param>
@@ -98,7 +98,7 @@ private AllPredicateWitness<T> SubscribeCore(IObserver<bool> observer)
         }
     }
 
-    /// <summary>Contains operator implemented without composing Any and comparer closures.</summary>
+    /// <summary>Emits whether the source produced a value equal to the one sought.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="value">The value to locate.</param>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
index 1874be83..39229e3e 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
@@ -14,7 +14,7 @@ namespace ReactiveUI.Primitives;
 /// <summary>FlatMap helper implementations.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Chaining FlatMap signal that avoids the Map + Chain composition path.</summary>
+    /// <summary>FlatMap signal that subscribes the projected inner observables in source order.</summary>
     /// <typeparam name="TSource">The source value type.</typeparam>
     /// <typeparam name="TResult">The result value type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -119,7 +119,7 @@ private sealed class FlatMapCoordinator<TSource, TResult> : IDisposable
         /// <summary>Value indicating whether the active inner source is currently subscribing.</summary>
         private bool _subscribingInner;
 
-        /// <summary>Value indicating whether the active inner source completed while its subscribe call was still on the stack.</summary>
+        /// <summary>Value indicating whether the active inner source completed during its own subscribe call.</summary>
         private bool _completedInnerWhileSubscribing;
 
         /// <summary>Initializes a new instance of the <see cref="FlatMapCoordinator{TSource, TResult}"/> class.</summary>
@@ -129,8 +129,7 @@ private sealed class FlatMapCoordinator<TSource, TResult> : IDisposable
         [SuppressMessage(
             "Correctness",
             "SST2403:Do not let 'this' escape from a constructor",
-            Justification =
-                "The witnesses are this coordinator's own sinks, stored back into its fields, and nothing notifies them until Run subscribes.")]
+            Justification = "The witnesses are this coordinator's own fields and nothing notifies them until Run subscribes.")]
         internal FlatMapCoordinator(
             IObservable<TSource> source,
             Func<TSource, IObservable<TResult>> selector,
@@ -229,9 +228,9 @@ private void OnOuterCompleted()
         /// <param name="value">The inner value.</param>
         private void OnInnerNext(TResult value)
         {
-            // Hot path: only one inner is active at a time (sequential concat semantics), so the
-            // forward is already serialized. A lock-free volatile read of the disposed flag avoids
-            // a monitor acquire on every value; the lock releases elsewhere publish the write.
+            // Hot path: only one inner is active at a time (sequential concat semantics), so this forward is
+            // serialized without the gate. A volatile read of the disposed flag avoids a monitor acquire on
+            // every value; the lock releases elsewhere publish the write.
             if (Volatile.Read(ref _disposed))
             {
                 return;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.ForkJoin.cs b/src/Primitives.Shared/SignalOperatorParityMixins.ForkJoin.cs
index 85b07d1b..a77f4603 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.ForkJoin.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.ForkJoin.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives;
 /// <summary>The ForkJoin operator: pairs the final value of each source once both have completed.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Dedicated signal for <c>ForkJoin</c>; runs the coordinator without a Create closure.</summary>
+    /// <summary>Dedicated signal for <c>ForkJoin</c> that pairs each source's final value.</summary>
     /// <typeparam name="TLeft">The left value type.</typeparam>
     /// <typeparam name="TRight">The right value type.</typeparam>
     /// <typeparam name="TResult">The result value type.</typeparam>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
index bd7a44ee..085202b6 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
@@ -46,7 +46,7 @@ private static EmptyDisposable EmitShiftedRange<T>(Action<T> onNext, Action onCo
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Prepends a single value without composing through concat and return signals.</summary>
+    /// <summary>Emits one value, then the source sequence.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="value">The prepended value.</param>
@@ -85,7 +85,7 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
         internal T GetValue() => _value;
     }
 
-    /// <summary>Prepends an enumerable without composing through concat and enumerable signals.</summary>
+    /// <summary>Emits the values of an enumerable, then the source sequence.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="values">Values emitted before source subscription.</param>
@@ -205,7 +205,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Range timestamp projection with no intermediate map observer.</summary>
+    /// <summary>Projects a range's values into timestamped moments.</summary>
     /// <typeparam name="T">The range value type.</typeparam>
     /// <param name="range">The range source.</param>
     /// <param name="sequencer">The sequencer used to read timestamps.</param>
@@ -258,7 +258,7 @@ private void Emit(Action<Moment<T>> onNext)
             }
         }
 
-        /// <summary>Emits timestamped range values to an observer without allocating a delegate wrapper.</summary>
+        /// <summary>Emits timestamped range values straight to an observer.</summary>
         /// <param name="observer">The downstream observer.</param>
         private void Emit(IObserver<Moment<T>> observer)
         {
@@ -280,7 +280,7 @@ private void Emit(IObserver<Moment<T>> observer)
         }
     }
 
-    /// <summary>Range time-interval projection with no intermediate safe signal closure.</summary>
+    /// <summary>Projects a range's values into interval-tagged values.</summary>
     /// <typeparam name="T">The range value type.</typeparam>
     /// <param name="range">The range source.</param>
     /// <param name="sequencer">The sequencer used to read timestamps.</param>
@@ -336,7 +336,7 @@ private void Emit(Action<TimeInterval<T>> onNext)
             }
         }
 
-        /// <summary>Emits interval-tagged range values to an observer without allocating a delegate wrapper.</summary>
+        /// <summary>Emits interval-tagged range values straight to an observer.</summary>
         /// <param name="observer">The downstream observer.</param>
         private void Emit(IObserver<TimeInterval<T>> observer)
         {
@@ -361,7 +361,7 @@ private void Emit(IObserver<TimeInterval<T>> observer)
         }
     }
 
-    /// <summary>Range delay projection with no safe-signal wrapper allocation.</summary>
+    /// <summary>Emits a whole range as one batch scheduled after the due time.</summary>
     /// <typeparam name="T">The range value type.</typeparam>
     /// <param name="range">The range source.</param>
     /// <param name="dueTime">The normalized due time.</param>
@@ -531,7 +531,7 @@ private void OnError(Exception error)
             Dispose();
         }
 
-        /// <summary>Emits the value still waiting inside the quiet window, then forwards completion.</summary>
+        /// <summary>Emits any value waiting inside the quiet window, then forwards completion.</summary>
         private void OnCompleted()
         {
             lock (_gate)
@@ -543,9 +543,9 @@ private void OnCompleted()
 
                 _done = true;
 
-                // The quiet window is cut short by completion rather than cancelled by it: the value it was
-                // holding is delivered first, matching the sibling EmitIfQuiet operator. A value the timer has
-                // already delivered cleared _hasLatest under this same gate, so it cannot be emitted twice.
+                // Completion cuts the quiet window short rather than cancelling it, so a value the window was
+                // holding is delivered first. A value the timer delivered cleared _hasLatest under this same
+                // gate, so it cannot be emitted twice.
                 if (_hasLatest)
                 {
                     _hasLatest = false;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
index 991cfa71..32bc2f72 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
@@ -53,7 +53,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Coordinates a sampled observable sequence without the anonymous signal wrapper.</summary>
+    /// <summary>Coordinates a sampled observable sequence and its tick timer.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="period">The sample period.</param>
@@ -73,18 +73,14 @@ private sealed class ProbeCoordinator<T>(IObservable<T> source, TimeSpan period,
         /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer = observer;
 
-        /// <summary>
-        /// The synchronization gate. A reentrant monitor is used because emissions are serialized
-        /// while the gate is held, which a non-reentrant spin lock cannot do safely.
-        /// </summary>
+        /// <summary>The synchronization gate, reentrant because emissions are made while it is held.</summary>
         private readonly Lock _gate = new();
 
         /// <summary>The active source subscription.</summary>
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Usage",
             "CA2213:Disposable fields should be disposed",
-            Justification =
-                "Disposed via the thread-safe Interlocked.Exchange teardown in Dispose; CA2213 does not recognize disposal of a field through Interlocked.Exchange.")]
+            Justification = "Dispose tears this field down through Interlocked.Exchange.")]
         private IDisposable? _subscription;
 
         /// <summary>The active timer.</summary>
@@ -114,8 +110,8 @@ public void Dispose()
             }
 
             // Latch the terminal state as well as the resources: a source that ignores the disposal of its
-            // subscription can keep pushing, and its completion or error must not reach an observer that has
-            // already unsubscribed. The gate is reentrant, so the terminal paths may reach this while holding it.
+            // subscription can keep pushing, and its completion or error must not reach an unsubscribed observer.
+            // The gate is reentrant, so a terminal path may reach this while holding it.
             lock (_gate)
             {
                 _done = true;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
index fe02b7ac..66cd1e6c 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
@@ -54,16 +54,15 @@ public IObservable<TResult> CombineLatest<TResult>(Func<IList<T>, TResult> resul
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="sources"/> or one of its elements is <see langword="null"/>.</exception>
     /// <remarks>
-    /// Ranked below the tuple overloads, which are themselves ranked below the selector overloads. Two to
-    /// sixteen same-typed sources listed inline keep binding to the tuple overload that names each of them;
-    /// this one takes over past that arity, and whenever the sources arrive as an array.
+    /// Ranked below the tuple overloads, so two to sixteen same-typed sources listed inline bind to the tuple
+    /// overload instead; this one takes over past that arity and whenever the sources arrive as an array.
     /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [OverloadResolutionPriority(-2)]
     public static IObservable<IList<T>> CombineLatest<T>(params IObservable<T>[] sources) =>
         CombineLatestOf(CombineLatestSources(sources));
 
-    /// <summary>Builds the list-valued combine-latest signal for already-validated sources.</summary>
+    /// <summary>Builds the list-valued combine-latest signal from validated sources.</summary>
     /// <typeparam name="T">The element type shared by every source.</typeparam>
     /// <param name="sources">The validated source array.</param>
     /// <returns>The combine-latest signal.</returns>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
index f16cb135..75860fea 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
@@ -17,7 +17,7 @@ public static partial class LinqExtensions
     /// <summary>System.Reactive-named tuple-returning latest-value combination operators.</summary>
     /// <typeparam name="T">The element type of source 1.</typeparam>
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
-    /// <remarks>Lower overload priority preserves existing selector calls that pass an untyped null selector.</remarks>
+    /// <remarks>Lower overload priority keeps a call that passes an untyped null binding to the selector overload.</remarks>
     extension<T>(IObservable<T> source)
     {
         /// <summary>Combines latest values from 2 observable sources into tuple values.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
index e4bbf65c..f64774a8 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
@@ -11,11 +11,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// System.Reactive-named CombineLatest over ten through sixteen observable sources. Each overload is the
-/// System.Reactive spelling of the identically shaped <c>SyncLatest</c> overload and forwards straight to it,
-/// so the operator has a single implementation and argument-validation path.
-/// </summary>
+/// <summary>System.Reactive-named CombineLatest over ten through sixteen sources, forwarding to <c>SyncLatest</c>.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>System.Reactive-named latest-value combination operators for ten through sixteen observable sources.</summary>
@@ -53,7 +49,7 @@ public static partial class LinqExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -109,7 +105,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -169,7 +165,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -233,7 +229,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -301,7 +297,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -373,7 +369,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -449,7 +445,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
index 6fdc25d6..390af0f3 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
@@ -238,7 +238,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, TResult>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
@@ -298,7 +298,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification = "An arity-N combinator takes one observable per source; a parameter object would erase the element type each source contributes to the selector.")]
+            Justification = "An arity-N combinator takes one observable per source.")]
         public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
             IObservable<T2> source2,
             IObservable<T3> source3,
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.SubscribeSafe.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.SubscribeSafe.cs
index a90cbe79..c6bd8e73 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.SubscribeSafe.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.SubscribeSafe.cs
@@ -142,10 +142,7 @@ public static IDisposable SubscribeSafe<T>(
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "PublicApi",
         "PAS0003:Public API differs from the baseline",
-        Justification =
-            "This overload and its 'where T : struct' twin have identical signatures apart from the generic "
-            + "constraint. The baseline records both, but an entry is resolved by the constraint-erased signature "
-            + "and compared against the first match, so only one of the pair can ever be matched.")]
+        Justification = "The twin overloads differ only by a generic constraint, which the baseline lookup erases.")]
     public static IDisposable SubscribeSafe<T>(
         IObservable<T?> source,
         Action<Exception> onError,
@@ -167,10 +164,7 @@ public static IDisposable SubscribeSafe<T>(
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "Reference-type and value-type constraint overloads (where T : class / where T : struct) of the same "
-            + "operator. The bodies are necessarily identical, and the two cannot forward to one another because their "
-            + "generic constraints differ; both must exist so nullable T? resolves for either kind of T.")]
+        Justification = "The class-constrained and struct-constrained overloads cannot forward to one another.")]
     public static IDisposable SubscribeSafe<T>(
         IObservable<T?> source,
         Action<Exception> onError,
@@ -213,17 +207,11 @@ public static IDisposable SubscribeSafe<T>(
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "Reference-type and value-type constraint overloads (where T : class / where T : struct) of the same "
-            + "operator. The bodies are necessarily identical, and the two cannot forward to one another because their "
-            + "generic constraints differ; both must exist so nullable T? resolves for either kind of T.")]
+        Justification = "The class-constrained and struct-constrained overloads cannot forward to one another.")]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "PublicApi",
         "PAS0003:Public API differs from the baseline",
-        Justification =
-            "This overload and its 'where T : class' twin have identical signatures apart from the generic "
-            + "constraint. The baseline records both, but an entry is resolved by the constraint-erased signature "
-            + "and compared against the first match, so only one of the pair can ever be matched.")]
+        Justification = "The twin overloads differ only by a generic constraint, which the baseline lookup erases.")]
     public static IDisposable SubscribeSafe<T>(
         IObservable<T?> source,
         Action<Exception> onError,
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
index 55def5f4..08b03163 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
@@ -11,9 +11,8 @@ namespace ReactiveUI.Primitives;
 #endif
 
 /// <summary>
-/// System.Reactive / LINQ familiar names for the Primitives operator vocabulary. Each method builds the same sink as
-/// its Primitives-named counterpart directly, so the two names are interchangeable with identical behaviour and
-/// allocation profile. Both name sets are fully supported.
+/// System.Reactive and LINQ names for the Primitives operator vocabulary. Each one builds the same sink as its
+/// Primitives-named counterpart, so either name can be used interchangeably.
 /// </summary>
 public static partial class LinqExtensions
 {
@@ -129,8 +128,7 @@ public IObservable<T> Dematerialize()
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observer"/> is <see langword="null"/>.</exception>
         /// <remarks>
         /// System.Reactive declares an observer-taking <c>SubscribeSafe</c> in the <c>System</c> namespace, so the
-        /// two are ambiguous whenever both packages are in scope. The other <c>SubscribeSafe</c> shapes here have no
-        /// System.Reactive counterpart and stay callable under their own name.
+        /// two are ambiguous whenever both packages are in scope; the other overloads have no such counterpart.
         /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribeSafePrimitives(IObserver<T> observer) => SubscribeSafeCore(source, observer);
@@ -268,9 +266,7 @@ public IObservable<T> Synchronize()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Modernization",
             "SST2000:Use ArgumentNullException.ThrowIfNull",
-            Justification =
-                "ThrowIfNull takes object, so passing the Lock gate triggers CS9216 (unintended monitor-based locking), "
-                + "which is an error under TreatWarningsAsErrors and cannot be suppressed by attribute.")]
+            Justification = "ThrowIfNull takes object, so passing the Lock gate is a CS9216 error.")]
         public IObservable<T> Synchronize(Lock gate)
         {
             if (gate is null)
@@ -968,8 +964,7 @@ public IObservable<T> Concat()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification =
-                "The type parameter defines the element type for this Rx-style operator and cannot be inferred from the arguments.")]
+            Justification = "No argument carries the result type, so it can only come from an explicit type argument.")]
         public IObservable<TResult> OfType<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -984,8 +979,7 @@ public IObservable<TResult> OfType<TResult>()
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification =
-                "The type parameter defines the element type for this Rx-style operator and cannot be inferred from the arguments.")]
+            Justification = "No argument carries the result type, so it can only come from an explicit type argument.")]
         public IObservable<TResult> Cast<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.cs b/src/Primitives.Shared/SignalOperatorParityMixins.cs
index 915f1c02..3bacf622 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.cs
@@ -239,7 +239,7 @@ public IObservable<T> IgnoreValues()
             return new IgnoreValuesSignal<T>(source);
         }
 
-        /// <summary>Emits the supplied value if the source completes without values.</summary>
+        /// <summary>Emits <see langword="default"/> if the source completes without values.</summary>
         /// <returns>A sequence that emits <see langword="default"/> when the source is empty.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
         public IObservable<T> DefaultIfEmpty()
@@ -690,7 +690,7 @@ public IObservable<TimeInterval<T>> TimeInterval(ISequencer? scheduler)
                 : new TimeIntervalSignal<T>(source, scheduler);
         }
 
-        /// <summary>Combines latest values from both sources. Alias for latest-fusion vocabulary.</summary>
+        /// <summary>Combines the latest values from both sources into a projected result.</summary>
         /// <typeparam name="TRight">The right value type.</typeparam>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <param name="right">The right sequence.</param>
@@ -760,7 +760,7 @@ public IObservable<TResult> ForkJoin<TRight, TResult>(
         }
     }
 
-    /// <summary>Task-compatibility helpers for migrations from System.Reactive.</summary>
+    /// <summary>Conversion operators that expose a task under the System.Reactive names.</summary>
     /// <typeparam name="T">The task result type.</typeparam>
     /// <param name="task">The task.</param>
     extension<T>(Task<T> task)
@@ -771,7 +771,7 @@ public IObservable<TResult> ForkJoin<TRight, TResult>(
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Concurrency",
             "PSH1315:A blocking wait on an awaitable that may not be done",
-            Justification = "Synchronous read is limited to the already-completed task fast path.")]
+            Justification = "The read is guarded by a RanToCompletion check, so the task is done.")]
         public IObservable<T> ToObservable()
         {
             ArgumentExceptionHelper.ThrowIfNull(task);
@@ -791,13 +791,13 @@ public IObservable<T> ToObservable()
                 : new TaskInstanceSignal<T>(task);
         }
 
-        /// <summary>Identity helper that keeps source-compatible <c>FirstAsync().ToTask()</c> migrations compiling.</summary>
+        /// <summary>Returns the task unchanged, so a <c>FirstAsync().ToTask()</c> chain resolves.</summary>
         /// <returns>The supplied task.</returns>
         /// <exception cref="ArgumentNullException">The receiver task is <see langword="null"/>.</exception>
         public Task<T> ToTask() => task ?? throw new ArgumentNullException(nameof(task));
 
         /// <summary>Returns a task that mirrors the supplied task but transitions to the canceled state when
-        /// <paramref name="cancellationToken"/> is canceled first; keeps source-compatible <c>FirstAsync().ToTask(token)</c> migrations compiling.</summary>
+        /// <paramref name="cancellationToken"/> is canceled first.</summary>
         /// <param name="cancellationToken">The token used to cancel the returned task.</param>
         /// <returns>The supplied task, or a task that completes with the supplied task's outcome or cancels when <paramref name="cancellationToken"/> is canceled.</returns>
         /// <exception cref="ArgumentNullException">The receiver task is <see langword="null"/>.</exception>
@@ -816,7 +816,7 @@ public Task<T> ToTask(CancellationToken cancellationToken)
         }
     }
 
-    /// <summary>Stamps a value with the supplied scheduler's current time. A non-capturing selector reused by <c>Timestamp</c> via <c>MapWith</c>.</summary>
+    /// <summary>Stamps a value with the supplied scheduler's current time.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="scheduler">The sequencer that supplies the timestamp.</param>
     /// <param name="value">The value to stamp.</param>
@@ -837,8 +837,8 @@ private static async Task<T> AwaitWithCancellationAsync<T>(Task<T> task, Cancell
         }
         catch (OperationCanceledException)
         {
-            // The wait was abandoned while the underlying task may still be running; observe any later
-            // fault so it cannot surface as an UnobservedTaskException on the finalizer thread.
+            // The wait is abandoned while the underlying task can keep running, so observe any later fault
+            // to keep it from surfacing as an UnobservedTaskException on the finalizer thread.
             _ = task.ContinueWith(
                 static abandoned => _ = abandoned.Exception,
                 CancellationToken.None,
diff --git a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
index 9d5a8465..bc2c2f7f 100644
--- a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
@@ -174,7 +174,7 @@ public void Dispose()
         _inner.Dispose();
     }
 
-    /// <summary>Queues a value when the signal is still accepting input.</summary>
+    /// <summary>Queues a value while the signal accepts input.</summary>
     /// <param name="value">The value to enqueue.</param>
     /// <returns><see langword="true"/> when the value was queued; otherwise, <see langword="false"/>.</returns>
     private bool Enqueue(T value)
@@ -192,12 +192,10 @@ private bool Enqueue(T value)
         }
     }
 
-    /// <summary>Dequeue and forwards values while capacity is available.</summary>
+    /// <summary>Forwards queued values downstream while capacity is available.</summary>
     /// <remarks>
-    /// Only a single thread ever delivers downstream at a time. A caller that finds a drain
-    /// already in progress hands its work to the active owner and returns; the owner re-checks
-    /// for newly queued work under the gate before relinquishing ownership, so no wakeup is lost
-    /// and no two threads can deliver to the inner signal concurrently.
+    /// Only one thread delivers downstream at a time: a caller that finds a drain in progress leaves its work to the
+    /// owner, and the owner re-checks for queued work under the gate before relinquishing ownership, so no wakeup is lost.
     /// </remarks>
     private void YieldUntilEmptyOrBlocked()
     {
@@ -356,10 +354,7 @@ private void Deliver(DrainItem item)
         }
     }
 
-    /// <summary>
-    /// A captured value or terminal notification to deliver outside the gate. A readonly struct: one is produced
-    /// per delivered value on the drain path, so it is passed by value instead of allocating per item.
-    /// </summary>
+    /// <summary>A value or terminal notification captured under the gate and delivered outside it.</summary>
     private readonly record struct DrainItem
     {
         /// <summary>An empty drain item used for failed capture paths.</summary>
diff --git a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
index a6026a4b..06b85cd6 100644
--- a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
+++ b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
@@ -11,60 +11,55 @@ namespace ReactiveUI.Primitives.Signals;
 #endif
 
 /// <summary>A signal that replays buffered values to new subscribers.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <typeparam name="T">The element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ReplaySignal<T> : ISignal<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The maximum number of values replayed to a new subscriber.</summary>
     private readonly int _bufferSize;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The maximum age of a replayed value.</summary>
     private readonly TimeSpan _window;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The clock reading that buffered intervals are measured from.</summary>
     private readonly DateTimeOffset _startTime;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer supplying the clock used for window trimming.</summary>
     private readonly ISequencer _scheduler;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether a finite replay window is in effect.</summary>
     private readonly bool _usesWindow;
 
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Serializes buffer mutation, broadcast and subscription.</summary>
     private readonly Lock _observerLock = new();
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The observers values are broadcast to.</summary>
     private Broadcaster<T> _broadcaster;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether the signal has terminated.</summary>
     private bool _isStopped;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The terminal error replayed to later subscribers.</summary>
     private Exception? _lastError;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The buffered values and their intervals, used when a window or an unbounded buffer is in effect.</summary>
     private Queue<TimeInterval<T>>? _queue;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The fixed-size ring buffer, used when the buffer is bounded and no window is in effect.</summary>
     private T[]? _ring;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The number of values held in the ring.</summary>
     private int _ringCount;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The ring index the next value is written to.</summary>
     private int _ringNext;
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="bufferSize">Size of the buffer.</param>
-    /// <param name="window">The window.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <exception cref="ArgumentOutOfRangeException">
-    /// bufferSize
-    /// or
-    /// window.
-    /// </exception>
-    /// <exception cref="ArgumentNullException">scheduler.</exception>
+    /// <param name="bufferSize">The maximum number of values to replay.</param>
+    /// <param name="window">The maximum age of a replayed value.</param>
+    /// <param name="scheduler">The sequencer supplying the clock used for window trimming.</param>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> or <paramref name="window"/> is negative.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is <see langword="null"/>.</exception>
     public ReplaySignal(int bufferSize, TimeSpan window, ISequencer scheduler)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfNegative(bufferSize);
@@ -88,8 +83,8 @@ public ReplaySignal(int bufferSize, TimeSpan window, ISequencer scheduler)
     }
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="bufferSize">Size of the buffer.</param>
-    /// <param name="window">The window.</param>
+    /// <param name="bufferSize">The maximum number of values to replay.</param>
+    /// <param name="window">The maximum age of a replayed value.</param>
     public ReplaySignal(int bufferSize, TimeSpan window)
         : this(bufferSize, window, Sequencer.CurrentThread)
     {
@@ -102,50 +97,44 @@ public ReplaySignal()
     }
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer supplying the clock used for window trimming.</param>
     public ReplaySignal(ISequencer scheduler)
         : this(int.MaxValue, TimeSpan.MaxValue, scheduler)
     {
     }
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="bufferSize">Size of the buffer.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="bufferSize">The maximum number of values to replay.</param>
+    /// <param name="scheduler">The sequencer supplying the clock used for window trimming.</param>
     public ReplaySignal(int bufferSize, ISequencer scheduler)
         : this(bufferSize, TimeSpan.MaxValue, scheduler)
     {
     }
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="bufferSize">Size of the buffer.</param>
+    /// <param name="bufferSize">The maximum number of values to replay.</param>
     public ReplaySignal(int bufferSize)
         : this(bufferSize, TimeSpan.MaxValue, Sequencer.CurrentThread)
     {
     }
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="window">The window.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="window">The maximum age of a replayed value.</param>
+    /// <param name="scheduler">The sequencer supplying the clock used for window trimming.</param>
     public ReplaySignal(TimeSpan window, ISequencer scheduler)
         : this(int.MaxValue, window, scheduler) => _window = window;
 
     /// <summary>Initializes a new instance of the <see cref="ReplaySignal{T}"/> class.</summary>
-    /// <param name="window">The window.</param>
+    /// <param name="window">The maximum age of a replayed value.</param>
     public ReplaySignal(TimeSpan window)
         : this(int.MaxValue, window, Sequencer.CurrentThread)
     {
     }
 
-    /// <summary>Gets a value indicating whether this instance has observers.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance has observers; otherwise, <c>false</c>.
-    /// </value>
+    /// <summary>Gets a value indicating whether the signal has observers and has not terminated.</summary>
     public bool HasObservers => _broadcaster.HasObservers && !_isStopped;
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed { get; private set; }
 
     /// <summary>Gets the debugger display text.</summary>
@@ -153,7 +142,7 @@ public ReplaySignal(TimeSpan window)
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Drops the buffered values and observers and marks the signal disposed.</summary>
     public void Dispose()
     {
         if (IsDisposed)
@@ -174,7 +163,7 @@ public void Dispose()
         IsDisposed = true;
     }
 
-    /// <summary>Called when [completed].</summary>
+    /// <summary>Terminates the signal and completes every observer; later calls are ignored.</summary>
     public void OnCompleted()
     {
         lock (_observerLock)
@@ -196,9 +185,9 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Called when [error].</summary>
-    /// <param name="error">The exception.</param>
-    /// <exception cref="ArgumentNullException">error.</exception>
+    /// <summary>Terminates the signal with the error, forwarding it to every observer and replaying it to later subscribers.</summary>
+    /// <param name="error">The terminating exception.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="error"/> is <see langword="null"/>.</exception>
     public void OnError(Exception error)
     {
         ArgumentExceptionHelper.ThrowIfNull(error);
@@ -223,14 +212,11 @@ public void OnError(Exception error)
         }
     }
 
-    /// <summary>Called when [next].</summary>
-    /// <param name="value">The value.</param>
+    /// <summary>Buffers the value for replay and broadcasts it to the current observers.</summary>
+    /// <param name="value">The value to emit.</param>
     /// <remarks>
-    /// The buffer append and the broadcast happen together under <see cref="_observerLock"/>, which is the
-    /// same gate <see cref="Subscribe"/> holds while it adds an observer and replays the buffer. A value is
-    /// therefore atomically either buffered-and-broadcast before a new observer is added (so that observer
-    /// receives it only via replay) or buffered-and-broadcast after the observer's replay completes (so it
-    /// receives it only live) - never both, and never out of order.
+    /// The append and the broadcast share the gate <see cref="Subscribe"/> holds while it attaches an observer and
+    /// replays the buffer, so a value reaches a new observer either through replay or live, never both or out of order.
     /// </remarks>
     public void OnNext(T value)
     {
@@ -258,10 +244,10 @@ public void OnNext(T value)
         }
     }
 
-    /// <summary>Subscribes the specified observer.</summary>
-    /// <param name="observer">The observer.</param>
-    /// <returns>A Disposable.</returns>
-    /// <exception cref="ArgumentNullException">observer.</exception>
+    /// <summary>Replays the buffered values to the observer, then attaches it unless the signal has terminated.</summary>
+    /// <param name="observer">The observer to attach.</param>
+    /// <returns>A disposable that detaches the observer, or an empty disposable when the signal has terminated.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -310,8 +296,8 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the ThrowIfDisposed operation.</summary>
-    /// <exception cref="ObjectDisposedException">The signal has already been disposed.</exception>
+    /// <summary>Throws when the signal has been disposed.</summary>
+    /// <exception cref="ObjectDisposedException">The signal has been disposed.</exception>
     private void ThrowIfDisposed()
     {
         if (!IsDisposed)
@@ -322,7 +308,7 @@ private void ThrowIfDisposed()
         throw new ObjectDisposedException(string.Empty);
     }
 
-    /// <summary>Executes the Trim operation.</summary>
+    /// <summary>Drops queued values beyond the buffer size and older than the replay window.</summary>
     private void Trim()
     {
         while (_queue!.Count > _bufferSize)
@@ -343,8 +329,8 @@ private void Trim()
         }
     }
 
-    /// <summary>Executes the AppendToRing operation.</summary>
-    /// <param name="value">The value.</param>
+    /// <summary>Writes the value into the ring, overwriting the oldest entry once it is full.</summary>
+    /// <param name="value">The value to buffer.</param>
     private void AppendToRing(T value)
     {
         var ring = _ring!;
@@ -368,8 +354,8 @@ private void AppendToRing(T value)
         _ringCount++;
     }
 
-    /// <summary>Executes the ReplayRing operation.</summary>
-    /// <param name="observer">The observer value.</param>
+    /// <summary>Replays the ring contents to the observer in arrival order.</summary>
+    /// <param name="observer">The observer receiving the replay.</param>
     private void ReplayRing(IObserver<T> observer)
     {
         var ring = _ring!;
@@ -395,26 +381,25 @@ private void ReplayRing(IObserver<T> observer)
         }
     }
 
-    /// <summary>Represents the ObserverHandler class.</summary>
-    /// <param name="subject">The subject value.</param>
-    /// <param name="observer">The observer value.</param>
+    /// <summary>Detaches one observer from the signal when disposed.</summary>
+    /// <param name="subject">The signal the observer is attached to.</param>
+    /// <param name="observer">The observer to detach.</param>
     [SuppressMessage(
         "Usage",
         "CA2213:Disposable fields should be disposed",
-        Justification = "_subject is the signal that owns this subscription, not a resource it owns; disposing it would tear down the signal when one observer unsubscribes.")]
+        Justification = "The field references the owning signal, not a resource this subscription owns.")]
     private sealed class ObserverHandler(ReplaySignal<T> subject, IObserver<T> observer) : IDisposable
     {
-        /// <summary>Executes the new operation.</summary>
-        /// <returns>The result.</returns>
+        /// <summary>Serializes concurrent disposal.</summary>
         private readonly Lock _lock = new();
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The signal the observer is attached to; null once disposed.</summary>
         private ReplaySignal<T>? _subject = subject;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The observer to detach; null once disposed.</summary>
         private IObserver<T>? _observer = observer;
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Removes the observer from the signal and clears both references.</summary>
         public void Dispose()
         {
             lock (_lock)
diff --git a/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs b/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
index 210ff458..6e0a4983 100644
--- a/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
@@ -18,22 +18,22 @@ public class ScheduledSignal<T> : ISignal<T>
     /// <summary>Guards default-observer and subscription-count state.</summary>
     private readonly Lock _observerLock = new();
 
-    /// <summary>Stores the fallback observer for the signal implementation.</summary>
+    /// <summary>The observer that receives values while no other subscriber is active.</summary>
     private readonly IObserver<T>? _defaultObserver;
 
-    /// <summary>Stores the scheduler for the signal implementation.</summary>
+    /// <summary>The sequencer notifications are emitted on.</summary>
     private readonly ISequencer _scheduler;
 
-    /// <summary>Stores the underlying signal implementation.</summary>
+    /// <summary>The backing signal this instance wraps.</summary>
     private readonly ISignal<T> _subject;
 
-    /// <summary>Stores the active non-default observer count.</summary>
+    /// <summary>The number of active non-default observers.</summary>
     private int _observerRefCount;
 
-    /// <summary>Stores the active default-observer subscription.</summary>
+    /// <summary>The default observer's subscription, or null while other subscribers are attached.</summary>
     private IDisposable? _defaultObserverSub;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether this instance has been disposed.</summary>
     private bool _isDisposed;
 
     /// <summary>Initializes a new instance of the <see cref="ScheduledSignal{T}"/> class.</summary>
@@ -164,8 +164,8 @@ protected virtual void Dispose(bool disposing)
     }
 
     /// <summary>Subscribes the default observer through the configured scheduler.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The subscription value.</returns>
+    /// <param name="observer">The default observer.</param>
+    /// <returns>The subscription to dispose once another observer arrives.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private IDisposable SubscribeDefaultObserver(IObserver<T> observer) =>
         _subject.ObserveOn(_scheduler).Subscribe(observer);
@@ -180,7 +180,7 @@ private void ReleaseObserver()
     }
 
     /// <summary>Releases one observer while the observer lock is held.</summary>
-    /// <param name="defaultObserver">The default observer value.</param>
+    /// <param name="defaultObserver">The default observer to resubscribe once the last observer leaves, or null when there is none.</param>
     private void ReleaseObserverLocked(IObserver<T>? defaultObserver)
     {
         if (_observerRefCount > 0)
@@ -196,7 +196,7 @@ private void ReleaseObserverLocked(IObserver<T>? defaultObserver)
         _defaultObserverSub = SubscribeDefaultObserver(defaultObserver);
     }
 
-    /// <summary>Executes the ThrowIfDisposed operation.</summary>
+    /// <summary>Throws when this instance or its backing signal has been disposed.</summary>
     /// <exception cref="ObjectDisposedException">This instance or its backing signal has been disposed.</exception>
     private void ThrowIfDisposed()
     {
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
index 82d98c0a..e4a506ca 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
@@ -19,9 +19,9 @@ public static partial class SignalExtensions
     /// <param name="source">The source signal.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Witnesses the on.</summary>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <returns>An Observable.</returns>
+        /// <summary>Delivers the source notifications on the supplied sequencer.</summary>
+        /// <param name="scheduler">The sequencer that notifications are delivered on.</param>
+        /// <returns>A signal that forwards the source on <paramref name="scheduler"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> WitnessOn(ISequencer scheduler) =>
             new WitnessOnSignal<T>(source, scheduler);
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs b/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
index dd08c445..52c95051 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
@@ -18,21 +18,17 @@ public static partial class SignalExtensions
     /// <param name="asyncTask">The asynchronous task.</param>
     extension<TResult>(IObservable<TResult> asyncTask)
     {
-        /// <summary>Handles the cancellation.</summary>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        /// A Task.
-        /// </returns>
+        /// <summary>Awaits the source and returns its final value, or the default value when the token cancels the wait.</summary>
+        /// <param name="token">The token that cancels the wait.</param>
+        /// <returns>A task carrying the final source value, or the default value on cancellation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Task<TResult?> HandleCancellation(CancellationToken token) =>
             asyncTask.HandleCancellation(null, token);
 
-        /// <summary>Handles the cancellation.</summary>
-        /// <param name="action">The action.</param>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        /// A Task.
-        /// </returns>
+        /// <summary>Awaits the source and returns its final value; on cancellation invokes the action and returns the default value.</summary>
+        /// <param name="action">Invoked when the wait is cancelled.</param>
+        /// <param name="token">The token that cancels the wait.</param>
+        /// <returns>A task carrying the final source value, or the default value on cancellation.</returns>
         public async Task<TResult?> HandleCancellation(Action? action, CancellationToken token)
         {
             try
@@ -53,14 +49,14 @@ public static partial class SignalExtensions
     /// <param name="asyncTask">The asynchronous task.</param>
     extension(Task asyncTask)
     {
-        /// <summary>Handles the cancellation.</summary>
-        /// <returns>A Task.</returns>
+        /// <summary>Awaits the task and completes normally when it is cancelled.</summary>
+        /// <returns>A task that completes once the awaited task finishes or is cancelled.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Task HandleCancellation() => asyncTask.HandleCancellation(null);
 
-        /// <summary>Handles the cancellation.</summary>
-        /// <param name="action">The action.</param>
-        /// <returns>A Task.</returns>
+        /// <summary>Awaits the task and invokes the action instead of throwing when it is cancelled.</summary>
+        /// <param name="action">Invoked when the task is cancelled.</param>
+        /// <returns>A task that completes once the awaited task finishes or is cancelled.</returns>
         public async Task HandleCancellation(Action? action)
         {
             try
@@ -79,14 +75,14 @@ public async Task HandleCancellation(Action? action)
     /// <param name="asyncTask">The asynchronous task.</param>
     extension<TResult>(Task<TResult> asyncTask)
     {
-        /// <summary>Handles the cancellation.</summary>
-        /// <returns>A Task of TResult.</returns>
+        /// <summary>Awaits the task and returns its result, or the default value when it is cancelled.</summary>
+        /// <returns>A task carrying the result, or the default value on cancellation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Task<TResult?> HandleCancellation() => asyncTask.HandleCancellation(null);
 
-        /// <summary>Handles the cancellation.</summary>
-        /// <param name="action">The action.</param>
-        /// <returns>A Task of TResult.</returns>
+        /// <summary>Awaits the task and returns its result; on cancellation invokes the action and returns the default value.</summary>
+        /// <param name="action">Invoked when the task is cancelled.</param>
+        /// <returns>A task carrying the result, or the default value on cancellation.</returns>
         public async Task<TResult?> HandleCancellation(Action? action)
         {
             try
@@ -101,9 +97,9 @@ public async Task HandleCancellation(Action? action)
             return default;
         }
 
-        /// <summary>Executes the WhenCancelled operation.</summary>
-        /// <param name="cancellationToken">The cancellationToken value.</param>
-        /// <returns>The result.</returns>
+        /// <summary>Awaits whichever completes first, the task or the token, and reports which one it was.</summary>
+        /// <param name="cancellationToken">The token raced against the task.</param>
+        /// <returns>The task result, and whether the wait ended in cancellation.</returns>
         internal async Task<(TResult Value, bool IsCanceled)> WhenCancelled(CancellationToken cancellationToken)
         {
             TaskCompletionSource<TResult> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs b/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
index a6457b23..8172b432 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
@@ -23,7 +23,7 @@ public static partial class SignalExtensions
         /// This operation subscribes to the observable sequence, making it hot.
         /// </summary>
         /// <returns>A final signal awaiter.</returns>
-        /// <exception cref="ArgumentExceptionHelper">source.</exception>
+        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IAwaitSignal<TSource> GetAwaiter() =>
             Signal.RunAsync(source);
@@ -32,11 +32,9 @@ public IAwaitSignal<TSource> GetAwaiter() =>
         /// Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty.
         /// This operation subscribes to the observable sequence, making it hot.
         /// </summary>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <returns>
-        /// A final signal awaiter.
-        /// </returns>
-        /// <exception cref="ArgumentExceptionHelper">source.</exception>
+        /// <param name="cancellationToken">Token that cancels the await and disposes the subscription.</param>
+        /// <returns>A final signal awaiter.</returns>
+        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IAwaitSignal<TSource> GetAwaiter(CancellationToken cancellationToken) =>
             Signal.RunAsync(source, cancellationToken);
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
index fac3b590..a15b63e8 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
@@ -51,9 +51,9 @@ public IObservable<TSource> Recover<TException>(Func<TException, IObservable<TSo
             return new RecoverSignal<TSource, TException>(source, handler);
         }
 
-        /// <summary>Finallies the specified finally action.</summary>
-        /// <param name="finallyAction">The finally action.</param>
-        /// <returns>An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.</returns>
+        /// <summary>Invokes an action when the subscription is torn down, whether the source terminated or the subscription was disposed.</summary>
+        /// <param name="finallyAction">The action to invoke on teardown.</param>
+        /// <returns>An observable sequence that forwards the source and invokes <paramref name="finallyAction"/> on teardown.</returns>
         public IObservable<TSource> OnCleanup(Action finallyAction)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/Primitives.Shared/Signals/Signal{Collect}.cs b/src/Primitives.Shared/Signals/Signal{Collect}.cs
index c84636f3..2d7c3d8a 100644
--- a/src/Primitives.Shared/Signals/Signal{Collect}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Collect}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Signals;
 namespace ReactiveUI.Primitives.Signals;
 #endif
 
-/// <summary>Create Signals functionality.</summary>
+/// <summary>Time-windowed buffering support for the signal factory surface.</summary>
 public static partial class Signal
 {
     /// <summary>Coordinates time-windowed buffering for a single subscription.</summary>
@@ -38,7 +38,7 @@ internal sealed class CollectCoordinator<TSource>(IObserver<IList<TSource>> obse
         /// <summary>The values collected for the current window.</summary>
         private readonly List<TSource> _values = [];
 
-        /// <summary>Whether a flush has already been scheduled for the current window.</summary>
+        /// <summary>Whether a flush is scheduled for the current window.</summary>
         private bool _flushScheduled;
 
         /// <summary>Whether the source has terminated.</summary>
@@ -89,7 +89,7 @@ private void OnCompleted()
             _observer.OnCompleted();
         }
 
-        /// <summary>Flushes the current window if it still has buffered values.</summary>
+        /// <summary>Emits the current window when it holds buffered values.</summary>
         private void Flush()
         {
             var batch = TakeScheduledBatch();
diff --git a/src/Primitives.Shared/Signals/Signal{Create}.cs b/src/Primitives.Shared/Signals/Signal{Create}.cs
index 854c0777..61632298 100644
--- a/src/Primitives.Shared/Signals/Signal{Create}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Create}.cs
@@ -12,17 +12,16 @@ namespace ReactiveUI.Primitives.Reactive.Signals;
 namespace ReactiveUI.Primitives.Signals;
 #endif
 
-/// <summary>Create Signals functionality.</summary>
+/// <summary>Factory methods that build signals from subscribe functions and deferred sources.</summary>
 public static partial class Signal
 {
     /// <summary>
-    /// Create anonymous Signals. Observer has exception durability.
-    /// This is recommended for make operator and event, generating a HotSignals.
+    /// Creates a signal that runs the subscribe function for each observer. A downstream <c>OnNext</c> that throws
+    /// leaves the subscription intact, which suits hot signals built over operators and events.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <returns>An Signals.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)
     {
@@ -51,10 +50,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, Task<IDisposable>> sub
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "A deliberate overload accepting a cancellable subscribe delegate. The body matches the non-cancellable "
-            + "overload because AsyncCreateSignal<T> exposes a constructor for each delegate shape; the two take "
-            + "different delegate types and cannot forward to one another.")]
+        Justification = "The overloads take different delegate types and cannot forward to one another.")]
     public static IObservable<T> Create<T>(Func<IObserver<T>, CancellationToken, Task<IDisposable>> subscribe)
     {
         ArgumentExceptionHelper.ThrowIfNull(subscribe);
@@ -63,14 +59,13 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, CancellationToken, Tas
     }
 
     /// <summary>
-    /// Create anonymous Signals. Observer has exception durability.
-    /// This is recommended for make operator and event, generating a HotSignals.
+    /// Creates a signal that runs the subscribe function for each observer. A downstream <c>OnNext</c> that throws
+    /// leaves the subscription intact, which suits hot signals built over operators and events.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
-    /// <returns>An Signals.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> Create<T>(
         Func<IObserver<T>, IDisposable> subscribe,
@@ -82,15 +77,14 @@ public static IObservable<T> Create<T>(
     }
 
     /// <summary>
-    /// Create anonymous Signals. Observer has exception durability.
-    /// This is recommended for make operator and event, generating a HotSignals.
+    /// Creates a signal that passes the state to the subscribe function for each observer, so the function can be
+    /// static instead of capturing a closure.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <typeparam name="TState">The type of the state.</typeparam>
-    /// <param name="state">The state.</param>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <returns>An Signals.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TState">The type of the captured state.</typeparam>
+    /// <param name="state">The state passed to <paramref name="subscribe"/> on each subscription.</param>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateWithState<T, TState>(
         TState state,
@@ -102,16 +96,15 @@ public static IObservable<T> CreateWithState<T, TState>(
     }
 
     /// <summary>
-    /// Create anonymous Signals. Observer has exception durability.
-    /// This is recommended for make operator and event, generating a HotSignals.
+    /// Creates a signal that passes the state to the subscribe function for each observer, so the function can be
+    /// static instead of capturing a closure.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <typeparam name="TState">The type of the state.</typeparam>
-    /// <param name="state">The state.</param>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
-    /// <returns>An Signals.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <typeparam name="TState">The type of the captured state.</typeparam>
+    /// <param name="state">The state passed to <paramref name="subscribe"/> on each subscription.</param>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateWithState<T, TState>(
         TState state,
@@ -124,13 +117,12 @@ public static IObservable<T> CreateWithState<T, TState>(
     }
 
     /// <summary>
-    /// Create anonymous Signals. Safe means auto detach when error raised in onNext pipeline.
-    /// This is recommended for making a ColdSignals.
+    /// Creates a signal that runs the subscribe function for each observer and releases the subscription when a
+    /// downstream <c>OnNext</c> throws, which suits cold signals.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <returns>An Signals.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe)
     {
@@ -140,14 +132,13 @@ public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subsc
     }
 
     /// <summary>
-    /// Create anonymous Signals. Safe means auto detach when error raised in onNext pipeline.
-    /// This is recommended for making a ColdSignals.
+    /// Creates a signal that runs the subscribe function for each observer and releases the subscription when a
+    /// downstream <c>OnNext</c> throws, which suits cold signals.
     /// </summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="subscribe">The subscribe.</param>
-    /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
-    /// <returns>An Observable.</returns>
-    /// <exception cref="ArgumentExceptionHelper">subscribe.</exception>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
+    /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
+    /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateSafe<T>(
         Func<IObserver<T>, IDisposable> subscribe,
@@ -159,9 +150,9 @@ public static IObservable<T> CreateSafe<T>(
     }
 
     /// <summary>Lazily creates the source sequence for each subscription.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="observableFactory">The observable factory.</param>
-    /// <returns>An Observable.</returns>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="observableFactory">Invoked once per subscription to build the source.</param>
+    /// <returns>A signal that subscribes to the factory-produced source for each observer.</returns>
     public static IObservable<T> Lazy<T>(Func<IObservable<T>> observableFactory)
     {
         ArgumentExceptionHelper.ThrowIfNull(observableFactory);
@@ -189,10 +180,7 @@ public static IObservable<T> Defer<T>(Func<Task<IObservable<T>>> observableFacto
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "A deliberate overload accepting a cancellable factory delegate. The body matches the non-cancellable "
-            + "overload because AsyncDeferSignal<T> exposes a constructor for each delegate shape; the two take "
-            + "different delegate types and cannot forward to one another.")]
+        Justification = "The overloads take different delegate types and cannot forward to one another.")]
     public static IObservable<T> Defer<T>(Func<CancellationToken, Task<IObservable<T>>> observableFactory)
     {
         ArgumentExceptionHelper.ThrowIfNull(observableFactory);
diff --git a/src/Primitives.Shared/Signals/Signal{Emit}.cs b/src/Primitives.Shared/Signals/Signal{Emit}.cs
index 6d24f725..b2af64bd 100644
--- a/src/Primitives.Shared/Signals/Signal{Emit}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Emit}.cs
@@ -13,47 +13,47 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Emit a single value on the specified scheduler.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="value">The value.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits a single value on the supplied scheduler and completes.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="value">The value to emit.</param>
+    /// <param name="scheduler">The scheduler the value is emitted on.</param>
+    /// <returns>A signal that emits <paramref name="value"/> and completes.</returns>
     public static IObservable<T> Emit<T>(T value, ISequencer scheduler) => scheduler == Sequencer.Immediate
         ? new ImmediateReturnSignal<T>(value)
         : new ReturnSignal<T>(value, scheduler);
 
-    /// <summary>Emit a single value immediately.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="value">The value.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits a single value to each subscriber and completes, without scheduling.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="value">The value to emit.</param>
+    /// <returns>A signal that emits <paramref name="value"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> Emit<T>(T value) =>
         new ImmediateReturnSignal<T>(value);
 
-    /// <summary>Emit a single RxVoid value immediately, optimized for no allocation.</summary>
-    /// <param name="value">The value.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Returns the shared signal that emits the unit value and completes, without allocating.</summary>
+    /// <param name="value">The unit value to emit.</param>
+    /// <returns>A signal that emits <see cref="RxVoid.Default"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<RxVoid> Emit(RxVoid value) =>
         ImmutableReturnRxVoidSignal.Instance;
 
-    /// <summary>Emit a single Boolean value immediately, optimized for no allocation.</summary>
-    /// <param name="value">if set to <c>true</c> [value].</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Returns one of the two shared Boolean signals that emit the value and complete, without allocating.</summary>
+    /// <param name="value">The value to emit.</param>
+    /// <returns>A signal that emits <paramref name="value"/> and completes.</returns>
     public static IObservable<bool> Emit(bool value) =>
         value
             ? ImmutableReturnTrueSignal.Instance
             : ImmutableReturnFalseSignal.Instance;
 
-    /// <summary>Emit a single Int32 value immediately, optimized for cached values.</summary>
-    /// <param name="value">The value.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits a single 32-bit integer and completes, without scheduling.</summary>
+    /// <param name="value">The value to emit.</param>
+    /// <returns>A signal that emits <paramref name="value"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<int> Emit(int value) =>
         new ImmediateReturnSignal<int>(value);
 
-    /// <summary>Same as Signals.Emit(RxVoid.Default); but no allocate memory.</summary>
-    /// <returns>An Signals.</returns>
+    /// <summary>Returns the shared signal that emits the unit value and completes, without allocating.</summary>
+    /// <returns>A signal that emits <see cref="RxVoid.Default"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<RxVoid> EmitRxVoid() =>
         ImmutableReturnRxVoidSignal.Instance;
diff --git a/src/Primitives.Shared/Signals/Signal{Factories}.cs b/src/Primitives.Shared/Signals/Signal{Factories}.cs
index d07e1dfd..ba4f3e45 100644
--- a/src/Primitives.Shared/Signals/Signal{Factories}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Factories}.cs
@@ -18,7 +18,7 @@ public static partial class Signal
     /// <summary>Creates a finite integer signal from <paramref name="start"/> for <paramref name="count"/> values.</summary>
     /// <param name="start">The first value to emit.</param>
     /// <param name="count">The number of values to emit.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits <paramref name="count"/> consecutive integers and completes.</returns>
     public static IObservable<int> Sequence(int start, int count)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfNegative(count);
@@ -29,8 +29,8 @@ public static IObservable<int> Sequence(int start, int count)
     /// <summary>Creates a finite integer signal from <paramref name="start"/> for <paramref name="count"/> values on <paramref name="scheduler"/>.</summary>
     /// <param name="start">The first value to emit.</param>
     /// <param name="count">The number of values to emit.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the values are emitted on.</param>
+    /// <returns>A signal that emits <paramref name="count"/> consecutive integers and completes.</returns>
     public static IObservable<int> Sequence(int start, int count, ISequencer scheduler)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfNegative(count);
@@ -48,18 +48,18 @@ public static IObservable<int> Sequence(int start, int count, ISequencer schedul
     }
 
     /// <summary>Creates a signal that repeats a value forever.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="value">The value.</param>
-    /// <returns>An Signals.</returns>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="value">The value to repeat.</param>
+    /// <returns>A signal that repeats <paramref name="value"/> and never completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> Loop<T>(T value) =>
         new LoopSignal<T>(value);
 
     /// <summary>Creates a signal that repeats a value <paramref name="count"/> times.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="value">The value.</param>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="value">The value to repeat.</param>
     /// <param name="count">The number of times to repeat the value.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits <paramref name="value"/> <paramref name="count"/> times and completes.</returns>
     public static IObservable<T> Loop<T>(T value, int count)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfNegative(count);
@@ -74,7 +74,7 @@ public static IObservable<T> Loop<T>(T value, int count)
     /// <param name="condition">The condition that determines whether to continue.</param>
     /// <param name="iterate">The function that advances the state.</param>
     /// <param name="resultSelector">The function that produces the result from the state.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits a projection of each state until the condition fails, then completes.</returns>
     public static IObservable<TResult> Unfold<TState, TResult>(
         TState initialState,
         Func<TState, bool> condition,
@@ -97,7 +97,7 @@ public static IObservable<TResult> Unfold<TState, TResult>(
     /// <param name="condition">The condition that determines whether to continue.</param>
     /// <param name="iterator">The function that advances the state.</param>
     /// <param name="resultSelector">The function that produces the result from the state.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits a projection of each state until the condition fails, then completes.</returns>
     public static IObservable<TResult> Iterate<TState, TResult>(
         TState initialState,
         Func<TState, bool> condition,
@@ -115,10 +115,10 @@ public static IObservable<TResult> Iterate<TState, TResult>(
 
     /// <summary>Creates a signal whose subscription lifetime owns a resource.</summary>
     /// <typeparam name="TResource">The type of the resource.</typeparam>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="resourceFactory">The factory that creates the resource.</param>
     /// <param name="signalFactory">The factory that creates the signal from the resource.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that disposes the resource when the subscription ends.</returns>
     public static IObservable<T> Use<TResource, T>(
         Func<TResource> resourceFactory,
         Func<TResource, IObservable<T>> signalFactory)
@@ -134,7 +134,7 @@ public static IObservable<T> Use<TResource, T>(
     /// <summary>Converts an event into a signal of event pattern values.</summary>
     /// <param name="addHandler">The action that subscribes the event handler.</param>
     /// <param name="removeHandler">The action that unsubscribes the event handler.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits an event pattern for each raised event.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<EventPattern<EventArgs>> FromEventPattern(
         Action<EventHandler> addHandler,
@@ -163,7 +163,7 @@ public static IObservable<EventPattern<EventArgs>> FromEventPattern(
     /// <typeparam name="TEventArgs">The type of the event arguments.</typeparam>
     /// <param name="addHandler">The action that subscribes the event handler.</param>
     /// <param name="removeHandler">The action that unsubscribes the event handler.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits an event pattern for each raised event.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(
         Action<EventHandler<TEventArgs>> addHandler,
@@ -202,8 +202,7 @@ public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The event argument type is part of the returned EventPattern and must be specified for non-generic event handlers.")]
+        Justification = "The event argument type appears only in the return type.")]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(
         Action<TEventHandler> addHandler,
@@ -224,8 +223,7 @@ public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandl
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The event argument type is part of the returned EventPattern and must be specified for non-generic event handlers.")]
+        Justification = "The event argument type appears only in the return type.")]
     public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(
         Action<TEventHandler> addHandler,
         Action<TEventHandler> removeHandler,
@@ -299,7 +297,7 @@ public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandl
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "The sender type is part of the returned EventPattern and cannot be inferred from the handler conversion.")]
+        Justification = "The sender type appears only in the return type.")]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TEventHandler, TSender, TEventArgs>(
         Func<EventHandler<TEventArgs>, TEventHandler> conversion,
@@ -323,7 +321,7 @@ public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TE
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "The sender type is part of the returned EventPattern and cannot be inferred from the handler conversion.")]
+        Justification = "The sender type appears only in the return type.")]
     public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TEventHandler, TSender, TEventArgs>(
         Func<EventHandler<TEventArgs>, TEventHandler> conversion,
         Action<TEventHandler> addHandler,
@@ -401,9 +399,9 @@ public static IObservable<TEventArgs> FromEvent<TEventHandler, TEventArgs>(
     }
 
     /// <summary>Creates a signal from an enumerable sequence.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="values">The values to emit.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits each value in order and completes.</returns>
     public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values)
     {
         ArgumentExceptionHelper.ThrowIfNull(values);
@@ -412,10 +410,10 @@ public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values)
     }
 
     /// <summary>Creates a signal from an enumerable sequence and stops enumeration when the token is cancelled.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="values">The values to emit.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="cancellationToken">The token that stops enumeration.</param>
+    /// <returns>A signal that emits each value in order and completes.</returns>
     public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values, CancellationToken cancellationToken)
     {
         ArgumentExceptionHelper.ThrowIfNull(values);
@@ -426,14 +424,13 @@ public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values, Cancellati
     }
 
     /// <summary>Creates a signal from a task instance.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="task">The task to convert.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits the task result and completes, or fails with the task error.</returns>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification =
-            "Synchronous read of an already-completed (RanToCompletion) task for an allocation-free fast path; await is invalid in this synchronous factory.")]
+        Justification = "The result is read only once the task status is RanToCompletion.")]
     public static IObservable<T> FromTask<T>(Task<T> task)
     {
         ArgumentExceptionHelper.ThrowIfNull(task);
@@ -454,9 +451,9 @@ public static IObservable<T> FromTask<T>(Task<T> task)
     }
 
     /// <summary>Creates a signal by invoking an asynchronous factory at subscription time.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="taskFactory">The factory that creates the task.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits the task result and completes.</returns>
     public static IObservable<T> FromAsync<T>(Func<Task<T>> taskFactory)
     {
         ArgumentExceptionHelper.ThrowIfNull(taskFactory);
@@ -465,18 +462,18 @@ public static IObservable<T> FromAsync<T>(Func<Task<T>> taskFactory)
     }
 
     /// <summary>Creates a signal by invoking an asynchronous factory at subscription time.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="taskFactory">The factory that creates the task.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits the task result and completes, cancelling the task when the subscription ends.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> FromAsync<T>(Func<CancellationToken, Task<T>> taskFactory) =>
         new FromAsyncSignal<T>(taskFactory);
 
     /// <summary>Creates a signal by invoking an asynchronous factory at subscription time.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="taskFactory">The factory that creates the task.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="cancellationToken">The external token that cancels the task.</param>
+    /// <returns>A signal that emits the task result and completes.</returns>
     public static IObservable<T> FromAsync<T>(
         Func<CancellationToken, Task<T>> taskFactory,
         CancellationToken cancellationToken)
@@ -512,10 +509,10 @@ public static IObservable<T> Expire<T>(IObservable<T> source, TimeSpan dueTime,
         return new ExpireSignal<T>(source, dueTime, scheduler);
     }
 
-    /// <summary>Runs a function on the supplied scheduler and emits its result.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <summary>Runs a function on the default sequencer and emits its result.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="function">The function to run.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits the function result and completes.</returns>
     public static IObservable<T> Start<T>(Func<T> function)
     {
         ArgumentExceptionHelper.ThrowIfNull(function);
@@ -524,10 +521,10 @@ public static IObservable<T> Start<T>(Func<T> function)
     }
 
     /// <summary>Runs a function on the supplied scheduler and emits its result.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="function">The function to run.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the function runs on.</param>
+    /// <returns>A signal that emits the function result and completes.</returns>
     public static IObservable<T> Start<T>(Func<T> function, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(function);
@@ -537,9 +534,9 @@ public static IObservable<T> Start<T>(Func<T> function, ISequencer scheduler)
         return new StartSignal<T>(function, scheduler);
     }
 
-    /// <summary>Runs an action on the supplied scheduler and emits <see cref="RxVoid.Default"/> when it completes.</summary>
+    /// <summary>Runs an action on the default sequencer and emits <see cref="RxVoid.Default"/> when it completes.</summary>
     /// <param name="action">The action to run.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits the unit value and completes.</returns>
     public static IObservable<RxVoid> Start(Action action)
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
@@ -549,8 +546,8 @@ public static IObservable<RxVoid> Start(Action action)
 
     /// <summary>Runs an action on the supplied scheduler and emits <see cref="RxVoid.Default"/> when it completes.</summary>
     /// <param name="action">The action to run.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the action runs on.</param>
+    /// <returns>A signal that emits the unit value and completes.</returns>
     public static IObservable<RxVoid> Start(Action action, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
@@ -562,9 +559,9 @@ public static IObservable<RxVoid> Start(Action action, ISequencer scheduler)
 
 #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER || NET5_0_OR_GREATER
     /// <summary>Creates a signal from an async enumerable sequence and cancels enumeration when disposed.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="values">The values to emit.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits each value in order and completes.</returns>
     public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values)
     {
         ArgumentExceptionHelper.ThrowIfNull(values);
@@ -573,10 +570,10 @@ public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values)
     }
 
     /// <summary>Creates a signal from an async enumerable sequence and cancels enumeration when disposed.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="values">The values to emit.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="cancellationToken">The token that stops enumeration.</param>
+    /// <returns>A signal that emits each value in order and completes.</returns>
     public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values, CancellationToken cancellationToken)
     {
         ArgumentExceptionHelper.ThrowIfNull(values);
@@ -588,15 +585,15 @@ public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values,
 
     /// <summary>Emits a single zero tick after the due time.</summary>
     /// <param name="dueTime">The relative time after which to emit the tick.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits 0 after <paramref name="dueTime"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<long> After(TimeSpan dueTime) =>
         new AfterSignal(dueTime, ThreadPoolSequencer.Instance);
 
     /// <summary>Emits a single zero tick after the due time.</summary>
     /// <param name="dueTime">The relative time after which to emit the tick.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the tick is emitted on.</param>
+    /// <returns>A signal that emits 0 after <paramref name="dueTime"/> and completes.</returns>
     public static IObservable<long> After(TimeSpan dueTime, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -606,15 +603,15 @@ public static IObservable<long> After(TimeSpan dueTime, ISequencer scheduler)
 
     /// <summary>Emits a single zero tick at the specified absolute due time.</summary>
     /// <param name="dueTime">The absolute time at which to emit the tick.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits 0 at <paramref name="dueTime"/> and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<long> After(DateTimeOffset dueTime) =>
         new AfterSignal(Sequencer.Normalize(dueTime - ThreadPoolSequencer.Instance.Now), ThreadPoolSequencer.Instance);
 
     /// <summary>Emits a single zero tick at the specified absolute due time.</summary>
     /// <param name="dueTime">The absolute time at which to emit the tick.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the tick is emitted on.</param>
+    /// <returns>A signal that emits 0 at <paramref name="dueTime"/> and completes.</returns>
     public static IObservable<long> After(DateTimeOffset dueTime, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -625,7 +622,7 @@ public static IObservable<long> After(DateTimeOffset dueTime, ISequencer schedul
     /// <summary>Emits first after <paramref name="dueTime"/> and then at <paramref name="period"/>.</summary>
     /// <param name="dueTime">The relative time before the first tick.</param>
     /// <param name="period">The period between subsequent ticks.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits increasing ticks, the first after <paramref name="dueTime"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<long> After(TimeSpan dueTime, TimeSpan period) =>
         new AfterSignal(dueTime, period, ThreadPoolSequencer.Instance);
@@ -633,8 +630,8 @@ public static IObservable<long> After(TimeSpan dueTime, TimeSpan period) =>
     /// <summary>Emits first after <paramref name="dueTime"/> and then at <paramref name="period"/>.</summary>
     /// <param name="dueTime">The relative time before the first tick.</param>
     /// <param name="period">The period between subsequent ticks.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the ticks are emitted on.</param>
+    /// <returns>A signal that emits increasing ticks, the first after <paramref name="dueTime"/>.</returns>
     public static IObservable<long> After(TimeSpan dueTime, TimeSpan period, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -644,7 +641,7 @@ public static IObservable<long> After(TimeSpan dueTime, TimeSpan period, ISequen
 
     /// <summary>Emits monotonically increasing ticks at the specified period.</summary>
     /// <param name="period">The period between ticks.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits increasing ticks every <paramref name="period"/>.</returns>
     public static IObservable<long> Every(TimeSpan period)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(period, TimeSpan.Zero);
@@ -654,8 +651,8 @@ public static IObservable<long> Every(TimeSpan period)
 
     /// <summary>Emits monotonically increasing ticks at the specified period.</summary>
     /// <param name="period">The period between ticks.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <param name="scheduler">The scheduler the ticks are emitted on.</param>
+    /// <returns>A signal that emits increasing ticks every <paramref name="period"/>.</returns>
     public static IObservable<long> Every(TimeSpan period, ISequencer scheduler)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(period, TimeSpan.Zero);
@@ -666,9 +663,9 @@ public static IObservable<long> Every(TimeSpan period, ISequencer scheduler)
     }
 
     /// <summary>Concatenates the supplied signals.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="sources">The signals to concatenate.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that subscribes to each source after the previous one completes.</returns>
     public static IObservable<T> Chain<T>(params IObservable<T>[] sources)
     {
         var validated = ValidateSources(sources);
@@ -677,9 +674,9 @@ public static IObservable<T> Chain<T>(params IObservable<T>[] sources)
     }
 
     /// <summary>Merges the supplied signals.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="sources">The signals to merge.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that forwards values from every source.</returns>
     public static IObservable<T> Blend<T>(params IObservable<T>[] sources)
     {
         var validated = ValidateSources(sources);
@@ -688,23 +685,23 @@ public static IObservable<T> Blend<T>(params IObservable<T>[] sources)
     }
 
     /// <summary>Races the supplied signals and mirrors the first one to produce a value or terminal signal.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
     /// <param name="sources">The signals to race.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that mirrors the first source to respond.</returns>
     public static IObservable<T> Race<T>(params IObservable<T>[] sources)
     {
         var validated = ValidateSources(sources);
         return validated.Length > 0 && validated[0] is RangeSignal ? validated[0] : new RaceSignal<T>(validated);
     }
 
-    /// <summary>Mirrors the first supplied signal to produce a value or terminal signal.</summary>
+    /// <summary>Pairs values from two signals by position and emits the combined result.</summary>
     /// <typeparam name="TLeft">The type of the left signal values.</typeparam>
     /// <typeparam name="TRight">The type of the right signal values.</typeparam>
     /// <typeparam name="TResult">The type of the result.</typeparam>
     /// <param name="left">The left signal.</param>
     /// <param name="right">The right signal.</param>
     /// <param name="selector">The function that combines the paired values.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits one combined result per pair of values.</returns>
     public static IObservable<TResult> Pair<TLeft, TRight, TResult>(
         IObservable<TLeft> left,
         IObservable<TRight> right,
@@ -729,7 +726,7 @@ public static IObservable<TResult> Pair<TLeft, TRight, TResult>(
     /// <param name="left">The left signal.</param>
     /// <param name="right">The right signal.</param>
     /// <param name="selector">The function that combines the latest values.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits a combined result whenever either side produces a value.</returns>
     public static IObservable<TResult> SyncLatest<TLeft, TRight, TResult>(
         IObservable<TLeft> left,
         IObservable<TRight> right,
@@ -754,7 +751,7 @@ public static IObservable<TResult> SyncLatest<TLeft, TRight, TResult>(
     /// <param name="left">The left signal.</param>
     /// <param name="right">The right signal.</param>
     /// <param name="selector">The function that combines the last values.</param>
-    /// <returns>An Signals.</returns>
+    /// <returns>A signal that emits one combined result once both sources complete.</returns>
     public static IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(
         IObservable<TLeft> left,
         IObservable<TRight> right,
diff --git a/src/Primitives.Shared/Signals/Signal{Fail}.cs b/src/Primitives.Shared/Signals/Signal{Fail}.cs
index b069c6cf..b807ac05 100644
--- a/src/Primitives.Shared/Signals/Signal{Fail}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Fail}.cs
@@ -13,62 +13,54 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Empty Signals. Returns only onError on specified scheduler.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="error">The error.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and fails with the supplied error on the supplied scheduler.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="error">The error the signal terminates with.</param>
+    /// <param name="scheduler">The scheduler the error is emitted on.</param>
+    /// <returns>A signal that terminates with <paramref name="error"/>.</returns>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler) => scheduler == Sequencer.Immediate
         ? new ImmediateThrowSignal<T>(error)
         : new ThrowSignal<T>(error, scheduler);
 
-    /// <summary>Empty Signals. Returns only onError.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="error">The error.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and fails with the supplied error on subscription.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="error">The error the signal terminates with.</param>
+    /// <returns>A signal that terminates with <paramref name="error"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Fail<T>(Exception error) =>
         new ImmediateThrowSignal<T>(error);
 
-    /// <summary>Empty Signals. Returns only onError. witness if for Type inference.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="error">The error.</param>
-    /// <param name="witness">The witness.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and fails with the supplied error on subscription.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="error">The error the signal terminates with.</param>
+    /// <param name="witness">An unobserved value whose type fixes <typeparamref name="T"/>.</param>
+    /// <returns>A signal that terminates with <paramref name="error"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "The witness parameter exists only so callers can let T be inferred; it is unused, so the body "
-            + "intentionally mirrors the witness-less Fail overload. They are distinct Rx-parity overloads that build "
-            + "the signal directly rather than forwarding.")]
+        Justification = "The witness parameter only fixes the element type, so this overload builds the same signal.")]
     public static IObservable<T> Fail<T>(Exception error, T witness) =>
         new ImmediateThrowSignal<T>(error);
 
-    /// <summary>Empty Signals. Returns only onError on specified scheduler. witness if for Type inference.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="error">The error.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <param name="witness">The witness.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and fails with the supplied error on the supplied scheduler.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="error">The error the signal terminates with.</param>
+    /// <param name="scheduler">The scheduler the error is emitted on.</param>
+    /// <param name="witness">An unobserved value whose type fixes <typeparamref name="T"/>.</param>
+    /// <returns>A signal that terminates with <paramref name="error"/>.</returns>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "The witness parameter exists only so callers can let T be inferred; it is unused, so the body "
-            + "intentionally mirrors the scheduler Fail overload. They are distinct Rx-parity overloads that build "
-            + "the signal directly rather than forwarding.")]
+        Justification = "The witness parameter only fixes the element type, so this overload builds the same signal.")]
     public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler, T witness) =>
         scheduler == Sequencer.Immediate
             ? new ImmediateThrowSignal<T>(error)
diff --git a/src/Primitives.Shared/Signals/Signal{FromTask}.cs b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
index b6fb3706..201b5645 100644
--- a/src/Primitives.Shared/Signals/Signal{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
@@ -13,34 +13,28 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Handles Asnyc Tasks with cancellation.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription, handing it the cancellation source disposal cancels.</summary>
     /// <param name="execution">The function to execute.</param>
-    /// <returns>
-    /// An ITaskSignal of T.
-    /// </returns>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<RxVoid> FromTask(Func<CancellationTokenSource, Task<RxVoid>> execution) =>
         FromTask(execution, null, null);
 
-    /// <summary>Handles Asnyc Tasks with cancellation.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription and notifies on the supplied sequencer.</summary>
     /// <param name="execution">The function to execute.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>
-    /// An ITaskSignal of T.
-    /// </returns>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<RxVoid> FromTask(
         Func<CancellationTokenSource, Task<RxVoid>> execution,
         ISequencer? scheduler) =>
         FromTask(execution, scheduler, null);
 
-    /// <summary>Handles Asnyc Tasks with cancellation.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription, observing the supplied cancellation source.</summary>
     /// <param name="execution">The function to execute.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <param name="cancellationTokenSource">The cancellation token source.</param>
-    /// <returns>
-    /// An ITaskSignal of T.
-    /// </returns>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <param name="cancellationTokenSource">The cancellation source handed to the function, or <see langword="null"/> to own a new one.</param>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<RxVoid> FromTask(
         Func<CancellationTokenSource, Task<RxVoid>> execution,
@@ -48,37 +42,31 @@ public static ITaskSignal<RxVoid> FromTask(
         CancellationTokenSource? cancellationTokenSource) =>
         CreateTaskSignal(execution, scheduler, cancellationTokenSource);
 
-    /// <summary>Froms the asynchronous.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription, handing it the cancellation source disposal cancels.</summary>
     /// <typeparam name="TResult">The type of the return value.</typeparam>
-    /// <param name="actionAsync">The action asynchronous.</param>
-    /// <returns>
-    /// An TaskSignal of T.
-    /// </returns>
+    /// <param name="actionAsync">The function to execute.</param>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> FromTask<TResult>(Func<CancellationTokenSource, Task<TResult>> actionAsync) =>
         FromTask(actionAsync, null, null);
 
-    /// <summary>Froms the asynchronous.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription and notifies on the supplied sequencer.</summary>
     /// <typeparam name="TResult">The type of the return value.</typeparam>
-    /// <param name="actionAsync">The action asynchronous.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>
-    /// An TaskSignal of T.
-    /// </returns>
+    /// <param name="actionAsync">The function to execute.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> FromTask<TResult>(
         Func<CancellationTokenSource, Task<TResult>> actionAsync,
         ISequencer? scheduler) =>
         FromTask(actionAsync, scheduler, null);
 
-    /// <summary>Froms the asynchronous.</summary>
+    /// <summary>Creates a task-backed signal that runs the function on subscription, observing the supplied cancellation source.</summary>
     /// <typeparam name="TResult">The type of the return value.</typeparam>
-    /// <param name="actionAsync">The action asynchronous.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <param name="cancellationTokenSource">The cancellation token source.</param>
-    /// <returns>
-    /// An TaskSignal of T.
-    /// </returns>
+    /// <param name="actionAsync">The function to execute.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <param name="cancellationTokenSource">The cancellation source handed to the function, or <see langword="null"/> to own a new one.</param>
+    /// <returns>A signal that emits the function's result and completes.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> FromTask<TResult>(
         Func<CancellationTokenSource, Task<TResult>> actionAsync,
@@ -86,12 +74,12 @@ public static ITaskSignal<TResult> FromTask<TResult>(
         CancellationTokenSource? cancellationTokenSource) =>
         CreateTaskSignal(actionAsync, scheduler, cancellationTokenSource);
 
-    /// <summary>Executes the CreateTaskSignal operation.</summary>
-    /// <typeparam name="TResult">The TResult type.</typeparam>
-    /// <param name="execution">The execution value.</param>
-    /// <param name="scheduler">The scheduler value.</param>
-    /// <param name="cancellationTokenSource">The cancellationTokenSource value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Builds the task-backed signal, taking a direct-subscription form for the immediate sequencer.</summary>
+    /// <typeparam name="TResult">The result type.</typeparam>
+    /// <param name="execution">The function to execute.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on.</param>
+    /// <param name="cancellationTokenSource">The cancellation source handed to the function.</param>
+    /// <returns>The task-backed signal.</returns>
     private static ITaskSignal<TResult> CreateTaskSignal<TResult>(
         Func<CancellationTokenSource, Task<TResult>> execution,
         ISequencer? scheduler,
@@ -103,12 +91,12 @@ private static ITaskSignal<TResult> CreateTaskSignal<TResult>(
                 scheduler,
                 cancellationTokenSource);
 
-    /// <summary>Executes the SubscribeTask operation.</summary>
-    /// <typeparam name="TResult">The TResult type.</typeparam>
-    /// <param name="signal">The signal value.</param>
-    /// <param name="execution">The execution value.</param>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Starts the task for one subscription and forwards its terminal notification to the observer.</summary>
+    /// <typeparam name="TResult">The result type.</typeparam>
+    /// <param name="signal">The signal whose cancellation source the task runs under.</param>
+    /// <param name="execution">The function producing the task.</param>
+    /// <param name="observer">The observer receiving the result.</param>
+    /// <returns>A disposable that cancels the task when it wins the terminal transition.</returns>
     /// <exception cref="InvalidOperationException"><paramref name="execution"/> returned <see langword="null"/>.</exception>
     private static IDisposable SubscribeTask<TResult>(
         ITaskSignal<TResult> signal,
@@ -155,20 +143,19 @@ private static ActionDisposable CancelOnDispose(TaskStopGate gate, CancellationT
             Cancel(source);
         });
 
-    /// <summary>Emits a synchronous terminal notification when the task has already finished.</summary>
-    /// <typeparam name="TResult">The TResult type.</typeparam>
+    /// <summary>Emits the terminal notification synchronously when the task has finished.</summary>
+    /// <typeparam name="TResult">The result type.</typeparam>
     /// <param name="task">The task to inspect.</param>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="token">The token value.</param>
+    /// <param name="observer">The observer receiving the notification.</param>
+    /// <param name="token">The token checked for cancellation.</param>
     /// <returns><see langword="true"/> when a synchronous terminal notification was produced.</returns>
     /// <remarks>
-    /// Runs before any disposer is handed out, so no dispose race is possible and the emission is ungated.
+    /// Runs before any disposer is handed out, so no dispose race is possible and the emission needs no gate.
     /// </remarks>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification =
-            "Synchronous read of an already-completed (RanToCompletion) task for an allocation-free fast path; await is invalid in this synchronous factory.")]
+        Justification = "The result is read only once the task status is RanToCompletion.")]
     private static bool TryEmitSynchronously<TResult>(
         Task<TResult> task,
         IObserver<TResult> observer,
@@ -197,16 +184,15 @@ private static bool TryEmitSynchronously<TResult>(
     }
 
     /// <summary>Observes a pending task and forwards the terminal notification while honoring disposal.</summary>
-    /// <typeparam name="TResult">The TResult type.</typeparam>
-    /// <param name="cancellableTask">The cancellableTask value.</param>
-    /// <param name="observer">The observer value.</param>
+    /// <typeparam name="TResult">The result type.</typeparam>
+    /// <param name="cancellableTask">The task raced against cancellation.</param>
+    /// <param name="observer">The observer receiving the notification.</param>
     /// <param name="gate">The terminal-notification gate shared with the disposer.</param>
-    /// <param name="token">The token value.</param>
-    /// <returns>The result.</returns>
+    /// <param name="token">The token checked for cancellation.</param>
+    /// <returns>A task that completes once the notification is forwarded or suppressed.</returns>
     /// <remarks>
-    /// The terminal notification is gated on <see cref="TaskStopGate.TryStop"/>, the same atomic
-    /// transition the disposer wins when the subscription is torn down. Only the winner emits, so a
-    /// subscription disposed while the task continuation runs never observes a post-dispose notification.
+    /// The notification is gated on <see cref="TaskStopGate.TryStop"/>, the transition the disposer wins on teardown,
+    /// so a subscription disposed while this continuation runs observes nothing.
     /// </remarks>
     private static async Task ObserveTask<TResult>(
         Task<(TResult Value, bool IsCanceled)> cancellableTask,
@@ -241,8 +227,8 @@ private static async Task ObserveTask<TResult>(
         }
     }
 
-    /// <summary>Executes the Cancel operation.</summary>
-    /// <param name="source">The source value.</param>
+    /// <summary>Cancels the source, tolerating a source another completion path disposed.</summary>
+    /// <param name="source">The cancellation source to cancel.</param>
     private static void Cancel(CancellationTokenSource source)
     {
         try
@@ -251,15 +237,15 @@ private static void Cancel(CancellationTokenSource source)
         }
         catch (ObjectDisposedException)
         {
-            // Another completion path already released the token source.
+            // Another completion path released the token source.
         }
     }
 
-    /// <summary>Immediate task signal that subscribes directly instead of building a nested observable pipeline.</summary>
+    /// <summary>Task signal that starts the task in <c>Subscribe</c> rather than through a nested observable pipeline.</summary>
     /// <typeparam name="TResult">The result type.</typeparam>
     private sealed class ImmediateTaskSignal<TResult> : ITaskSignal<TResult>
     {
-        /// <summary>Executes the task.</summary>
+        /// <summary>The factory that starts the task for each subscription.</summary>
         private readonly Func<CancellationTokenSource, Task<TResult>> _execution;
 
         /// <summary>Non-zero after disposal.</summary>
@@ -346,8 +332,8 @@ public void Dispose()
             SourceCore.Dispose();
         }
 
-        /// <summary>Throws when disposed.</summary>
-        /// <exception cref="ObjectDisposedException">The signal has already been disposed.</exception>
+        /// <summary>Throws when the signal has been disposed.</summary>
+        /// <exception cref="ObjectDisposedException">The signal has been disposed.</exception>
         private void ThrowIfDisposed()
         {
             if (!IsDisposed)
@@ -361,9 +347,8 @@ private void ThrowIfDisposed()
 
     /// <summary>Atomic gate that serializes the terminal notification against subscription disposal.</summary>
     /// <remarks>
-    /// Mirrors the <c>TaskInstanceSubscription.TryStop()</c> pattern: both the task continuation and the
-    /// disposer race on a single <see cref="Interlocked.Exchange(ref int, int)"/>; only the winner proceeds,
-    /// so a notification can never reach a subscription that has already been disposed.
+    /// The task continuation and the disposer race on a single <see cref="Interlocked.Exchange(ref int, int)"/> and only
+    /// the winner proceeds, so no notification reaches a disposed subscription.
     /// </remarks>
     private sealed class TaskStopGate
     {
diff --git a/src/Primitives.Shared/Signals/Signal{GetAwaiter}.cs b/src/Primitives.Shared/Signals/Signal{GetAwaiter}.cs
index e1b23053..0aef67e8 100644
--- a/src/Primitives.Shared/Signals/Signal{GetAwaiter}.cs
+++ b/src/Primitives.Shared/Signals/Signal{GetAwaiter}.cs
@@ -13,19 +13,19 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Executes the RunAsync operation.</summary>
-    /// <typeparam name="TSource">The TSource type.</typeparam>
-    /// <param name="source">The source value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes to the source and returns an awaiter for its final value.</summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <param name="source">The source sequence, subscribed immediately.</param>
+    /// <returns>An awaiter that completes with the final source value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAwaitSignal<TSource> RunAsync<TSource>(IObservable<TSource> source) =>
         RunAsync(source, CancellationToken.None);
 
-    /// <summary>Executes the RunAsync operation.</summary>
-    /// <typeparam name="TSource">The TSource type.</typeparam>
-    /// <param name="source">The source value.</param>
-    /// <param name="cancellationToken">The cancellationToken value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes to the source and returns an awaiter for its final value, cancelled through the token.</summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <param name="source">The source sequence, subscribed immediately.</param>
+    /// <param name="cancellationToken">The token that disposes the subscription and faults the awaiter.</param>
+    /// <returns>An awaiter that completes with the final source value, or faults with <see cref="OperationCanceledException"/>.</returns>
     public static IAwaitSignal<TSource> RunAsync<TSource>(
         IObservable<TSource> source,
         CancellationToken cancellationToken)
@@ -101,22 +101,22 @@ public static Task<TSource> ToTask<TSource>(IObservable<TSource> source, Cancell
         return completion.Attach(subscription, cancellationToken);
     }
 
-    /// <summary>Executes the Cancel operation.</summary>
-    /// <typeparam name="T">The T type.</typeparam>
-    /// <param name="subject">The subject value.</param>
-    /// <param name="cancellationToken">The cancellationToken value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Faults the awaiter with an <see cref="OperationCanceledException"/> carrying the token.</summary>
+    /// <typeparam name="T">The awaited value type.</typeparam>
+    /// <param name="subject">The awaiter to fault.</param>
+    /// <param name="cancellationToken">The token reported by the exception.</param>
+    /// <returns>The same awaiter.</returns>
     internal static IAwaitSignal<T> Cancel<T>(IAwaitSignal<T> subject, CancellationToken cancellationToken)
     {
         subject.OnError(new OperationCanceledException(cancellationToken));
         return subject;
     }
 
-    /// <summary>Executes the RegisterCancelation operation.</summary>
-    /// <typeparam name="T">The T type.</typeparam>
-    /// <param name="subject">The subject value.</param>
-    /// <param name="subscription">The subscription value.</param>
-    /// <param name="token">The token value.</param>
+    /// <summary>Cancels the awaiter and disposes the subscription when the token fires, releasing the registration once the awaiter terminates.</summary>
+    /// <typeparam name="T">The awaited value type.</typeparam>
+    /// <param name="subject">The awaiter to cancel.</param>
+    /// <param name="subscription">The subscription disposed on cancellation.</param>
+    /// <param name="token">The token watched for cancellation.</param>
     internal static void RegisterCancelation<T>(
         IAwaitSignal<T> subject,
         IDisposable subscription,
diff --git a/src/Primitives.Shared/Signals/Signal{None}.cs b/src/Primitives.Shared/Signals/Signal{None}.cs
index 5c2ff7b0..f87bdb8e 100644
--- a/src/Primitives.Shared/Signals/Signal{None}.cs
+++ b/src/Primitives.Shared/Signals/Signal{None}.cs
@@ -13,51 +13,46 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Empty Signals. Returns only OnCompleted on specified scheduler.</summary>
-    /// <typeparam name="T">The Type.</typeparam>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and completes on the supplied scheduler.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="scheduler">The scheduler the completion is emitted on.</param>
+    /// <returns>A signal that completes without emitting a value.</returns>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> None<T>(ISequencer scheduler) => scheduler == Sequencer.Immediate
         ? ImmutableEmptySignal<T>.Instance
         : new EmptySignal<T>(scheduler);
 
-    /// <summary>Empty Signals. Returns only OnCompleted on specified scheduler. witness is for type inference.</summary>
-    /// <typeparam name="T">The Type.</typeparam>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <param name="witness">The witness.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits no values and completes on the supplied scheduler.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="scheduler">The scheduler the completion is emitted on.</param>
+    /// <param name="witness">An unobserved value whose type fixes <typeparamref name="T"/>.</param>
+    /// <returns>A signal that completes without emitting a value.</returns>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "The witness parameter exists only so callers can let T be inferred; it is unused, so the body "
-            + "intentionally mirrors the scheduler None overload. They are distinct Rx-parity overloads that build "
-            + "the signal directly rather than forwarding.")]
+        Justification = "The witness parameter only fixes the element type, so this overload builds the same signal.")]
     public static IObservable<T> None<T>(ISequencer scheduler, T witness) => scheduler == Sequencer.Immediate
         ? ImmutableEmptySignal<T>.Instance
         : new EmptySignal<T>(scheduler);
 
-    /// <summary>Empty Signals. Returns only OnCompleted.</summary>
-    /// <typeparam name="T">The Type.</typeparam>
-    /// <returns>An Signals.</returns>
+    /// <summary>Returns the shared signal that emits no values and completes on subscription.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <returns>A signal that completes without emitting a value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> None<T>() =>
         ImmutableEmptySignal<T>.Instance;
 
-    /// <summary>Empty Signals. Returns only OnCompleted. witness is for type inference.</summary>
-    /// <typeparam name="T">The Type.</typeparam>
-    /// <param name="witness">The witness.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Returns the shared signal that emits no values and completes on subscription.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="witness">An unobserved value whose type fixes <typeparamref name="T"/>.</param>
+    /// <returns>A signal that completes without emitting a value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> None<T>(T witness) =>
         ImmutableEmptySignal<T>.Instance;
diff --git a/src/Primitives.Shared/Signals/Signal{RxAliases}.cs b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
index 149cde95..9d60e386 100644
--- a/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
+++ b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
@@ -137,8 +137,7 @@ public static IObservable<T> Repeat<T>(T value, int repeatCount)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Empty<T>() => ImmutableEmptySignal<T>.Instance;
 
     /// <summary>Returns an empty observable sequence on the supplied scheduler.</summary>
@@ -148,8 +147,7 @@ public static IObservable<T> Repeat<T>(T value, int repeatCount)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Empty<T>(ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -164,8 +162,7 @@ public static IObservable<T> Empty<T>(ISequencer scheduler)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Never<T>() => ImmutableNeverSignal<T>.Instance;
 
     /// <summary>Returns an observable sequence that terminates with an error.</summary>
@@ -176,8 +173,7 @@ public static IObservable<T> Empty<T>(ISequencer scheduler)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Throw<T>(Exception error) => new ImmediateThrowSignal<T>(error);
 
     /// <summary>Returns an observable sequence that terminates with a scheduled error.</summary>
@@ -188,8 +184,7 @@ public static IObservable<T> Empty<T>(ISequencer scheduler)
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Throw<T>(Exception error, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
diff --git a/src/Primitives.Shared/Signals/Signal{Silent}.cs b/src/Primitives.Shared/Signals/Signal{Silent}.cs
index 6ce0954b..d502d997 100644
--- a/src/Primitives.Shared/Signals/Signal{Silent}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Silent}.cs
@@ -13,21 +13,20 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides static factory and operator methods for signals.</summary>
 public static partial class Signal
 {
-    /// <summary>Non-Terminating Signals. It's no returns, never finish.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits nothing and never terminates.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <returns>A signal that produces no notifications.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static IObservable<T> Silent<T>() => ImmutableNeverSignal<T>.Instance;
 
-    /// <summary>Non-Terminating Signals. It's no returns, never finish. witness is for type inference.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="witness">The witness.</param>
-    /// <returns>An Signals.</returns>
+    /// <summary>Creates a signal that emits nothing and never terminates.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="witness">An unobserved value whose type fixes <typeparamref name="T"/>.</param>
+    /// <returns>A signal that produces no notifications.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> Silent<T>(T witness) => ImmutableNeverSignal<T>.Instance;
 }
diff --git a/src/Primitives.Shared/Signals/Signal{Subjects}.cs b/src/Primitives.Shared/Signals/Signal{Subjects}.cs
index 97f2f5cd..cc4721b0 100644
--- a/src/Primitives.Shared/Signals/Signal{Subjects}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Subjects}.cs
@@ -18,8 +18,7 @@ public static partial class Signal
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification =
-            "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")]
+        Justification = "The element type cannot be inferred from the arguments.")]
     public static ScheduledSignal<T> Scheduled<T>(ISequencer scheduler) =>
         new(scheduler);
 
diff --git a/src/Primitives.Shared/Signals/TaskSignal.cs b/src/Primitives.Shared/Signals/TaskSignal.cs
index 3fa21223..7f30e67b 100644
--- a/src/Primitives.Shared/Signals/TaskSignal.cs
+++ b/src/Primitives.Shared/Signals/TaskSignal.cs
@@ -13,41 +13,35 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Provides factory methods for creating task-backed signals.</summary>
 public static class TaskSignal
 {
-    /// <summary>Creates the specified source.</summary>
+    /// <summary>Creates a task-backed signal whose source the factory builds from the signal itself.</summary>
     /// <typeparam name="TResult">The type of the result.</typeparam>
-    /// <param name="observableFactory">The observable factory.</param>
-    /// <returns>
-    /// An AsyncObservable.
-    /// </returns>
-    /// <exception cref="ArgumentExceptionHelper">observableFactory.</exception>
+    /// <param name="observableFactory">Builds the source, receiving the signal it will belong to.</param>
+    /// <returns>A task-backed signal that notifies on the current thread and owns its own cancellation source.</returns>
+    /// <exception cref="ArgumentExceptionHelper"><paramref name="observableFactory"/> is <see langword="null"/>.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> Create<TResult>(
         Func<ITaskSignal<TResult>, IObservable<TResult>> observableFactory) =>
         Instance(observableFactory, null, null);
 
-    /// <summary>Creates the specified source.</summary>
+    /// <summary>Creates a task-backed signal that notifies on the supplied sequencer.</summary>
     /// <typeparam name="TResult">The type of the result.</typeparam>
-    /// <param name="observableFactory">The observable factory.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <returns>
-    /// An AsyncObservable.
-    /// </returns>
-    /// <exception cref="ArgumentExceptionHelper">observableFactory.</exception>
+    /// <param name="observableFactory">Builds the source, receiving the signal it will belong to.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <returns>A task-backed signal that owns its own cancellation source.</returns>
+    /// <exception cref="ArgumentExceptionHelper"><paramref name="observableFactory"/> is <see langword="null"/>.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> Create<TResult>(
         Func<ITaskSignal<TResult>, IObservable<TResult>> observableFactory,
         ISequencer? scheduler) =>
         Instance(observableFactory, scheduler, null);
 
-    /// <summary>Creates the specified source.</summary>
+    /// <summary>Creates a task-backed signal that notifies on the supplied sequencer and cancels through the supplied source.</summary>
     /// <typeparam name="TResult">The type of the result.</typeparam>
-    /// <param name="observableFactory">The observable factory.</param>
-    /// <param name="scheduler">The scheduler.</param>
-    /// <param name="cancellationTokenSource">The cancellation token source.</param>
-    /// <returns>
-    /// An AsyncObservable.
-    /// </returns>
-    /// <exception cref="ArgumentExceptionHelper">observableFactory.</exception>
+    /// <param name="observableFactory">Builds the source, receiving the signal it will belong to.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on, or <see langword="null"/> for the current thread.</param>
+    /// <param name="cancellationTokenSource">The cancellation source to observe, or <see langword="null"/> to own a new one.</param>
+    /// <returns>A task-backed signal.</returns>
+    /// <exception cref="ArgumentExceptionHelper"><paramref name="observableFactory"/> is <see langword="null"/>.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ITaskSignal<TResult> Create<TResult>(
         Func<ITaskSignal<TResult>, IObservable<TResult>> observableFactory,
@@ -55,12 +49,12 @@ public static ITaskSignal<TResult> Create<TResult>(
         CancellationTokenSource? cancellationTokenSource) =>
         Instance(observableFactory, scheduler, cancellationTokenSource);
 
-    /// <summary>Executes the Instance operation.</summary>
-    /// <typeparam name="TResult">The TResult type.</typeparam>
-    /// <param name="observableFactory">The observableFactory value.</param>
-    /// <param name="scheduler">The scheduler value.</param>
-    /// <param name="cancellationTokenSource">The cancellationTokenSource value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Validates the factory and builds the signal the public overloads return.</summary>
+    /// <typeparam name="TResult">The result type.</typeparam>
+    /// <param name="observableFactory">Builds the source from the signal.</param>
+    /// <param name="scheduler">The sequencer notifications are delivered on.</param>
+    /// <param name="cancellationTokenSource">The cancellation source to observe.</param>
+    /// <returns>The built signal.</returns>
     private static TaskSignal<TResult> Instance<TResult>(
         Func<ITaskSignal<TResult>, IObservable<TResult>> observableFactory,
         ISequencer? scheduler,
diff --git a/src/Primitives.Shared/Signals/TaskSignal{T}.cs b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
index 0d72424d..9e5d77f3 100644
--- a/src/Primitives.Shared/Signals/TaskSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
@@ -11,60 +11,47 @@ namespace ReactiveUI.Primitives.Signals;
 #endif
 
 /// <summary>A task-backed signal of values.</summary>
-/// <typeparam name="T">The object that provides notification information.</typeparam>
+/// <typeparam name="T">The value type.</typeparam>
 internal sealed class TaskSignal<T> : ITaskSignal<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The sequencer subscriptions are observed on.</summary>
     private readonly ISequencer _sequencer;
 
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The subscriptions and cancellation registrations released on disposal.</summary>
     private readonly MultipleDisposable _cleanUp = [];
 
     /// <summary>Initializes a new instance of the <see cref="TaskSignal{T}" /> class.</summary>
     /// <param name="sequencer">The sequencer.</param>
-    /// <param name="cancellationTokenSource">The cancellation token source.</param>
-    /// <remarks>
-    /// Private, so the factory can only ever see a signal that is already built. See <see cref="Create"/>.
-    /// </remarks>
+    /// <param name="cancellationTokenSource">The cancellation token source, or <see langword="null"/> to own a new one.</param>
     private TaskSignal(ISequencer? sequencer, CancellationTokenSource? cancellationTokenSource)
     {
         CancellationTokenSource = cancellationTokenSource ?? new();
         _sequencer = sequencer ?? CurrentThreadSequencer.Instance;
     }
 
-    /// <summary>Gets or sets the source.</summary>
-    /// <value>
-    /// The source.
-    /// </value>
+    /// <summary>Gets or sets the sequence subscribers are forwarded to.</summary>
     public IObservable<T>? Source { get; set; }
 
-    /// <summary>Gets the cancellation token source.</summary>
-    /// <value>
-    /// The cancellation token source.
-    /// </value>
+    /// <summary>Gets the cancellation source that cancels the backing task.</summary>
     public CancellationTokenSource? CancellationTokenSource { get; }
 
-    /// <summary>Gets a value indicating whether this instance is cancellation requested.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is cancellation requested; otherwise, <c>false</c>.
-    /// </value>
+    /// <summary>Gets a value indicating whether cancellation has been requested.</summary>
     public bool IsCancellationRequested => CancellationTokenSource?.IsCancellationRequested == true;
 
-    /// <summary>Gets a value indicating whether gets a value that indicates whether the object is disposed.</summary>
+    /// <summary>Gets a value indicating whether the signal has been disposed.</summary>
     public bool IsDisposed => _cleanUp.IsDisposed;
 
-    /// <summary>Gets the operation canceled.</summary>
-    /// <param name="observer">The observer.</param>
+    /// <summary>Pushes an <see cref="OperationCanceledException"/> to the observer when cancellation is requested.</summary>
+    /// <param name="observer">The observer notified on cancellation.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void GetOperationCanceled(IObserver<Exception> observer) =>
         CancellationTokenSource?.Token
             .UnsafeRegister(static o => ((IObserver<Exception>)o!).OnNext(new OperationCanceledException()), observer)
             .DisposeWith(_cleanUp);
 
-    /// <summary>Subscribes the specified observer.</summary>
-    /// <param name="observer">The observer.</param>
-    /// <returns>A Disposable.</returns>
+    /// <summary>Subscribes the observer to the source, observing on the sequencer unless it is the immediate one.</summary>
+    /// <param name="observer">The observer to subscribe.</param>
+    /// <returns>A disposable that ends the subscription.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         var subscription = ReferenceEquals(_sequencer, Sequencer.Immediate)
@@ -74,19 +61,18 @@ public IDisposable Subscribe(IObserver<T> observer)
         return subscription.DisposeWith(_cleanUp);
     }
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Cancels the backing task and releases the subscriptions.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Dispose() => Dispose(true);
 
     /// <summary>Creates a task-backed signal whose source the supplied factory builds.</summary>
-    /// <param name="observableFactory">The observable factory.</param>
-    /// <param name="sequencer">The sequencer.</param>
-    /// <param name="cancellationTokenSource">The cancellation token source.</param>
+    /// <param name="observableFactory">Builds the source, receiving the signal it will belong to.</param>
+    /// <param name="sequencer">The sequencer subscriptions are observed on.</param>
+    /// <param name="cancellationTokenSource">The cancellation source to observe.</param>
     /// <returns>The created signal.</returns>
     /// <remarks>
-    /// The factory is handed the signal, so the signal has to be whole before it runs. A factory is
-    /// caller-supplied code that may subscribe to, dispose, or stash the signal the moment it receives
-    /// it; from a constructor it would be doing that to an object the runtime had not finished building.
+    /// The factory receives the signal and may subscribe to, dispose, or store it the moment it is called, so
+    /// construction finishes before the factory runs rather than calling it from the constructor.
     /// </remarks>
     internal static TaskSignal<T> Create(
         Func<ITaskSignal<T>, IObservable<T>> observableFactory,
@@ -100,8 +86,8 @@ internal static TaskSignal<T> Create(
         return signal;
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
-    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    /// <summary>Cancels the token source and releases the subscriptions when disposing.</summary>
+    /// <param name="disposing"><c>true</c> to release managed resources; otherwise, <c>false</c>.</param>
     private void Dispose(bool disposing)
     {
         if (_cleanUp.IsDisposed || !disposing)
diff --git a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
index 8015a44c..9eedb81e 100644
--- a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
@@ -11,11 +11,9 @@ namespace ReactiveUI.Primitives.Signals;
 #endif
 
 /// <summary>
-/// Shared completion plumbing for task-returning terminals with optional cancellation: owns the task source,
-/// the source subscription, and the cancellation registration. Callers wire their observer callbacks to
-/// <see cref="Resolve"/>/<see cref="Fail"/> and hand the subscription to <see cref="Attach"/>, which registers
-/// for cancellation only while the task is still pending — synchronous sources never pay for a registration,
-/// and registering after the subscription write publishes it to the thread that runs the cancellation callback.
+/// Owns the task source, the source subscription and the cancellation registration for task-returning terminals.
+/// Callers wire their observer callbacks to <see cref="Resolve"/>/<see cref="Fail"/> and hand the subscription to
+/// <see cref="Attach"/>, which registers for cancellation only while the task is pending.
 /// </summary>
 /// <typeparam name="T">The task result type.</typeparam>
 internal sealed class TaskTerminalCompletion<T>
@@ -56,15 +54,13 @@ internal void Fail(Exception error)
     internal void FailEmpty() =>
         Fail(new InvalidOperationException("The source completed without producing a value."));
 
-    /// <summary>
-    /// Adopts the subscription created after the observer callbacks were wired, then registers for cancellation
-    /// only when the task is still pending.
-    /// </summary>
+    /// <summary>Adopts the source subscription and registers for cancellation only while the task is pending.</summary>
     /// <param name="subscription">The source subscription.</param>
     /// <param name="cancellationToken">The token that cancels the task and disposes the subscription.</param>
     /// <returns>The terminal task.</returns>
     internal Task<T> Attach(IDisposable subscription, CancellationToken cancellationToken)
     {
+        // Writing the subscription before registering publishes it to the thread that runs the cancellation callback.
         _subscription = subscription;
         if (_completion.Task.IsCompleted)
         {
@@ -79,9 +75,8 @@ internal Task<T> Attach(IDisposable subscription, CancellationToken cancellation
                 static state => ((TaskTerminalCompletion<T>)state!).Cancel(),
                 this);
 
-            // The source may have completed while the registration was being created; the observer callbacks
-            // saw a default registration then, so release the real one here (without waiting on an in-flight
-            // callback, whose effects are already race-safe).
+            // A source that completed while the registration was being created saw a default registration in the
+            // observer callbacks, so release the real one here.
             if (_completion.Task.IsCompleted)
             {
                 _ = _cancellationRegistration.Unregister();
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
index f0c51133..4e644a8e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
@@ -9,9 +9,9 @@ namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
 /// Asynchronous mutual-exclusion primitive that serializes critical sections in the async pipeline.
-/// Uncontended acquire is a pure <see cref="Interlocked.CompareExchange(ref int, int, int)"/> (no
-/// <see cref="SemaphoreSlim"/> touch); the contended path waits on a signal-only semaphore and retries
-/// the CAS after each signal. Same-thread reentry is granted via the owner-thread-id and a recursion counter.
+/// Each acquire hands back a <see cref="Lease"/> that releases the gate when disposed. Ownership is keyed
+/// on the managed thread id, so a nested acquire on the holding thread is granted immediately and reentry
+/// is recognised only while the caller stays on the thread that took the gate.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("AsyncSerialGate: OwnerThreadId = {_ownerThreadId}, Waiters = {_waiters}, RecursionDepth = {_recursionDepth}")]
 public sealed class AsyncSerialGate : IDisposable
@@ -31,9 +31,7 @@ public sealed class AsyncSerialGate : IDisposable
     /// <summary>Disposal latch; non-zero once this instance has been disposed.</summary>
     private int _disposedValue;
 
-    /// <summary>Gets the number of awaiters currently parked on the slow path. Exposed for
-    /// deterministic contention tests so they can spin-wait until a contender has entered
-    /// <see cref="WaitForEntryAsync"/> before tripping the release.</summary>
+    /// <summary>Gets the number of awaiters parked on the slow path.</summary>
     internal int WaitersCount => Volatile.Read(ref _waiters);
 
     /// <summary>Asynchronously acquires the gate, returning a <see cref="Lease"/> that releases it on disposal.</summary>
@@ -44,14 +42,17 @@ public ValueTask<Lease> EnterAsync() =>
         EnterAsync(CancellationToken.None);
 
     /// <summary>Asynchronously acquires the gate, returning a <see cref="Lease"/> that releases it on disposal.</summary>
-    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <param name="cancellationToken">Observed only while waiting for a contended gate; an uncontended acquire
+    /// never checks it.</param>
     /// <returns>A <see cref="ValueTask{Lease}"/> that completes when the gate has been acquired.</returns>
+    /// <exception cref="OperationCanceledException">Thrown when the token is cancelled before the gate is
+    /// acquired.</exception>
     [DebuggerStepThrough]
     public ValueTask<Lease> EnterAsync(CancellationToken cancellationToken)
     {
         var currentThreadId = Environment.CurrentManagedThreadId;
 
-        // Same-thread reentry: bump depth, no synchronization needed (we already own it).
+        // Same-thread reentry: the calling thread owns the gate, so bumping depth needs no synchronization.
         if (Volatile.Read(ref _ownerThreadId) == currentThreadId)
         {
             _recursionDepth++;
@@ -92,9 +93,8 @@ internal void Exit()
     }
 
     /// <summary>
-    /// Signals one parked waiter if any are present. An extra signal observed across the
-    /// <see cref="_waiters"/> read / <see cref="SemaphoreSlim.Release()"/> race lands harmlessly in
-    /// the semaphore count and is consumed by the next waiter that arrives.
+    /// Signals one parked waiter if any are present. A signal released after the last waiter has left
+    /// lands in the semaphore count and is consumed by the next waiter to arrive.
     /// </summary>
     private void WakeNextWaiter()
     {
@@ -132,7 +132,7 @@ private async ValueTask<Lease> WaitForEntryAsync(CancellationToken cancellationT
         }
     }
 
-    /// <summary>Releases a previously acquired <see cref="AsyncSerialGate"/> when disposed.</summary>
+    /// <summary>Holds one acquisition of an <see cref="AsyncSerialGate"/> and releases it on disposal.</summary>
     [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
     public readonly record struct Lease : IDisposable
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
index 2dcb589a..b3611bb8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
@@ -12,7 +12,8 @@ public sealed class BackgroundJobSignal<T> : IObservableAsync<T>
     /// <summary>Initializes a new instance of the <see cref="BackgroundJobSignal{T}"/> class.</summary>
     /// <param name="job">The job to execute for each subscription.</param>
     /// <param name="startSynchronously">A value indicating whether the job starts synchronously on subscribe.</param>
-    /// <param name="taskScheduler">The scheduler used to start the job asynchronously.</param>
+    /// <param name="taskScheduler">The scheduler that starts the job, or <see langword="null"/> to start it on
+    /// the thread pool after a yield.</param>
     public BackgroundJobSignal(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job,
         bool startSynchronously,
@@ -31,7 +32,7 @@ public BackgroundJobSignal(
     /// <summary>Gets a value indicating whether the job starts synchronously on subscribe.</summary>
     private bool StartSynchronously { get; }
 
-    /// <summary>Gets the scheduler used to start the job asynchronously.</summary>
+    /// <summary>Gets the scheduler that starts the job asynchronously.</summary>
     private TaskScheduler? TaskScheduler { get; }
 
     /// <inheritdoc/>
@@ -66,7 +67,7 @@ private async ValueTask ExecuteAfterYieldAsync(IObserverAsync<T> observer, Cance
 
     /// <summary>Starts the job through the configured task scheduler.</summary>
     /// <param name="observer">The observer receiving job notifications.</param>
-    /// <param name="taskScheduler">The scheduler used to run the job.</param>
+    /// <param name="taskScheduler">The scheduler that runs the job.</param>
     /// <param name="cancellationToken">The cancellation token for the job.</param>
     /// <returns>A task representing the job.</returns>
     private async ValueTask ExecuteOnSchedulerAsync(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
index d9cdcbcc..be99c208 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
@@ -4,7 +4,8 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>An witness that routes notifications through user-supplied asynchronous callbacks.</summary>
+/// <summary>A witness that routes notifications through caller-supplied asynchronous callbacks. A callback left
+/// unset reports resumable errors and terminal failures to the unhandled exception handler.</summary>
 /// <typeparam name="T">The type of the elements received by the witness.</typeparam>
 /// <param name="onNextAsync">The asynchronous function invoked for each element.</param>
 /// <param name="onErrorResumeAsync">An optional asynchronous function invoked when a resumable error occurs.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
index ee2bef82..cdba6c72 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
@@ -53,14 +53,17 @@ public FlatMapCoordinator(IObserverAsync<TResult> observer)
     /// <summary>Gets or sets a value indicating whether this coordinator has been disposed.</summary>
     private bool Disposed { get; set; }
 
-    /// <summary>Sets the outer observer.</summary>
-    /// <param name="observer">The outer observer.</param>
-    /// <returns>A task representing the asynchronous assignment.</returns>
+    /// <summary>Takes ownership of the outer subscription, disposing it immediately when this coordinator
+    /// has finished. Callable once per coordinator.</summary>
+    /// <param name="observer">The outer subscription to own.</param>
+    /// <returns>A task that completes once the subscription has been stored or disposed.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when an outer subscription is set twice.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask SetOuterObserverAsync(IAsyncDisposable observer) =>
         OuterObserver.SetDisposableAsync(observer);
 
-    /// <summary>Links subscribe-time cancellation into the coordinator lifecycle.</summary>
+    /// <summary>Cancels this coordinator's lifetime when <paramref name="external"/> is cancelled. A token that
+    /// cannot be cancelled is ignored; a token cancelled at call time cancels the lifetime immediately.</summary>
     /// <param name="external">The subscribe-time cancellation token.</param>
     public void LinkExternalCancellation(CancellationToken external)
     {
@@ -84,9 +87,10 @@ public void LinkExternalCancellation(CancellationToken external)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask DisposeAsync() => FinishAsync(null);
 
-    /// <summary>Subscribes and tracks an inner sequence.</summary>
+    /// <summary>Subscribes to an inner sequence and counts it as active until it completes. A failure raised while
+    /// subscribing finishes the whole sequence with that failure; a call after teardown is a no-op.</summary>
     /// <param name="inner">The inner sequence.</param>
-    /// <returns>A task representing the asynchronous subscription.</returns>
+    /// <returns>A task that completes once the inner sequence has been subscribed.</returns>
     public async ValueTask SubscribeInnerAsync(IObservableAsync<TResult> inner)
     {
         lock (_gate)
@@ -113,9 +117,10 @@ public async ValueTask SubscribeInnerAsync(IObservableAsync<TResult> inner)
         }
     }
 
-    /// <summary>Forwards an inner value to the downstream observer.</summary>
+    /// <summary>Forwards an inner value downstream, serialized against the other inner sequences so the observer
+    /// is never entered concurrently.</summary>
     /// <param name="value">The value.</param>
-    /// <returns>A task representing the asynchronous notification.</returns>
+    /// <returns>A task that completes once the observer has accepted the value.</returns>
     public async ValueTask RelayNextAsync(TResult value)
     {
         using (await ObserverGate.EnterAsync(DisposeToken).ConfigureAwait(false))
@@ -124,9 +129,10 @@ public async ValueTask RelayNextAsync(TResult value)
         }
     }
 
-    /// <summary>Forwards a non-terminal error to the downstream observer.</summary>
+    /// <summary>Forwards a non-terminal error downstream under the same serialization as values, leaving the
+    /// sequence running.</summary>
     /// <param name="error">The error.</param>
-    /// <returns>A task representing the asynchronous notification.</returns>
+    /// <returns>A task that completes once the observer has accepted the error.</returns>
     public async ValueTask RelayErrorAsync(Exception error)
     {
         using (await ObserverGate.EnterAsync(DisposeToken).ConfigureAwait(false))
@@ -135,9 +141,10 @@ public async ValueTask RelayErrorAsync(Exception error)
         }
     }
 
-    /// <summary>Handles outer source completion.</summary>
+    /// <summary>Records outer completion, finishing the sequence when the result is a failure or no inner
+    /// sequence is active, and otherwise waiting for the active inner sequences.</summary>
     /// <param name="result">The completion result.</param>
-    /// <returns>A task representing the asynchronous completion handling.</returns>
+    /// <returns>A task that completes once the sequence has finished, or immediately when it continues.</returns>
     public ValueTask CompleteOuterAsync(Result result)
     {
         bool shouldComplete;
@@ -150,9 +157,10 @@ public ValueTask CompleteOuterAsync(Result result)
         return shouldComplete ? FinishAsync(result) : default;
     }
 
-    /// <summary>Handles inner source completion.</summary>
+    /// <summary>Records one inner sequence finishing, completing the sequence when the result is a failure or
+    /// when the outer source has completed and no inner sequence remains.</summary>
     /// <param name="result">The completion result.</param>
-    /// <returns>A task representing the asynchronous completion handling.</returns>
+    /// <returns>A task that completes once the sequence has finished, or immediately when it continues.</returns>
     public ValueTask CompleteInnerAsync(Result result)
     {
         bool shouldComplete;
@@ -169,9 +177,11 @@ public ValueTask CompleteInnerAsync(Result result)
         return shouldComplete ? FinishAsync(result) : default;
     }
 
-    /// <summary>Finishes the flat-map sequence and disposes tracked subscriptions.</summary>
-    /// <param name="result">The optional result to forward.</param>
-    /// <returns>A task representing the asynchronous teardown.</returns>
+    /// <summary>Completes the downstream observer and disposes every tracked subscription. Idempotent; a failure
+    /// handed in after teardown goes to the unhandled exception handler.</summary>
+    /// <param name="result">The result to forward, or <see langword="null"/> to tear down without completing
+    /// the observer.</param>
+    /// <returns>A task that completes once teardown has finished.</returns>
     public async ValueTask FinishAsync(Result? result)
     {
         lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
index 39242aac..4bb02c4e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
@@ -5,9 +5,8 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Base observer that forwards every notification to a downstream observer. Every notification is already
-/// implemented here, so nothing is left for a derived type to supply: this is a base class, not a contract.
-/// The protected constructor, rather than <c>abstract</c>, is what keeps it from being used on its own.
+/// Base observer that forwards every notification unchanged to a downstream observer. A derived type
+/// overrides only the notifications it needs to intercept and inherits pass-through behaviour for the rest.
 /// </summary>
 /// <typeparam name="T">The observed element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ForwardingWitnessAsync: Downstream = {Downstream}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
index d74cc907..79580141 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
@@ -5,10 +5,9 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>An async-disposable that can be disposed from within its own in-flight notification.</summary>
-/// <remarks>Terminal sinks dispose themselves from inside the very <c>OnNext</c>/<c>OnCompleted</c> call that
-/// produced their result. The normal <see cref="IAsyncDisposable.DisposeAsync"/> path waits for in-flight
-/// calls on other threads to drain before completing; once that notification's continuation has hopped threads the
-/// wait would block on the call that is itself awaiting the dispose. This entry point skips that self-join.</remarks>
+/// <remarks>A terminal sink disposes itself from inside the <c>OnNext</c>/<c>OnCompleted</c> call that produced
+/// its result, which <see cref="IAsyncDisposable.DisposeAsync"/> cannot serve: that path waits for in-flight calls
+/// to drain, and the notification awaiting the dispose is one of them. This entry point skips the self-join.</remarks>
 public interface IReentrantAsyncDisposable
 {
     /// <summary>Disposes from within the object's own in-flight notification, skipping the in-flight-call wait.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
index 2cefff2c..01b0b253 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
@@ -4,13 +4,15 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>An observable that emits incrementing ticks at a fixed interval.</summary>
+/// <summary>An observable that emits incrementing ticks at a fixed interval. Ticks are numbered from one, each
+/// emitted after a further period has elapsed, and continue until the subscription is disposed.</summary>
 [System.Diagnostics.DebuggerDisplay("IntervalSignal: Period = {Period}, TimeProvider = {TimeProvider}")]
 public sealed class IntervalSignal : IObservableAsync<long>
 {
     /// <summary>Initializes a new instance of the <see cref="IntervalSignal"/> class.</summary>
     /// <param name="period">The delay between ticks.</param>
-    /// <param name="timeProvider">The time provider used for custom scheduling.</param>
+    /// <param name="timeProvider">The time provider that schedules the ticks, or <see langword="null"/> for the
+    /// system clock.</param>
     public IntervalSignal(TimeSpan period, TimeProvider? timeProvider)
     {
         Period = period;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
index 70a44769..24b95d8b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
@@ -11,7 +11,8 @@ public sealed class IntervalSubscription : TaskSignalSubscription<long>
     /// <summary>Initializes a new instance of the <see cref="IntervalSubscription"/> class.</summary>
     /// <param name="observer">The observer receiving ticks.</param>
     /// <param name="period">The delay between ticks.</param>
-    /// <param name="timeProvider">The time provider used for custom scheduling.</param>
+    /// <param name="timeProvider">The time provider that schedules the ticks, or <see langword="null"/> for the
+    /// system clock.</param>
     public IntervalSubscription(IObserverAsync<long> observer, TimeSpan period, TimeProvider? timeProvider)
         : base(observer)
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
index f7cf4970..63f4e692 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
@@ -47,16 +47,16 @@ public LeadSubscription(
     /// <summary>Gets the subscription cancellation source.</summary>
     private CancellationTokenSource Cancellation { get; }
 
-    /// <summary>Gets the reentrancy marker used to avoid self-joining the driver task.</summary>
+    /// <summary>Gets the flag marking the driver task, so disposal called from inside it skips awaiting it.</summary>
     private AsyncLocal<bool> Reentrant { get; } = new();
 
     /// <summary>Gets or sets the driver task.</summary>
     private Task Pipeline { get; set; }
 
-    /// <summary>Gets or sets a value indicating whether disposal has already run.</summary>
+    /// <summary>Gets or sets a value indicating whether disposal has run.</summary>
     private bool Disposed { get; set; }
 
-    /// <summary>Starts the lead pipeline.</summary>
+    /// <summary>Starts the pipeline that emits the leading values and then subscribes to the source.</summary>
     public void Start() => Pipeline = RunAsync();
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
index 5e8578fa..0dba9c7d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks.Sources;
@@ -11,18 +10,13 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Poolable <see cref="IValueTaskSource"/> used by <c>DelayAsync</c> for the non-System
-/// <see cref="TimeProvider"/> code path. Replaces the per-call
-/// <see cref="TaskCompletionSource{TResult}"/> + <see cref="Task{TResult}"/> +
-/// <see cref="CancellationTokenRegistration"/> allocation chain with a rented-then-returned
-/// instance. The wrapped <see cref="ManualResetValueTaskSourceCore{TResult}"/> is the standard
-/// poolable async-primitive shape from <c>System.Threading.Tasks.Sources</c>.
+/// Poolable <see cref="IValueTaskSource"/> backing <c>DelayAsync</c> for non-System
+/// <see cref="TimeProvider"/> instances, so a delay costs no per-call allocation.
 /// </summary>
 /// <remarks>
-/// <para>Completion is claimed by whichever of the timer callback or the cancellation registration
-/// fires first, using an <see cref="Interlocked.CompareExchange(ref int, int, int)"/> on a state
-/// flag. The loser is a no-op. After the caller awaits the returned <see cref="ValueTask"/>, the
-/// instance is reset and pushed back to the pool inside <see cref="GetResult(short)"/>.</para>
+/// Whichever of the timer callback and the cancellation registration fires first claims completion
+/// through an <see cref="Interlocked.CompareExchange(ref int, int, int)"/> on a state flag; the
+/// loser is a no-op.
 /// </remarks>
 [System.Diagnostics.DebuggerDisplay("PooledDelaySource: Completed = {_completed}, Timer = {_timer}")]
 public sealed class PooledDelaySource : IValueTaskSource
@@ -34,12 +28,9 @@ public sealed class PooledDelaySource : IValueTaskSource
     private const int StateClaimed = 1;
 
     /// <summary>
-    /// Per-thread cached instance. A thread-static slot has zero per-rent / per-return allocation
-    /// (a <see cref="ConcurrentStack{T}.Push(T)"/> allocates a <c>Node</c> wrapper, which
-    /// dominated allocation in the first cut of this pool). Single-slot caching is sufficient
-    /// because the operators that consume <c>DelayAsync</c> serialise their per-instance work
-    /// behind a gate, so a single thread holds at most one in-flight delay per operator at a time.
-    /// Concurrent delays from different threads each get their own cached slot.
+    /// Per-thread cached instance; one slot per thread suffices because the operators that consume
+    /// <c>DelayAsync</c> serialise their work behind a gate, so a thread holds at most one
+    /// in-flight delay per operator.
     /// </summary>
     [ThreadStatic]
     private static PooledDelaySource? _threadCached;
@@ -93,9 +84,8 @@ public ValueTask BeginAsync(TimeSpan delay, TimeProvider timeProvider, Cancellat
             return new(this, _core.Version);
         }
 
-        // CreateTimer may invoke the callback synchronously (the immediate-fire pattern used by
-        // some test / benchmark providers); in that case _completed flips to Claimed before this
-        // call returns.
+        // CreateTimer may invoke the callback synchronously, flipping _completed to Claimed before
+        // this call returns.
         _timer = timeProvider.CreateTimer(
             static state => ((PooledDelaySource)state!).OnTimerFired(),
             this,
@@ -104,7 +94,7 @@ public ValueTask BeginAsync(TimeSpan delay, TimeProvider timeProvider, Cancellat
 
         if (Volatile.Read(ref _completed) == StateClaimed)
         {
-            // Sync-fire fast path: no cancellation registration needed; the source is already done.
+            // Sync-fire fast path: the source is complete, so no cancellation registration is needed.
             return new(this, _core.Version);
         }
 
@@ -144,12 +134,7 @@ public void GetResult(short token)
         }
     }
 
-    /// <summary>
-    /// Callback invoked when the timer's dueTime elapses. The race-loser branch (where
-    /// <c>OnCancelled</c> claimed the state first) cannot be deterministically triggered in
-    /// unit tests because the timer and cancellation must fire concurrently — the underlying
-    /// claim logic is covered by direct tests against <see cref="ConcurrencyRaceHelpers.TryClaim"/>.
-    /// </summary>
+    /// <summary>Completes the delay successfully when the timer's dueTime elapses, unless cancellation claimed it first.</summary>
     [ExcludeFromCodeCoverage]
     private void OnTimerFired()
     {
@@ -161,7 +146,7 @@ private void OnTimerFired()
         _core.SetResult(true);
     }
 
-    /// <summary>Callback invoked when the caller's cancellation token transitions to cancelled. Same race-only loser branch as <see cref="OnTimerFired"/>.</summary>
+    /// <summary>Faults the delay with <see cref="OperationCanceledException"/> when the caller's token fires, unless the timer claimed it first.</summary>
     /// <param name="cancellationToken">The cancellation token that fired.</param>
     [ExcludeFromCodeCoverage]
     private void OnCancelled(CancellationToken cancellationToken)
@@ -184,8 +169,7 @@ private void ReturnToPool()
         _completed = StateOpen;
         _core.Reset();
 
-        // Only one instance cached per thread; drop the rest for the GC. Capacity-of-one is the
-        // sweet spot for these operators — they hold at most one in-flight delay per gate.
+        // One instance cached per thread; any extra instances are dropped for the GC.
         _threadCached ??= this;
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SingleElementWitness.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SingleElementWitness.cs
index 1e15ed26..5bb25f3a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SingleElementWitness.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SingleElementWitness.cs
@@ -5,17 +5,15 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Shared observer used by both <c>SingleAsync</c> and <c>SingleOrDefaultAsync</c>. The two operator
-/// surfaces previously held near-identical observer classes; the only behavioural difference is
-/// whether an empty sequence throws or returns a caller-supplied default. That difference is now a
-/// single flag on this type, so the OnNext / OnErrorResume / OnCompleted bodies live in one place.
+/// Observer that resolves the one element of the source sequence matching a predicate, faulting the
+/// result with an <see cref="InvalidOperationException"/> as soon as a second match arrives.
 /// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="predicate">An optional predicate to filter elements; <c>null</c> matches all elements.</param>
 /// <param name="requireExactlyOne">
-/// When <c>true</c> (the <c>SingleAsync</c> shape), an empty sequence completes the result task with
-/// an <see cref="InvalidOperationException"/>. When <c>false</c> (the <c>SingleOrDefaultAsync</c>
-/// shape), an empty sequence resolves the result task with <paramref name="defaultValue"/>.
+/// When <c>true</c>, an empty sequence faults the result task with an
+/// <see cref="InvalidOperationException"/>; when <c>false</c>, it resolves the result task with
+/// <paramref name="defaultValue"/>.
 /// </param>
 /// <param name="defaultValue">The value to return on empty when <paramref name="requireExactlyOne"/> is <c>false</c>.</param>
 /// <param name="cancellationToken">A cancellation token for the operation.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSignal{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSignal{TResult}.cs
index c88fdce9..57cfce3e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSignal{TResult}.cs
@@ -11,7 +11,7 @@ public sealed class StartSignal<TResult> : IObservableAsync<TResult>
 {
     /// <summary>Initializes a new instance of the <see cref="StartSignal{TResult}"/> class.</summary>
     /// <param name="function">The function to invoke.</param>
-    /// <param name="taskScheduler">The optional scheduler used to invoke the function.</param>
+    /// <param name="taskScheduler">The optional scheduler that invokes the function; <see langword="null"/> invokes it inline.</param>
     public StartSignal(Func<TResult> function, TaskScheduler? taskScheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(function);
@@ -23,7 +23,7 @@ public StartSignal(Func<TResult> function, TaskScheduler? taskScheduler)
     /// <summary>Gets the function to invoke.</summary>
     private Func<TResult> Function { get; }
 
-    /// <summary>Gets the optional scheduler used to invoke the function.</summary>
+    /// <summary>Gets the optional scheduler that invokes the function.</summary>
     private TaskScheduler? TaskScheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
index 51bc4962..a784cc14 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
@@ -12,7 +12,7 @@ public sealed class StartSubscription<TResult> : TaskSignalSubscription<TResult>
     /// <summary>Initializes a new instance of the <see cref="StartSubscription{TResult}"/> class.</summary>
     /// <param name="observer">The observer receiving the produced value.</param>
     /// <param name="function">The function to invoke.</param>
-    /// <param name="taskScheduler">The optional scheduler used to invoke the function.</param>
+    /// <param name="taskScheduler">The optional scheduler that invokes the function; <see langword="null"/> invokes it inline.</param>
     public StartSubscription(
         IObserverAsync<TResult> observer,
         Func<TResult> function,
@@ -28,7 +28,7 @@ public StartSubscription(
     /// <summary>Gets the function to invoke.</summary>
     private Func<TResult> Function { get; }
 
-    /// <summary>Gets the optional scheduler used to invoke the function.</summary>
+    /// <summary>Gets the optional scheduler that invokes the function.</summary>
     private TaskScheduler? TaskScheduler { get; }
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest10Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest10Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult}.cs
index 22f3b7f0..01d7b72c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest10Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest10Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult}.cs
@@ -170,10 +170,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source10.SubscribeAsync(new SyncLatestWitness<T10, TResult>(this, Source10Bit, value => Value10 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest11Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest11Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult}.cs
index 1d4ee742..3e704202 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest11Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest11Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult}.cs
@@ -182,10 +182,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source11.SubscribeAsync(new SyncLatestWitness<T11, TResult>(this, Source11Bit, value => Value11 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest12Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest12Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult}.cs
index e3744dd8..6040e7c8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest12Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest12Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult}.cs
@@ -207,10 +207,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source12.SubscribeAsync(new SyncLatestWitness<T12, TResult>(this, Source12Bit, value => Value12 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest13Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest13Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult}.cs
index 66147ca2..f8632737 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest13Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest13Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult}.cs
@@ -220,10 +220,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source13.SubscribeAsync(new SyncLatestWitness<T13, TResult>(this, Source13Bit, value => Value13 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest14Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest14Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult}.cs
index b7cd2805..fba0dca6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest14Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest14Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult}.cs
@@ -233,10 +233,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source14.SubscribeAsync(new SyncLatestWitness<T14, TResult>(this, Source14Bit, value => Value14 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest15Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest15Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult}.cs
index 5d490766..82fef33c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest15Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest15Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult}.cs
@@ -246,10 +246,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source15.SubscribeAsync(new SyncLatestWitness<T15, TResult>(this, Source15Bit, value => Value15 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest16Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest16Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult}.cs
index 5cf7d9c1..2cd9ca0d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest16Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest16Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult}.cs
@@ -258,10 +258,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source16.SubscribeAsync(new SyncLatestWitness<T16, TResult>(this, Source16Bit, value => Value16 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest2Coordinator{T1,T2,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest2Coordinator{T1,T2,TResult}.cs
index b7f999ed..decd0dd9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest2Coordinator{T1,T2,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest2Coordinator{T1,T2,TResult}.cs
@@ -71,10 +71,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source2.SubscribeAsync(new SyncLatestWitness<T2, TResult>(this, Source2Bit, value => Value2 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest3Coordinator{T1,T2,T3,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest3Coordinator{T1,T2,T3,TResult}.cs
index 44faa290..d7396651 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest3Coordinator{T1,T2,T3,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest3Coordinator{T1,T2,T3,TResult}.cs
@@ -83,10 +83,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source3.SubscribeAsync(new SyncLatestWitness<T3, TResult>(this, Source3Bit, value => Value3 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest4Coordinator{T1,T2,T3,T4,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest4Coordinator{T1,T2,T3,T4,TResult}.cs
index 02e997b0..95a8d13f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest4Coordinator{T1,T2,T3,T4,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest4Coordinator{T1,T2,T3,T4,TResult}.cs
@@ -95,10 +95,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source4.SubscribeAsync(new SyncLatestWitness<T4, TResult>(this, Source4Bit, value => Value4 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest5Coordinator{T1,T2,T3,T4,T5,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest5Coordinator{T1,T2,T3,T4,T5,TResult}.cs
index 149a2683..332ee78e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest5Coordinator{T1,T2,T3,T4,T5,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest5Coordinator{T1,T2,T3,T4,T5,TResult}.cs
@@ -107,10 +107,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source5.SubscribeAsync(new SyncLatestWitness<T5, TResult>(this, Source5Bit, value => Value5 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4, T5 V5) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest6Coordinator{T1,T2,T3,T4,T5,T6,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest6Coordinator{T1,T2,T3,T4,T5,T6,TResult}.cs
index 93d7e9af..7b23638e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest6Coordinator{T1,T2,T3,T4,T5,T6,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest6Coordinator{T1,T2,T3,T4,T5,T6,TResult}.cs
@@ -119,10 +119,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source6.SubscribeAsync(new SyncLatestWitness<T6, TResult>(this, Source6Bit, value => Value6 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4, T5 V5, T6 V6) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest7Coordinator{T1,T2,T3,T4,T5,T6,T7,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest7Coordinator{T1,T2,T3,T4,T5,T6,T7,TResult}.cs
index 57eb774a..d96c60ae 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest7Coordinator{T1,T2,T3,T4,T5,T6,T7,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest7Coordinator{T1,T2,T3,T4,T5,T6,T7,TResult}.cs
@@ -131,10 +131,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source7.SubscribeAsync(new SyncLatestWitness<T7, TResult>(this, Source7Bit, value => Value7 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4, T5 V5, T6 V6, T7 V7) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest8Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest8Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,TResult}.cs
index c3d8d8ed..e45a73d6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest8Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest8Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,TResult}.cs
@@ -143,10 +143,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source8.SubscribeAsync(new SyncLatestWitness<T8, TResult>(this, Source8Bit, value => Value8 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4, T5 V5, T6 V6, T7 V7, T8 V8) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest9Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest9Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult}.cs
index ce8bb04b..4606a3b3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest9Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatest9Coordinator{T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult}.cs
@@ -156,10 +156,7 @@ protected override ValueTask<IAsyncDisposable> SubscribeAtAsync(int index, Cance
             _ => Sources.Source9.SubscribeAsync(new SyncLatestWitness<T9, TResult>(this, Source9Bit, value => Value9 = new(value)), cancellationToken)
         };
 
-    /// <summary>
-    /// Reads every source's latest value into a single snapshot. Returns <see langword="false"/>
-    /// until every source has produced at least one value.
-    /// </summary>
+    /// <summary>Reads every source's latest value into a single snapshot.</summary>
     /// <param name="values">When the method returns <see langword="true"/>, the snapshot.</param>
     /// <returns><see langword="true"/> when every source has produced a value; otherwise <see langword="false"/>.</returns>
     private bool TryReadValues(out (T1 V1, T2 V2, T3 V3, T4 V4, T5 V5, T6 V6, T7 V7, T8 V8, T9 V9) values)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
index 83569bbf..f6d753ca 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
@@ -5,11 +5,9 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Shared scaffolding for the arity-specific <c>CombineLatestN</c> subscription types. Each
-/// per-arity <c>SyncLatestCoordinator</c> derives from this class so the otherwise-identical
-/// <see cref="SyncLatestLifecycle{TResult}"/> wiring (gate / dispose CTS / external link),
-/// the values-lock, the source-subscribe loop, the error-resume forwarder, and
-/// <see cref="DisposeAsync"/> live here once instead of repeated 15× across <c>CombineLatest2..16</c>.
+/// Base class for the arity-specific <c>CombineLatestN</c> coordinators, owning the
+/// <see cref="SyncLatestLifecycle{TResult}"/> wiring, the values-lock, the source-subscribe loop,
+/// the error-resume forwarder and disposal.
 /// </summary>
 /// <typeparam name="TResult">The downstream element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("SyncLatestCoordinatorBase: SourceCount = {Lifecycle.Subscriptions.Length}, HasDisposed = {Lifecycle.HasDisposed}")]
@@ -24,9 +22,7 @@ protected SyncLatestCoordinatorBase(IObserverAsync<TResult> observer, int source
     /// <summary>Gets the shared subscription lifecycle (gate / dispose CTS / external link / forwarders).</summary>
     internal SyncLatestLifecycle<TResult> Lifecycle { get; }
 
-    /// <summary>Gets the lock protecting per-arity latest-values caches. Internal so the shared
-    /// <see cref="SyncLatestIndexedWitness{TSource, TResult}"/> can lock on it without deriving
-    /// from this base.</summary>
+    /// <summary>Gets the lock guarding the derived coordinator's latest-value slots.</summary>
     internal Lock ValuesLock { get; } = new();
 
     /// <summary>Subscribes to every source observable via <see cref="SubscribeAtAsync"/>.</summary>
@@ -49,9 +45,9 @@ public async ValueTask DisposeAsync()
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Relays an upstream error to the downstream observer; thin shim with the <c>(error, ct)</c> signature that <see cref="IObservableAsync{T}.SubscribeAsync"/> expects.</summary>
+    /// <summary>Relays an upstream error to the downstream observer.</summary>
     /// <param name="error">The error to forward.</param>
-    /// <param name="cancellationToken">Ignored — the lifecycle uses its own dispose token.</param>
+    /// <param name="cancellationToken">Ignored; the lifecycle uses its own dispose token.</param>
     /// <returns>A ValueTask representing the asynchronous forward.</returns>
     internal ValueTask RelaySourceErrorAsync(Exception error, CancellationToken cancellationToken)
     {
@@ -60,18 +56,14 @@ internal ValueTask RelaySourceErrorAsync(Exception error, CancellationToken canc
     }
 
     /// <summary>
-    /// Reads the per-arity Optional slots, projects them through the selector when every source
-    /// has produced a value, and forwards the result downstream via the lifecycle. Invoked by
-    /// <see cref="SyncLatestIndexedWitness{TSource, TResult}"/> after a per-source OnNext has
-    /// landed under <see cref="ValuesLock"/>.
+    /// Projects the latest-value slots through the selector and forwards the result downstream, doing
+    /// nothing until every source has produced a value. Called after a per-source OnNext has landed
+    /// under <see cref="ValuesLock"/>.
     /// </summary>
     /// <returns>A ValueTask representing the asynchronous emit.</returns>
     internal abstract ValueTask EmitLatestAsync();
 
-    /// <summary>
-    /// Subscribes to a single source by 0-based index. Implemented per-arity by the derived
-    /// <c>SyncLatestCoordinator</c> with a typed switch dispatch over the bundled sources.
-    /// </summary>
+    /// <summary>Subscribes to a single source by 0-based index, dispatching to the derived coordinator's typed slot.</summary>
     /// <param name="index">0-based source index.</param>
     /// <param name="cancellationToken">A token to cancel the subscription.</param>
     /// <returns>The subscription disposable for the source at <paramref name="index"/>.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
index c5c2c0f1..7138fc4f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
@@ -97,7 +97,7 @@ public async ValueTask SubscribeSourcesAsync(CancellationToken cancellationToken
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask DisposeAsync() => FinishAsync(null);
 
-    /// <summary>Handles OnNext from a source.</summary>
+    /// <summary>Records the source's latest value and emits the projected snapshot once every source has produced one.</summary>
     /// <param name="index">The source index.</param>
     /// <param name="indexValue">The value.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
@@ -143,7 +143,7 @@ internal async ValueTask OnNextAsync(int index, TSource indexValue, Cancellation
         }
     }
 
-    /// <summary>Handles OnErrorResume from a source.</summary>
+    /// <summary>Forwards a non-terminal source error downstream under the gate.</summary>
     /// <param name="error">The error.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>A value task representing the operation.</returns>
@@ -160,7 +160,7 @@ internal async ValueTask OnErrorResumeAsync(Exception error, CancellationToken c
         }
     }
 
-    /// <summary>Handles OnCompleted from a source.</summary>
+    /// <summary>Completes the combined sequence when the source failed, completed without a value, or was the last to complete.</summary>
     /// <param name="index">The source index.</param>
     /// <param name="result">The result.</param>
     /// <returns>A value task representing the operation.</returns>
@@ -187,8 +187,8 @@ internal ValueTask OnCompletedAsync(int index, Result result)
         return shouldComplete ? FinishAsync(Result.Success) : default;
     }
 
-    /// <summary>Completes the subscription. The gate and dispose CTS are always released in the finally block.</summary>
-    /// <param name="result">The result.</param>
+    /// <summary>Completes the subscription once, disposing every source subscription, the gate and the dispose token.</summary>
+    /// <param name="result">The completion result, or <see langword="null"/> when disposing without signalling.</param>
     /// <returns>A value task representing the operation.</returns>
     internal async ValueTask FinishAsync(Result? result)
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
index 8dce1f40..81bbcb87 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
@@ -5,20 +5,16 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Per-source <see cref="WitnessAsync{T}"/> used by every <c>CombineLatestN</c> subscription. The
-/// per-arity class previously declared N hand-rolled <c>OnNextN</c> / <c>OnCompletedN</c> method
-/// pairs whose bodies differed only in which <c>Optional&lt;TN&gt;</c> field they wrote and which
-/// completion bit they passed to the lifecycle. Pre-building N of these witnesses at subscription
-/// time keeps the typing exact and eliminates the per-source method declarations from the per-arity
-/// files. The closure cost (one delegate per source for the value-write) is paid once at subscribe
-/// and not per emission; the actual per-emission cost is one indirect delegate invoke under the
-/// values-lock.
+/// Per-source <see cref="WitnessAsync{T}"/> for a <c>CombineLatestN</c> subscription: records each
+/// value into the parent's typed slot under the values-lock, then asks the parent to emit. One
+/// instance is built per source at subscribe time, so the per-emission cost is a single delegate
+/// invoke.
 /// </summary>
 /// <typeparam name="TSource">The element type of the upstream source this witness subscribes to.</typeparam>
 /// <typeparam name="TResult">The downstream element type owned by the parent subscription.</typeparam>
 /// <param name="parent">The parent subscription that owns the values-lock and lifecycle.</param>
 /// <param name="sourceBit">The completion bitmask bit owned by this source (1 &lt;&lt; index).</param>
-/// <param name="recordValue">Stores the freshly-emitted value into the parent's typed <c>_valN</c> slot.</param>
+/// <param name="recordValue">Stores the emitted value into the parent's typed slot for this source.</param>
 public sealed class SyncLatestIndexedWitness<TSource, TResult>(
     SyncLatestCoordinatorBase<TResult> parent,
     int sourceBit,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
index 13426390..c9ab8df4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
@@ -7,11 +7,9 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Shared subscription lifecycle for the arity-specific <c>CombineLatestN</c> operators (2..16) and
-/// the enumerable variant. Each per-arity <c>SyncLatestCoordinator</c> composes one instance of
-/// this class (has-a, not is-a) and forwards lifecycle / error / gating work into it, so the
-/// previously-duplicated infrastructure (gate, dispose CTS, external-link registration, observer
-/// fan-out, completion-bitmask handling) lives in one place.
+/// Subscription lifecycle for the <c>CombineLatestN</c> operators (2..16) and the enumerable
+/// variant: owns the serialization gate, the dispose cancellation source, the external-link
+/// registration, the gated observer fan-out and the completion bitmask.
 /// </summary>
 /// <typeparam name="TResult">The downstream element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("SyncLatestLifecycle: SourceCount = {Subscriptions.Length}, HasDisposed = {HasDisposed}")]
@@ -62,9 +60,8 @@ public SyncLatestLifecycle(IObserverAsync<TResult> observer, int sourceCount)
     public bool HasDisposed => DisposalHelper.HasDisposed(_disposed);
 
     /// <summary>
-    /// Links the original subscribe-time cancellation token into this subscription's dispose chain so
-    /// per-emission methods can use <see cref="DisposeToken"/> directly instead of allocating a
-    /// per-emission linked CTS.
+    /// Links the subscribe-time cancellation token into this subscription's dispose chain, so
+    /// <see cref="DisposeToken"/> alone covers both and no per-emission linked source is needed.
     /// </summary>
     /// <param name="external">The subscribe-time token.</param>
     public void LinkExternalCancellation(CancellationToken external)
@@ -177,9 +174,8 @@ public async ValueTask FinishAsync(Result? result)
         }
         finally
         {
-            // Always release the unmanaged-style primitives even if upstream DisposeAsync or
-            // OnCompletedAsync throws — otherwise a misbehaving downstream leaks the gate's
-            // SemaphoreSlim and the dispose CTS's wait handles.
+            // A throwing upstream DisposeAsync or OnCompletedAsync must not leak the gate's
+            // SemaphoreSlim or the dispose CTS's wait handles.
 #if NETCOREAPP3_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
             await _externalLinkRegistration.DisposeAsync().ConfigureAwait(false);
 #else
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
index 8337b317..5de76507 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
@@ -5,12 +5,9 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Shared subscription lifecycle for the TakeUntil family of operators (CancellationToken / Task /
-/// raw-signal / async-observable / async-predicate variants). Each per-trigger Subscription
-/// composes one instance of this class (has-a, not is-a) and forwards forward-on-next / -error /
-/// -completed plus external-cancellation linking into it, so the previously-duplicated
-/// infrastructure (gate, dispose CTS, external-link registration, gated observer fan-out) lives
-/// in one place.
+/// Subscription lifecycle for the TakeUntil family of operators (CancellationToken, Task,
+/// raw-signal, async-observable and async-predicate triggers): owns the serialization gate, the
+/// dispose cancellation source, the external-link registration and the gated observer fan-out.
 /// </summary>
 /// <typeparam name="T">The downstream element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("TakeUntilLifecycle: Observer = {_observer}, DisposeRequested = {DisposeToken.IsCancellationRequested}")]
@@ -40,9 +37,8 @@ public TakeUntilLifecycle(IObserverAsync<T> observer)
     public CancellationToken DisposeToken { get; }
 
     /// <summary>
-    /// Links the original subscribe-time cancellation token into this subscription's dispose chain so
-    /// per-emission methods can use <see cref="DisposeToken"/> directly instead of allocating a
-    /// per-emission linked CTS.
+    /// Links the subscribe-time cancellation token into this subscription's dispose chain, so
+    /// <see cref="DisposeToken"/> alone covers both and no per-emission linked source is needed.
     /// </summary>
     /// <param name="external">The subscribe-time token.</param>
     public void LinkExternalCancellation(CancellationToken external)
@@ -97,12 +93,9 @@ public async ValueTask RelayCompletionAsync(Result result)
     }
 
     /// <summary>
-    /// Tears down the shared subscription state: cancels the dispose CTS, releases the external-link
-    /// registration, disposes the gate. The owning Subscription is responsible for disposing its
-    /// per-operator handles (source subscription, token callback, etc.) BEFORE or AFTER calling this
-    /// — the order is operator-specific. The release of unmanaged-style primitives is wrapped in
-    /// try/finally so a misbehaving downstream can't leak the gate's SemaphoreSlim or the CTS wait
-    /// handles.
+    /// Cancels the dispose token, releases the external-link registration and disposes the gate. The
+    /// owning subscription disposes its own per-operator handles (source subscription, token
+    /// callback) separately, in whichever order that operator requires.
     /// </summary>
     /// <returns>A ValueTask representing the asynchronous teardown.</returns>
     public async ValueTask DisposeAsync()
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
index ac7e6d06..2850efc3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
@@ -5,10 +5,8 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Shared <see cref="WitnessAsync{T}"/> implementation that forwards every source notification
-/// straight into a <see cref="TakeUntilLifecycle{T}"/> instance. Used by every per-trigger
-/// TakeUntil Subscription so the per-operator inner-class shells (which previously held identical
-/// three-method forwarders) collapse into a single shared type.
+/// <see cref="WitnessAsync{T}"/> that forwards every source notification straight into a
+/// <see cref="TakeUntilLifecycle{T}"/>, which gates it on its way downstream.
 /// </summary>
 /// <typeparam name="T">The downstream element type.</typeparam>
 /// <param name="lifecycle">The shared lifecycle owning the gate and forwarding logic.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
index ba971422..6a6f89d9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
@@ -12,7 +12,7 @@ namespace ReactiveUI.Primitives.Async.Advanced;
 [System.Diagnostics.DebuggerDisplay("TaskResultCompletionSource: IsCompleted = {_taskSource.Task.IsCompleted}")]
 public sealed class TaskResultCompletionSource<T>(CancellationToken cancellationToken)
 {
-    /// <summary>The task completion source used to publish the terminal result.</summary>
+    /// <summary>The task completion source that publishes the terminal result.</summary>
     private readonly TaskCompletionSource<T> _taskSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
     /// <summary>The cancellation token that cancels the terminal wait.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultWitnessAsyncBase.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultWitnessAsyncBase.cs
index 36cbd2d1..04df541f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultWitnessAsyncBase.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultWitnessAsyncBase.cs
@@ -10,11 +10,11 @@ namespace ReactiveUI.Primitives.Async.Advanced;
 /// <summary>Base class for witnesses that produce a single task-based result value when the observed sequence completes.</summary>
 /// <typeparam name="T">The type of elements received from the observable sequence.</typeparam>
 /// <typeparam name="TTaskValue">The type of the result value produced by this witness.</typeparam>
-/// <param name="cancellationToken">A cancellation token used to cancel the waiting operation.</param>
+/// <param name="cancellationToken">A token that cancels the wait for the result value.</param>
 [System.Diagnostics.DebuggerDisplay("TaskResultWitnessAsyncBase: Completion = {_completion}")]
 public abstract class TaskResultWitnessAsyncBase<T, TTaskValue>(CancellationToken cancellationToken) : WitnessAsync<T>
 {
-    /// <summary>The completion helper used to produce and cancel the observer's single result value.</summary>
+    /// <summary>The completion helper that produces and cancels the observer's single result value.</summary>
     private readonly TaskResultCompletionSource<TTaskValue> _completion = new(cancellationToken);
 
     /// <summary>Asynchronously waits for the observer to produce its result value.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
index 469b7580..bee366c6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
@@ -5,47 +5,37 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>
-/// Represents an asynchronous subscription that can be cancelled and disposed, managing the lifecycle of an
-/// observer and its associated operations.
+/// A subscription that runs a cancellable asynchronous job feeding a single observer, and joins that
+/// job on disposal.
 /// </summary>
 /// <typeparam name="T">The type of the elements observed by the subscription.</typeparam>
 /// <param name="observer">The observer that receives notifications for the subscription. Cannot be null.</param>
-/// <remarks>This type provides a base for implementing cancellable, asynchronously disposable
-/// subscriptions that coordinate observer notifications and resource cleanup. Disposal cancels any ongoing
-/// operations and ensures that all resources are released before completion. Derived classes should implement the
-/// core execution logic in <see cref="ExecuteAsyncCore"/>.</remarks>
+/// <remarks>Disposal cancels the running job and waits for it to finish before releasing resources;
+/// derived classes supply the job body in <see cref="ExecuteAsyncCore"/>.</remarks>
 [System.Diagnostics.DebuggerDisplay("TaskSignalSubscription: Disposed = {_disposed}, Completed = {_tcs.Task.IsCompleted}")]
 public abstract class TaskSignalSubscription<T>(IObserverAsync<T> observer) : IAsyncDisposable
 {
-    /// <summary>The task completion source used to signal when the subscription's asynchronous operation has finished.</summary>
+    /// <summary>The task completion source that signals when the subscription's job has finished.</summary>
     private readonly TaskCompletionSource<bool> _tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-    /// <summary>The cancellation token source used to cancel the subscription's asynchronous operation upon disposal.</summary>
+    /// <summary>The cancellation token source that cancels the subscription's job on disposal.</summary>
     private readonly CancellationTokenSource _cts = new();
 
-    /// <summary>Flows into the job's notification call chain (across any thread hops) so a reentrant
-    /// <see cref="DisposeAsync"/> issued from inside the job — e.g. a downstream operator disposing the
-    /// subscription from within its own <c>OnNextAsync</c> — is recognised and skips the self-join on
-    /// <see cref="_tcs"/> that would otherwise deadlock. A thread-ID marker only catches the synchronous
-    /// same-thread case; once the notification continuation hops threads the ID no longer matches and the
-    /// dispose waits for a job that cannot complete until the dispose returns.</summary>
+    /// <summary>Flows through the job's notification chain across thread hops, so a reentrant
+    /// <see cref="DisposeAsync"/> issued from inside the job skips the self-join on <see cref="_tcs"/>
+    /// that would otherwise deadlock.</summary>
     private readonly AsyncLocal<bool> _executing = new();
 
-    /// <summary>Indicates whether disposal has already been initiated to prevent double-disposal.</summary>
+    /// <summary>Set on the first disposal so later calls are no-ops.</summary>
     private int _disposed;
 
-    /// <summary>Starts the operation synchronously using the current cancellation token.</summary>
-    /// <remarks>This method initiates the asynchronous operation and does not wait for its completion. To
-    /// monitor progress or handle completion, use the asynchronous counterpart directly. The
-    /// <see cref="ValueTask"/> returned by <see cref="ExecuteAsync"/> is converted to a <see cref="Task"/>
-    /// before being discarded so the fire-and-forget pattern stays compatible with CA2012.</remarks>
+    /// <summary>Starts the subscription's job and returns without waiting for it to finish.</summary>
     public void Start() => _ = ExecuteAsync(_cts.Token).AsTask();
 
     /// <summary>Asynchronously releases the resources used by the object and cancels any ongoing operations.</summary>
     /// <returns>A ValueTask that represents the asynchronous dispose operation.</returns>
-    /// <remarks>Call this method to ensure that all resources are released and any pending operations
-    /// are cancelled before the object is discarded. Await the returned ValueTask to guarantee that disposal has
-    /// completed.</remarks>
+    /// <remarks>Joins the in-flight job before returning, except when called from inside that job's own
+    /// notification, where joining would deadlock.</remarks>
     public async ValueTask DisposeAsync()
     {
         if (Interlocked.Exchange(ref _disposed, 1) != 0)
@@ -84,7 +74,7 @@ internal static async ValueTask CompleteWithFailureAsync(IObserverAsync<T> obser
     }
 
     /// <summary>Executes the subscription's core logic, handling exceptions by completing the observer with a failure result.</summary>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <param name="cancellationToken">A token that cancels the subscription's job.</param>
     /// <returns>A <see cref="ValueTask"/> representing the asynchronous operation.</returns>
     internal async ValueTask ExecuteAsync(CancellationToken cancellationToken)
     {
@@ -105,7 +95,7 @@ internal async ValueTask ExecuteAsync(CancellationToken cancellationToken)
 
     /// <summary>When overridden in a derived class, executes the core subscription logic asynchronously.</summary>
     /// <param name="observer">The observer that receives notifications.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <param name="cancellationToken">A token that cancels the subscription's job.</param>
     /// <returns>A <see cref="ValueTask"/> representing the asynchronous operation.</returns>
     protected abstract ValueTask ExecuteAsyncCore(IObserverAsync<T> observer, CancellationToken cancellationToken);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
index cdb2c66f..10726809 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
@@ -5,41 +5,31 @@
 namespace ReactiveUI.Primitives.Internal;
 
 /// <summary>
-/// Pure helpers for the two recurring race-claim primitives in the async layer:
-/// the "first caller wins" <see cref="Interlocked.CompareExchange(ref int, int, int)"/>
-/// transition used by <c>PooledDelaySource</c>, and the "tolerate already-disposed CTS"
-/// <c>CancellationTokenSource.CancelAsync</c> wrapper used by <c>ObserverAsync</c>'s
-/// dispose path. Both are pure functions over their inputs and are directly unit-tested
-/// against this class.
+/// Pure race-claim helpers shared by the async layer: a first-caller-wins sentinel transition, and a cancel call that
+/// treats a concurrently disposed token source as a lost race rather than a failure.
 /// </summary>
 internal static class ConcurrencyRaceHelpers
 {
     /// <summary>
-    /// Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/>
-    /// to <paramref name="claimedSentinel"/>. Returns <see langword="true"/> if this caller
-    /// won the race; <see langword="false"/> if another caller had already claimed the state.
+    /// Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/> to
+    /// <paramref name="claimedSentinel"/>.
     /// </summary>
     /// <param name="state">The reference to the state field.</param>
     /// <param name="openSentinel">The sentinel value the state must currently hold.</param>
     /// <param name="claimedSentinel">The sentinel value the state transitions to on success.</param>
     /// <returns>
-    /// <see langword="true"/> if the claim succeeded; <see langword="false"/> if another caller
-    /// already claimed the state.
+    /// <see langword="true"/> when this caller won the claim; <see langword="false"/> when another caller held it.
     /// </returns>
     internal static bool TryClaim(ref int state, int openSentinel, int claimedSentinel) =>
         Interlocked.CompareExchange(ref state, claimedSentinel, openSentinel) == openSentinel;
 
     /// <summary>
-    /// Calls <c>CancellationTokenSource.CancelAsync</c> on <paramref name="cts"/>,
-    /// tolerating the <see cref="ObjectDisposedException"/> that another concurrent dispose
-    /// may have already raced ahead with. Returns <see langword="true"/> if the cancellation
-    /// went through; <see langword="false"/> if another caller had already cancelled-and-
-    /// disposed the source.
+    /// Cancels <paramref name="cts"/>, swallowing the <see cref="ObjectDisposedException"/> a racing dispose raises.
     /// </summary>
     /// <param name="cts">The cancellation token source to cancel.</param>
     /// <returns>
-    /// <see langword="true"/> if the cancellation completed; <see langword="false"/> if the
-    /// source was already disposed.
+    /// <see langword="true"/> when the cancellation completed; <see langword="false"/> when a concurrent caller had
+    /// disposed the source first.
     /// </returns>
     internal static async ValueTask<bool> TryCancelAsync(CancellationTokenSource cts)
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
index abf674b7..5dde5678 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
@@ -12,13 +12,13 @@ namespace ReactiveUI.Primitives.Async;
 /// The exception that is thrown when multiple concurrent calls are made to observer methods that do not support
 /// concurrent execution.
 /// </summary>
-/// <remarks>This exception indicates that a call to OnNextAsync, OnErrorResumeAsync, or OnCompletedAsync was
-/// attempted while a previous call to one of these methods is still pending. ObserverAsync{T} does not allow concurrent
-/// invocations of these methods; callers should ensure that each call completes before initiating another.</remarks>
+/// <remarks><see cref="WitnessAsync{T}"/> serializes <c>OnNextAsync</c>, <c>OnErrorResumeAsync</c> and
+/// <c>OnCompletedAsync</c>; this exception reports one of those calls arriving while another is in flight. Await each
+/// call to completion before starting the next.</remarks>
 [Serializable]
 public class ConcurrentWitnessCallsException : Exception
 {
-    /// <summary>The default error message describing the concurrent observer call violation.</summary>
+    /// <summary>The message used when no caller-supplied message is given.</summary>
     private const string DefaultMessage =
         $"Concurrent calls of {nameof(WitnessAsync<>)}.OnNextAsync, {nameof(WitnessAsync<>)}.OnErrorResumeAsync,"
         + $" {nameof(WitnessAsync<>)}.OnCompletedAsync are not allowed. There is already a call pending";
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
index 58c4bce0..f2ff57d1 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
@@ -9,14 +9,12 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>
-/// Represents an asynchronous observable sequence that can be connected to a data source, allowing control over when
-/// the subscription to the underlying resource is established.
+/// An asynchronous observable that multicasts a cold source through a signal, leaving the caller to decide when the
+/// source subscription is established.
 /// </summary>
 /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
-/// <remarks>A connectable observable enables explicit control over the connection to the data source, which can
-/// be useful for sharing a single subscription among multiple observers or for deferring the start of data emission
-/// until explicitly connected. Implementations may vary in how connections are managed and whether multiple connections
-/// are supported concurrently.</remarks>
+/// <remarks>Subscribing attaches the observer to the signal without touching the source, so observers that subscribe
+/// before <see cref="ConnectAsync"/> all share the one source subscription it creates.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConnectableSignalAsync: State = {State}")]
 public sealed class ConnectableSignalAsync<T> : IObservableAsync<T>, IDisposable
 {
@@ -30,27 +28,22 @@ public ConnectableSignalAsync(IObservableAsync<T> source, ISignalAsync<T> signal
     private ConnectableSignalAsyncState<T> State { get; }
 
     /// <summary>
-    /// Asynchronously establishes a connection to the target resource and returns a disposable handle for managing the
-    /// connection's lifetime.
+    /// Subscribes the signal to the source, or returns the live connection when one exists.
     /// </summary>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous connection operation.</param>
-    /// <returns>A value task that represents the asynchronous operation. The result contains an <see cref="IAsyncDisposable"/>
-    /// that should be disposed to close the connection.</returns>
-    /// <remarks>The returned <see cref="IAsyncDisposable"/> must be disposed when the connection is no longer
-    /// needed to ensure proper resource cleanup. Multiple calls to this method may result in multiple independent
-    /// connections, depending on the implementation.</remarks>
+    /// <returns>A handle whose disposal drops the source subscription, allowing a later call to reconnect.</returns>
+    /// <exception cref="OperationCanceledException">This instance has been disposed, or
+    /// <paramref name="cancellationToken"/> was cancelled.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<IAsyncDisposable> ConnectAsync(CancellationToken cancellationToken) =>
         ConnectableSignalAsyncHelper.ConnectAsync(State, cancellationToken);
 
-    /// <summary>Releases all resources used by the current instance of the class.</summary>
-    /// <remarks>Call this method when you are finished using the object to release managed resources.</remarks>
+    /// <summary>Drops any live connection and blocks further ones.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification =
-            "IDisposable.Dispose is intrinsically synchronous; this method must tear down async connection state on the sync dispose path.")]
+        Justification = "The synchronous dispose contract leaves no way to await teardown of the async connection state.")]
     public void Dispose() => ConnectableSignalAsyncHelper.Dispose(State);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
index 5a38e6cf..bf6edcb5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Provides connectable-signal operations over flat state records.</summary>
 internal static class ConnectableSignalAsyncHelper
 {
-    /// <summary>Connects the state source once and returns a handle that can disconnect that connection.</summary>
+    /// <summary>Subscribes the state's signal to its source once, returning a handle that disconnects it.</summary>
     /// <typeparam name="T">The type of elements produced by the source sequence.</typeparam>
     /// <param name="state">The connectable signal state to operate on.</param>
     /// <param name="cancellationToken">A token that can cancel connection establishment.</param>
@@ -85,8 +85,7 @@ internal static async ValueTask<IAsyncDisposable> ConnectAsync<T>(
     [SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification =
-            "IDisposable.Dispose is intrinsically synchronous; this method must tear down async connection state on the sync dispose path.")]
+        Justification = "The synchronous dispose contract leaves no way to await teardown of the async connection state.")]
     internal static void Dispose<T>(ConnectableSignalAsyncState<T> state)
     {
         if (!state.TryMarkDisposed())
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
index 28509bf9..7ecc671d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
@@ -17,7 +17,7 @@ internal sealed class ConnectableSignalAsyncState<T> : IDisposable
     [SuppressMessage(
         "Style",
         "SST1401:Field should be private",
-        Justification = "Gate fields are intentionally direct readonly state for helper access.")]
+        Justification = "The helper class that drives this state enters the gate directly.")]
     internal readonly AsyncSerialGate Gate = new();
 
     /// <summary>The monitor used to make synchronous disposal idempotent.</summary>
@@ -45,14 +45,11 @@ public ConnectableSignalAsyncState(IObservableAsync<T> source, ISignalAsync<T> s
     /// <summary>Gets or sets the active source subscription, if connected.</summary>
     internal SingleAssignmentDisposableAsync? Connection { get; set; }
 
-    /// <summary>Gets or sets a value indicating whether synchronous disposal has run.</summary>
+    /// <summary>Gets or sets a value indicating whether disposal has been claimed.</summary>
     internal bool IsDisposed { get; set; }
 
-    /// <summary>Gets the token canceled when the connectable signal is disposed. Captured while the source is
-    /// still alive because <see cref="Dispose"/> disposes that source, and reading
-    /// <see cref="CancellationTokenSource.Token"/> from a disposed source throws
-    /// <see cref="ObjectDisposedException"/>. Disposal always cancels before it disposes, so this token is
-    /// already cancelled by the time anyone can observe it post-disposal.</summary>
+    /// <summary>Gets the token cancelled when the connectable signal is disposed, captured at construction because
+    /// <see cref="Dispose"/> makes <see cref="CancellationTokenSource.Token"/> throw.</summary>
     internal CancellationToken DisposedCancellationToken { get; }
 
     /// <inheritdoc/>
@@ -62,7 +59,7 @@ public void Dispose()
         DisposedCts.Dispose();
     }
 
-    /// <summary>Marks the state as disposed if disposal has not already started.</summary>
+    /// <summary>Claims disposal for the first caller to ask.</summary>
     /// <returns><see langword="true"/> when this call owns disposal; otherwise, <see langword="false"/>.</returns>
     internal bool TryMarkDisposed()
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
index 23dd9a75..edc1db4e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
@@ -7,14 +7,11 @@
 namespace ReactiveUI.Primitives.Async.Disposables;
 
 /// <summary>Provides factory methods for creating and working with implementations of <see cref="IAsyncDisposable"/>.</summary>
-/// <remarks>This class offers utility members to simplify the creation of asynchronous disposables, such as
-/// wrapping a delegate in an <see cref="IAsyncDisposable"/> implementation or providing a no-op disposable instance.
-/// All members are thread-safe and can be used to facilitate resource management in asynchronous scenarios.</remarks>
+/// <remarks>Every disposable handed out here runs its delegate at most once, however many times — and from however many
+/// threads — it is disposed.</remarks>
 public static class DisposableAsync
 {
-    /// <summary>Gets an <see cref="IAsyncDisposable"/> instance that performs no action when disposed asynchronously.</summary>
-    /// <remarks>Use this property when an <see cref="IAsyncDisposable"/> is required but no disposal logic is
-    /// necessary. This can be useful as a default or placeholder implementation.</remarks>
+    /// <summary>Gets a shared <see cref="IAsyncDisposable"/> that does nothing when disposed.</summary>
     public static IAsyncDisposable Empty { get; } = new NoopAsyncDisposable();
 
     /// <summary>Creates a new asynchronous disposable object that invokes the specified delegate when disposed asynchronously.</summary>
@@ -30,9 +27,8 @@ public static IAsyncDisposable Create(Func<ValueTask> disposeAsync)
 
     /// <summary>
     /// Creates a new asynchronous disposable that invokes the specified delegate, passing the supplied state, when
-    /// disposed asynchronously. Prefer this overload over <see cref="Create(Func{ValueTask})"/> at call sites that
-    /// would otherwise capture locals or <c>this</c> in the lambda — the state-carrying overload removes the
-    /// closure object and lets the lambda be declared <c>static</c>.
+    /// disposed asynchronously. Preferred over <see cref="Create(Func{ValueTask})"/> wherever the lambda would capture
+    /// locals or <c>this</c>: passing them as state lets the lambda be <c>static</c> and costs no closure.
     /// </summary>
     /// <typeparam name="TState">The type of the state passed to the dispose delegate.</typeparam>
     /// <param name="state">The state forwarded to <paramref name="disposeAsync"/> at dispose time.</param>
@@ -49,7 +45,7 @@ public static IAsyncDisposable Create<TState>(TState state, Func<TState, ValueTa
     /// <param name="disposeAsync">The delegate invoked to perform asynchronous disposal.</param>
     internal sealed class DelegateAsyncDisposable(Func<ValueTask> disposeAsync) : IAsyncDisposable
     {
-        /// <summary>A flag indicating whether <see cref="DisposeAsync"/> has already been called (0 = not disposed, 1 = disposed).</summary>
+        /// <summary>Guard that keeps the delegate to a single invocation (0 = open, 1 = disposed).</summary>
         private int _disposed;
 
         /// <inheritdoc/>
@@ -57,16 +53,15 @@ internal sealed class DelegateAsyncDisposable(Func<ValueTask> disposeAsync) : IA
     }
 
     /// <summary>
-    /// An asynchronous disposable that invokes a delegate, passing a stored state, when disposed. The state
-    /// indirection avoids a closure allocation when the caller can supply the captured data as <typeparamref
-    /// name="TState"/>.
+    /// An asynchronous disposable that invokes a delegate with a stored state when disposed, so the caller's data
+    /// travels in <typeparamref name="TState"/> instead of a closure.
     /// </summary>
     /// <typeparam name="TState">The type of the state passed to the dispose delegate.</typeparam>
     /// <param name="state">The state forwarded to the dispose delegate at dispose time.</param>
     /// <param name="disposeAsync">The delegate invoked to perform asynchronous disposal.</param>
     internal sealed class DelegateAsyncDisposable<TState>(TState state, Func<TState, ValueTask> disposeAsync) : IAsyncDisposable
     {
-        /// <summary>A flag indicating whether <see cref="DisposeAsync"/> has already been called (0 = not disposed, 1 = disposed).</summary>
+        /// <summary>Guard that keeps the delegate to a single invocation (0 = open, 1 = disposed).</summary>
         private int _disposed;
 
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
index c283948a..602cc1fb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
@@ -26,8 +26,6 @@ public static class DisposableAsyncSlot
     /// <param name="slot">Reference to the caller-owned <see cref="IAsyncDisposable"/> field.</param>
     /// <param name="value">The new value to store, or <see langword="null"/> to clear the slot.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once the previous occupant (if any) has been disposed.</returns>
-    /// <remarks>The compare-exchange retry (the loop back-edge) is only taken when a concurrent writer
-    /// wins the race, so it is unreachable by single-threaded tests; excluded from coverage accordingly.</remarks>
     [DebuggerStepThrough]
     [ExcludeFromCodeCoverage]
     public static ValueTask SwapAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value)
@@ -50,14 +48,14 @@ public static ValueTask SwapAsync(ref IAsyncDisposable? slot, IAsyncDisposable?
         }
     }
 
-    /// <summary>Atomically assigns <paramref name="value"/> to the slot exactly once. If the slot has
-    /// already been disposed, <paramref name="value"/> is disposed immediately. If the slot already
-    /// holds a non-null, non-disposed value, throws <see cref="InvalidOperationException"/>.
-    /// Equivalent to <see cref="SingleAssignmentDisposableAsync.SetDisposableAsync(IAsyncDisposable?)"/>.</summary>
+    /// <summary>Atomically fills an empty slot with <paramref name="value"/>. A closed slot disposes
+    /// <paramref name="value"/> instead. Equivalent to
+    /// <see cref="SingleAssignmentDisposableAsync.SetDisposableAsync(IAsyncDisposable?)"/>.</summary>
     /// <param name="slot">Reference to the caller-owned <see cref="IAsyncDisposable"/> field.</param>
     /// <param name="value">The value to assign, or <see langword="null"/>.</param>
-    /// <returns>A <see cref="ValueTask"/> that completes once <paramref name="value"/> has been disposed
-    /// (if the slot was already disposed); otherwise a completed task.</returns>
+    /// <returns>A <see cref="ValueTask"/> that completes once <paramref name="value"/> has been disposed when the slot
+    /// was closed; otherwise a completed task.</returns>
+    /// <exception cref="InvalidOperationException">The slot holds a live occupant.</exception>
     [DebuggerStepThrough]
     public static ValueTask AssignAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value)
     {
@@ -92,7 +90,7 @@ public static ValueTask DisposeAsync(ref IAsyncDisposable? slot)
     public static bool IsDisposed(IAsyncDisposable? slot) =>
         ReferenceEquals(slot, DisposedSentinel);
 
-    /// <summary>Creates an exception indicating that a single-assignment slot already has a value.</summary>
+    /// <summary>Creates the exception for a second assignment into a single-assignment slot.</summary>
     /// <returns>The invalid-operation exception to throw from the assignment path.</returns>
     internal static InvalidOperationException CreateAlreadyAssignedException() =>
         new("Disposable is already assigned.");
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
index 97445482..dfe94093 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
@@ -10,17 +10,15 @@ namespace ReactiveUI.Primitives.Async.Disposables;
 /// Represents a thread-safe collection of asynchronous disposable objects that are disposed together as a group.
 /// Provides methods to add, remove, and asynchronously dispose contained resources as a single operation.
 /// </summary>
-/// <remarks>Use this class to manage the lifetime of multiple <see cref="IAsyncDisposable"/> resources, ensuring
-/// that all are disposed when the collection is disposed. Once disposed, the collection cannot be used to add or remove
-/// items. This class is not read-only and is safe for concurrent access from multiple threads.</remarks>
+/// <remarks>Disposal is one-way: a disposed collection holds nothing, and adding to it disposes the incoming item
+/// instead of storing it. Safe for concurrent access from several threads.</remarks>
 [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
 public sealed class MultipleDisposableAsync : IAsyncDisposable
 {
-    /// <summary>Capacity allocated on first <see cref="AddAsync"/>. Chosen as the typical upper bound
-    /// of subscriptions a composite holds, so most lifetimes never trigger a resize.</summary>
+    /// <summary>Capacity allocated on first <see cref="AddAsync"/>, sized so a typical composite never resizes.</summary>
     private const int DefaultCapacity = 8;
 
-    /// <summary>Length threshold below which Remove no longer compacts the array.</summary>
+    /// <summary>Used-slot count at or below which a remove leaves the array uncompacted.</summary>
     private const int ShrinkThreshold = 16;
 
     /// <summary>Divisor used to decide whether a remove triggers compaction (count * 4 &lt; length).</summary>
@@ -29,17 +27,16 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>Factor the backing array's capacity is multiplied by when it overflows.</summary>
     private const int GrowthFactor = 2;
 
-    /// <summary>Divisor applied to the backing array's capacity when a sparse collection is compacted.
-    /// Compaction only runs when fewer than a quarter of the slots are occupied, so halving always leaves room.</summary>
+    /// <summary>Divisor applied to the backing array's capacity when a sparse collection is compacted; safe because
+    /// compaction only runs below quarter occupancy.</summary>
     private const int CompactionShrinkDivisor = 2;
 
     /// <summary>The synchronization gate protecting all mutable state in this collection.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>
-    /// Backing array of disposables. Slots may be <see langword="null"/> after removal to avoid shifting elements;
-    /// <see cref="_length"/> tracks the high-water mark of used slots and <see cref="_count"/> tracks non-null slots.
-    /// <see langword="null"/> until the first <see cref="AddAsync"/>; the no-arg constructor leaves it unallocated.
+    /// Backing array, <see langword="null"/> until something is added. A removal zeroes its slot rather than shifting
+    /// elements, so <see cref="_length"/> is the high-water mark and <see cref="_count"/> the non-null slots.
     /// </summary>
     private IAsyncDisposable?[]? _items;
 
@@ -53,8 +50,8 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     private bool _isDisposed;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class. The backing array is allocated
-    /// lazily on the first <see cref="AddAsync"/> call; an unused composite costs only its instance header + gate.
+    /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class, allocating its backing array on
+    /// the first <see cref="AddAsync"/> call.
     /// </summary>
     public MultipleDisposableAsync()
     {
@@ -72,7 +69,7 @@ public MultipleDisposableAsync(int capacity)
 
     /// <summary>
     /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class that contains the specified
-    /// disposables — the backing array is sized exactly so no resize occurs.
+    /// disposables, sizing the backing array exactly.
     /// </summary>
     /// <param name="disposables">An array of objects implementing <see cref="IAsyncDisposable"/>.</param>
     public MultipleDisposableAsync(params IAsyncDisposable[] disposables)
@@ -149,13 +146,10 @@ public int Count
     }
 
     /// <summary>
-    /// Adds an asynchronous disposable item to the collection, or disposes it immediately if the collection has already
-    /// been disposed.
+    /// Takes ownership of a disposable, disposing it on the spot when this collection has been disposed.
     /// </summary>
-    /// <param name="item">The item to add. The item must implement <see cref="IAsyncDisposable"/> and will be disposed asynchronously if
-    /// the collection is disposed.</param>
-    /// <returns>A <see cref="ValueTask"/> that represents the asynchronous operation. The returned task is completed if the item
-    /// was added; otherwise, it represents the asynchronous disposal of the item.</returns>
+    /// <param name="item">The item whose lifetime this collection takes over. Cannot be null.</param>
+    /// <returns>A completed task when the item was stored; otherwise the task disposing it.</returns>
     public ValueTask AddAsync(IAsyncDisposable item)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
@@ -179,8 +173,7 @@ public ValueTask AddAsync(IAsyncDisposable item)
     /// <param name="item">The item to remove and dispose. Cannot be null.</param>
     /// <returns>A task that represents the asynchronous remove operation. The task result is <see langword="true"/> if the item
     /// was found and removed; otherwise, <see langword="false"/>.</returns>
-    /// <remarks>If the item is not found in the collection, it is not disposed. This method is
-    /// thread-safe.</remarks>
+    /// <remarks>An item this collection does not hold is left alone, not disposed.</remarks>
     public async ValueTask<bool> Remove(IAsyncDisposable item)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
@@ -216,10 +209,10 @@ public async ValueTask<bool> Remove(IAsyncDisposable item)
         return true;
     }
 
-    /// <summary>Asynchronously disposes all items in the collection and removes them.</summary>
-    /// <returns>A task that represents the asynchronous clear operation.</returns>
-    /// <remarks>If the collection is already empty or has been disposed, this method performs no action. Each
-    /// item is disposed asynchronously before being removed from the collection. This method is thread-safe.</remarks>
+    /// <summary>Empties the collection and disposes everything it held, leaving it reusable.</summary>
+    /// <returns>A task that completes once every item has been disposed.</returns>
+    /// <remarks>Items are disposed one after another in insertion order, outside the lock, so the collection accepts
+    /// additions while the disposals are in flight.</remarks>
     public async ValueTask Clear()
     {
         IAsyncDisposable?[] rented;
@@ -257,9 +250,8 @@ public async ValueTask Clear()
 
     /// <summary>Determines whether the collection contains the specified asynchronous disposable item.</summary>
     /// <param name="item">The asynchronous disposable item to locate in the collection. Can be null.</param>
-    /// <returns>true if the specified item is found in the collection and the collection has not been disposed; otherwise,
-    /// false.</returns>
-    /// <remarks>If the collection has been disposed, this method always returns false.</remarks>
+    /// <returns><see langword="true"/> when the collection is live and holds the item; otherwise
+    /// <see langword="false"/>.</returns>
     public bool Contains(IAsyncDisposable item)
     {
         lock (_gate)
@@ -275,6 +267,7 @@ public bool Contains(IAsyncDisposable item)
     /// length of the array.</param>
     /// <exception cref="ArgumentOutOfRangeException">Thrown when arrayIndex is less than zero, greater than or equal to the length of array, or when there is not
     /// enough space from arrayIndex to the end of array to accommodate all elements in the collection.</exception>
+    /// <remarks>A disposed collection copies nothing and raises nothing.</remarks>
     public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
     {
         if (arrayIndex < 0 || arrayIndex >= array?.Length)
@@ -308,9 +301,7 @@ public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
     /// disposable object.
     /// </summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>After calling this method, the collection is considered disposed and cannot be used. This
-    /// method is thread-safe and can be called multiple times; subsequent calls after the first have no
-    /// effect.</remarks>
+    /// <remarks>Idempotent. Items are disposed one after another in insertion order.</remarks>
     public async ValueTask DisposeAsync()
     {
         IAsyncDisposable?[]? snapshot;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
index 859f45e4..4297e435 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
@@ -11,68 +11,57 @@ namespace ReactiveUI.Primitives.Async.Disposables;
 /// Represents an asynchronously disposable resource that allows a single assignment of its underlying disposable. Once
 /// disposed, further assignments will dispose the assigned resource immediately.
 /// </summary>
-/// <remarks>This type is useful for scenarios where an asynchronous disposable resource must be assigned exactly
-/// once, and where disposal may occur before or after the assignment. If disposed before assignment, any subsequently
-/// assigned resource will be disposed immediately. This class is not thread-safe for concurrent assignment and
-/// disposal; external synchronization is required if used from multiple threads.</remarks>
+/// <remarks>A second assignment throws <see cref="InvalidOperationException"/>, so this type suits the common shape
+/// where a subscription handle has to be stored before the work it cancels can produce it.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleAssignmentDisposableAsync: IsDisposed = {IsDisposed}, Current = {_current}")]
 public sealed class SingleAssignmentDisposableAsync : IAsyncDisposable
 {
-    /// <summary>The currently assigned disposable resource, or the disposed sentinel if already disposed.</summary>
+    /// <summary>The assigned disposable, or the sentinel that marks the slot closed.</summary>
     private IAsyncDisposable? _current;
 
     /// <summary>Gets a value indicating whether the object has been disposed.</summary>
     public bool IsDisposed => DisposableAsyncSlot.IsDisposed(Volatile.Read(ref _current));
 
-    /// <summary>Gets the current asynchronous disposable resource, or an empty disposable if the resource has already been disposed.</summary>
-    /// <returns>An <see cref="IAsyncDisposable"/> representing the current resource, or <see cref="DisposableAsync.Empty"/> if
-    /// the resource has been disposed. Returns <see langword="null"/> if no resource is set.</returns>
+    /// <summary>Gets the assigned disposable, hiding the internal sentinel behind <see cref="DisposableAsync.Empty"/>.</summary>
+    /// <returns>The assigned resource, <see cref="DisposableAsync.Empty"/> after disposal, or <see langword="null"/>
+    /// when nothing has been assigned.</returns>
     public IAsyncDisposable? GetDisposable()
     {
         var field = Volatile.Read(ref _current);
         return DisposableAsyncSlot.IsDisposed(field) ? DisposableAsync.Empty : field;
     }
 
-    /// <summary>Asynchronously sets the current disposable resource to the specified value, replacing any previously set resource.</summary>
-    /// <param name="value">The new <see cref="IAsyncDisposable"/> instance to set as the current resource, or <see langword="null"/> to
-    /// clear the current resource.</param>
-    /// <returns>A <see cref="ValueTask"/> that represents the asynchronous operation.</returns>
+    /// <summary>Assigns the resource this instance owns, disposing <paramref name="value"/> on the spot when this
+    /// instance has been disposed.</summary>
+    /// <param name="value">The <see cref="IAsyncDisposable"/> to take ownership of, or <see langword="null"/>.</param>
+    /// <returns>A <see cref="ValueTask"/> that completes once any disposal this call triggered has finished.</returns>
+    /// <exception cref="InvalidOperationException">A resource has been assigned by an earlier call.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask SetDisposableAsync(IAsyncDisposable? value) => AssignDisposableAsync(ref _current, value);
 
-    /// <summary>Asynchronously releases the unmanaged resources used by the object.</summary>
-    /// <returns>A ValueTask that represents the asynchronous dispose operation.</returns>
+    /// <summary>Disposes the assigned resource and closes the slot, so a later assignment disposes its argument.</summary>
+    /// <returns>A <see cref="ValueTask"/> that completes once the assigned resource has been disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask DisposeAsync() => DisposeAsync(ref _current);
 
-    /// <summary>Atomically assigns an asynchronous disposable object to the specified field if it has not already been set.</summary>
-    /// <param name="field">A reference to the field that will hold the assigned <see cref="IAsyncDisposable"/> instance. The field must
-    /// initially be null.</param>
-    /// <param name="value">The <see cref="IAsyncDisposable"/> instance to assign to the field, or null to leave the field unset.</param>
-    /// <returns>A <see cref="ValueTask"/> that represents the asynchronous dispose operation if the field was already disposed;
-    /// otherwise, a default <see cref="ValueTask"/>.</returns>
-    /// <remarks>If the field has already been assigned or disposed, the method either throws an exception or
-    /// disposes the provided value, as appropriate. This method is intended for use in thread-safe scenarios where a
-    /// disposable resource should only be set once.</remarks>
+    /// <summary>Assigns <paramref name="value"/> into an empty caller-owned field, with no wrapper instance.</summary>
+    /// <param name="field">A reference to the field that takes ownership of <paramref name="value"/>.</param>
+    /// <param name="value">The <see cref="IAsyncDisposable"/> to assign, or <see langword="null"/>.</param>
+    /// <returns>A <see cref="ValueTask"/> that completes once any disposal this call triggered has finished.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static ValueTask AssignDisposableAsync(ref IAsyncDisposable? field, IAsyncDisposable? value) =>
         DisposableAsyncSlot.AssignAsync(ref field, value);
 
-    /// <summary>Asynchronously disposes the object referenced by the specified field, if it has not already been disposed.</summary>
-    /// <param name="field">A reference to an <see cref="IAsyncDisposable"/> field to be disposed. The field will be set to a sentinel value
-    /// to prevent multiple disposals.</param>
-    /// <returns>A <see cref="ValueTask"/> that represents the asynchronous dispose operation. The returned task is completed if
-    /// the field was already disposed or null.</returns>
-    /// <remarks>This method is intended for use in thread-safe disposal patterns to ensure that the
-    /// referenced object is disposed only once. After calling this method, the field will reference a sentinel value
-    /// indicating it has been disposed.</remarks>
+    /// <summary>Disposes a caller-owned field's occupant once and leaves the field holding the closed sentinel.</summary>
+    /// <param name="field">A reference to the <see cref="IAsyncDisposable"/> field to close.</param>
+    /// <returns>A <see cref="ValueTask"/> that completes once the occupant has been disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [DebuggerStepThrough]
     internal static ValueTask DisposeAsync(ref IAsyncDisposable? field) =>
         DisposableAsyncSlot.DisposeAsync(ref field);
 
-    /// <summary>Creates an exception indicating that the disposable has already been assigned.</summary>
-    /// <returns>An <see cref="InvalidOperationException"/> with the already-assigned message.</returns>
+    /// <summary>Creates the exception for a second assignment.</summary>
+    /// <returns>The <see cref="InvalidOperationException"/> to throw from the assignment path.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static InvalidOperationException CreateAlreadyAssignedException() =>
         DisposableAsyncSlot.CreateAlreadyAssignedException();
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
index 9e305c6c..b23dcbb7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
@@ -10,38 +10,29 @@ namespace ReactiveUI.Primitives.Async.Disposables;
 /// Provides a thread-safe mechanism for managing a single asynchronously disposable resource that can be replaced or
 /// disposed of serially.
 /// </summary>
-/// <remarks>When a new disposable is set using SetDisposableAsync, the previously held disposable (if any) is
-/// asynchronously disposed. Disposing the SerialDisposableAsync instance disposes the current disposable and prevents
-/// further disposables from being set. This class is useful for scenarios where a resource needs to be replaced or
-/// updated over time, ensuring that only one resource is active and properly disposed of at any given moment. All
-/// operations are safe to use concurrently from multiple threads.</remarks>
+/// <remarks>Exactly one resource is live at a time: each assignment disposes the one it displaces, and disposing this
+/// instance closes the slot so a further assignment disposes its argument. Safe to use from several threads.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleReplaceableDisposableAsync: Current = {_current}")]
 public class SingleReplaceableDisposableAsync : IAsyncDisposable
 {
-    /// <summary>The currently tracked disposable resource, or the disposed sentinel if already disposed.</summary>
+    /// <summary>The tracked disposable, or the sentinel that marks the slot closed.</summary>
     private IAsyncDisposable? _current;
 
     /// <summary>
-    /// Replaces the currently tracked asynchronous disposable resource with a new one, disposing the previous resource
-    /// if present.
+    /// Takes over from the tracked resource, disposing the one it displaces — or disposing <paramref name="value"/>
+    /// itself when this instance has been disposed.
     /// </summary>
     /// <param name="value">The new <see cref="IAsyncDisposable"/> instance to track. Can be <see langword="null"/> to clear the current
     /// resource.</param>
-    /// <returns>A <see cref="ValueTask"/> that represents the asynchronous dispose operation of the previously tracked resource,
-    /// or of <paramref name="value"/> if the object has already been disposed. If there is no resource to dispose, the
-    /// returned task is already completed.</returns>
-    /// <remarks>If the object has already been disposed, <paramref name="value"/> is disposed immediately.
-    /// Otherwise, the previously tracked resource, if any, is disposed asynchronously. This method is
-    /// thread-safe.</remarks>
+    /// <returns>A <see cref="ValueTask"/> that completes once whichever resource this call gave up has been
+    /// disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask SetDisposableAsync(IAsyncDisposable? value) =>
         DisposableAsyncSlot.SwapAsync(ref _current, value);
 
-    /// <summary>Asynchronously releases the resources used by the object.</summary>
-    /// <returns>A ValueTask that represents the asynchronous dispose operation. The task will be completed when all resources
-    /// have been released.</returns>
-    /// <remarks>Subsequent calls to this method after disposal will have no effect. This method is safe to
-    /// call multiple times.</remarks>
+    /// <summary>Disposes the tracked resource and closes the slot.</summary>
+    /// <returns>A <see cref="ValueTask"/> that completes once the tracked resource has been disposed.</returns>
+    /// <remarks>Idempotent.</remarks>
     public ValueTask DisposeAsync()
     {
         GC.SuppressFinalize(this);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
index 0bfa6f5d..5e3c1a65 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
@@ -17,9 +17,9 @@ public static class DisposalHelper
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static bool HasDisposed(int disposed) => disposed == 1;
 
-    /// <summary>Atomically sets the disposed flag and returns whether it was already set.</summary>
+    /// <summary>Atomically raises the disposed flag, reporting whether an earlier call got there first.</summary>
     /// <param name="disposed">A reference to the disposed flag.</param>
-    /// <returns><see langword="true"/> if already disposed; otherwise <see langword="false"/>.</returns>
+    /// <returns><see langword="true"/> when the flag was set before this call; otherwise <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static bool TrySetDisposed(ref int disposed) => Interlocked.Exchange(ref disposed, 1) == 1;
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
index 72bde3ce..01fab590 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
@@ -7,9 +7,8 @@
 namespace ReactiveUI.Primitives.Async.Helpers;
 
 /// <summary>
-/// Provides a helper for executing async actions as fire-and-forget with exception swallowing.
-/// Used for async void callbacks (e.g. cancellation token registrations, signal handlers)
-/// where exceptions cannot propagate to a caller.
+/// Runs asynchronous work from a synchronous callback — a cancellation-token registration, a signal handler — where
+/// there is no caller to observe a task, reporting failures to <see cref="UnhandledExceptionHandler"/>.
 /// </summary>
 [ExcludeFromCodeCoverage]
 public static class FireAndForgetHelper
@@ -19,9 +18,7 @@ public static class FireAndForgetHelper
     [SuppressMessage(
         "Concurrency",
         "SST1905:Do not use async void",
-        Justification =
-            "Intentional fire-and-forget helper. There is no caller to hand a Task back to; failures are routed to the "
-            + "global handler instead. Returning Task would defeat the fire-and-forget contract this helper exists to provide.")]
+        Justification = "There is no caller to hand a Task back to, so failures go to the global handler instead.")]
     [SuppressMessage(
         "ReSharper",
         "AsyncVoidMethod",
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
index 7f451a6b..e8f50932 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
@@ -10,10 +10,11 @@ namespace ReactiveUI.Primitives.Async.Helpers;
 /// </summary>
 public static class SubscriptionHelper
 {
-    /// <summary>Executes <paramref name="subscribeAsync"/> and returns <paramref name="subscription"/>.</summary>
+    /// <summary>Runs <paramref name="subscribeAsync"/>, disposing <paramref name="subscription"/> and rethrowing if it
+    /// fails, so a half-built subscription is never handed back.</summary>
     /// <param name="subscription">The subscription to manage.</param>
     /// <param name="subscribeAsync">The async action that wires up the subscription.</param>
-    /// <returns>The subscription if successful.</returns>
+    /// <returns>The subscription, once wiring succeeded.</returns>
     internal static async ValueTask<IAsyncDisposable> SubscribeAndDisposeOnFailureAsync(
         IAsyncDisposable subscription,
         Func<ValueTask> subscribeAsync)
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
index bed67c88..4d507c84 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
@@ -6,19 +6,15 @@ namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Represents a provider for asynchronous push-based notifications that supports asynchronous subscription and disposal.</summary>
 /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
-/// <remarks>Use this interface to implement observable sequences that allow observers to subscribe asynchronously
-/// and receive notifications in an asynchronous manner. This is useful for scenarios where subscription or
-/// unsubscription may involve asynchronous operations, such as network or I/O-bound tasks. Implementations should
-/// ensure that notifications are delivered according to the observer's contract and that resources are released when
-/// the subscription is disposed.</remarks>
+/// <remarks>Subscription and unsubscription are themselves awaitable, so a sequence backed by network or I/O work can
+/// complete its setup and teardown before the caller proceeds.</remarks>
 public interface IObservableAsync<T>
 {
     /// <summary>Subscribes the specified asynchronous observer to receive notifications from the observable sequence.</summary>
     /// <param name="observer">The observer that will receive asynchronous notifications. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the subscription operation.</param>
-    /// <returns>A task that represents the asynchronous subscription operation. The result contains an <see
-    /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe the observer.</returns>
-    /// <remarks>The returned <see cref="IAsyncDisposable"/> should be disposed when the observer no longer
-    /// wishes to receive notifications. Multiple observers may be subscribed concurrently.</remarks>
+    /// <returns>A handle whose disposal unsubscribes the observer.</returns>
+    /// <remarks>Implementations must tolerate several observers subscribed at once, and must release the
+    /// subscription's resources when the returned handle is disposed.</remarks>
     ValueTask<IAsyncDisposable> SubscribeAsync(IObserverAsync<T> observer, CancellationToken cancellationToken);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
index 688defaf..1bef1a1c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
@@ -9,27 +9,26 @@ namespace ReactiveUI.Primitives.Async;
 /// supports asynchronous resource cleanup.
 /// </summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
-/// <remarks>Implementations of this interface allow for non-blocking, asynchronous handling of data streams,
-/// including support for cancellation and proper disposal of resources. This is useful in scenarios where observers
-/// need to process events or data asynchronously, such as in reactive or event-driven programming models.</remarks>
+/// <remarks>Every notification is awaitable and cancellable, so a producer that awaits them gets backpressure for
+/// free: the observer's handler has to finish before the next value is pushed.</remarks>
 public interface IObserverAsync<in T> : IAsyncDisposable
 {
-    /// <summary>Performs asynchronous completion logic in response to the specified result.</summary>
-    /// <param name="result">The result object that provides information about the completed operation. Cannot be null.</param>
-    /// <returns>A ValueTask that represents the asynchronous completion operation.</returns>
+    /// <summary>Signals that the sequence has terminated, successfully or with a failure.</summary>
+    /// <param name="result">The terminal outcome, carrying the failure when the sequence faulted.</param>
+    /// <returns>A task that completes when the observer has handled the termination.</returns>
     ValueTask OnCompletedAsync(Result result);
 
-    /// <summary>Handles the specified error and resumes asynchronous processing, if possible.</summary>
-    /// <param name="error">The exception that caused the error. Cannot be null.</param>
+    /// <summary>Reports a non-terminal error, leaving the sequence free to carry on.</summary>
+    /// <param name="error">The exception to report.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the error handling operation.</param>
-    /// <returns>A ValueTask that represents the asynchronous error handling operation.</returns>
-    /// <remarks>Implementations may choose to suppress the error and continue processing, or perform cleanup
-    /// and terminate gracefully. The behavior depends on the specific implementation.</remarks>
+    /// <returns>A task that completes when the observer has handled the error.</returns>
+    /// <remarks>Unlike a faulted <see cref="OnCompletedAsync"/>, this does not end the sequence; an implementation
+    /// chooses whether to swallow the error or tear itself down.</remarks>
     ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken);
 
-    /// <summary>Asynchronously processes the next value in the sequence.</summary>
+    /// <summary>Delivers the next value in the sequence.</summary>
     /// <param name="value">The value to be processed.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
-    /// <returns>A task that represents the asynchronous operation.</returns>
+    /// <returns>A task that completes when the observer has consumed the value.</returns>
     ValueTask OnNextAsync(T value, CancellationToken cancellationToken);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs b/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
index d89f7b5b..7dc5b4b0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for converting synchronous disposable objects to asynchronous disposables.</summary>
-/// <remarks>These extension methods enable the use of existing IDisposable implementations in asynchronous
-/// disposal scenarios by wrapping them as IAsyncDisposable. This is useful when working with APIs that require
-/// asynchronous disposal, but only a synchronous Dispose method is available.</remarks>
 public static class DisposableAsyncExtensions
 {
     /// <summary>Asynchronous-disposal wrapping operators for an <see cref="IDisposable"/> instance.</summary>
@@ -19,13 +16,11 @@ public static class DisposableAsyncExtensions
         /// <summary>Converts an <see cref="IDisposable"/> instance to an <see cref="IAsyncDisposable"/> wrapper.</summary>
         /// <returns>An <see cref="IAsyncDisposable"/> that disposes the underlying <see cref="IDisposable"/> when disposed
         /// asynchronously.</returns>
-        /// <remarks>The returned <see cref="IAsyncDisposable"/> invokes the synchronous <see
-        /// cref="IDisposable.Dispose"/> method when <see cref="IAsyncDisposable.DisposeAsync"/> is called. This is useful
-        /// for integrating synchronous disposables into asynchronous disposal patterns.</remarks>
+        /// <remarks>Disposal runs synchronously on the caller's thread; the returned handle only adapts the shape.</remarks>
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the IAsyncDisposable the method returns, not asynchronous work.")]
         public IAsyncDisposable ToDisposableAsync()
         {
             ArgumentExceptionHelper.ThrowIfNull(disposable);
@@ -35,14 +30,10 @@ public IAsyncDisposable ToDisposableAsync()
     }
 
     /// <summary>
-    /// Provides an implementation of <see cref="IAsyncDisposable"/> that wraps a synchronous <see cref="IDisposable"/>
-    /// instance, enabling it to be used in asynchronous disposal scenarios.
+    /// Presents a synchronous <see cref="IDisposable"/> as an <see cref="IAsyncDisposable"/>, calling
+    /// <see cref="IDisposable.Dispose"/> inline and completing synchronously.
     /// </summary>
     /// <param name="disposable">The <see cref="IDisposable"/> instance to be wrapped for asynchronous disposal. Cannot be null.</param>
-    /// <remarks>This class allows objects that implement <see cref="IDisposable"/> but not <see
-    /// cref="IAsyncDisposable"/> to be used in contexts that require asynchronous disposal. The asynchronous dispose
-    /// operation is performed by invoking the synchronous <see cref="IDisposable.Dispose"/> method; no actual
-    /// asynchronous work is performed.</remarks>
     internal sealed class DisposableToDisposableAsync(IDisposable disposable) : IAsyncDisposable
     {
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
index 2eb613a0..6979bd74 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
@@ -9,9 +9,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with signals in a reactive programming context.</summary>
-/// <remarks>The methods in this class enable interoperability between signals and asynchronous observer
-/// patterns. These extensions are intended to simplify the integration of signals with APIs that expect asynchronous
-/// observers.</remarks>
 public static class SignalExtensions
 {
     /// <summary>Observer-wrapping and value-mapping operators for a signal source.</summary>
@@ -24,7 +21,7 @@ public static class SignalExtensions
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the IObserverAsync the method returns, not asynchronous work.")]
         public IObserverAsync<T> AsObserverAsync()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -38,10 +35,10 @@ public IObserverAsync<T> AsObserverAsync()
         /// </summary>
         /// <param name="mapper">A function that takes an asynchronous observable of type T and returns a transformed asynchronous observable of
         /// type T. This function defines how the values are mapped.</param>
-        /// <returns>A signal that emits values transformed by the specified mapping function.</returns>
-        /// <remarks>The returned signal reflects the mapped values of the original signal. Subscribers to the
-        /// returned signal will observe the transformed sequence as defined by the mapper function. The mapping is applied
-        /// to all values published by the source signal.</remarks>
+        /// <returns>A signal that publishes into <paramref name="source"/> but exposes the mapped sequence to its own
+        /// subscribers.</returns>
+        /// <remarks><paramref name="mapper"/> runs once, against the source's value sequence, rather than per
+        /// subscriber.</remarks>
         public ISignalAsync<T> MapValues(Func<IObservableAsync<T>, IObservableAsync<T>> mapper)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -95,13 +92,9 @@ public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellat
     internal sealed class SignalAsyncWitness<T>(ISignalAsync<T> signal) : WitnessAsync<T>
     {
         /// <summary>
-        /// Forwards the value to the wrapped signal. The cancellation token is intentionally
-        /// replaced with <see cref="CancellationToken.None"/> rather than passing our own dispose
-        /// token through: subscribers downstream of the signal are <see cref="WitnessAsync{T}"/>
-        /// wraps whose <c>TryEnter</c> short-circuits on <see cref="CancellationToken.None"/> via
-        /// its fast path, avoiding a per-emission linked-CTS allocation on every observer. The
-        /// upstream-disposal cascade is unaffected — by the time this observer is disposed (on
-        /// source completion / error) no further <c>OnNext</c> calls reach this method.
+        /// Forwards the value to the wrapped signal under <see cref="CancellationToken.None"/>, which every downstream
+        /// <see cref="WitnessAsync{T}"/> takes its no-link fast path on. Passing this observer's own dispose token
+        /// instead would buy nothing: disposal stops values from reaching this method at all.
         /// </summary>
         /// <param name="value">The value to be processed by the observer.</param>
         /// <param name="cancellationToken">The token captured by the base observer's TryEnter scope. Ignored on the forward.</param>
@@ -122,9 +115,9 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
             return signal.OnErrorResumeAsync(error, CancellationToken.None);
         }
 
-        /// <summary>Performs asynchronous completion logic when the operation has finished, using the specified result.</summary>
+        /// <summary>Forwards the terminal result to the wrapped signal.</summary>
         /// <param name="result">The result of the completed operation, containing any relevant outcome information.</param>
-        /// <returns>A ValueTask that represents the asynchronous completion operation.</returns>
+        /// <returns>A task that completes when the signal has handled the result.</returns>
         protected override ValueTask OnCompletedAsyncCore(Result result) => signal.OnCompletedAsync(result);
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
index 05a43a83..fe75b5d9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
@@ -10,10 +10,8 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides factory methods for creating asynchronous observables and background jobs that emit values to observers
 /// asynchronously.
 /// </summary>
-/// <remarks>The methods in this class allow developers to construct asynchronous observables by supplying custom
-/// subscription logic or background jobs. Observables created with these methods support asynchronous notification and
-/// cancellation, enabling integration with modern async workflows. Use these methods to bridge asynchronous producers
-/// with consumers following the observer pattern.</remarks>
+/// <remarks>These are the entry points for turning an arbitrary asynchronous producer into a sequence: supply the
+/// subscribe logic yourself, or hand over a job to run per subscriber.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates a new asynchronous observable sequence using the specified subscription function.</summary>
@@ -21,11 +19,10 @@ public static partial class SignalAsync
     /// <param name="subscribeAsync">A function that is invoked when an observer subscribes to the sequence. The function receives an asynchronous
     /// observer and a cancellation token, and returns a task that yields a disposable resource representing the
     /// subscription.</param>
-    /// <returns>An SignalAsync{T} that invokes the specified subscription function for each observer.</returns>
+    /// <returns>An observable sequence that runs <paramref name="subscribeAsync"/> for each observer.</returns>
     /// <exception cref="ArgumentNullException">Thrown if <paramref name="subscribeAsync"/> is <see langword="null"/>.</exception>
-    /// <remarks>The subscription function is responsible for handling observer notifications and managing the
-    /// lifetime of the subscription. The returned disposable should release any resources or cancel ongoing operations
-    /// when disposed.</remarks>
+    /// <remarks>The disposable <paramref name="subscribeAsync"/> returns owns the subscription's resources and must
+    /// stop the producer when disposed.</remarks>
     public static IObservableAsync<T> Create<T>(
         Func<IObserverAsync<T>, CancellationToken, ValueTask<IAsyncDisposable>> subscribeAsync) =>
         subscribeAsync is null
@@ -36,7 +33,7 @@ subscribeAsync is null
     /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
     /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
     /// a cancellation token to observe cancellation requests.</param>
-    /// <returns>An SignalAsync{T} that represents the observable sequence produced by the background job.</returns>
+    /// <returns>An observable sequence that runs <paramref name="job"/> on a scheduled task per subscriber.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> CreateAsBackgroundJob<T>(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job) =>
@@ -48,7 +45,7 @@ public static IObservableAsync<T> CreateAsBackgroundJob<T>(
     /// a cancellation token to observe cancellation requests.</param>
     /// <param name="startSynchronously">true to start the job synchronously on the calling thread; otherwise, false to schedule it to run
     /// asynchronously.</param>
-    /// <returns>An SignalAsync{T} that represents the observable sequence produced by the background job.</returns>
+    /// <returns>An observable sequence that runs <paramref name="job"/> per subscriber.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> CreateAsBackgroundJob<T>(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job,
@@ -63,7 +60,8 @@ public static IObservableAsync<T> CreateAsBackgroundJob<T>(
     /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
     /// a cancellation token to observe cancellation requests.</param>
     /// <param name="taskScheduler">The task scheduler that is used to schedule the background job.</param>
-    /// <returns>An SignalAsync{T} that represents the asynchronous background job and emits the results produced by the job.</returns>
+    /// <returns>An observable sequence that runs <paramref name="job"/> per subscriber on
+    /// <paramref name="taskScheduler"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> CreateAsBackgroundJob<T>(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
index ef84854f..15672725 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
@@ -10,21 +10,16 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides factory methods for creating observable sequences that are generated by invoking a specified function each
 /// time a new observer subscribes.
 /// </summary>
-/// <remarks>The methods in this class enable deferred creation of asynchronous observable sequences. Each
-/// subscription triggers a new invocation of the provided factory function, ensuring that each observer receives a
-/// fresh sequence. This is useful for scenarios where the observable's behavior or state should be determined at the
-/// time of subscription rather than at the time of declaration.</remarks>
+/// <remarks>Nothing runs at declaration: the factory is called once per subscriber, so each one gets a sequence built
+/// from the state that holds at its own subscribe time.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates a new observable sequence for each subscription by invoking the specified asynchronous factory function.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <param name="factory">A function that receives a cancellation token and returns a task that produces an observable sequence to
     /// subscribe to.</param>
-    /// <returns>An observable sequence that, upon each subscription, invokes the factory function to obtain the actual
-    /// observable sequence to subscribe to.</returns>
-    /// <remarks>Use this method to defer the creation of the observable sequence until an observer
-    /// subscribes. This is useful when the observable sequence depends on per-subscription state or resources, or when
-    /// you want to ensure a fresh sequence for each subscriber.</remarks>
+    /// <returns>An observable sequence that awaits <paramref name="factory"/> on each subscribe and subscribes to
+    /// whatever it yields.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> Defer<T>(Func<CancellationToken, ValueTask<IObservableAsync<T>>> factory) =>
         new DeferAsyncSignalAsync<T>(factory);
@@ -35,19 +30,14 @@ public static IObservableAsync<T> Defer<T>(Func<CancellationToken, ValueTask<IOb
     /// </summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <param name="factory">A function that returns a new instance of an observable sequence to be subscribed to for each observer.</param>
-    /// <returns>An observable sequence whose observers trigger the invocation of the factory function upon subscription.</returns>
-    /// <remarks>Use this method to defer the creation of the observable sequence until an observer
-    /// subscribes, ensuring that each subscription receives a fresh instance. This is useful when the observable
-    /// sequence has side effects or depends on external state at the time of subscription.</remarks>
+    /// <returns>An observable sequence that calls <paramref name="factory"/> on each subscribe and subscribes to
+    /// whatever it returns.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> Defer<T>(Func<IObservableAsync<T>> factory) =>
         new DeferSyncSignalAsync<T>(factory);
 
-    /// <summary>Dedicated observable for <see cref="Defer{T}(Func{IObservableAsync{T}})"/>.
-    /// Holds the factory delegate directly — no closure-capturing lambda, no
-    /// <see cref="Create{T}"/>-wrapper indirection. Per-subscribe path invokes the factory,
-    /// wraps the downstream observer once for contract compliance, and subscribes to the
-    /// freshly-produced inner observable.</summary>
+    /// <summary>Backs <see cref="Defer{T}(Func{IObservableAsync{T}})"/>: each subscribe calls the factory and hands the
+    /// wrapped observer to the sequence it returns.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="factory">The deferred factory invoked once per subscribe.</param>
     internal sealed class DeferSyncSignalAsync<T>(Func<IObservableAsync<T>> factory) : IObservableAsync<T>
@@ -60,10 +50,9 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             factory().SubscribeAsync(observer.Wrap(), cancellationToken);
     }
 
-    /// <summary>Dedicated observable for the <see cref="ValueTask"/>-returning
-    /// <see cref="Defer{T}(Func{CancellationToken, ValueTask{IObservableAsync{T}}})"/>.
-    /// Same allocation profile as <see cref="DeferSyncSignalAsync{T}"/> with one extra
-    /// state-machine box per call to host the factory's <c>await</c>.</summary>
+    /// <summary>Backs the <see cref="ValueTask"/>-returning
+    /// <see cref="Defer{T}(Func{CancellationToken, ValueTask{IObservableAsync{T}}})"/>, awaiting the factory before it
+    /// can subscribe.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="factory">The deferred factory invoked once per subscribe.</param>
     internal sealed class DeferAsyncSignalAsync<T>(Func<CancellationToken, ValueTask<IObservableAsync<T>>> factory) : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
index f437ef53..7b475e0f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
@@ -9,23 +9,17 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods for constructing instances of asynchronous
-/// observables. Use these methods to create observable sequences that support asynchronous notification
-/// patterns.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that completes immediately without emitting any items.</summary>
     /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
     /// <returns>An observable sequence of type <typeparamref name="T"/> that completes immediately without producing any values.</returns>
-    /// <remarks>This method is useful for representing an empty sequence in asynchronous or reactive
-    /// scenarios. The returned sequence signals completion to observers as soon as it is subscribed to.
-    /// The returned instance is a process-wide singleton per element type — no allocation occurs after the
-    /// first call for a given <typeparamref name="T"/>.</remarks>
+    /// <remarks>The returned instance is a singleton per element type.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: SignalAsync.Empty<int>().")]
+        Justification = "There are no parameters to infer from; the caller states the element type: SignalAsync.None<int>().")]
     public static IObservableAsync<T> None<T>() => EmptySignalAsync<T>.Instance;
 
     /// <summary>Creates an observable sequence that completes immediately without emitting any items.</summary>
@@ -35,13 +29,12 @@ public static partial class SignalAsync
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: SignalAsync.Empty<int>().")]
+        Justification = "There are no parameters to infer from; the caller states the element type: SignalAsync.Empty<int>().")]
     public static IObservableAsync<T> Empty<T>() => EmptySignalAsync<T>.Instance;
 
     /// <summary>
-    /// Dedicated singleton observable that signals immediate successful completion on subscribe. Replaces the
-    /// previous <c>Create&lt;T&gt;((observer, _) =&gt; ...)</c> + <see cref="DisposableAsync.Empty"/> shape with a
-    /// per-T cached instance — no anonymous observable wrapper, no closure, no per-subscribe allocation.
+    /// Signals successful completion on subscribe and hands back <see cref="DisposableAsync.Empty"/>, from a cached
+    /// instance per element type.
     /// </summary>
     /// <typeparam name="T">The element type of the empty sequence.</typeparam>
     internal sealed class EmptySignalAsync<T> : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/FromAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/FromAsync.cs
index 65139b4e..9ce1a00c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/FromAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/FromAsync.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observables from asynchronous operations.</summary>
-/// <remarks>The methods in this class allow integration of asynchronous tasks or functions into the observable
-/// pattern, enabling consumers to subscribe to results produced by asynchronous operations. All created observables
-/// execute the provided asynchronous factory as a background job and emit the result to subscribers upon
-/// completion.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an asynchronous observable sequence that emits a single value produced by the specified factory function.</summary>
@@ -18,14 +14,13 @@ public static partial class SignalAsync
     /// <param name="factory">A function that asynchronously produces a value of type <typeparamref name="T"/> when invoked with a <see
     /// cref="CancellationToken"/>. Cannot be null.</param>
     /// <returns>An observable that emits the value returned by the factory function and then completes.</returns>
-    /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="factory"/> is null.</exception>
-    /// <remarks>The observable sequence will emit the value produced by the factory and then signal
-    /// completion. The factory function is invoked when the sequence is subscribed to, and supports cancellation via
-    /// the provided <see cref="CancellationToken"/>.</remarks>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="factory"/> is null.</exception>
+    /// <remarks><paramref name="factory"/> runs once per subscriber, started by the subscribe call rather than awaited
+    /// by it.</remarks>
     [SuppressMessage(
         "Roslynator",
         "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-        Justification = "This is an existing method")]
+        Justification = "The name states where the values come from; the method itself returns a sequence synchronously.")]
     public static IObservableAsync<T> FromAsync<T>(Func<CancellationToken, ValueTask<T>> factory)
     {
         ArgumentExceptionHelper.ThrowIfNull(factory);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
index 52c67094..92afac0e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
@@ -7,19 +7,12 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers static methods to construct observables that emit values
-/// asynchronously. These methods are useful for scenarios where data needs to be produced or streamed over time, such
-/// as timers or event-driven sequences. All members of this class are thread-safe and can be used from multiple threads
-/// concurrently.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an asynchronous observable sequence that emits a long integer value at each specified time interval.</summary>
     /// <param name="period">The time interval between emissions of values. Must be a positive duration.</param>
-    /// <returns>An SignalAsync{long} that emits an increasing long value at each interval, starting from 1, until the
-    /// sequence is cancelled.</returns>
-    /// <remarks>The sequence continues emitting values until the observer unsubscribes or the cancellation
-    /// token is triggered. This method is useful for generating periodic events or timers in asynchronous
-    /// workflows.</remarks>
+    /// <returns>An observable sequence that emits an increasing count, starting at 1, on every tick until the
+    /// subscription is disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<long> Interval(TimeSpan period) =>
         new IntervalSignal(period, null);
@@ -28,11 +21,8 @@ public static IObservableAsync<long> Interval(TimeSpan period) =>
     /// <param name="period">The time interval between emissions of values. Must be a positive duration.</param>
     /// <param name="timeProvider">An optional time provider used to control the timing of emissions. If null or set to TimeProvider.System, the
     /// system clock is used.</param>
-    /// <returns>An SignalAsync{long} that emits an increasing long value at each interval, starting from 1, until the
-    /// sequence is cancelled.</returns>
-    /// <remarks>The sequence continues emitting values until the observer unsubscribes or the cancellation
-    /// token is triggered. This method is useful for generating periodic events or timers in asynchronous
-    /// workflows.</remarks>
+    /// <returns>An observable sequence that emits an increasing count, starting at 1, on every tick until the
+    /// subscription is disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<long> Interval(TimeSpan period, TimeProvider? timeProvider) =>
         new IntervalSignal(period, timeProvider);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
index de82c6a9..24376c6f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
@@ -9,22 +9,17 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides static methods for creating and composing asynchronous observable sequences.</summary>
-/// <remarks>This class contains factory and utility methods for working with asynchronous observables. Use these
-/// methods to construct, transform, or combine observable sequences in asynchronous scenarios. All members are
-/// thread-safe and can be used in concurrent environments.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that never produces any values and never completes.</summary>
     /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
     /// <returns>An observable sequence of type <typeparamref name="T"/> that never emits any items and never terminates.</returns>
-    /// <remarks>This method is useful for testing or composing observables where a sequence that remains idle
-    /// is required. The returned observable will not invoke any callbacks and will not signal completion or
-    /// error.</remarks>
+    /// <remarks>The returned instance is a singleton per element type.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: SignalAsync.Never<int>().")]
+        Justification = "There are no parameters to infer from; the caller states the element type: SignalAsync.Never<int>().")]
     public static IObservableAsync<T> Never<T>() => NeverSignalAsync<T>.Instance;
 
     /// <summary>An observable sequence that never produces any values and never completes.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Range.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Range.cs
index 927128c2..6818f405 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Range.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Range.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides static methods for creating and manipulating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers factory methods and utilities for working with asynchronous
-/// observables, enabling reactive programming patterns with support for asynchronous event streams. Members of this
-/// class are thread-safe and designed for use in concurrent environments.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that emits a range of consecutive integer values, starting from the specified value.</summary>
@@ -17,9 +14,7 @@ public static partial class SignalAsync
     /// <param name="count">The number of sequential integers to emit. Must be non-negative.</param>
     /// <returns>An observable sequence that emits integers from <paramref name="start"/> to <paramref name="start"/> + <paramref
     /// name="count"/> - 1, in order.</returns>
-    /// <remarks>The sequence completes after emitting all values. If <paramref name="count"/> is zero, the
-    /// sequence completes immediately without emitting any values. The operation supports cancellation via the
-    /// observer's cancellation token.</remarks>
+    /// <remarks>A <paramref name="count"/> of zero completes the sequence without emitting anything.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<int> Sequence(int start, int count) => new SequenceSignal(start, count);
 
@@ -32,8 +27,6 @@ public static partial class SignalAsync
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "Range is the System.Reactive name for Sequence. Both operators intentionally build the same signal "
-            + "directly rather than one forwarding to the other, so the Rx-named alias costs nothing at the call site.")]
+        Justification = "Range is the Rx-compatible alias for Sequence and builds the same signal with no forwarding hop.")]
     public static IObservableAsync<int> Range(int start, int count) => new SequenceSignal(start, count);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
index 442306b6..448eda43 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
@@ -7,18 +7,14 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods for constructing and manipulating asynchronous
-/// observables. Use these methods to create observables that emit values asynchronously, supporting scenarios such as
-/// background processing or integration with asynchronous workflows.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that emits a single value and then completes.</summary>
     /// <typeparam name="T">The type of the value to be emitted by the observable sequence.</typeparam>
     /// <param name="value">The value to be emitted by the observable sequence.</param>
     /// <returns>An observable sequence that emits the specified value and then signals completion.</returns>
-    /// <remarks>The returned observable sequence emits the value asynchronously and completes immediately
-    /// after. Subscribe returns before the value is observed — emit + complete are scheduled onto the
-    /// threadpool, preserving the deferred semantic the surrounding pipeline expects.</remarks>
+    /// <remarks>Subscribing returns before the value is observed: the emit and the completion are scheduled onto the
+    /// thread pool, so an observer must not assume it has seen the value by the time subscribe finishes.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> Emit<T>(T value) => new ReturnSignalAsync<T>(value);
 
@@ -30,15 +26,12 @@ public static partial class SignalAsync
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "Return is the System.Reactive name for Emit. Both operators intentionally build the same signal directly "
-            + "rather than one forwarding to the other, so the Rx-named alias costs nothing at the call site.")]
+        Justification = "Return is the Rx-compatible alias for Emit and builds the same signal with no forwarding hop.")]
     public static IObservableAsync<T> Return<T>(T value) => new ReturnSignalAsync<T>(value);
 
     /// <summary>
-    /// Single-value observable that captures the emitted value as a field and routes through a typed
-    /// <see cref="TaskSignalSubscription{T}"/>. Same deferred-emit semantic as the previous
-    /// <c>CreateAsBackgroundJob</c> path, but without the per-call <c>Func</c> closure allocation.
+    /// Holds the single value in a field and emits it from a <see cref="TaskSignalSubscription{T}"/> started per
+    /// subscriber, so the emit is deferred without a delegate to close over.
     /// </summary>
     /// <typeparam name="T">The element type emitted.</typeparam>
     /// <param name="value">The captured value emitted on each subscribe.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Throw.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Throw.cs
index c55125b6..fbc2ffb6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Throw.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Throw.cs
@@ -9,22 +9,18 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers static methods to construct and manipulate asynchronous observables.
-/// Use these methods to create sequences that emit values, errors, or completion notifications in an asynchronous
-/// manner.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that terminates immediately with the specified exception.</summary>
     /// <typeparam name="T">The type of the elements in the observable sequence.</typeparam>
     /// <param name="error">The exception to be propagated to observers as an error notification. Cannot be null.</param>
     /// <returns>An observable sequence of type <typeparamref name="T"/> that signals the specified exception upon subscription.</returns>
-    /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="error"/> is null.</exception>
-    /// <remarks>Use this method to create an observable sequence that fails immediately, which can be useful
-    /// for testing error handling or representing error conditions in reactive workflows.</remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="error"/> is <see langword="null"/>.</exception>
+    /// <remarks>The exception arrives as a terminal completion, not thrown from the subscribe call.</remarks>
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: SignalAsync.Throw<int>(ex).")]
+        Justification = "The element type cannot be inferred from an exception; the caller states it: SignalAsync.Fail<int>(ex).")]
     public static IObservableAsync<T> Fail<T>(Exception error)
     {
         ArgumentExceptionHelper.ThrowIfNull(error);
@@ -41,16 +37,13 @@ public static IObservableAsync<T> Fail<T>(Exception error)
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: SignalAsync.Throw<int>(ex).")]
+        Justification = "The element type cannot be inferred from an exception; the caller states it: SignalAsync.Throw<int>(ex).")]
     public static IObservableAsync<T> Throw<T>(Exception error) =>
         new ThrowSignalAsync<T>(error ?? throw new ArgumentNullException(nameof(error)));
 
     /// <summary>Represents an asynchronous observable sequence that immediately terminates with the specified exception.</summary>
     /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
     /// <param name="error">The exception that will be signaled to observers as the terminal error.</param>
-    /// <remarks>Use this type to create an observable sequence that fails immediately upon subscription,
-    /// propagating the provided exception to subscribers. This can be useful for representing error conditions in
-    /// asynchronous observable scenarios.</remarks>
     internal sealed class ThrowSignalAsync<T>(Exception error) : IObservableAsync<T>
     {
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
index d9025f8a..ec2324dc 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
@@ -7,10 +7,8 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>
-/// Provides the Timer factory method for creating asynchronous observable sequences that produce
-/// a single value after a specified delay.
+/// Provides the clock-driven factory methods: a one-shot value after a delay, and periodic ticks.
 /// </summary>
-/// <remarks>Timer is useful for triggering one-shot deferred actions in observable pipelines.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then completes.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
index 4e841b0b..3017f5da 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
@@ -11,10 +11,8 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides extension methods for converting tasks, asynchronous enumerables, and enumerable sequences into
 /// asynchronous observable sequences.
 /// </summary>
-/// <remarks>The methods in this class enable integration of task-based and enumerable workflows with asynchronous
-/// observables. Each method returns an observable sequence that emits values or completion notifications based on the
-/// source sequence or task. Cancellation and error propagation are supported according to the source's behavior. These
-/// extensions are useful for bridging between different asynchronous programming models.</remarks>
+/// <remarks>Every overload is spelled <c>ToAsyncSignal</c>, so the conversion reads the same whatever the source, and a
+/// sequence that is an <see cref="IObservableAsync{T}"/> passes straight through.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Observable-conversion operators for an asynchronous enumerable source.</summary>
@@ -24,14 +22,12 @@ public static partial class SignalAsyncExtensions
     {
         /// <summary>Converts an asynchronous enumerable sequence to an asynchronous observable sequence.</summary>
         /// <returns>An asynchronous observable sequence that emits the elements of the source sequence.</returns>
-        /// <remarks>The returned observable emits each element from the source sequence as it is produced and
-        /// signals completion when the source sequence ends. Cancellation is supported via the observer's cancellation
-        /// token.</remarks>
+        /// <remarks>The source is enumerated once per subscriber.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the asynchronous signal the method returns, not asynchronous work.")]
         public IObservableAsync<T> ToAsyncSignal() => new AsyncEnumerableSignal<T>(source);
     }
 
@@ -46,13 +42,13 @@ public static partial class SignalAsyncExtensions
         /// </summary>
         /// <returns>An asynchronous observable sequence that emits each element from the source enumerable and completes when all
         /// elements have been emitted.</returns>
-        /// <remarks>The returned observable emits items on a background thread. Cancellation is supported via the
-        /// observer's cancellation token. If the source sequence is empty, the observable completes immediately.</remarks>
+        /// <remarks>Enumeration runs on a background thread, once per subscriber, so a blocking or side-effecting
+        /// sequence neither stalls the subscribe call nor is shared between observers.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the asynchronous signal the method returns, not asynchronous work.")]
         public IObservableAsync<T> ToAsyncSignal() => new EnumerableSignal<T>(source);
     }
 
@@ -61,13 +57,14 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Returns an async observable as an async signal.</summary>
-        /// <returns>An observable sequence validated.</returns>
+        /// <summary>Null-checks and returns the source unchanged, so generic code can convert without knowing whether
+        /// it has a signal already.</summary>
+        /// <returns>The same sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the asynchronous signal the method returns, not asynchronous work.")]
         public IObservableAsync<T> ToAsyncSignal() =>
             source ?? throw new ArgumentNullException(nameof(source));
     }
@@ -83,14 +80,13 @@ public IObservableAsync<T> ToAsyncSignal() =>
         /// </summary>
         /// <returns>An asynchronous observable sequence that emits the result of the task when it completes, followed by a
         /// completion notification.</returns>
-        /// <remarks>The returned observable will emit the task's result and then complete. If the task is
-        /// canceled or fails, the observable will propagate the corresponding error. The task is awaited in the background,
-        /// and cancellation is supported via the observable's subscription.</remarks>
+        /// <remarks>A faulted or cancelled task terminates the sequence with that error. Since the task is a single
+        /// shared instance, every subscriber observes the same outcome.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "The suffix names the asynchronous signal the method returns, not asynchronous work.")]
         public IObservableAsync<T> ToAsyncSignal() => new TaskResultSignal<T>(task);
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/AnyAllAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/AnyAllAsync.cs
index 009d9153..76a673b8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/AnyAllAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/AnyAllAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and evaluating asynchronous observable sequences, such as
-/// determining whether any or all elements satisfy a condition. These methods are designed to be used with types that
-/// implement asynchronous observation patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous quantifier operators that evaluate elements of an observable source sequence.</summary>
@@ -53,7 +50,7 @@ public ValueTask<bool> AnyAsync(CancellationToken cancellationToken) =>
         /// <returns>A task that represents the asynchronous operation. The task result contains <see langword="true"/> if every
         /// element of the sequence passes the test in the specified predicate, or if the sequence is empty; otherwise,
         /// <see langword="false"/>.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<bool> AllAsync(Func<T, bool> predicate) => source.AllAsync(predicate, CancellationToken.None);
 
@@ -64,7 +61,7 @@ public ValueTask<bool> AnyAsync(CancellationToken cancellationToken) =>
         /// <returns>A task that represents the asynchronous operation. The task result contains <see langword="true"/> if every
         /// element of the sequence passes the test in the specified predicate, or if the sequence is empty; otherwise,
         /// <see langword="false"/>.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public async ValueTask<bool> AllAsync(Func<T, bool> predicate, CancellationToken cancellationToken)
         {
             ArgumentExceptionHelper.ThrowIfNull(predicate);
@@ -105,7 +102,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
     /// <param name="cancellationToken">A cancellation token for the operation.</param>
     internal sealed class AllTaskWitness<T>(Func<T, bool> predicate, CancellationToken cancellationToken) : TaskResultWitnessAsyncBase<T, bool>(cancellationToken)
     {
-        /// <summary>The predicate function used to test each element in the sequence.</summary>
+        /// <summary>The test applied to every element.</summary>
         private readonly Func<T, bool> _predicate = predicate;
 
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
index 101a82e4..f196f0d5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
@@ -9,11 +9,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of static methods for composing and merging asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers extension methods that enable advanced composition patterns for
-/// asynchronous observables, such as merging multiple sequences into a single stream. These methods are designed to
-/// work with the SignalAsync{T} abstraction, supporting scenarios where asynchronous event streams need to be
-/// combined or coordinated. All methods are thread-safe and intended for use in asynchronous, reactive programming
-/// models.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Blend/Merge operators for an enumerable collection of observable source sequences.</summary>
@@ -26,10 +21,8 @@ public static partial class SignalAsyncExtensions
         /// source sequences as they arrive.
         /// </summary>
         /// <returns>An observable sequence that emits items from all input sequences as they are produced.</returns>
-        /// <remarks>The resulting observable sequence emits items from all source sequences in the order they
-        /// arrive, interleaving emissions if sources produce items concurrently. The merged sequence completes when all
-        /// source sequences have completed. If any source sequence signals an error, the merged sequence will propagate
-        /// that error and terminate.</remarks>
+        /// <remarks>Emissions interleave as the sources produce them; the result completes once every source has
+        /// completed, and an error from any source propagates and terminates it.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Blend() =>
             new BlendEnumerableSignal<T>(sources);
@@ -55,9 +48,8 @@ public IObservableAsync<T> Merge() =>
         /// inner sequences as they arrive.
         /// </summary>
         /// <returns>An asynchronous observable sequence that emits items from all inner observable sequences as they are produced.</returns>
-        /// <remarks>The resulting sequence emits items from all inner sequences concurrently as they become
-        /// available. The merged sequence completes when the source sequence and all inner sequences have completed. If any
-        /// inner sequence signals an error, the merged sequence will propagate that error and terminate.</remarks>
+        /// <remarks>Every inner sequence stays subscribed at once; the result completes only after the outer sequence
+        /// and all inner sequences have completed, and an error from any of them propagates and terminates it.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Blend() =>
             new BlendSignalSourcesSignal<T>(source);
@@ -90,9 +82,8 @@ public IObservableAsync<T> Merge(int maxConcurrent) =>
         /// <summary>Combines the elements of two asynchronous observable sequences into a single sequence by merging their emissions.</summary>
         /// <param name="other">The second asynchronous observable sequence to merge with the first.</param>
         /// <returns>An SignalAsync{T} that emits the elements from both input sequences as they arrive.</returns>
-        /// <remarks>The resulting sequence emits items from both source sequences in the order they are produced.
-        /// The merged sequence completes when both input sequences have completed. If either source sequence signals an
-        /// error, the merged sequence will propagate that error and terminate.</remarks>
+        /// <remarks>The result completes once both sequences have completed; an error from either propagates and
+        /// terminates it.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Blend(IObservableAsync<T> other) =>
             new BlendEnumerableSignal<T>([source, other]);
@@ -239,22 +230,16 @@ internal void LinkExternalCancellation(CancellationToken external)
                 _disposeCts);
         }
 
-        /// <summary>
-        /// Re-checks the disposed flag inside the serialization gate and forwards the value to
-        /// downstream if still alive. Extracted as an <see langword="internal"/> method so the
-        /// inside-gate after-dispose decision is directly unit-testable without racing the gate.
-        /// </summary>
+        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if the
+        /// subscription is alive.</summary>
         /// <param name="value">The value to forward.</param>
         /// <returns>A task representing the asynchronous forward operation.</returns>
         internal ValueTask RelayNextIfActiveAsync(T value) => DisposalHelper.HasDisposed(_disposed)
             ? default
             : _observer.OnNextAsync(value, DisposedCancellationToken);
 
-        /// <summary>
-        /// Re-checks the disposed flag inside the serialization gate and forwards the error to
-        /// downstream if still alive. Extracted as an <see langword="internal"/> method for
-        /// direct unit testing.
-        /// </summary>
+        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if the
+        /// subscription is alive.</summary>
         /// <param name="exception">The error to forward.</param>
         /// <returns>A task representing the asynchronous forward operation.</returns>
         internal ValueTask RelayErrorIfActiveAsync(Exception exception) => DisposalHelper.HasDisposed(_disposed)
@@ -445,15 +430,10 @@ internal override BlendBranchWitness CreateBranchObserver() =>
         /// <param name="parent">The parent bounded merge coordinator whose semaphore slot is released on disposal.</param>
         internal sealed class BlendBranchWitnessWithPermit(BoundedBlendCoordinator<T> parent) : BlendBranchWitness(parent)
         {
-            /// <summary>Tracks whether the semaphore slot has already been released for this witness.</summary>
-            /// <remarks>
-            /// <see cref="WitnessAsync{T}.DisposeAsync"/> can be invoked more than once for the same witness
-            /// (auto-dispose after <c>OnCompletedAsync</c>, then again from <c>CompositeDisposableAsync.Remove</c>
-            /// and from the parent's <c>FinishAsync</c> path). Without this guard, <see cref="SemaphoreSlim.Release()"/>
-            /// would be called multiple times per witness, exceeding <c>maxCount</c> and throwing
-            /// <see cref="SemaphoreFullException"/> — which interrupts the parent's completion chain and leaves
-            /// downstream witnesses waiting forever.
-            /// </remarks>
+            /// <summary>Guards the one-time release of this witness's semaphore slot.</summary>
+            /// <remarks><see cref="WitnessAsync{T}.DisposeAsync"/> can run several times for one witness, and a repeat
+            /// <see cref="SemaphoreSlim.Release()"/> would exceed the semaphore's count and throw
+            /// <see cref="SemaphoreFullException"/>, breaking the parent's completion chain.</remarks>
             private int _released;
 
             /// <inheritdoc/>
@@ -498,7 +478,7 @@ internal sealed class BlendSequenceCoordinator : IAsyncDisposable
             /// <summary>Cancellation source for disposal.</summary>
             private readonly CancellationTokenSource _cts = new();
 
-            /// <summary>A cached token from <see cref="_cts"/> used to link with per-emission tokens.</summary>
+            /// <summary>Token signalled when this subscription is disposed.</summary>
             private readonly CancellationToken _disposedCancellationToken;
 
             /// <summary>Serializes observer notifications to prevent concurrent calls.</summary>
@@ -508,7 +488,8 @@ internal sealed class BlendSequenceCoordinator : IAsyncDisposable
             private readonly TaskCompletionSource<bool> _subscriptionFinished =
                 new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            /// <summary>Tracks reentrant calls to prevent deadlocks.</summary>
+            /// <summary>Marks the subscribing loop's own async flow so that a <see cref="FinishAsync"/> raised from
+            /// inside it does not wait on <see cref="_subscriptionFinished"/> and deadlock.</summary>
             private readonly AsyncLocal<bool> _reentrant = new();
 
             /// <summary>The downstream observer.</summary>
@@ -538,11 +519,8 @@ public BlendSequenceCoordinator(IObserverAsync<T> observer, IEnumerable<IObserva
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask DisposeAsync() => FinishAsync(null);
 
-            /// <summary>
-            /// Routes an exception from a post-disposal completion result to the unhandled exception handler.
-            /// Called when <see cref="DisposalHelper.TrySetDisposed"/> returns true (already disposed)
-            /// and the completion result carries an exception.
-            /// </summary>
+            /// <summary>Routes the exception of a completion result that arrives after disposal to the unhandled
+            /// exception handler.</summary>
             /// <param name="result">The completion result, or null if disposing without signaling.</param>
             internal static void RoutePostDisposalException(Result? result)
             {
@@ -559,7 +537,7 @@ internal static void RoutePostDisposalException(Result? result)
             [SuppressMessage(
                 "Roslynator",
                 "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-                Justification = "Method already named with Async")]
+                Justification = "Fire-and-forget launcher; the asynchronous work is the lambda it starts.")]
             internal void BeginSubscribing() => FireAndForgetHelper.Run(async () =>
             {
                 _reentrant.Value = true;
@@ -649,11 +627,8 @@ internal async ValueTask RelayNextAsync(T value, CancellationToken token)
                 }
             }
 
-            /// <summary>
-            /// Re-checks the disposed flag inside the serialization gate and forwards the value
-            /// to downstream if still alive. Extracted as an <see langword="internal"/> method for
-            /// direct unit testing of the inside-gate after-dispose decision.
-            /// </summary>
+            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if
+            /// the subscription is alive.</summary>
             /// <param name="value">The value to forward.</param>
             /// <returns>A task representing the asynchronous forward operation.</returns>
             internal ValueTask RelayNextIfActiveAsync(T value) => DisposalHelper.HasDisposed(_disposed)
@@ -678,11 +653,8 @@ internal async ValueTask RelayErrorAsync(Exception ex, CancellationToken token)
                 }
             }
 
-            /// <summary>
-            /// Re-checks the disposed flag inside the serialization gate and forwards the error
-            /// to downstream if still alive. Extracted as an <see langword="internal"/> method
-            /// for direct unit testing of the inside-gate after-dispose decision.
-            /// </summary>
+            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if
+            /// the subscription is alive.</summary>
             /// <param name="ex">The error to forward.</param>
             /// <returns>A task representing the asynchronous forward operation.</returns>
             internal ValueTask RelayErrorIfActiveAsync(Exception ex) => DisposalHelper.HasDisposed(_disposed)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Cast.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Cast.cs
index 800000d9..7da2eb4d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Cast.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Cast.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observables, enabling additional operations such as type casting and sequence manipulation. These methods are
-/// intended to be used with the SignalAsync{T} type to facilitate reactive programming patterns in asynchronous
-/// scenarios.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Type-casting operators for an observable source sequence.</summary>
@@ -22,13 +18,12 @@ public static partial class SignalAsyncExtensions
         /// <typeparam name="TResult">The type to which the elements of the sequence are cast.</typeparam>
         /// <returns>An observable sequence whose elements are the result of casting each element of the source sequence to
         /// <typeparamref name="TResult"/>.</returns>
-        /// <remarks>If an element in the source sequence cannot be cast to <typeparamref
-        /// name="TResult"/>, the sequence completes with a failure containing the exception. This method is useful for
-        /// working with sequences of objects when the actual element type is known at runtime.</remarks>
+        /// <remarks>A failed cast does not throw at the call site: the sequence completes with a failure carrying the
+        /// cast exception.</remarks>
         [SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification = "Public extension API — caller specifies TResult explicitly: source.Cast<Derived>().")]
+            Justification = "The caller chooses TResult; no parameter carries it.")]
         public IObservableAsync<TResult> Cast<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -47,7 +42,7 @@ public IObservableAsync<TResult> Cast<TResult>()
         [SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification = "Deliberate lack of type inference.")]
+            Justification = "The caller chooses TResult; no parameter carries it.")]
         public IObservableAsync<TResult> CastTo<TResult>()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
index 576d55ee..b09f9e00 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for composing and concatenating asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable fluent composition of asynchronous observables, allowing multiple
-/// sequences to be combined into a single sequence that emits items in order. These methods are intended for use with
-/// types that implement asynchronous, push-based data streams.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Chain/Concat operators for a collection of observable sequences.</summary>
@@ -23,8 +20,8 @@ public static partial class SignalAsyncExtensions
         /// </summary>
         /// <returns>An asynchronous observable sequence that emits all items from each source sequence in the order they appear in
         /// the collection.</returns>
-        /// <remarks>Each source sequence is subscribed to only after the previous one completes. If any source
-        /// sequence signals an error, concatenation stops and the error is propagated to the observer.</remarks>
+        /// <remarks>A source is subscribed only after the previous one completes, so at most one source is active at a
+        /// time; an error from any source stops the concatenation and is propagated.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Chain() =>
             new ChainEnumerableSignal<T>(sources);
@@ -51,9 +48,8 @@ public IObservableAsync<T> Concat() =>
         /// </summary>
         /// <returns>An observable sequence that emits the elements of each inner observable sequence in order, waiting for each to
         /// complete before subscribing to the next.</returns>
-        /// <remarks>If any inner observable sequence signals an error, the resulting sequence will propagate that
-        /// error and terminate immediately. The concatenation is performed in a deferred and sequential manner, ensuring
-        /// that only one inner sequence is active at a time.</remarks>
+        /// <remarks>At most one inner sequence is subscribed at a time; an error from any of them terminates the result
+        /// immediately.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Chain() =>
             new ChainSignalSourcesSignal<T>(source);
@@ -80,9 +76,8 @@ public IObservableAsync<T> Concat() =>
         /// <param name="second">The second observable sequence to concatenate. Cannot be null.</param>
         /// <returns>An observable sequence that emits all elements from the first sequence, followed by all elements from the second
         /// sequence.</returns>
-        /// <remarks>The resulting sequence emits all items from the first observable before subscribing to and
-        /// emitting items from the second observable. If either sequence signals an error, the concatenation terminates and
-        /// the error is propagated to observers.</remarks>
+        /// <remarks><paramref name="second"/> is not subscribed until the first sequence completes; an error from
+        /// either terminates the result.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Chain(IObservableAsync<T> second) =>
             new ChainEnumerableSignal<T>([source, second]);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
index fb415ddc..f18e70cd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
@@ -14,17 +14,14 @@ namespace ReactiveUI.Primitives.Async;
 /// <typeparam name="T">The type of elements produced by the concatenated observable sequences.</typeparam>
 /// <param name="signals">A collection of asynchronous signals to be concatenated. Each signal is subscribed to sequentially; the next
 /// begins only after the previous completes.</param>
-/// <remarks>This class enables sequential composition of multiple asynchronous observables, ensuring that items
-/// from each source are emitted in order and that subsequent observables are not subscribed to until the preceding one
-/// has completed. If any observable in the sequence signals an error, the concatenation terminates and the error is
-/// propagated to the observer.</remarks>
+/// <remarks>An error from any signal terminates the concatenation and is propagated to the observer.</remarks>
 [System.Diagnostics.DebuggerDisplay("ChainEnumerableSignal: Signals = {_signals}")]
 public sealed class ChainEnumerableSignal<T>(IEnumerable<IObservableAsync<T>> signals) : IObservableAsync<T>
 {
     /// <summary>The enumerable collection of signal sequences to concatenate.</summary>
     private readonly IEnumerable<IObservableAsync<T>> _signals = signals;
 
-    /// <summary>Subscribes the specified observer by creating a <see cref="ChainSequenceCoordinator"/> that iterates through the enumerable of observables sequentially.</summary>
+    /// <summary>Subscribes the observer to a <see cref="ChainSequenceCoordinator"/> that walks the signals one at a time.</summary>
     /// <param name="observer">The observer to receive elements from the concatenated sequences.</param>
     /// <param name="cancellationToken">A token to cancel the subscription.</param>
     /// <returns>An async disposable that tears down the subscription when disposed.</returns>
@@ -53,7 +50,7 @@ internal sealed class ChainSequenceCoordinator : IAsyncDisposable
         /// <summary>Cancellation token source used to signal disposal of the subscription.</summary>
         private readonly CancellationTokenSource _cts = new();
 
-        /// <summary>Cached cancellation token from the dispose cancellation token source.</summary>
+        /// <summary>Token signalled when this subscription is disposed.</summary>
         private readonly CancellationToken _disposedCancellationToken;
 
         /// <summary>The downstream observer to forward elements to.</summary>
@@ -76,8 +73,8 @@ public ChainSequenceCoordinator(ChainEnumerableSignal<T> parent, IObserverAsync<
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask DisposeAsync() => FinishAsync(null);
 
-        /// <summary>Handles a second call to <see cref="FinishAsync"/> when already disposed, routing any failure exception to the unhandled exception handler.</summary>
-        /// <param name="result">The completion result from the second call.</param>
+        /// <summary>Routes the failure carried by a redundant <see cref="FinishAsync"/> call to the unhandled exception handler.</summary>
+        /// <param name="result">The completion result from the redundant call.</param>
         internal static void HandleAlreadyDisposed(Result? result)
         {
             if (result?.Exception is not { } exception)
@@ -121,11 +118,9 @@ internal async ValueTask SubscribeNextSignalAsync()
         /// <returns>A task representing the asynchronous operation.</returns>
         internal ValueTask RelayInnerErrorAsync(Exception exception, CancellationToken cancellationToken)
         {
-            // The inner subscription is rooted in _disposedCancellationToken (see SubscribeNextSignalAsync),
-            // so its disposal already cascades into the inner observer's own cancellation. Forwarding
-            // _disposedCancellationToken directly preserves the cancellation semantics that a linked
-            // CTS would have provided, without the per-emission Linked2CancellationTokenSource alloc
-            // that dominated the GC profile.
+            // The inner subscription is rooted in _disposedCancellationToken (see SubscribeNextSignalAsync), so
+            // disposing it cascades into the inner observer's own cancellation. Forwarding that token directly
+            // gives the same cancellation semantics as a linked CTS without allocating one per emission.
             _ = cancellationToken;
             return _observer.OnErrorResumeAsync(exception, _disposedCancellationToken);
         }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
index 8ffc1995..292eeee3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
@@ -42,7 +42,7 @@ internal sealed class ChainCoordinator : IAsyncDisposable
         /// <summary>Cancellation token source used to signal disposal of the subscription.</summary>
         private readonly CancellationTokenSource _disposeCts = new();
 
-        /// <summary>Cached cancellation token from the dispose cancellation token source.</summary>
+        /// <summary>Token signalled when this subscription is disposed.</summary>
         private readonly CancellationToken _disposedCancellationToken;
 
         /// <summary>Disposable that holds the single outer subscription.</summary>
@@ -75,8 +75,8 @@ public ChainCoordinator(IObserverAsync<T> observer)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask DisposeAsync() => FinishAsync(null);
 
-        /// <summary>Handles a second call to <see cref="FinishAsync"/> when already disposed, routing any failure exception to the unhandled exception handler.</summary>
-        /// <param name="result">The completion result from the second call.</param>
+        /// <summary>Routes the failure carried by a redundant <see cref="FinishAsync"/> call to the unhandled exception handler.</summary>
+        /// <param name="result">The completion result from the redundant call.</param>
         internal static void HandleAlreadyDisposed(Result? result)
         {
             if (result?.Exception is not { } exception)
@@ -237,10 +237,9 @@ protected override async ValueTask OnErrorResumeAsyncCore(
                 Exception error,
                 CancellationToken cancellationToken)
             {
-                // The outer subscription is rooted in _disposedCancellationToken, so its disposal
-                // already cascades into this observer's cancellation. Forwarding the dispose token
-                // directly preserves the cancellation semantics that a linked CTS would have
-                // provided, without the per-emission Linked2CancellationTokenSource alloc.
+                // The outer subscription is rooted in _disposedCancellationToken, so disposing it cascades
+                // into this observer's cancellation. Forwarding the dispose token directly gives the same
+                // cancellation semantics as a linked CTS without allocating one per emission.
                 _ = cancellationToken;
                 var token = subscription._disposedCancellationToken;
                 using (await subscription._observerOnSomethingGate.EnterAsync(token).ConfigureAwait(false))
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
index d3015c6a..a969cde6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
@@ -11,7 +11,5 @@ namespace ReactiveUI.Primitives.Async;
 /// <param name="notifyStop">An action to be invoked with a <see cref="Result"/> when the completion event occurs. This callback is called to
 /// notify the subscriber of the completion result.</param>
 /// <returns>An <see cref="IAsyncDisposable"/> that unsubscribes the notification when disposed asynchronously.</returns>
-/// <remarks>The returned <see cref="IAsyncDisposable"/> should be disposed to stop receiving completion
-/// notifications and to release any associated resources. The <paramref name="notifyStop"/> callback may be invoked on
-/// a background thread.</remarks>
+/// <remarks><paramref name="notifyStop"/> may be invoked on a background thread.</remarks>
 public delegate IAsyncDisposable CompletionSignalDelegate(Action<Result> notifyStop);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ContainsAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ContainsAsync.cs
index 6c821ffd..01ebddfe 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ContainsAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ContainsAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and manipulation of asynchronous observables, such as
-/// determining whether a sequence contains a specified element. These extensions are designed to integrate with the
-/// SignalAsync{T} pattern for asynchronous, push-based data streams.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous containment operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/CountAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/CountAsync.cs
index 2a9d6694..c428ff2b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/CountAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/CountAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for performing asynchronous operations on observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observable sequences, enabling operations such as counting elements that satisfy a specified condition. These
-/// methods are designed to work with types that implement asynchronous observation patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous element-counting operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
index 5cd2c7b5..64784606 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
@@ -5,10 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of static methods for creating and composing asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers extension methods that enable functional-style operations, such as
-/// filtering for distinct elements, on asynchronous observable sequences. These methods are designed to work with the
-/// SignalAsync{T} type, allowing developers to build complex, asynchronous event processing pipelines in a
-/// composable manner.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Distinctness operators for an observable source sequence.</summary>
@@ -21,8 +17,8 @@ public static partial class SignalAsyncExtensions
         /// comparer for the element type.
         /// </summary>
         /// <returns>An observable sequence that contains distinct elements from the source sequence.</returns>
-        /// <remarks>Elements are considered distinct based on the default equality comparer for type T.
-        /// The order of elements is preserved.</remarks>
+        /// <remarks>Only the first occurrence of each element reaches observers, in source order; the set of seen
+        /// elements lives for the whole subscription.</remarks>
         public IObservableAsync<T> Distinct()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -38,8 +34,8 @@ public IObservableAsync<T> Distinct()
         /// used.</param>
         /// <returns>An observable sequence that emits each distinct element from the source sequence, in the order in which they
         /// are received.</returns>
-        /// <remarks>Only the first occurrence of each element, as determined by the specified equality
-        /// comparer, is emitted to observers. Subsequent duplicate elements are ignored.</remarks>
+        /// <remarks>Only the first occurrence of each element, as judged by <paramref name="equalityComparer"/>,
+        /// reaches observers.</remarks>
         public IObservableAsync<T> Distinct(IEqualityComparer<T> equalityComparer)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -56,8 +52,7 @@ public IObservableAsync<T> Distinct(IEqualityComparer<T> equalityComparer)
         /// <param name="keySelector">A function to extract the key for each element. Cannot be null.</param>
         /// <returns>An observable sequence that contains only the first occurrence of each distinct key as determined by the key
         /// selector.</returns>
-        /// <remarks>Elements are considered distinct based on the value returned by the key selector and
-        /// the default equality comparer for the key type.</remarks>
+        /// <remarks>Keys are compared with the default equality comparer for <typeparamref name="TKey"/>.</remarks>
         public IObservableAsync<T> DistinctBy<TKey>(Func<T, TKey> keySelector)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -75,10 +70,7 @@ public IObservableAsync<T> DistinctBy<TKey>(Func<T, TKey> keySelector)
         /// <param name="equalityComparer">An equality comparer to compare keys for equality. Cannot be null.</param>
         /// <returns>An observable sequence that contains only the first occurrence of each distinct key as determined by the
         /// specified key selector and equality comparer.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="keySelector"/> or <paramref name="equalityComparer"/> is null.</exception>
-        /// <remarks>Elements are considered distinct based on the value returned by the <paramref
-        /// name="keySelector"/> function and compared using the provided <paramref name="equalityComparer"/>. Only the
-        /// first occurrence of each key is included in the resulting sequence.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> or <paramref name="equalityComparer"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> DistinctBy<TKey>(
             Func<T, TKey> keySelector,
             IEqualityComparer<TKey> equalityComparer)
@@ -123,7 +115,7 @@ internal sealed class DistinctWitness(
             IEqualityComparer<T> comparer,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>Set of previously-forwarded values; <see cref="HashSet{T}.Add"/> returns <see langword="false"/> for duplicates.</summary>
+            /// <summary>The values forwarded so far; <see cref="HashSet{T}.Add"/> returns <see langword="false"/> for a duplicate.</summary>
             private readonly HashSet<T> _seen = [with(comparer)];
 
             /// <inheritdoc/>
@@ -179,7 +171,7 @@ internal sealed class DistinctByWitness(
             IEqualityComparer<TKey> comparer,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>Set of previously-seen keys.</summary>
+            /// <summary>The keys seen so far.</summary>
             private readonly HashSet<TKey> _seen = [with(comparer)];
 
             /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
index 50ec7a5a..177d980f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Timeout extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Timeout applies a time limit to the observable sequence. If the sequence does not produce
-/// a value within the specified time span, a <see cref="TimeoutException"/> is signalled as a failure
-/// completion.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Timeout operators for an observable source sequence.</summary>
@@ -18,13 +15,13 @@ public static partial class SignalAsyncExtensions
     extension<T>(IObservableAsync<T> source)
     {
         /// <summary>
-        /// Applies a dueTime policy to the observable sequence. If the next element is not received within
-        /// the specified time span, the sequence completes with a <see cref="TimeoutException"/>.
+        /// Applies a time limit between elements. If the next element does not arrive within
+        /// <paramref name="dueTime"/>, the sequence completes with a <see cref="TimeoutException"/>.
         /// </summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <returns>An observable sequence that mirrors the source but completes with a
-        /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified dueTime.</returns>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
+        /// <see cref="TimeoutException"/> once an inter-element gap exceeds <paramref name="dueTime"/>.</returns>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="dueTime"/> is negative or zero.</exception>
         public IObservableAsync<T> Expire(TimeSpan dueTime)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThanOrEqual(dueTime, TimeSpan.Zero);
@@ -35,15 +32,15 @@ public IObservableAsync<T> Expire(TimeSpan dueTime)
 
     /// <summary>
     /// Async observable that mirrors the source but completes with a <see cref="TimeoutException"/>
-    /// if any inter-element interval exceeds the specified dueTime.
+    /// once an inter-element gap exceeds the configured interval.
     /// </summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence.</param>
     /// <param name="dueTime">The maximum allowed inter-element interval.</param>
-    /// <param name="timeProvider">The time provider used for scheduling the dueTime.</param>
+    /// <param name="timeProvider">The time provider used to schedule the deadline.</param>
     internal sealed class TimeoutSignal<T>(IObservableAsync<T> source, TimeSpan dueTime, TimeProvider timeProvider) : IObservableAsync<T>
     {
-        /// <summary>Subscribes the specified observer and starts the dueTime timer.</summary>
+        /// <summary>Subscribes the specified observer and starts the deadline timer.</summary>
         /// <param name="observer">The observer to receive elements from the source.</param>
         /// <param name="cancellationToken">A token to cancel the subscription.</param>
         /// <returns>An async disposable that tears down the subscription when disposed.</returns>
@@ -59,30 +56,27 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
 
         /// <summary>
         /// Observer that resets a timer on each received element and signals a <see cref="TimeoutException"/>
-        /// if no element arrives within the configured dueTime.
+        /// if no element arrives within the configured interval.
         /// </summary>
         /// <param name="observer">The downstream observer to forward elements to.</param>
         /// <param name="dueTime">The maximum allowed inter-element interval.</param>
-        /// <param name="timeProvider">The time provider used for scheduling the dueTime.</param>
+        /// <param name="timeProvider">The time provider used to schedule the deadline.</param>
         internal sealed class TimeoutWitness(IObserverAsync<T> observer, TimeSpan dueTime, TimeProvider timeProvider) : WitnessAsync<T>
         {
             /// <summary>Synchronization gate protecting timer state.</summary>
             private readonly Lock _gate = new();
 
             /// <summary>
-            /// Single pre-allocated timer rearmed via <see cref="ITimer.Change(TimeSpan, TimeSpan)"/>
-            /// on every emission. Replaces the previous per-emission fire-and-forget
-            /// <c>OnTimeoutAsync</c> task; the per-emission allocations (linked CTS, async state
-            /// machine box for OnTimeoutAsync, Task.Delay's TimerQueueTimer) collapse to a single
-            /// <c>Change</c> call which is highly optimised in the BCL.
+            /// The one timer for this subscription, rearmed via <see cref="ITimer.Change(TimeSpan, TimeSpan)"/> on
+            /// every emission so that tracking the deadline costs no per-emission allocation.
             /// </summary>
             private ITimer? _timer;
 
-            /// <summary>Indicates whether the observer has already received a completion signal; ignored timeouts once true.</summary>
+            /// <summary>Set once the observer has been terminated; suppresses any later timeout signal.</summary>
             private bool _completed;
 
-            /// <summary>Allocates the timer and schedules the first dueTime tick.</summary>
-            /// <param name="cancellationToken">Cancellation token; unused after the redesign but kept for API compatibility.</param>
+            /// <summary>Allocates the timer and schedules the first deadline tick.</summary>
+            /// <param name="cancellationToken">Unused; the timer carries its own deadline.</param>
             internal void StartTimer(CancellationToken cancellationToken)
             {
                 _ = cancellationToken;
@@ -96,15 +90,14 @@ internal void StartTimer(CancellationToken cancellationToken)
                 }
                 catch (Exception e)
                 {
-                    // Preserve the legacy contract: CreateTimer failures route to the unhandled
-                    // exception handler rather than tearing down the subscription. Without a timer
-                    // the operator degrades to a pass-through; downstream callers continue to
-                    // receive emissions without a timeout signal.
+                    // A CreateTimer failure routes to the unhandled exception handler rather than tearing
+                    // down the subscription: with no timer the operator degrades to a pass-through that
+                    // forwards every emission and never signals a timeout.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
 
-            /// <summary>Rearms the dueTime timer and forwards the element to the downstream observer.</summary>
+            /// <summary>Rearms the deadline timer and forwards the element to the downstream observer.</summary>
             /// <param name="value">The element to forward.</param>
             /// <param name="cancellationToken">A token to cancel the operation.</param>
             /// <returns>A task representing the asynchronous operation.</returns>
@@ -114,7 +107,7 @@ protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancella
                 return observer.OnNextAsync(value, cancellationToken);
             }
 
-            /// <summary>Stops the dueTime timer and forwards the error to the downstream observer.</summary>
+            /// <summary>Stops the deadline timer and forwards the error to the downstream observer.</summary>
             /// <param name="error">The error to forward.</param>
             /// <param name="cancellationToken">A token to cancel the operation.</param>
             /// <returns>A task representing the asynchronous operation.</returns>
@@ -129,7 +122,7 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
                 return observer.OnErrorResumeAsync(error, cancellationToken);
             }
 
-            /// <summary>Stops the dueTime timer and forwards completion to the downstream observer.</summary>
+            /// <summary>Stops the deadline timer and forwards completion to the downstream observer.</summary>
             /// <param name="result">The completion result.</param>
             /// <returns>A task representing the asynchronous operation.</returns>
             protected override ValueTask OnCompletedAsyncCore(Result result)
@@ -143,7 +136,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result)
                 return observer.OnCompletedAsync(result);
             }
 
-            /// <summary>Disposes the dueTime timer during teardown.</summary>
+            /// <summary>Disposes the deadline timer during teardown.</summary>
             /// <returns>A completed task.</returns>
             protected override async ValueTask DisposeAsyncCore()
             {
@@ -176,7 +169,7 @@ private static async Task FireTimeoutAsync(IObserverAsync<T> target)
                 }
             }
 
-            /// <summary>Timer callback: signals the downstream observer with a <see cref="TimeoutException"/> completion unless the observer has already terminated.</summary>
+            /// <summary>Timer callback: completes the downstream observer with a <see cref="TimeoutException"/> unless it has terminated.</summary>
             private void OnTimerFired()
             {
                 lock (_gate)
@@ -192,18 +185,15 @@ private void OnTimerFired()
                 _ = FireTimeoutAsync(observer);
             }
 
-            /// <summary>Rearms the timeout deadline for the next emission. Isolated from
-            /// coverage because the <c>_timer is null</c> branch is only reachable when the
-            /// source emits after the sink's <c>DisposeAsyncCore</c> has nulled the timer —
-            /// a race the single-threaded test harness cannot deterministically trigger.</summary>
+            /// <summary>Rearms the timeout deadline for the next emission; <c>_timer</c> is null only when the source
+            /// emits after <c>DisposeAsyncCore</c> has torn the timer down, a race no deterministic test can hit.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
             private void RearmTimer() =>
                 _timer?.Change(dueTime, System.Threading.Timeout.InfiniteTimeSpan);
 
-            /// <summary>Stops the timeout deadline on terminal forwarding. Isolated from
-            /// coverage because the <c>_timer is null</c> branch is only reachable under the
-            /// same source-after-Dispose race that <see cref="RearmTimer"/> guards against.</summary>
+            /// <summary>Stops the timeout deadline on terminal forwarding; <c>_timer</c> is null only under the same
+            /// post-teardown race as <see cref="RearmTimer"/>.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
             private void StopTimer() =>
@@ -213,20 +203,20 @@ private void StopTimer() =>
 
     /// <summary>
     /// Async observable that mirrors the source but switches to a fallback observable
-    /// if any inter-element interval exceeds the specified dueTime.
+    /// once an inter-element gap exceeds the configured interval.
     /// </summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence.</param>
     /// <param name="dueTime">The maximum allowed inter-element interval.</param>
-    /// <param name="fallback">The fallback observable to switch to on dueTime.</param>
-    /// <param name="timeProvider">The time provider used for scheduling the dueTime.</param>
+    /// <param name="fallback">The observable to switch to when the interval elapses.</param>
+    /// <param name="timeProvider">The time provider used to schedule the deadline.</param>
     internal sealed class TimeoutWithFallbackSignal<T>(
         IObservableAsync<T> source,
         TimeSpan dueTime,
         IObservableAsync<T> fallback,
         TimeProvider timeProvider) : IObservableAsync<T>
     {
-        /// <summary>Subscribes the specified observer by wrapping the source with a dueTime and a catch-to-fallback.</summary>
+        /// <summary>Subscribes the specified observer by wrapping the source with a deadline and a catch-to-fallback.</summary>
         /// <param name="observer">The observer to receive elements.</param>
         /// <param name="cancellationToken">A token to cancel the subscription.</param>
         /// <returns>An async disposable that tears down the subscription when disposed.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstAsync.cs
index 742bd4c5..a2a8cfdd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and manipulation of asynchronous observables, such as
-/// retrieving the first element that matches a specified condition. These extensions are designed to be used with types
-/// that implement asynchronous observable patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>First-element operators for an observable source sequence.</summary>
@@ -22,6 +19,7 @@ public static partial class SignalAsyncExtensions
         /// predicate returns <see langword="true"/>.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element that matches
         /// the predicate.</returns>
+        /// <exception cref="InvalidOperationException">The sequence completes without a matching element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> FirstAsync(Func<T, bool> predicate) =>
             source.FirstAsync(predicate, CancellationToken.None);
@@ -32,6 +30,7 @@ public ValueTask<T> FirstAsync(Func<T, bool> predicate) =>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element that matches
         /// the predicate.</returns>
+        /// <exception cref="InvalidOperationException">The sequence completes without a matching element.</exception>
         public async ValueTask<T> FirstAsync(Func<T, bool> predicate, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -44,8 +43,7 @@ public async ValueTask<T> FirstAsync(Func<T, bool> predicate, CancellationToken
         /// <summary>Asynchronously returns the first element of the sequence.</summary>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element of the
         /// sequence.</returns>
-        /// <remarks>If the sequence is empty, the behavior depends on the implementation and may result
-        /// in an exception being thrown.</remarks>
+        /// <exception cref="InvalidOperationException">The sequence completes without producing an element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> FirstAsync() =>
             source.FirstAsync(CancellationToken.None);
@@ -54,8 +52,7 @@ public ValueTask<T> FirstAsync() =>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element of the
         /// sequence.</returns>
-        /// <remarks>If the sequence is empty, the behavior depends on the implementation and may result
-        /// in an exception being thrown.</remarks>
+        /// <exception cref="InvalidOperationException">The sequence completes without producing an element.</exception>
         public async ValueTask<T> FirstAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
index f3b3626f..8e67ae98 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and retrieving elements from asynchronous observables, such
-/// as obtaining the first element that matches a condition or a default value if no such element exists. These
-/// extensions are designed to be used with types implementing asynchronous observable patterns and support cancellation
-/// via cancellation tokens.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>First-or-default operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
index 364877a2..338cacaa 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
@@ -5,9 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides SelectMany (flat map) extension methods for asynchronous observable sequences.</summary>
-/// <remarks>SelectMany projects each element of an observable sequence to an observable sequence and
-/// merges the resulting observable sequences into one observable sequence. This is the monadic bind
-/// operation for observables and is essential for composing chains of asynchronous operations.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>FlatMap/SelectMany operators for an observable source sequence.</summary>
@@ -24,7 +21,7 @@ public static partial class SignalAsyncExtensions
         /// for each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform
         /// function on each element of the source sequence and merging the results.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="selector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> FlatMap<TResult>(Func<T, IObservableAsync<TResult>> selector)
         {
             ArgumentExceptionHelper.ThrowIfNull(selector);
@@ -41,7 +38,7 @@ public IObservableAsync<TResult> FlatMap<TResult>(Func<T, IObservableAsync<TResu
         /// sequence for each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform
         /// function on each element of the source sequence and merging the results.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="selector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> FlatMap<TResult>(
             Func<T, CancellationToken, ValueTask<IObservableAsync<TResult>>> selector)
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
index d64f0296..a445cb75 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
@@ -8,10 +8,6 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides extension methods for asynchronous observable sequences, enabling functional operations such as scanning
 /// and accumulation over streamed data.
 /// </summary>
-/// <remarks>The methods in this class allow developers to perform stateful transformations and aggregations on
-/// asynchronous observables. These operations are useful for scenarios where intermediate results or running totals are
-/// needed as items are received. All methods are designed to work with asynchronous patterns and support cancellation
-/// via tokens.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Fold/Scan (running accumulation) operators for an observable source sequence.</summary>
@@ -28,7 +24,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="accumulator">An asynchronous accumulator function to be invoked on each element. Receives the current accumulator value,
         /// the current element, and a cancellation token.</param>
         /// <returns>An observable sequence containing the accumulated values produced after each element is processed.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TAcc> Fold<TAcc>(
             TAcc seed,
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator)
@@ -44,7 +40,7 @@ public IObservableAsync<TAcc> Fold<TAcc>(
         /// <param name="accumulator">An accumulator function to be invoked on each element. Receives the current accumulator value and the
         /// current element.</param>
         /// <returns>An observable sequence containing the accumulated values produced after each element is processed.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TAcc> Fold<TAcc>(TAcc seed, Func<TAcc, T, TAcc> accumulator)
         {
             ArgumentExceptionHelper.ThrowIfNull(accumulator);
@@ -54,9 +50,8 @@ public IObservableAsync<TAcc> Fold<TAcc>(TAcc seed, Func<TAcc, T, TAcc> accumula
     }
 
     /// <summary>
-    /// Async-accumulator variant of <see cref="Fold{T,TAcc}(IObservableAsync{T},TAcc,Func{TAcc,T,CancellationToken,ValueTask{TAcc}})"/>.
-    /// Allocates one observable wrapper and one sealed observer per subscription — no per-emission closure or
-    /// state-machine box from the previous <c>Create&lt;TAcc&gt;((observer, token) =&gt; ...)</c> pattern.
+    /// Async-accumulator variant of <see cref="Fold{T,TAcc}(IObservableAsync{T},TAcc,Func{TAcc,T,CancellationToken,ValueTask{TAcc}})"/>,
+    /// allocating one observer per subscription and nothing per emission.
     /// </summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <typeparam name="TAcc">The accumulator type.</typeparam>
@@ -136,9 +131,8 @@ private async ValueTask AwaitAndForwardAsync(ValueTask<TAcc> pending, Cancellati
     }
 
     /// <summary>
-    /// Synchronous-accumulator variant of <see cref="Fold{T,TAcc}(IObservableAsync{T},TAcc,Func{TAcc,T,TAcc})"/>. Same
-    /// allocation profile as <see cref="FoldAsyncSignal{T,TAcc}"/> but the per-emission <c>OnNextAsyncCore</c> is
-    /// sync-completed when the downstream completes synchronously.
+    /// Synchronous-accumulator variant of <see cref="Fold{T,TAcc}(IObservableAsync{T},TAcc,Func{TAcc,T,TAcc})"/>, whose
+    /// per-emission path completes synchronously whenever the downstream does.
     /// </summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <typeparam name="TAcc">The accumulator type.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ForEachAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ForEachAsync.cs
index 5e760566..cbc45811 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ForEachAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ForEachAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains utility methods that enable consumers to process items emitted by
-/// asynchronous observables in a convenient and idiomatic way. These methods are designed to simplify common patterns
-/// when interacting with IAsyncObservable or similar asynchronous push-based data sources.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous per-element iteration operators for an observable source sequence.</summary>
@@ -22,9 +19,9 @@ public static partial class SignalAsyncExtensions
         /// token, and returns a ValueTask that completes when processing is finished.</param>
         /// <returns>A ValueTask that represents the asynchronous operation. The task completes when all elements have been
         /// processed or the operation is canceled.</returns>
-        /// <remarks>If the sequence completes or is canceled, the method returns when all in-flight
-        /// actions have finished. Exceptions thrown by the action or during enumeration will propagate to the returned
-        /// task.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
+        /// <remarks>The returned task completes once the sequence terminates and the last invocation has finished; an
+        /// exception from <paramref name="onNextAsync"/> or from the sequence surfaces on it.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask ForEachAsync(Func<T, CancellationToken, ValueTask> onNextAsync) =>
             source.ForEachAsync(onNextAsync, CancellationToken.None);
@@ -36,9 +33,9 @@ public ValueTask ForEachAsync(Func<T, CancellationToken, ValueTask> onNextAsync)
         /// signaled.</param>
         /// <returns>A ValueTask that represents the asynchronous operation. The task completes when all elements have been
         /// processed or the operation is canceled.</returns>
-        /// <remarks>If the sequence completes or is canceled, the method returns when all in-flight
-        /// actions have finished. Exceptions thrown by the action or during enumeration will propagate to the returned
-        /// task.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
+        /// <remarks>The returned task completes once the sequence terminates and the last invocation has finished; an
+        /// exception from <paramref name="onNextAsync"/> or from the sequence surfaces on it.</remarks>
         public async ValueTask ForEachAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
             CancellationToken cancellationToken)
@@ -55,7 +52,7 @@ public async ValueTask ForEachAsync(
         /// <param name="onNext">The action to invoke for each element in the sequence. Cannot be null.</param>
         /// <returns>A task that represents the asynchronous iteration operation. The task completes when the sequence has been
         /// fully processed or the operation is canceled.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask ForEachAsync(Action<T> onNext) =>
             source.ForEachAsync(onNext, CancellationToken.None);
@@ -65,7 +62,7 @@ public ValueTask ForEachAsync(Action<T> onNext) =>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the iteration.</param>
         /// <returns>A task that represents the asynchronous iteration operation. The task completes when the sequence has been
         /// fully processed or the operation is canceled.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
         public async ValueTask ForEachAsync(Action<T> onNext, CancellationToken cancellationToken)
         {
             ArgumentExceptionHelper.ThrowIfNull(onNext);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
index 5067d2f7..a077a8a2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
@@ -10,9 +10,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for creating and manipulating asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable advanced operations on asynchronous observables, such as grouping
-/// elements by key. These extensions are intended for use with types implementing asynchronous observation patterns,
-/// allowing developers to compose and transform streams of data in a reactive manner.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Grouping operators for an observable source sequence.</summary>
@@ -24,10 +21,9 @@ public static partial class SignalAsyncExtensions
         /// <typeparam name="TKey">The type of the key returned by the key selector function. Must be non-nullable.</typeparam>
         /// <param name="keySelector">A function to extract the key for each element in the source sequence.</param>
         /// <returns>An asynchronous observable sequence of grouped observables, each containing elements that share a common key.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="keySelector"/> is null.</exception>
-        /// <remarks>Each group in the resulting sequence corresponds to a unique key produced by the key
-        /// selector. The groups are emitted as soon as their first element is encountered in the source sequence. The
-        /// returned grouped observables can be subscribed to independently.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is <see langword="null"/>.</exception>
+        /// <remarks>A group is emitted when its first element arrives, and each grouped observable can be subscribed
+        /// independently.</remarks>
         public IObservableAsync<GroupedAsyncSignal<TKey, TValue>> GroupBy<TKey>(Func<TValue, TKey> keySelector)
             where TKey : notnull
         {
@@ -50,11 +46,9 @@ public IObservableAsync<GroupedAsyncSignal<TKey, TValue>> GroupBy<TKey>(Func<TVa
         /// within each group.</param>
         /// <returns>An asynchronous observable sequence containing grouped observables, each representing a collection of elements
         /// that share a common key.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="keySelector"/> is null.</exception>
-        /// <remarks>Each group in the resulting sequence is represented by a <see
-        /// cref="GroupedAsyncSignal{TKey, TValue}"/>, which exposes the group's key and an observable sequence of its
-        /// elements. The <paramref name="groupSignalSelector"/> parameter allows customization of the signal used for
-        /// each group, which can affect how elements are buffered or multicast within the group.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is <see langword="null"/>.</exception>
+        /// <remarks>The signal returned by <paramref name="groupSignalSelector"/> decides how a group's elements are
+        /// buffered or multicast to its subscribers.</remarks>
         public IObservableAsync<GroupedAsyncSignal<TKey, TValue>> GroupBy<TKey>(
             Func<TValue, TKey> keySelector,
             Func<TKey, ISignalAsync<TValue>> groupSignalSelector)
@@ -136,7 +130,6 @@ protected override async ValueTask OnNextAsyncCore(TValue value, CancellationTok
                     signal = parent._groupSignalSelector(key);
                     _signalsByKey.Add(key, signal);
 
-                    // We use the cancellationToken passed from the source subscription.
                     await observer.OnNextAsync(
                         new(
                             key,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupedAsyncSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupedAsyncSignal.cs
index 4c26b7d5..598ecbe8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupedAsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupedAsyncSignal.cs
@@ -10,8 +10,6 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Represents an asynchronous observable sequence that is grouped by a specified key.</summary>
 /// <typeparam name="TKey">The type of the key used to group elements in the observable sequence.</typeparam>
 /// <typeparam name="TValue">The type of the elements contained in the grouped observable sequence.</typeparam>
-/// <remarks>Each instance corresponds to a group within the parent observable, identified by its key. Observers
-/// can subscribe to receive elements belonging to the group associated with the specified key.</remarks>
 [System.Diagnostics.DebuggerDisplay("GroupedAsyncSignal: Key = {Key}")]
 public sealed class GroupedAsyncSignal<TKey, TValue> : IObservableAsync<TValue>
 {
@@ -27,7 +25,7 @@ internal GroupedAsyncSignal(
         CancellationToken parentDisposedToken) =>
         State = new(key, signalValues, disposables, parentDisposedToken);
 
-    /// <summary>Gets the key associated with the current object.</summary>
+    /// <summary>Gets the key shared by every element in this group.</summary>
     public TKey Key => State.Key;
 
     /// <summary>Gets the state shared by this grouped observable and its helper operations.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
index 377f838e..9f381fad 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for creating and manipulating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers LINQ-style operators for working with asynchronous observables,
-/// enabling developers to compose, filter, and transform event streams in an asynchronous context. These methods are
-/// designed to integrate with the SignalAsync{T} type, supporting both synchronous and asynchronous predicate
-/// functions for filtering sequences.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Filtering (Keep/Where) operators for an observable source sequence.</summary>
@@ -27,10 +23,8 @@ public static partial class SignalAsyncExtensions
         /// langword="false"/>.</param>
         /// <returns>An observable sequence that emits only those elements for which the predicate returns <see
         /// langword="true"/>.</returns>
-        /// <remarks>The predicate is invoked asynchronously for each element as it is observed. If the
-        /// predicate throws an exception or the ValueTask is faulted, the resulting sequence will propagate the error
-        /// to its observers. The cancellation token provided to the predicate can be used to observe cancellation
-        /// requests during predicate evaluation.</remarks>
+        /// <remarks>An exception thrown by <paramref name="predicate"/>, or a faulted task from it, propagates to the
+        /// observers of the resulting sequence.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Keep(Func<T, CancellationToken, ValueTask<bool>> predicate) =>
             new KeepAsyncSignal<T>(source, predicate);
@@ -43,9 +37,6 @@ public IObservableAsync<T> Keep(Func<T, CancellationToken, ValueTask<bool>> pred
         /// function returns <see langword="true"/>.</param>
         /// <returns>An observable sequence that contains elements from the current sequence that satisfy the specified
         /// predicate.</returns>
-        /// <remarks>The resulting observable emits only those elements for which the <paramref
-        /// name="predicate"/> returns <see langword="true"/>. The order and timing of element emission are preserved
-        /// from the original sequence.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Keep(Func<T, bool> predicate) =>
             new KeepSyncSignal<T>(source, predicate);
@@ -55,6 +46,7 @@ public IObservableAsync<T> Keep(Func<T, bool> predicate) =>
         /// <param name="state">The caller-supplied state passed to the predicate.</param>
         /// <param name="predicate">The predicate that values and the state must satisfy.</param>
         /// <returns>An observable sequence of values that satisfy the predicate.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> KeepWith<TState>(
             TState state,
             Func<TState, T, bool> predicate)
@@ -86,9 +78,8 @@ public IObservableAsync<T> Where(Func<T, bool> predicate) =>
     }
 
     /// <summary>
-    /// Async-predicate variant of <see cref="Keep{T}(IObservableAsync{T}, Func{T,CancellationToken,ValueTask{bool}})"/>.
-    /// Allocates one observable wrapper and one sealed observer per subscription — no per-emission closure or
-    /// state-machine box from the previous <c>Create&lt;T&gt;((observer, token) =&gt; ...)</c> pattern.
+    /// Async-predicate variant of <see cref="Keep{T}(IObservableAsync{T}, Func{T,CancellationToken,ValueTask{bool}})"/>,
+    /// allocating one observer per subscription and nothing per emission.
     /// </summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -145,9 +136,8 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
     }
 
     /// <summary>
-    /// Synchronous-predicate variant of <see cref="Keep{T}(IObservableAsync{T}, Func{T,bool})"/>. Same allocation
-    /// profile as <see cref="KeepAsyncSignal{T}"/> but the per-emission <c>OnNextAsyncCore</c> is sync-completed
-    /// when the predicate rejects, avoiding any state-machine box on rejection.
+    /// Synchronous-predicate variant of <see cref="Keep{T}(IObservableAsync{T}, Func{T,bool})"/>, whose per-emission
+    /// path completes synchronously when the predicate rejects a value.
     /// </summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
index 054f9ce5..3fdaa43f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observables, enabling advanced filtering, transformation, and composition operations. These methods are intended to
-/// be used with types implementing asynchronous observable patterns, such as SignalAsync{T}.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Type-filtering operators for an observable source sequence.</summary>
@@ -23,13 +20,10 @@ public static partial class SignalAsyncExtensions
         /// </summary>
         /// <typeparam name="TResult">The reference type to filter and project elements to. Must be a class.</typeparam>
         /// <returns>An observable sequence containing only the elements of type TResult from the original sequence.</returns>
-        /// <remarks>Elements that are not of type TResult are ignored and not included in the resulting
-        /// sequence. This method is useful for working with observable sequences containing heterogeneous types,
-        /// allowing subscribers to focus on elements of a specific type.</remarks>
         [SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification = "Public extension API — caller specifies TResult explicitly: source.OfType<Derived>().")]
+            Justification = "The caller chooses TResult; no parameter carries it.")]
         public IObservableAsync<TResult> OfType<TResult>()
             where TResult : class
         {
@@ -49,7 +43,7 @@ public IObservableAsync<TResult> OfType<TResult>()
         [SuppressMessage(
             "Design",
             "SST2307:Generic method type parameters should be inferable from the parameters",
-            Justification = "Deliberate lack of type inference.")]
+            Justification = "The caller chooses TResult; no parameter carries it.")]
         public IObservableAsync<TResult> KeepType<TResult>()
             where TResult : class
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/LastAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/LastAsync.cs
index 12931f2e..c3435f6d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/LastAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/LastAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and manipulation of asynchronous observables, such as
-/// retrieving the last element of a sequence. These extensions are designed to support asynchronous and reactive
-/// programming patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Last-element operators for an observable source sequence.</summary>
@@ -22,6 +19,7 @@ public static partial class SignalAsyncExtensions
         /// predicate returns <see langword="true"/>.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the last element that matches
         /// the predicate.</returns>
+        /// <exception cref="InvalidOperationException">The sequence completes without a matching element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> LastAsync(Func<T, bool> predicate) =>
             source.LastAsync(predicate, CancellationToken.None);
@@ -32,6 +30,7 @@ public ValueTask<T> LastAsync(Func<T, bool> predicate) =>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the last element that matches
         /// the predicate.</returns>
+        /// <exception cref="InvalidOperationException">The sequence completes without a matching element.</exception>
         public async ValueTask<T> LastAsync(Func<T, bool> predicate, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -44,9 +43,7 @@ public async ValueTask<T> LastAsync(Func<T, bool> predicate, CancellationToken c
         /// <summary>Asynchronously returns the last element of the sequence.</summary>
         /// <returns>A task that represents the asynchronous operation. The task result contains the last element of the
         /// sequence.</returns>
-        /// <remarks>If the sequence is empty, the behavior depends on the implementation and may result
-        /// in an exception being thrown. The operation is performed asynchronously and may not complete
-        /// immediately.</remarks>
+        /// <exception cref="InvalidOperationException">The sequence completes without producing an element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> LastAsync() =>
             source.LastAsync(CancellationToken.None);
@@ -55,9 +52,7 @@ public ValueTask<T> LastAsync() =>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the last element of the
         /// sequence.</returns>
-        /// <remarks>If the sequence is empty, the behavior depends on the implementation and may result
-        /// in an exception being thrown. The operation is performed asynchronously and may not complete
-        /// immediately.</remarks>
+        /// <exception cref="InvalidOperationException">The sequence completes without producing an element.</exception>
         public async ValueTask<T> LastAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
index d8d3ceb3..5729144a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and retrieving elements from asynchronous observables, such
-/// as obtaining the last element or a default value if no elements are found. These extensions are designed to support
-/// asynchronous and cancellation-aware operations on observable sequences.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Last-or-default operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
index 449aaaff..db561212 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers utility methods that enable manipulation and composition of
-/// asynchronous observables, such as prepending values to a sequence. These methods facilitate common operations when
-/// building reactive, asynchronous workflows.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Prepend (value-prepending) operators for an observable source sequence.</summary>
@@ -39,9 +36,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="values">The collection of values to emit before the original sequence. Cannot be null.</param>
         /// <returns>An observable sequence that emits the specified values first, followed by the items from the current
         /// sequence.</returns>
-        /// <remarks>The values in the provided collection are emitted in order before any items from the
-        /// original sequence. If the sequence is unsubscribed before completion, remaining values may not be
-        /// emitted.</remarks>
+        /// <remarks>Disposing the subscription while <paramref name="values"/> is being emitted drops the
+        /// remainder.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Prepend(IEnumerable<T> values) => new LeadSignal<T>(source, values);
     }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/LongCountAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/LongCountAsync.cs
index 4c588b66..41c4f9aa 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/LongCountAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/LongCountAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable querying and aggregating data from asynchronous observables in a
-/// manner similar to LINQ operators. These extensions are designed to be used with types that implement asynchronous
-/// observable patterns, allowing for efficient and composable asynchronous data processing.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous 64-bit element-counting operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
index ecc68540..4eee32e5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for creating and transforming asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable functional-style operations, such as projection, on asynchronous
-/// observables. These extensions facilitate composing and manipulating streams of data in an asynchronous context,
-/// similar to LINQ operations for synchronous observables.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Projection (Map/Select) operators for an observable source sequence.</summary>
@@ -23,9 +20,8 @@ public static partial class SignalAsyncExtensions
         /// name="TDest"/> asynchronously. The function receives the source element and a cancellation token.</param>
         /// <returns>An observable sequence of type <typeparamref name="TDest"/> containing the results of applying the selector
         /// function to each element of the source sequence.</returns>
-        /// <remarks>The selector function is invoked for each element as it is observed. If the selector
-        /// function throws an exception or returns a faulted task, the error is propagated to the observer. The
-        /// operation supports cancellation via the provided cancellation token.</remarks>
+        /// <remarks>The selector runs for each element as it is observed; a thrown exception or a faulted task is
+        /// propagated to the observer.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<TDest> Map<TDest>(
             Func<T, CancellationToken, ValueTask<TDest>> selector) =>
@@ -36,9 +32,8 @@ public IObservableAsync<TDest> Map<TDest>(
         /// <param name="selector">A function that transforms each element of the source sequence into a new value. Cannot be null.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the selector function on each element of
         /// the source sequence.</returns>
-        /// <remarks>The selector function is applied to each element as it is observed. If the selector
-        /// throws an exception, the error is propagated to the observer. This method does not modify the source
-        /// sequence; it produces a new sequence with transformed elements.</remarks>
+        /// <remarks>The selector runs for each element as it is observed; a thrown exception is propagated to the
+        /// observer.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<TDest> Map<TDest>(
             Func<T, TDest> selector) =>
@@ -78,11 +73,7 @@ public IObservableAsync<TDest> Select<TDest>(
             new MapSyncSignal<T, TDest>(source, selector);
     }
 
-    /// <summary>
-    /// Async-selector variant of <see cref="Map{T,TDest}(IObservableAsync{T}, Func{T,CancellationToken,ValueTask{TDest}})"/>.
-    /// Allocates one observable wrapper and one sealed observer per subscription — no per-emission closure or
-    /// state-machine box from the previous <c>Create&lt;TDest&gt;((observer, token) =&gt; ...)</c> pattern.
-    /// </summary>
+    /// <summary>Applies an asynchronous selector to each source value, allocating one observer per subscription.</summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <typeparam name="TDest">The projected element type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -136,11 +127,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Synchronous-selector variant of <see cref="Map{T,TDest}(IObservableAsync{T}, Func{T,TDest})"/>. Same
-    /// allocation profile as <see cref="MapAsyncSignal{T,TDest}"/> but the per-emission <c>OnNextAsyncCore</c>
-    /// is sync-completed so no state-machine box is allocated when the downstream completes synchronously.
-    /// </summary>
+    /// <summary>Applies a synchronous selector to each source value, forwarding without an await state machine.</summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <typeparam name="TDest">The projected element type.</typeparam>
     /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
index 7d848caf..cf132ebd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
@@ -10,10 +10,6 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides a set of extension methods for creating and managing connectable asynchronous observables using various
 /// Signal types.
 /// </summary>
-/// <remarks>The methods in this class enable advanced multicasting scenarios for asynchronous observables,
-/// allowing multiple subscribers to share a single subscription to the underlying data source. These methods support
-/// different Signal types and configuration options, including stateless and replay behaviors, to accommodate a wide
-/// range of reactive programming patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Multicasting and publishing operators for an observable source sequence.</summary>
@@ -25,10 +21,9 @@ public static partial class SignalAsyncExtensions
         /// Creates a connectable observable sequence that shares a single subscription to the underlying sequence using
         /// the specified Signal.
         /// </summary>
-        /// <param name="signal">The signal used to multicast the elements of the source sequence to multiple observers. Cannot be null.</param>
+        /// <param name="signal">The signal that multicasts the source elements to multiple observers. Cannot be null.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence through the specified signal.</returns>
-        /// <remarks>The returned connectable observable will not begin emitting items until its Connect
-        /// method is called. This allows multiple observers to subscribe before the sequence starts.</remarks>
+        /// <remarks>The source is not subscribed until Connect is called, so observers can subscribe first.</remarks>
         public ConnectableSignalAsync<T> Multicast(ISignalAsync<T> signal) =>
             new(source, signal);
 
@@ -38,10 +33,7 @@ public ConnectableSignalAsync<T> Multicast(ISignalAsync<T> signal) =>
         /// </summary>
         /// <returns>A connectable observable sequence that multicasts notifications to all subscribed observers. The sequence
         /// does not begin emitting items until its Connect method is called.</returns>
-        /// <remarks>Use this method to create a hot observable that allows multiple observers to share a
-        /// single subscription to the source. This is useful for scenarios where you want to avoid multiple
-        /// subscriptions to the source sequence or coordinate the timing of subscriptions. The returned connectable
-        /// observable is asynchronous and supports concurrent observers.</remarks>
+        /// <remarks>Notifications are delivered to observers serially.</remarks>
         public ConnectableSignalAsync<T> Publish() =>
             new(source, new SerialSignalAsync<T>());
 
@@ -49,13 +41,11 @@ public ConnectableSignalAsync<T> Publish() =>
         /// Creates a connectable observable sequence that shares a single subscription to the underlying sequence,
         /// using a Signal created with the specified options.
         /// </summary>
-        /// <param name="options">The options used to configure the Signal that will multicast the source sequence. Cannot be null.</param>
+        /// <param name="options">The options that configure the multicasting signal. Cannot be null.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence using a Signal configured with the
         /// specified options.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> names an unsupported publishing option.</exception>
-        /// <remarks>The returned connectable observable does not begin emitting items until its Connect
-        /// method is called. Use this method to control when the subscription to the source sequence starts and to
-        /// share the subscription among multiple observers.</remarks>
+        /// <remarks>The source is not subscribed until Connect is called.</remarks>
         public ConnectableSignalAsync<T> Publish(SignalCreationOptions options) =>
             new(source, options switch
             {
@@ -77,9 +67,8 @@ public ConnectableSignalAsync<T> Publish(SignalCreationOptions options) =>
         /// <param name="initialValue">The initial value to be emitted to subscribers before any values are emitted by the source sequence.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence and replays the latest value, starting
         /// with the specified initial value.</returns>
-        /// <remarks>Subscribers will immediately receive the initial value upon subscription, followed by
-        /// subsequent values from the source sequence. The returned connectable observable does not begin emitting
-        /// values until its Connect method is called.</remarks>
+        /// <remarks>A subscriber receives the latest value — the initial value until the source publishes one — and the
+        /// source is not subscribed until Connect is called.</remarks>
         public ConnectableSignalAsync<T> Publish(T initialValue) =>
             new(source, new SerialReplayLatestSignalAsync<T>(new(initialValue)));
 
@@ -88,13 +77,12 @@ public ConnectableSignalAsync<T> Publish(T initialValue) =>
         /// starts with the specified initial value.
         /// </summary>
         /// <param name="initialValue">The initial value to be emitted to subscribers before any items are emitted by the source sequence.</param>
-        /// <param name="options">The options used to configure the behavior of the underlying behavior Signal.</param>
+        /// <param name="options">The options that configure the underlying behavior signal.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence and emits the specified initial value
         /// to new subscribers.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> names an unsupported publishing option.</exception>
-        /// <remarks>The returned connectable observable will not begin emitting items from the source
-        /// sequence until its Connect method is called. Subscribers will immediately receive the most recent value,
-        /// starting with the specified initial value, upon subscription.</remarks>
+        /// <remarks>A subscriber receives the latest value — the initial value until the source publishes one — and the
+        /// source is not subscribed until Connect is called.</remarks>
         public ConnectableSignalAsync<T> Publish(T initialValue, BehaviorSignalCreationOptions options) =>
             new(source, options switch
             {
@@ -118,9 +106,7 @@ public ConnectableSignalAsync<T> Publish(T initialValue, BehaviorSignalCreationO
         /// </summary>
         /// <returns>A connectable observable sequence that multicasts notifications from the source without retaining state
         /// between subscribers.</returns>
-        /// <remarks>Use this method when you want to share a single subscription to the source among
-        /// multiple observers, but do not require the observable to cache or replay any items for new subscribers. Each
-        /// connection to the returned observable is independent and does not affect subsequent connections.</remarks>
+        /// <remarks>Each connection is independent of the ones around it, and no value is cached for late subscribers.</remarks>
         public ConnectableSignalAsync<T> StatelessPublish() =>
             new(source, new SerialStatelessSignalAsync<T>());
 
@@ -131,20 +117,15 @@ public ConnectableSignalAsync<T> StatelessPublish() =>
         /// <param name="initialValue">The initial value to be emitted to subscribers before any values are published by the source sequence.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence and replays the latest value, starting
         /// with the specified initial value.</returns>
-        /// <remarks>The returned observable does not maintain any state between connections. Each
-        /// connection starts with the provided initial value and only replays the most recent value published during
-        /// that connection. This is useful for scenarios where late subscribers should always receive the latest value,
-        /// even if they subscribe after the source has started emitting.</remarks>
+        /// <remarks>Each connection starts from the initial value and replays only the most recent value published
+        /// during that connection; nothing is retained between connections.</remarks>
         public ConnectableSignalAsync<T> StatelessPublish(T initialValue) =>
             new(source, new SerialStatelessReplayLatestSignalAsync<T>(new(initialValue)));
 
         /// <summary>Creates a connectable observable sequence that replays only the most recent item to new subscribers.</summary>
         /// <returns>A connectable observable sequence that publishes the latest item to current and future subscribers until a
         /// new item is emitted.</returns>
-        /// <remarks>This method enables late subscribers to immediately receive the most recently
-        /// published value, followed by subsequent values. The returned sequence does not replay earlier items beyond
-        /// the latest one. Use this method when you want all subscribers to observe the most recent value, regardless
-        /// of when they subscribe.</remarks>
+        /// <remarks>A late subscriber receives the most recent value on subscription; earlier values are not replayed.</remarks>
         public ConnectableSignalAsync<T> ReplayLatestPublish() =>
             new(source, new SerialReplayLatestSignalAsync<T>(Optional<T>.Empty));
 
@@ -152,14 +133,12 @@ public ConnectableSignalAsync<T> ReplayLatestPublish() =>
         /// Creates a connectable observable sequence that replays only the latest published value to new subscribers,
         /// using the specified replay Signal creation options.
         /// </summary>
-        /// <param name="options">The options used to configure the replay Signal, such as buffer size, scheduler, or other replay behavior
-        /// settings.</param>
+        /// <param name="options">The options that configure the replay signal.</param>
         /// <returns>A connectable observable sequence that replays the most recent value to each new subscriber after
         /// connection.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> names an unsupported publishing option.</exception>
-        /// <remarks>Use this method when you want late subscribers to receive only the most recently
-        /// published value, rather than the entire sequence or a fixed buffer. The returned connectable observable does
-        /// not begin emitting items until its Connect method is called.</remarks>
+        /// <remarks>A late subscriber receives the most recent value only, and the source is not subscribed until
+        /// Connect is called.</remarks>
         public ConnectableSignalAsync<T> ReplayLatestPublish(ReplayLatestSignalCreationOptions options) =>
             new(source, options switch
             {
@@ -183,10 +162,8 @@ public ConnectableSignalAsync<T> ReplayLatestPublish(ReplayLatestSignalCreationO
         /// </summary>
         /// <returns>A connectable observable sequence that replays the most recent item to new subscribers and multicasts
         /// notifications to all current subscribers.</returns>
-        /// <remarks>This method is stateless; each call returns a new connectable observable. Subscribers
-        /// that connect after an item has been published will immediately receive the latest item. This is useful for
-        /// scenarios where late subscribers should catch up with the most recent value without receiving the full
-        /// history.</remarks>
+        /// <remarks>Each connection replays only the most recent value published during that connection; nothing is
+        /// retained between connections.</remarks>
         public ConnectableSignalAsync<T> StatelessReplayLatestPublish() =>
             new(source, new SerialStatelessReplayLatestSignalAsync<T>(Optional<T>.Empty));
     }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/OnDispose.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/OnDispose.cs
index 7f3e3440..67ed6a73 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/OnDispose.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/OnDispose.cs
@@ -5,10 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for composing and managing asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers utility methods for working with asynchronous observables, enabling
-/// additional behaviors such as resource cleanup or side-effect handling when subscriptions are disposed. These methods
-/// are intended to simplify the creation and management of custom observable pipelines in asynchronous programming
-/// scenarios.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Disposal-callback operators that run an action when the observable source subscription is disposed.</summary>
@@ -20,9 +16,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="disposeAction">A function that returns a ValueTask representing the asynchronous operation to execute upon disposal of the
         /// observable sequence. Cannot be null.</param>
         /// <returns>An SignalAsync{T} that invokes the specified asynchronous callback when disposed.</returns>
-        /// <remarks>Use this method to perform custom asynchronous cleanup or resource release logic when
-        /// the observable sequence is disposed. The callback is invoked when the subscription is disposed, either
-        /// explicitly or when the observer completes or errors.</remarks>
+        /// <remarks>The callback runs when the subscription is disposed, whether explicitly or through completion or
+        /// error.</remarks>
         public IObservableAsync<T> OnDispose(Func<ValueTask> disposeAction)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -34,9 +29,8 @@ public IObservableAsync<T> OnDispose(Func<ValueTask> disposeAction)
         /// <summary>Registers an action to be invoked when the observable sequence is disposed.</summary>
         /// <param name="disposeAction">The action to execute when the subscription is disposed. Cannot be null.</param>
         /// <returns>An observable sequence that invokes the specified action upon disposal of the subscription.</returns>
-        /// <remarks>Use this method to perform cleanup or resource release logic when a subscription to
-        /// the observable is disposed. The specified action is called synchronously during disposal. If multiple
-        /// actions are registered through chained calls, each will be invoked in the order registered.</remarks>
+        /// <remarks>The action runs synchronously during disposal; chained registrations run in the order they were
+        /// added.</remarks>
         public IObservableAsync<T> OnDispose(Action disposeAction)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -46,7 +40,7 @@ public IObservableAsync<T> OnDispose(Action disposeAction)
         }
     }
 
-    /// <summary>Wraps a source observable with an async-action <c>OnDispose</c> observer without the prior <c>Create&lt;T&gt;</c> wrapper layer.</summary>
+    /// <summary>Wraps a source observable with an observer that awaits a callback when the subscription is disposed.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="disposeAction">The async dispose action.</param>
@@ -62,7 +56,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         }
     }
 
-    /// <summary>Wraps a source observable with a sync-action <c>OnDispose</c> observer without the prior <c>Create&lt;T&gt;</c> wrapper layer.</summary>
+    /// <summary>Wraps a source observable with an observer that runs an action when the subscription is disposed.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="disposeAction">The sync dispose action.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/OnErrorResumeAsFailure.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/OnErrorResumeAsFailure.cs
index a5a1d6fa..658c5ff1 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/OnErrorResumeAsFailure.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/OnErrorResumeAsFailure.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observables, enabling advanced composition and error handling scenarios. These methods are intended to be used with
-/// types that implement asynchronous push-based notification patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Error-handling operators that convert source errors into failure completion results for an observable source sequence.</summary>
@@ -23,9 +20,8 @@ public static partial class SignalAsyncExtensions
         /// </summary>
         /// <returns>An observable sequence that emits the same elements as the source, but represents errors as failure results
         /// instead of throwing exceptions.</returns>
-        /// <remarks>This method enables error handling by transforming exceptions into failure notifications
-        /// within the sequence, rather than terminating the sequence with an error. Consumers can inspect the result to
-        /// determine whether an operation succeeded or failed.</remarks>
+        /// <remarks>The completion result carries the error, so an observer inspects that result to tell success from
+        /// failure.</remarks>
         public IObservableAsync<T> OnErrorResumeAsFailure()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
index 934ba9bb..ff73bfff 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
@@ -8,8 +8,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Zip extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Zip combines elements from two observable sequences pair-wise. The nth element from
-/// each source is paired together. The resulting sequence completes when either source completes.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Pair/Zip operators for a first observable source sequence.</summary>
@@ -25,6 +23,8 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence whose elements are the result of pair-wise combining the source
         /// elements using the result selector.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if any argument is null.</exception>
+        /// <remarks>The nth element of one source is paired with the nth element of the other, so an element waits until
+        /// its partner arrives. The result completes when either source completes with no pending pair.</remarks>
         public IObservableAsync<TResult> Pair<T2, TResult>(
             IObservableAsync<T2> second,
             Func<T1, T2, TResult> resultSelector)
@@ -37,20 +37,13 @@ public IObservableAsync<TResult> Pair<T2, TResult>(
         }
     }
 
-    /// <summary>
-    /// Represents an observable sequence that combines the latest values from two asynchronous observable sequences
-    /// into a single result sequence using a specified selector function.
-    /// </summary>
+    /// <summary>Pairs elements of two sources in arrival order and projects each pair through a selector.</summary>
     /// <typeparam name="T1">The type of the elements in the first source sequence.</typeparam>
     /// <typeparam name="T2">The type of the elements in the second source sequence.</typeparam>
     /// <typeparam name="TResult">The type of the elements in the resulting sequence produced by the selector function.</typeparam>
     /// <param name="first">The first asynchronous observable sequence to combine.</param>
     /// <param name="second">The second asynchronous observable sequence to combine.</param>
     /// <param name="resultSelector">A function that specifies how to combine elements from the first and second sequences into a result element.</param>
-    /// <remarks>The resulting sequence produces a value each time both source sequences have produced an
-    /// element, pairing elements in the order they are received. The sequence completes when either source sequence
-    /// completes and there are no more pairs to combine. If either source sequence signals an error, the resulting
-    /// sequence will propagate that error.</remarks>
     internal sealed class ZipSignal<T1, T2, TResult>(
         IObservableAsync<T1> first,
         IObservableAsync<T2> second,
@@ -80,7 +73,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TResult>.SubscribeAsync(
 
         /// <summary>Shared state that coordinates pair-wise combination of elements from both source sequences.</summary>
         /// <param name="observer">The downstream observer to forward combined results to.</param>
-        /// <param name="resultSelector">The function used to combine paired elements.</param>
+        /// <param name="resultSelector">The function that combines paired elements.</param>
         internal sealed class ZipState(
             IObserverAsync<TResult> observer,
             Func<T1, T2, TResult> resultSelector) : IAsyncDisposable
@@ -251,11 +244,7 @@ internal async ValueTask OnCompleted2Async(Result result)
             internal ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken) =>
                 observer.OnErrorResumeAsync(error, cancellationToken);
 
-            /// <summary>
-            /// Links the original subscribe-time cancellation token into this state's dispose chain so
-            /// later per-emission methods can rely on <see cref="_disposeCts"/> instead of allocating
-            /// a per-emission linked CTS.
-            /// </summary>
+            /// <summary>Routes cancellation of the subscribe-time token into <see cref="_disposeCts"/>, so per-emission code needs no linked source.</summary>
             /// <param name="external">The subscribe-time token.</param>
             internal void LinkExternalCancellation(CancellationToken external)
             {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
index 8445b1de..4f062322 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
@@ -7,11 +7,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Fused filter / projection observables that back the parity-helper extension methods in <see cref="SignalAsyncExtensions"/>.</summary>
 public static partial class SignalAsyncExtensions
 {
-    /// <summary>
-    /// Fuses the previous <c>Create&lt;(T, T)&gt;</c> + closure-based <c>Pairwise</c> implementation
-    /// into a single <see cref="WitnessAsync{T}"/> layer; per-subscription state is held in fields
-    /// instead of a captured closure, eliminating the per-emission async-lambda state-machine box.
-    /// </summary>
+    /// <summary>Emits each adjacent pair of source values, holding the prior value in a field rather than a closure.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     internal sealed class PairwiseSignal<T>(IObservableAsync<T> source) : IObservableAsync<(T Previous, T Current)>
@@ -40,7 +36,7 @@ internal sealed class PairwiseWitness(
             IObserverAsync<(T Previous, T Current)> downstream,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>The previously-seen value; valid only when <see cref="_hasPrevious"/> is set.</summary>
+            /// <summary>The last value seen; valid only when <see cref="_hasPrevious"/> is set.</summary>
             private T? _previous;
 
             /// <summary>Latches to <see langword="true"/> after the first upstream emission.</summary>
@@ -71,12 +67,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Combined skip-then-cast observable that fuses the previous
-    /// <c>SkipWhile(value is null).Select(value!)</c> composition into a single
-    /// <see cref="WitnessAsync{T}"/> layer. Once a non-null value has been seen the gate latches
-    /// off and the operator becomes a transparent null-stripping forwarder.
-    /// </summary>
+    /// <summary>Skips values until the first non-null one arrives, then forwards every later value as non-nullable.</summary>
     /// <typeparam name="T">The non-nullable element type seen downstream.</typeparam>
     /// <param name="source">The nullable source observable.</param>
     internal sealed class SkipWhileNullSignal<T>(IObservableAsync<T?> source) : IObservableAsync<T>
@@ -135,12 +126,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Combined filter-and-cast observable that fuses the previous <c>Where(value is not null).Select(value!)</c>
-    /// composition into a single <see cref="WitnessAsync{T}"/> layer. Halves the per-emission observer-chain
-    /// cost (one TryEnter / Exit, one set of chain-aware-cancellation wiring) for what is fundamentally a
-    /// null-stripping projection over a single source.
-    /// </summary>
+    /// <summary>Forwards the non-null source values as non-nullable through a single observer layer.</summary>
     /// <typeparam name="T">The non-nullable element type seen downstream.</typeparam>
     /// <param name="source">The nullable source observable.</param>
     internal sealed class WhereIsNotNullSignal<T>(IObservableAsync<T?> source) : IObservableAsync<T>
@@ -188,13 +174,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Combined seed-and-distinct observable that fuses the previous
-    /// <c>StartWith(seed).DistinctUntilChanged()</c> composition into a single
-    /// <see cref="WitnessAsync{T}"/> layer. The seed is emitted on subscribe and tracked as the
-    /// initial "last value"; source emissions that compare equal under
-    /// <see cref="EqualityComparer{T}"/> are swallowed.
-    /// </summary>
+    /// <summary>Emits the seed on subscribe, then forwards only the source values that differ from the last emission.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="defaultValue">The seed value emitted on subscribe.</param>
@@ -221,14 +201,14 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
 
         /// <summary>Per-subscription observer that swallows values equal to the most-recently-forwarded one.</summary>
         /// <param name="downstream">The downstream observer.</param>
-        /// <param name="seed">The seed value already emitted during subscription; treated as the initial "last forwarded value".</param>
+        /// <param name="seed">The seed value emitted during subscription, which becomes the initial last-forwarded value.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token, linked into the dispose chain.</param>
         internal sealed class LatestOrDefaultWitness(
             IObserverAsync<T> downstream,
             T seed,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>Equality comparer used for the distinct check; matches DistinctUntilChanged's default.</summary>
+            /// <summary>The equality comparer for the distinct check.</summary>
             private static readonly EqualityComparer<T> Comparer = EqualityComparer<T>.Default;
 
             /// <summary>The most-recently-forwarded value; seeded by the constructor.</summary>
@@ -256,13 +236,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Combined filter-and-take-one observable that fuses the previous
-    /// <c>Where(predicate).Take(1)</c> composition into a single <see cref="WitnessAsync{T}"/>
-    /// layer. The first emission matching the predicate is forwarded, completion is signalled
-    /// downstream, and the source subscription is disposed via the base observer's
-    /// dispose-cascade.
-    /// </summary>
+    /// <summary>Forwards the first value matching the predicate, then completes and tears down the source subscription.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="predicate">The predicate matched against each value.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
index 900f304f..1c1dea53 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
@@ -7,11 +7,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Fused operator observables backing the parity-helper extension methods in <see cref="SignalAsyncExtensions"/>.</summary>
 public static partial class SignalAsyncExtensions
 {
-    /// <summary>
-    /// Fuses <c>Return(initial).Concat(source.Scan(initial, accumulator))</c> into a single layer.
-    /// The seed is emitted on subscribe and tracked as the initial accumulator; each upstream
-    /// emission updates the accumulator and forwards the new value.
-    /// </summary>
+    /// <summary>Emits the initial accumulator on subscribe, then folds each source value into it and forwards the result.</summary>
     /// <typeparam name="TSource">The upstream element type.</typeparam>
     /// <typeparam name="TAccumulate">The accumulator type.</typeparam>
     /// <param name="source">The upstream observable.</param>
@@ -43,7 +39,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TAccumulate>.SubscribeAsync(
 
         /// <summary>Per-subscription accumulator observer.</summary>
         /// <param name="downstream">The downstream observer.</param>
-        /// <param name="seed">The seed accumulator value already emitted during subscription.</param>
+        /// <param name="seed">The seed accumulator value emitted during subscription.</param>
         /// <param name="accumulator">The synchronous accumulator.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token.</param>
         internal sealed class ScanWithInitialWitness(
@@ -104,7 +100,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TAccumulate>.SubscribeAsync(
 
         /// <summary>Per-subscription async accumulator observer.</summary>
         /// <param name="downstream">The downstream observer.</param>
-        /// <param name="seed">The seed accumulator value already emitted during subscription.</param>
+        /// <param name="seed">The seed accumulator value emitted during subscription.</param>
         /// <param name="accumulator">The asynchronous accumulator.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token.</param>
         internal sealed class ScanWithInitialAsyncWitness(
@@ -151,16 +147,12 @@ private async ValueTask AwaitAndForwardAsync(
         }
     }
 
-    /// <summary>
-    /// Fuses <c>DistinctUntilChanged().Throttle(window).DistinctUntilChanged()</c> into a single
-    /// observer that tracks upstream-distinct, debounce-timer supersession, and downstream-distinct
-    /// state. Supersession follows the same id-based pattern used by <c>ThrottleSignal</c>: a
-    /// superseded delay still runs but its result is discarded.
-    /// </summary>
+    /// <summary>Drops upstream duplicates, debounces each value, and suppresses duplicates again before forwarding.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="dueTime">The debounce window.</param>
-    /// <param name="timeProvider">The time provider used for the debounce timer.</param>
+    /// <param name="timeProvider">The time provider for the debounce timer.</param>
+    /// <remarks>A superseded delay is not cancelled: it runs to completion and its result is dropped by the id check.</remarks>
     internal sealed class ThrottleDistinctSignal<T>(
         IObservableAsync<T> source,
         TimeSpan dueTime,
@@ -212,18 +204,14 @@ internal sealed class ThrottleDistinctWitness(
             /// <summary>Set to <see langword="true"/> after the first value has been forwarded downstream.</summary>
             private bool _hasEmitted;
 
-            /// <summary>Monotonically increasing identifier used to detect supersession.</summary>
+            /// <summary>Monotonically increasing identifier stamped on each pending delay; a mismatch marks it superseded.</summary>
             private long _id;
 
-            /// <summary>Post-delay decision: latches the emission if the id is still current and
-            /// the value differs from the most-recently-emitted one. Extracted as an
-            /// <see langword="internal"/> method so the decision is unit-testable directly
-            /// without racing the delay timer in tests.</summary>
+            /// <summary>Claims the emission when the stamped id is current and the value differs from the last forwarded one.</summary>
             /// <param name="value">The candidate value.</param>
             /// <param name="id">The id stamped when this delay was started.</param>
-            /// <returns><see langword="true"/> if the caller should forward the value
-            /// downstream; <see langword="false"/> if the emission was superseded or is a
-            /// duplicate of the most-recently-forwarded value.</returns>
+            /// <returns><see langword="true"/> when the caller should forward the value; <see langword="false"/> when it
+            /// was superseded or duplicates the last forwarded value.</returns>
             internal bool TryClaimEmission(T value, long id)
             {
                 lock (_gate)
@@ -297,11 +285,7 @@ protected override ValueTask DisposeAsyncCore()
                 return base.DisposeAsyncCore();
             }
 
-            /// <summary>Waits the debounce window, then forwards the value if
-            /// <see cref="TryClaimEmission"/> approves it. The single catch routes everything
-            /// through <see cref="UnhandledExceptionHandler.ReportUnhandledException"/>, which
-            /// already filters out <see cref="OperationCanceledException"/> internally —
-            /// so a separate OCE-only catch would just duplicate the same silent-drop behavior.</summary>
+            /// <summary>Waits the debounce window, then forwards the value when <see cref="TryClaimEmission"/> approves it.</summary>
             /// <param name="value">The candidate value.</param>
             /// <param name="id">The id stamped when this delay was started.</param>
             /// <param name="cancellationToken">The cancellation token.</param>
@@ -321,17 +305,14 @@ private async Task FireAfterDelayAsync(T value, long id, CancellationToken cance
                 }
                 catch (Exception e)
                 {
+                    // ReportUnhandledException drops cancellation itself, so no separate catch for it.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
         }
     }
 
-    /// <summary>
-    /// Fuses the <c>DropIfBusy</c> closure-based pipeline into a single observer layer.
-    /// Synchronously-completing async actions and downstream emissions take a zero-state-machine
-    /// fast path; only when the inner action genuinely suspends does the slow path run.
-    /// </summary>
+    /// <summary>Runs the action for one value at a time and drops the values that arrive while it is running.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="asyncAction">The async side-effect invoked for accepted values.</param>
@@ -356,7 +337,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return sink;
         }
 
-        /// <summary>Per-subscription witness that drops upstream emissions while a prior action is still pending.</summary>
+        /// <summary>Per-subscription witness that drops upstream emissions while a prior action is pending.</summary>
         /// <param name="downstream">The downstream observer.</param>
         /// <param name="asyncAction">The async side-effect invoked for accepted values.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token, linked into the dispose chain.</param>
@@ -445,18 +426,14 @@ private async ValueTask AwaitFullAsync(ValueTask actionTask, T value, Cancellati
         }
     }
 
-    /// <summary>
-    /// Fuses <c>Select(condition ? Return(value) : Return(value).Delay(...)).Switch()</c> into a
-    /// single observer layer. Bypass-true values flow through with zero allocation; bypass-false
-    /// values schedule a fire-and-forget delay with id-based supersession (the same pattern
-    /// <see cref="ThrottleDistinctSignal{T}"/> uses) so the previous pending delay is
-    /// effectively cancelled on every new upstream value.
-    /// </summary>
+    /// <summary>Forwards a value at once when the condition holds, otherwise after the debounce window elapses.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="debounce">The debounce window applied to bypass-false values.</param>
     /// <param name="condition">When <see langword="true"/> the value bypasses the delay and is forwarded immediately.</param>
-    /// <param name="timeProvider">The time provider used for the debounce timer.</param>
+    /// <param name="timeProvider">The time provider for the debounce timer.</param>
+    /// <remarks>Each new upstream value supersedes a pending delay, which is not cancelled: it runs to completion and its
+    /// result is dropped by the id check.</remarks>
     internal sealed class DebounceUntilSignal<T>(
         IObservableAsync<T> source,
         TimeSpan debounce,
@@ -496,16 +473,13 @@ internal sealed class DebounceUntilWitness(
             /// <summary>Synchronization gate protecting the id counter.</summary>
             private readonly Lock _gate = new();
 
-            /// <summary>Monotonically increasing identifier used to detect supersession of pending delays.</summary>
+            /// <summary>Monotonically increasing identifier stamped on each pending delay; a newer value supersedes the old id.</summary>
             private long _id;
 
-            /// <summary>Post-delay supersession check. Extracted as an <see langword="internal"/>
-            /// method so tests can verify the supersession decision directly without racing the
-            /// delay timer.</summary>
+            /// <summary>Reports whether the stamped id is the current one, so no newer value has superseded this delay.</summary>
             /// <param name="id">The id stamped when this delay was started.</param>
-            /// <returns><see langword="true"/> if the caller should forward the value
-            /// downstream; <see langword="false"/> if the emission was superseded by a newer
-            /// upstream value.</returns>
+            /// <returns><see langword="true"/> when the caller should forward the value; <see langword="false"/> when a
+            /// newer upstream value superseded it.</returns>
             internal bool IsCurrentEmission(long id)
             {
                 lock (_gate)
@@ -571,11 +545,7 @@ protected override ValueTask DisposeAsyncCore()
                 return base.DisposeAsyncCore();
             }
 
-            /// <summary>Waits the debounce window, then forwards the value if
-            /// <see cref="IsCurrentEmission"/> confirms the emission was not superseded.
-            /// The single catch routes everything through
-            /// <see cref="UnhandledExceptionHandler.ReportUnhandledException"/>, which already
-            /// filters out <see cref="OperationCanceledException"/> internally.</summary>
+            /// <summary>Waits the debounce window, then forwards the value when <see cref="IsCurrentEmission"/> confirms it.</summary>
             /// <param name="value">The candidate value.</param>
             /// <param name="id">The id stamped when this delay was started.</param>
             /// <param name="cancellationToken">The cancellation token.</param>
@@ -595,19 +565,14 @@ private async Task DelayAndEmitAsync(T value, long id, CancellationToken cancell
                 }
                 catch (Exception e)
                 {
+                    // ReportUnhandledException drops cancellation itself, so no separate catch for it.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
         }
     }
 
-    /// <summary>
-    /// Fuses <c>source.SelectMany(values =&gt; values.ToAsyncSignal())</c> into a single
-    /// observer that iterates the inner enumerable inline and forwards each element. Avoids the
-    /// <c>SelectMany</c>+<c>ToAsyncSignal</c> per-emission machinery; arrays and
-    /// <see cref="IReadOnlyList{T}"/> snapshots are walked with an indexed <c>for</c> loop to
-    /// dodge the enumerator-box allocation entirely.
-    /// </summary>
+    /// <summary>Forwards every element of each enumerable the source emits, walking arrays and lists by index.</summary>
     /// <typeparam name="T">The flattened element type.</typeparam>
     /// <param name="source">The upstream observable of <see cref="IEnumerable{T}"/> snapshots.</param>
     internal sealed class ForEachEnumerableSignal<T>(IObservableAsync<IEnumerable<T>> source) : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
index 0e76ef92..e6db6101 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
@@ -8,20 +8,13 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// The shared upstream coordinator backing the <c>Partition</c> parity helper. It lives apart from the
-/// other fused operators because it is the only one that fans a single subscription out to two
-/// observables, so its state is a branch table rather than a per-subscription witness.
-/// </summary>
+/// <summary>Provides the shared upstream coordinator backing the <c>Partition</c> parity helper.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>
-    /// Coordinates the shared upstream subscription and the two branch observables produced by
-    /// <c>Partition</c>. Maintains a single source subscription that is started when the first
-    /// branch subscribes and torn down when the last branch disposes. Each upstream emission
-    /// evaluates the predicate exactly once and dispatches to the branch observer (if any)
-    /// subscribed at that moment — no <c>Publish</c>/<c>RefCount</c>/intermediate-signal
-    /// allocations on the per-emission path.
+    /// Shares one upstream subscription between the two <c>Partition</c> branches, starting it when the first branch
+    /// subscribes and tearing it down when the last one disposes. Each emission dispatches to whichever branch observer
+    /// the predicate selects, or to nothing when that branch has no subscriber.
     /// </summary>
     /// <typeparam name="T">The element type partitioned across the two branches.</typeparam>
     internal sealed class PartitionCoordinator<T>
@@ -112,14 +105,10 @@ internal async ValueTask<IAsyncDisposable> SubscribeBranchAsync(
             return new BranchSubscription(this, isTrueBranch);
         }
 
-        /// <summary>Attempts to attach an in-flight upstream subscription to the coordinator.
-        /// Extracted as an <see langword="internal"/> method so the both-branches-gone race
-        /// (the subscribe completes after every branch has already disposed) can be tested
-        /// directly without racing the subscription pipeline.</summary>
+        /// <summary>Attaches an in-flight upstream subscription unless both branches have gone away first.</summary>
         /// <param name="subscription">The freshly-created upstream subscription.</param>
-        /// <returns><see langword="true"/> if the subscription was attached and the caller
-        /// should leave it running; <see langword="false"/> if both branches are gone and the
-        /// caller should dispose the subscription.</returns>
+        /// <returns><see langword="true"/> when the subscription was attached and the caller should leave it running;
+        /// <see langword="false"/> when both branches are gone and the caller should dispose it.</returns>
         internal bool TryAttachSourceSubscription(IAsyncDisposable subscription)
         {
             lock (_gate)
@@ -134,11 +123,7 @@ internal bool TryAttachSourceSubscription(IAsyncDisposable subscription)
             }
         }
 
-        /// <summary>Attempts to attach the just-created upstream subscription and disposes it if
-        /// both branches have raced ahead and already disposed. The dispose branch is only
-        /// reachable under genuine concurrent disposal during in-flight subscribe, so the entire
-        /// helper is isolated and excluded from coverage; <see cref="TryAttachSourceSubscription"/>
-        /// itself is covered by direct unit tests.</summary>
+        /// <summary>Attaches the new upstream subscription, disposing it when both branches disposed during the subscribe.</summary>
         /// <param name="subscription">The freshly-created upstream subscription.</param>
         /// <returns>A task that completes once the subscription has been attached or disposed.</returns>
         [ExcludeFromCodeCoverage]
@@ -258,8 +243,7 @@ internal sealed class PartitionBranchSignal(bool isTrueBranch) : IObservableAsyn
             ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
                 IObserverAsync<T> observer,
                 CancellationToken cancellationToken) =>
-                // The PartitionBranchSignal is created by the coordinator's constructor; the
-                // coordinator field is filled in below.
+                // The coordinator's constructor sets Coordinator on both branches, so it is never null here.
                 Coordinator.SubscribeBranchAsync(isTrueBranch, observer, cancellationToken);
         }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Start.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Start.cs
index 6875ede0..cbfca686 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Start.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Start.cs
@@ -5,9 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides static methods for creating and manipulating asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class offers factory methods and utilities for working with asynchronous
-/// observables, enabling reactive programming patterns with support for asynchronous event streams. Members of this
-/// class are thread-safe and designed for use in concurrent environments.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that executes the supplied function and emits its result.</summary>
@@ -24,7 +21,7 @@ public static IObservableAsync<TResult> Start<TResult>(Func<TResult> function)
     /// <summary>Creates an observable sequence that executes the supplied function and emits its result.</summary>
     /// <typeparam name="TResult">The result type.</typeparam>
     /// <param name="function">The function to execute.</param>
-    /// <param name="taskScheduler">An optional scheduler used to start the function.</param>
+    /// <param name="taskScheduler">An optional scheduler that runs the function.</param>
     /// <returns>An observable sequence that emits the function result and then completes.</returns>
     public static IObservableAsync<TResult> Start<TResult>(Func<TResult> function, TaskScheduler? taskScheduler)
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
index 876d7157..3ca19c7c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
@@ -7,16 +7,11 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides async-native counterparts for high-value helper operators exposed by the synchronous reactive surface in
-/// this repository.
-/// </summary>
-/// <remarks>These members intentionally compose existing async operators from this namespace so parity is achieved via
-/// the library's own async primitives instead of by delegating to System.Reactive implementations.</remarks>
+/// <summary>Provides async-native counterparts for the helper operators on the synchronous reactive surface.</summary>
 [SuppressMessage(
     "StyleCop.CSharp.OrderingRules",
     "SA1201:ElementsShouldAppearInTheCorrectOrder",
-    Justification = "C# 14 extension methods")]
+    Justification = "Extension blocks group members by receiver rather than by element kind.")]
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Aggregation parity helper operators for a sequence of boolean observable source sequences.</summary>
@@ -175,7 +170,7 @@ public IObservableAsync<T> DoOnSubscribe(Func<CancellationToken, ValueTask> acti
             return new DoOnSubscribeAsyncSignal<T>(source, action);
         }
 
-        /// <summary>Drops source values while the previous asynchronous action is still running.</summary>
+        /// <summary>Drops source values that arrive while the previous asynchronous action runs.</summary>
         /// <param name="asyncAction">The asynchronous action to execute for accepted values.</param>
         /// <returns>A sequence that emits only values that were accepted while the operator was idle.</returns>
         public IObservableAsync<T> DropIfBusy(Func<T, CancellationToken, ValueTask> asyncAction)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Reattempt.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Reattempt.cs
index 5c3b2e70..6de70feb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Reattempt.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Reattempt.cs
@@ -5,8 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Retry extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Retry re-subscribes to the source sequence upon failure, enabling automatic recovery
-/// from transient errors. An optional retry count limits the number of re-subscription attempts.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Retry operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
index 2323c1ce..dcd5f9fe 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for composing and handling asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable advanced error handling and composition scenarios for asynchronous
-/// observables. These extensions are intended to be used with the SignalAsync{T} type to facilitate robust,
-/// composable, and resilient asynchronous data streams.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Error-handling operators for an observable source sequence.</summary>
@@ -26,10 +23,7 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence that emits items from the source sequence, or from the handler-provided sequence if
         /// an exception is encountered.</returns>
         /// <exception cref="ArgumentNullException">Thrown if the source sequence or <paramref name="handler"/> is null.</exception>
-        /// <remarks>Use this method to recover from errors in the source sequence by switching to an
-        /// alternative observable sequence. The handler function is called with the exception, allowing custom error
-        /// recovery logic. If the handler itself throws an exception, the resulting sequence completes with that
-        /// exception.</remarks>
+        /// <remarks>If the handler throws, the resulting sequence completes with that exception.</remarks>
         public IObservableAsync<T> Recover(Func<Exception, IObservableAsync<T>> handler)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -56,9 +50,8 @@ public IObservableAsync<T> Resume(IObservableAsync<T> fallback)
         /// an error occurs.</param>
         /// <returns>An observable sequence that resumes with the sequence returned by the handler when an error is encountered,
         /// and ignores the error after handling.</returns>
-        /// <remarks>If an error occurs and the handler is invoked, the error is also reported to the
-        /// global unhandled exception handler before being ignored. This method allows the sequence to continue without
-        /// propagating the error to subscribers.</remarks>
+        /// <remarks>An error-resume notification is reported to the global unhandled-exception handler rather than
+        /// forwarded downstream, so subscribers never observe it.</remarks>
         public IObservableAsync<T> CatchAndIgnoreErrorResume(Func<Exception, IObservableAsync<T>> handler)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -75,11 +68,7 @@ public IObservableAsync<T> CatchAndIgnoreErrorResume(Func<Exception, IObservable
         }
     }
 
-    /// <summary>
-    /// Observable wrapper for <see cref="Catch{T}(IObservableAsync{T}, Func{Exception,IObservableAsync{T}}, Func{Exception,CancellationToken,ValueTask}?)"/>.
-    /// Allocates one observable wrapper and one sealed observer per subscription — no per-emission closure or
-    /// state-machine box from the previous <c>Create&lt;T&gt;((observer, token) =&gt; ...)</c> pattern.
-    /// </summary>
+    /// <summary>Subscribes the handler-produced fallback observable when the source completes with a failure.</summary>
     /// <typeparam name="T">The element type of the source sequence.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="handler">The fallback handler invoked with the source exception when the source completes with a failure.</param>
@@ -109,9 +98,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return sink;
         }
 
-        /// <summary>Per-subscription witness that forwards <c>OnNext</c> verbatim, delegates error-resume to the
-        /// supplied callback (or the downstream when none was supplied), and on a failed completion subscribes the
-        /// handler-produced fallback observable in place of forwarding the failure.</summary>
+        /// <summary>Forwards values, routes error-resume to the callback or downstream, and swaps in the fallback on failure.</summary>
         /// <param name="downstream">The downstream witness.</param>
         /// <param name="handler">The fallback factory.</param>
         /// <param name="onErrorResume">Optional async error-resume callback.</param>
@@ -123,8 +110,7 @@ internal sealed class CatchWitness(
             Func<Exception, CancellationToken, ValueTask>? onErrorResume,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>Holds the handler-produced subscription so it disposes with the sink. Single-assignment
-            /// because the handler is subscribed at most once (on a failed source completion).</summary>
+            /// <summary>Holds the handler-produced subscription, assigned at most once, so it disposes with the sink.</summary>
             private readonly SingleAssignmentDisposableAsync _handlerDisposable = new();
 
             /// <summary>The subscribe-time token, reused when subscribing the fallback handler observable.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
index d848bfe9..3e5722b8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Aggregate (fold/reduce) extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Aggregate applies an accumulator function over each element of the observable sequence
-/// and returns the final accumulated value when the sequence completes. This is equivalent to a fold
-/// or reduce operation.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Aggregate (fold/reduce) operators for an observable source sequence.</summary>
@@ -41,7 +38,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
         /// current accumulated value, the current element, and a cancellation token.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -75,7 +72,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
         /// accumulated value and the current element.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -113,7 +110,7 @@ public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element.</param>
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
         /// <paramref name="resultSelector"/> is null.</exception>
@@ -149,7 +146,7 @@ public ValueTask<TAcc> ReduceAsync<TAcc>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
         /// current accumulated value, the current element, and a cancellation token.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
         public async ValueTask<TAcc> ReduceAsync<TAcc>(
@@ -190,7 +187,7 @@ public ValueTask<TAccumulate> ReduceAsync<TAccumulate>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
         /// accumulated value and the current element.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
         public async ValueTask<TAcc> ReduceAsync<TAcc>(
@@ -235,7 +232,7 @@ public ValueTask<TResult> ReduceAsync<TAcc, TResult>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element.</param>
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
         /// <paramref name="resultSelector"/> is null.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
index 791dbecd..59ee2333 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
@@ -10,9 +10,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable advanced operations on asynchronous observables, such as reference
-/// counting for connectable observables. These utilities are intended to be used with types that implement asynchronous
-/// observer patterns.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Reference-counting operators for a connectable observable source sequence.</summary>
@@ -25,9 +22,6 @@ public static partial class SignalAsyncExtensions
         /// subscribes, and disconnects when the last observer unsubscribes.
         /// </summary>
         /// <returns>An observable sequence that stays connected to the source as long as there is at least one subscription.</returns>
-        /// <remarks>This operator is useful for sharing a single subscription to the underlying connectable
-        /// observable among multiple subscribers. When the last observer unsubscribes, the connection to the source is
-        /// automatically disposed.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> RefCount() =>
             new RefCountSignal<T>(source);
@@ -41,7 +35,7 @@ public IObservableAsync<T> RefCount() =>
     /// <param name="source">The connectable observable to manage with reference counting.</param>
     internal sealed class RefCountSignal<T>(ConnectableSignalAsync<T> source) : IObservableAsync<T>, IDisposable
     {
-        /// <summary>The asynchronous gate used to serialize subscribe and dispose operations.</summary>
+        /// <summary>The asynchronous gate that serializes subscribe and dispose operations.</summary>
         private readonly AsyncSerialGate _gate = new();
 
         /// <summary>The current number of active subscribers.</summary>
@@ -62,8 +56,7 @@ internal sealed class RefCountSignal<T>(ConnectableSignalAsync<T> source) : IObs
         [SuppressMessage(
             "Concurrency",
             "PSH1315:A blocking wait on an awaitable that may not be done",
-            Justification =
-                "IDisposable.Dispose is intrinsically synchronous; this method must tear down the async connection on the sync dispose path.")]
+            Justification = "IDisposable.Dispose is synchronous and must tear down the asynchronous connection.")]
         internal void Dispose(bool disposing)
         {
             if (Interlocked.Exchange(ref _disposedValue, 1) != 0)
@@ -94,7 +87,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             using (await _gate.EnterAsync(cancellationToken).ConfigureAwait(false))
             {
-                // incr refCount before Subscribe(completed source decrement refCxount in Subscribe)
+                // Increment before subscribing: a source that completes during the subscribe decrements it again.
                 ++_refCount;
                 var needConnect = _refCount == 1;
                 RefCountWitness refCountWitness = new(this, observer);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
index 727a9e2a..9a9bfa0b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
@@ -5,9 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Delay extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Delay time-shifts the observable sequence by the specified time span. Each element is
-/// emitted after a relative delay from the time it was produced by the source. Errors and completion
-/// are not delayed.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Delay operators that time-shift an observable source sequence.</summary>
@@ -22,6 +19,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <returns>An observable sequence with element notifications time-shifted by the specified duration.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="delayInterval"/> is negative.</exception>
+        /// <remarks>Only element notifications are delayed; errors and completion are forwarded as they arrive. A zero
+        /// interval returns the source unchanged.</remarks>
         public IObservableAsync<T> Shift(TimeSpan delayInterval)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(delayInterval, TimeSpan.Zero);
@@ -36,7 +35,7 @@ public IObservableAsync<T> Shift(TimeSpan delayInterval)
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence.</param>
     /// <param name="delayInterval">The time span by which to delay each element notification.</param>
-    /// <param name="timeProvider">The time provider used to control timing.</param>
+    /// <param name="timeProvider">The time provider that schedules the delay.</param>
     internal sealed class DelaySignal<T>(IObservableAsync<T> source, TimeSpan delayInterval, TimeProvider timeProvider) : IObservableAsync<T>
     {
         /// <inheritdoc/>
@@ -51,7 +50,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         /// <summary>A witness that delays each element by waiting before forwarding to the downstream witness.</summary>
         /// <param name="observer">The downstream observer to forward delayed notifications to.</param>
         /// <param name="delayInterval">The time span by which to delay each element notification.</param>
-        /// <param name="timeProvider">The time provider used to control timing.</param>
+        /// <param name="timeProvider">The time provider that schedules the delay.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token.</param>
         internal sealed class DelayWitness(
             IObserverAsync<T> observer,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
index c02a9c2b..5420d95b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
@@ -40,10 +40,7 @@ public IObservableAsync<T> Catch(Func<Exception, IObservableAsync<T>> handler)
         /// <returns>An observable sequence that emits items from the source sequence, or from the handler-provided sequence if
         /// an exception is encountered.</returns>
         /// <exception cref="ArgumentNullException">Thrown if the source sequence or <paramref name="handler"/> is null.</exception>
-        /// <remarks>Use this method to recover from errors in the source sequence by switching to an
-        /// alternative observable sequence. The handler function is called with the exception, allowing custom error
-        /// recovery logic. If the handler itself throws an exception, the resulting sequence completes with that
-        /// exception.</remarks>
+        /// <remarks>If the handler throws, the resulting sequence completes with that exception.</remarks>
         public IObservableAsync<T> Catch(
             Func<Exception, IObservableAsync<T>> handler,
             Func<Exception, CancellationToken, ValueTask>? onErrorResume)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
index 72381784..b504de43 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
@@ -30,7 +30,7 @@ public IObservableAsync<T> DistinctUntilChanged()
         /// Returns an observable sequence that emits elements from the source sequence only when the current element is
         /// not equal to the previous element, as determined by the specified equality comparer.
         /// </summary>
-        /// <param name="equalityComparer">An equality comparer used to determine whether consecutive elements are considered equal.</param>
+        /// <param name="equalityComparer">The comparer that decides whether consecutive elements are equal.</param>
         /// <returns>An observable sequence that contains only distinct consecutive elements from the source sequence, as
         /// determined by the specified equality comparer.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="equalityComparer"/> is <see langword="null"/>.</exception>
@@ -46,7 +46,7 @@ public IObservableAsync<T> DistinctUntilChanged(IEqualityComparer<T> equalityCom
         /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
         /// duplicates as determined by a key selector function.
         /// </summary>
-        /// <typeparam name="TKey">The type of the key used to determine whether consecutive elements are considered duplicates.</typeparam>
+        /// <typeparam name="TKey">The type of the key that decides whether consecutive elements are duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
         /// duplicates according to the specified key.</returns>
@@ -63,9 +63,9 @@ public IObservableAsync<T> DistinctUntilChangedBy<TKey>(Func<T, TKey> keySelecto
         /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
         /// duplicates as determined by a key selector and equality comparer.
         /// </summary>
-        /// <typeparam name="TKey">The type of the key used to determine whether consecutive elements are considered duplicates.</typeparam>
+        /// <typeparam name="TKey">The type of the key that decides whether consecutive elements are duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
-        /// <param name="equalityComparer">An equality comparer used to compare keys for equality.</param>
+        /// <param name="equalityComparer">The comparer that compares keys for equality.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
         /// duplicates according to the specified key and comparer.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="keySelector"/> or <paramref name="equalityComparer"/> is null.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
index ec93a5b6..27309ffb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
@@ -13,12 +13,12 @@ public static partial class SignalAsyncExtensions
     extension<T>(IObservableAsync<T> source)
     {
         /// <summary>
-        /// Applies a dueTime policy to the observable sequence. If the next element is not received within
+        /// Applies a timeout policy to the observable sequence. If the next element is not received within
         /// the specified time span, the sequence completes with a <see cref="TimeoutException"/>.
         /// </summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <returns>An observable sequence that mirrors the source but completes with a
-        /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified dueTime.</returns>
+        /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
         public IObservableAsync<T> Timeout(TimeSpan dueTime)
         {
@@ -28,14 +28,14 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime)
         }
 
         /// <summary>
-        /// Applies a dueTime policy to the observable sequence. If the next element is not received within
+        /// Applies a timeout policy to the observable sequence. If the next element is not received within
         /// the specified time span, the sequence completes with a <see cref="TimeoutException"/>.
         /// </summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
         /// is used.</param>
         /// <returns>An observable sequence that mirrors the source but completes with a
-        /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified dueTime.</returns>
+        /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
         public IObservableAsync<T> Timeout(TimeSpan dueTime, TimeProvider? timeProvider)
         {
@@ -45,13 +45,13 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, TimeProvider? timeProvider)
         }
 
         /// <summary>
-        /// Applies a dueTime policy to the observable sequence. If the next element is not received within
+        /// Applies a timeout policy to the observable sequence. If the next element is not received within
         /// the specified time span, the sequence switches to the specified fallback observable.
         /// </summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
-        /// <param name="fallback">The fallback observable to switch to when a dueTime occurs. Cannot be null.</param>
+        /// <param name="fallback">The fallback observable to switch to when a timeout occurs. Cannot be null.</param>
         /// <returns>An observable sequence that mirrors the source, switching to the fallback sequence
-        /// if any inter-element interval exceeds the specified dueTime.</returns>
+        /// if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="fallback"/> is null.</exception>
         public IObservableAsync<T> Timeout(TimeSpan dueTime, IObservableAsync<T> fallback)
@@ -63,15 +63,15 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, IObservableAsync<T> fallbac
         }
 
         /// <summary>
-        /// Applies a dueTime policy to the observable sequence. If the next element is not received within
+        /// Applies a timeout policy to the observable sequence. If the next element is not received within
         /// the specified time span, the sequence switches to the specified fallback observable.
         /// </summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
-        /// <param name="fallback">The fallback observable to switch to when a dueTime occurs. Cannot be null.</param>
+        /// <param name="fallback">The fallback observable to switch to when a timeout occurs. Cannot be null.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
         /// is used.</param>
         /// <returns>An observable sequence that mirrors the source, switching to the fallback sequence
-        /// if any inter-element interval exceeds the specified dueTime.</returns>
+        /// if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="fallback"/> is null.</exception>
         public IObservableAsync<T> Timeout(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
index 93bb72bf..ff682fdb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
@@ -10,10 +10,6 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides extension methods for asynchronous observable sequences, enabling operations such as retrieving a single
 /// element that matches a specified condition.
 /// </summary>
-/// <remarks>The methods in this class support querying and consuming asynchronous observables in a manner similar
-/// to LINQ, but adapted for asynchronous and reactive scenarios. These extensions are intended for use with types
-/// implementing the SignalAsync pattern, allowing developers to perform operations such as filtering and retrieving
-/// elements in an asynchronous context.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Single-element operators for an observable source sequence.</summary>
@@ -29,9 +25,7 @@ public static partial class SignalAsyncExtensions
         /// returns <see langword="true"/>.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element that matches
         /// the predicate.</returns>
-        /// <remarks>If no element satisfies the condition, or if more than one element satisfies the
-        /// condition, an exception is thrown. Use this method when exactly one element is expected to match the
-        /// predicate.</remarks>
+        /// <remarks>Both no match and more than one match throw.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(Func<T, bool> predicate) =>
             source.SingleAsync(predicate, CancellationToken.None);
@@ -42,12 +36,10 @@ public ValueTask<T> SingleAsync(Func<T, bool> predicate) =>
         /// </summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element that matches
         /// the predicate.</returns>
-        /// <remarks>If no element satisfies the condition, or if more than one element satisfies the
-        /// condition, an exception is thrown. Use this method when exactly one element is expected to match the
-        /// predicate.</remarks>
+        /// <remarks>Both no match and more than one match throw.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(Func<T, bool> predicate, CancellationToken cancellationToken) =>
             SingleCoreAsync(source, predicate, cancellationToken);
@@ -58,8 +50,7 @@ public ValueTask<T> SingleAsync(Func<T, bool> predicate, CancellationToken cance
         /// </summary>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
-        /// <remarks>Use this method when you expect the sequence to contain exactly one element. If the
-        /// sequence is empty or contains more than one element, an exception is thrown.</remarks>
+        /// <remarks>Both an empty sequence and a sequence of more than one element throw.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync() =>
             source.SingleAsync(CancellationToken.None);
@@ -68,11 +59,10 @@ public ValueTask<T> SingleAsync() =>
         /// Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not
         /// contain exactly one element.
         /// </summary>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
-        /// <remarks>Use this method when you expect the sequence to contain exactly one element. If the
-        /// sequence is empty or contains more than one element, an exception is thrown.</remarks>
+        /// <remarks>Both an empty sequence and a sequence of more than one element throw.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(CancellationToken cancellationToken) =>
             SingleCoreAsync(source, null, cancellationToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
index 6754a5ee..d4366b6f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a set of extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static extension methods that operate on instances of
-/// SignalAsync{T}. These methods enable querying and manipulation of asynchronous observable sequences in a manner
-/// similar to LINQ, supporting scenarios such as retrieving single elements or default values asynchronously.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Single-or-default operators for an observable source sequence.</summary>
@@ -28,9 +25,6 @@ public static partial class SignalAsyncExtensions
         /// <returns>A value task that represents the asynchronous operation. The result contains the single element that matches
         /// the predicate, the specified default value if no such element is found, or throws an exception if more than
         /// one matching element exists.</returns>
-        /// <remarks>If more than one element satisfies the condition, an exception is thrown. If no
-        /// elements satisfy the condition, the specified default value is returned. The operation observes the provided
-        /// cancellation token.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(
             Func<T, bool> predicate,
@@ -45,13 +39,10 @@ public static partial class SignalAsyncExtensions
         /// returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element in the sequence satisfies the condition specified by <paramref
         /// name="predicate"/>.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A value task that represents the asynchronous operation. The result contains the single element that matches
         /// the predicate, the specified default value if no such element is found, or throws an exception if more than
         /// one matching element exists.</returns>
-        /// <remarks>If more than one element satisfies the condition, an exception is thrown. If no
-        /// elements satisfy the condition, the specified default value is returned. The operation observes the provided
-        /// cancellation token.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(
             Func<T, bool> predicate,
@@ -73,7 +64,7 @@ public static partial class SignalAsyncExtensions
         /// Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this
         /// operation throws an exception if more than one element is found.
         /// </summary>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, or the default value of <typeparamref name="T"/> if the sequence is empty.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -88,9 +79,6 @@ public static partial class SignalAsyncExtensions
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, the specified default value if the sequence is empty, or throws if more than one element is
         /// present.</returns>
-        /// <remarks>Use this method when you expect the sequence to contain zero or one element. If the
-        /// sequence contains more than one element, an exception is thrown. If the sequence is empty, the specified
-        /// default value is returned.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(T? defaultValue) =>
             source.SingleOrDefaultAsync(defaultValue, CancellationToken.None);
@@ -100,13 +88,10 @@ public static partial class SignalAsyncExtensions
         /// empty. Throws an exception if the sequence contains more than one element.
         /// </summary>
         /// <param name="defaultValue">The value to return if the sequence contains no elements.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, the specified default value if the sequence is empty, or throws if more than one element is
         /// present.</returns>
-        /// <remarks>Use this method when you expect the sequence to contain zero or one element. If the
-        /// sequence contains more than one element, an exception is thrown. If the sequence is empty, the specified
-        /// default value is returned.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(T? defaultValue, CancellationToken cancellationToken) =>
             SingleOrDefaultCoreAsync(source, null, defaultValue, cancellationToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
index d30c9ecb..f800c91d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
@@ -5,9 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static extension methods that enable LINQ-style and other
-/// operations on asynchronous observables. These methods are intended to facilitate the composition and manipulation of
-/// asynchronous data streams in a reactive programming style.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Element-skipping operators for an observable source sequence.</summary>
@@ -29,10 +26,10 @@ public IObservableAsync<T> Skip(int count)
         }
     }
 
-    /// <summary>Single-observer-layer <c>Skip(count)</c>. Drops the first <c>count</c> emissions then forwards everything subsequent.</summary>
+    /// <summary>Drops the first <c>count</c> emissions, then forwards every later value.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
-    /// <param name="count">The number of leading emissions to drop (must be &gt; 0; the zero case bypasses this observable entirely).</param>
+    /// <param name="count">The number of leading emissions to drop, always greater than zero.</param>
     internal sealed class SkipSignal<T>(IObservableAsync<T> source, int count) : IObservableAsync<T>
     {
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
index dbe18a4d..506134ce 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
@@ -5,8 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides SkipWhile extension methods for asynchronous observable sequences.</summary>
-/// <remarks>SkipWhile bypasses elements in the source sequence as long as a predicate is satisfied,
-/// then emits all remaining elements.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>SkipWhile operators for an observable source sequence.</summary>
@@ -48,11 +46,7 @@ public IObservableAsync<T> SkipWhile(Func<T, bool> predicate)
         }
     }
 
-    /// <summary>
-    /// Synchronous-predicate <c>SkipWhile</c> as a single-observer-layer observable; once the
-    /// predicate returns <see langword="false"/> the gate latches and every subsequent emission
-    /// forwards without a predicate call.
-    /// </summary>
+    /// <summary>Skips values while the predicate holds; after it first fails, every later value forwards untested.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="predicate">The skip-while predicate.</param>
@@ -113,10 +107,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Async-predicate <c>SkipWhile</c> as a single-observer-layer observable with a sync-completion
-    /// fast path for the post-latch case.
-    /// </summary>
+    /// <summary>Skips values while the asynchronous predicate holds, then forwards every later value without awaiting it.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="predicate">The async skip-while predicate.</param>
@@ -141,7 +132,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return sink;
         }
 
-        /// <summary>Per-subscription observer with latched gate; once gated, async predicate is no longer invoked.</summary>
+        /// <summary>Per-subscription observer with a latched gate; once the gate opens, the predicate is not invoked again.</summary>
         /// <param name="downstream">The downstream observer.</param>
         /// <param name="predicate">The async skip-while predicate.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
index 7177e965..a0ff1658 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
@@ -7,8 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides the StartWith extension method for asynchronous observable sequences.</summary>
-/// <remarks>StartWith mirrors the System.Reactive naming convention and prepends one or more values
-/// to the beginning of an observable sequence before its own emissions.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>StartWith (value-prepending) operators for an observable source sequence.</summary>
@@ -20,8 +18,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="value">The value to prepend to the sequence.</param>
         /// <returns>An observable sequence that emits the specified value first, followed by the elements
         /// of the source sequence.</returns>
-        /// <remarks>This is equivalent to Prepend(T) and follows the System.Reactive
-        /// naming convention.</remarks>
+        /// <remarks>Equivalent to <c>Prepend(T)</c>, under the System.Reactive name.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> StartWith(T value) => new LeadSignal<T>(source, [value]);
 
@@ -29,8 +26,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="values">The values to prepend to the sequence. Cannot be null.</param>
         /// <returns>An observable sequence that emits the specified values first, followed by the elements
         /// of the source sequence.</returns>
-        /// <remarks>This is equivalent to Prepend(IEnumerable{T}) and follows the System.Reactive
-        /// naming convention. Values are emitted in the order they appear in the collection.</remarks>
+        /// <remarks>Equivalent to <c>Prepend(IEnumerable&lt;T&gt;)</c>, under the System.Reactive name; the values are
+        /// emitted in collection order.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> StartWith(IEnumerable<T> values) => new LeadSignal<T>(source, values);
 
@@ -38,8 +35,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="values">The values to prepend to the sequence.</param>
         /// <returns>An observable sequence that emits the specified values first, followed by the elements
         /// of the source sequence.</returns>
-        /// <remarks>This overload accepts a params array for convenience. Values are emitted in the
-        /// order they appear in the array.</remarks>
+        /// <remarks>The values are emitted in array order.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> StartWith(params T[] values) => new LeadSignal<T>(source, values);
     }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
index 8b406e2d..4596fa62 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
@@ -7,12 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for subscribing to asynchronous observable sequences using various delegate-based overloads.</summary>
-/// <remarks>The methods in this class enable consumers to subscribe to an asynchronous observable sequence by
-/// specifying delegate handlers for item notifications, error handling, and completion. These overloads offer both
-/// synchronous and asynchronous delegate options, allowing for flexible integration with different programming models.
-/// All subscriptions return an <see cref="IAsyncDisposable"/> that should be disposed to terminate the subscription and
-/// release resources. These methods are intended to simplify the process of observing asynchronous streams without
-/// requiring explicit implementation of observer interfaces.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Delegate-based subscription operators for an observable source sequence.</summary>
@@ -30,13 +24,11 @@ public static partial class SignalAsyncExtensions
         /// receives the exception and a cancellation token. If null, errors are not handled by the subscriber.</param>
         /// <param name="onCompletedAsync">An optional delegate that is invoked asynchronously when the data source completes successfully. The
         /// delegate receives a result indicating the completion status. If null, no action is taken on completion.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the subscription and any in-progress callbacks.</param>
+        /// <param name="cancellationToken">The token that cancels the subscription and any in-progress callbacks.</param>
         /// <returns>A value task that represents the asynchronous operation. The result is an <see cref="IAsyncDisposable"/>
         /// that can be disposed to unsubscribe from the data source.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying data source is null.</exception>
-        /// <remarks>The returned <see cref="IAsyncDisposable"/> should be disposed when the subscription
-        /// is no longer needed to release resources and stop receiving notifications. Callbacks may be invoked
-        /// concurrently; implement thread safety in the provided delegates if required.</remarks>
+        /// <remarks>Callbacks may be invoked concurrently, so the supplied delegates must be thread-safe.</remarks>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
             Func<Exception, CancellationToken, ValueTask>? onErrorResumeAsync,
@@ -81,7 +73,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
 
         /// <summary>Subscribes to the observable sequence and invokes the specified action for each element received.</summary>
         /// <param name="onNext">An action to invoke for each element in the sequence. Cannot be null.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the subscription operation.</param>
+        /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A value task that represents the asynchronous subscription operation. The result contains an <see
         /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe from the sequence.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null.</exception>
@@ -118,13 +110,10 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(Action<T> onNext) =>
         /// subscriber.</param>
         /// <param name="onCompleted">An optional action to invoke when the sequence completes. If null, completion is not handled by the
         /// subscriber.</param>
-        /// <param name="cancellationToken">A cancellation token that can be used to cancel the subscription.</param>
+        /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A value task that represents the asynchronous subscription operation. The result is an <see
         /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe from the sequence.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null, or if the underlying source is null.</exception>
-        /// <remarks>The returned <see cref="IAsyncDisposable"/> should be disposed when the subscription
-        /// is no longer needed to release resources and stop receiving notifications. This method enables asynchronous,
-        /// push-based event handling for observable sequences.</remarks>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Action<T> onNext,
             Action<Exception>? onErrorResume,
@@ -180,7 +169,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(Func<T, CancellationToken, Val
         /// </summary>
         /// <param name="onNextAsync">A function to invoke asynchronously for each item in the sequence. The function receives the item and a
         /// cancellation token, and returns a ValueTask that completes when processing is finished.</param>
-        /// <param name="cancellationToken">A token that can be used to cancel the subscription operation.</param>
+        /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A ValueTask that represents the asynchronous subscription operation. The result is an IAsyncDisposable that
         /// can be disposed to unsubscribe from the sequence.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying source is null.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
index a6cffb2b..d20c1afa 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
@@ -20,9 +20,6 @@ public static partial class SignalAsyncExtensions
         /// </summary>
         /// <returns>An observable sequence that emits items from the most recently emitted inner observable sequence. When a new
         /// inner sequence is emitted, the previous one is unsubscribed.</returns>
-        /// <remarks>This operator is commonly used to switch to a new data stream whenever a new inner
-        /// observable is produced, unsubscribing from the previous inner observable. Only items from the latest inner
-        /// observable are emitted to subscribers.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> SwitchTo() => new SwitchToSignal<T>(source);
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
index df6f2b63..1e6ea198 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
@@ -42,7 +42,7 @@ internal sealed class SwitchToCoordinator : IAsyncDisposable
         /// <summary>Disposable that holds the single outer subscription.</summary>
         private readonly SingleAssignmentDisposableAsync _outerDisposable = new();
 
-        /// <summary>Cancellation token source used to signal disposal of the subscription.</summary>
+        /// <summary>The cancellation token source that signals disposal of the subscription.</summary>
         private readonly CancellationTokenSource _disposeCts = new();
 
         /// <summary>Cached cancellation token from the dispose cancellation token source.</summary>
@@ -183,11 +183,7 @@ internal async ValueTask AcceptInnerErrorAsync(Exception error, CancellationToke
             }
         }
 
-        /// <summary>
-        /// Links the original subscribe-time cancellation token into this subscription's dispose chain so
-        /// later per-emission methods can rely on <see cref="_disposeCancellationToken"/> instead of
-        /// allocating a per-emission linked CTS.
-        /// </summary>
+        /// <summary>Routes cancellation of the subscribe-time token into <see cref="_disposeCts"/>, so per-emission code needs no linked source.</summary>
         /// <param name="external">The subscribe-time token.</param>
         internal void LinkExternalCancellation(CancellationToken external)
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
index 85ab0e2b..e9571374 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
@@ -44,8 +44,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -90,8 +89,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
index cda53b4e..082d77a9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
@@ -46,8 +46,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -95,8 +94,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
index f5ed6e76..43bfb58a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
@@ -48,8 +48,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -100,8 +99,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
index 81089c86..43be92df 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
@@ -50,8 +50,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -105,8 +104,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
index be67a278..eca356c5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
@@ -52,8 +52,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -110,8 +109,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult>
             CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(
                 IObservableAsync<T2> src2,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
index 7d9a6a76..2a52c9ff 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
@@ -54,8 +54,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<
             T2,
             T3,
@@ -130,8 +129,7 @@ public IObservableAsync<TResult> SyncLatest<
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<
             T2,
             T3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
index 9b2417c6..37bef000 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
@@ -56,8 +56,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -136,8 +135,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
index 9182cb41..aac19c3b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
@@ -40,8 +40,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -80,8 +79,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
index 43134838..c2c38f5c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
@@ -42,8 +42,7 @@ public static partial class SignalAsyncExtensions
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
@@ -85,8 +84,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, TRes
         [SuppressMessage(
             "Maintainability",
             "SST1472:Signatures should not declare too many parameters",
-            Justification =
-                "An arity-N combinator takes N distinctly-typed sources; a parameter object would need the same N type arguments.")]
+            Justification = "An arity-N combinator takes N distinctly-typed sources.")]
         public IObservableAsync<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
             IObservableAsync<T2> src2,
             IObservableAsync<T3> src3,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
index cecca337..21df8a1d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
@@ -16,20 +16,16 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence that emits a snapshot of the latest values whenever any source produces a new value,
         /// after all sources have produced at least one value.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="sources"/> is <see langword="null"/>.</exception>
-        /// <remarks>
-        /// <para>For perf reasons each emitted <see cref="IReadOnlyList{T}"/> is a reference to a single shared buffer
-        /// owned by the subscription, not a fresh allocation. Downstream observers MUST consume the snapshot synchronously
-        /// inside their <c>OnNextAsync</c> handler; retaining a reference past the handler will surface the next
-        /// emission's values instead, because the buffer is overwritten under the operator's gate before each emit.
-        /// If you need a stable copy, project to one via the projecting <c>CombineLatest</c> overload or
-        /// <c>.Select(static s =&gt; s.ToArray())</c>.</para>
-        /// </remarks>
+        /// <remarks>Each emitted <see cref="IReadOnlyList{T}"/> is a reference to one buffer owned by the subscription,
+        /// not a fresh allocation. An observer must consume the snapshot inside its <c>OnNextAsync</c> handler: the buffer
+        /// is overwritten under the operator's gate before each emit, so a retained reference surfaces the next emission's
+        /// values. For a stable copy, use the projecting <c>CombineLatest</c> overload or
+        /// <c>.Select(static s =&gt; s.ToArray())</c>.</remarks>
         public IObservableAsync<IReadOnlyList<TSource>> SyncLatest()
         {
             ArgumentExceptionHelper.ThrowIfNull(sources);
 
-            // Use the projecting sink with an identity selector so one subscription implementation
-            // backs both shapes. The static lambda avoids capturing enclosing state.
+            // An identity selector lets one subscription implementation back both shapes.
             return new SyncLatestEnumerableSignal<TSource, IReadOnlyList<TSource>>(sources, static s => s);
         }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Take.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Take.cs
index 42ed6eee..47c18d5f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Take.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Take.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static extension methods that enable advanced operations on
-/// asynchronous observables, such as filtering, transformation, and sequence control. These methods are intended to be
-/// used with the SignalAsync{T} type to facilitate reactive programming patterns in asynchronous
-/// scenarios.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Element-limiting operators for an observable source sequence.</summary>
@@ -24,9 +20,7 @@ public static partial class SignalAsyncExtensions
         /// sequence. If <paramref name="count"/> is zero, the resulting sequence completes immediately without emitting
         /// any elements.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="count"/> is less than zero.</exception>
-        /// <remarks>If the source sequence contains fewer elements than <paramref name="count"/>, all
-        /// available elements are emitted and the sequence completes. This method does not modify the source sequence;
-        /// it returns a new sequence with the specified behavior.</remarks>
+        /// <remarks>A source with fewer elements than <paramref name="count"/> emits all of them and completes.</remarks>
         public IObservableAsync<T> Take(int count)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -50,10 +44,10 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         }
     }
 
-    /// <summary>Single-observer-layer <c>Take(count)</c>. Forwards values until the budget is exhausted, then signals completion downstream.</summary>
+    /// <summary>Forwards values until the count is exhausted, then signals completion downstream.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
-    /// <param name="count">The maximum number of values to forward (must be &gt; 0; the zero case uses <see cref="TakeZeroSignal{T}"/>).</param>
+    /// <param name="count">The maximum number of values to forward, always greater than zero.</param>
     internal sealed class TakeSignal<T>(IObservableAsync<T> source, int count) : IObservableAsync<T>
     {
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.PredicateSignals.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.PredicateSignals.cs
index 966a1ce3..c0e54a1f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.PredicateSignals.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.PredicateSignals.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Predicate-driven stop signals backing the <c>TakeUntil(predicate)</c> overloads declared in
-/// <c>TakeUntil.cs</c>. Unlike the other take-until signals these have no second sequence, task or
-/// token to race against: the stop condition is evaluated inline on each source element.
-/// </summary>
+/// <summary>Provides the predicate-driven stop signals that evaluate their stop condition inline on each source element.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Async observable that emits items from the source until the specified predicate returns true.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
index a32ba603..b7437840 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
@@ -11,10 +11,6 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides a set of extension methods for creating observable sequences that emit items from a source sequence until a
 /// specified condition is met or an external signal is received.
 /// </summary>
-/// <remarks>The methods in this class allow you to control the lifetime of an observable sequence based on
-/// various triggers, such as another observable, a task, a cancellation token, or a predicate. These methods are useful
-/// for scenarios where you need to automatically stop processing items from a source sequence when a certain event
-/// occurs or a condition is satisfied.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Take-until operators that emit items from an observable source until a stop condition is met.</summary>
@@ -173,8 +169,7 @@ public IObservableAsync<T> TakeUntil(
         /// <param name="cancellationToken">A cancellation token that, when canceled, will terminate the resulting observable sequence.</param>
         /// <returns>An observable sequence that completes when the provided cancellation token is canceled or when the source
         /// sequence completes.</returns>
-        /// <remarks>If the cancellation token is already canceled when the method is called, the
-        /// resulting observable sequence will complete immediately.</remarks>
+        /// <remarks>A token that is canceled at the time of the call completes the sequence immediately.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> TakeUntil(CancellationToken cancellationToken) =>
             new CancellationStopSignal<T>(source, cancellationToken);
@@ -185,8 +180,6 @@ public IObservableAsync<T> TakeUntil(CancellationToken cancellationToken) =>
         /// <returns>An observable sequence that contains the elements from the source sequence up to, but not including, the
         /// first element for which the predicate returns true.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="predicate"/> is null.</exception>
-        /// <remarks>The element that causes the predicate to return true is not included in the resulting
-        /// sequence. Subsequent elements from the source are not emitted.</remarks>
         public IObservableAsync<T> TakeUntil(Func<T, bool> predicate)
         {
             ArgumentExceptionHelper.ThrowIfNull(predicate);
@@ -337,11 +330,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
                 () => subscription.SubscribeSourcesAsync(cancellationToken));
         }
 
-        /// <summary>
-        /// Manages the subscription lifetime and completes when the cancellation token is canceled.
-        /// Composes <see cref="TakeUntilLifecycle{T}"/> for the shared gate / dispose-CTS / external-
-        /// link / gated-forwarding plumbing so this class only carries the operator-specific state.
-        /// </summary>
+        /// <summary>Manages the subscription lifetime and completes the sequence when the cancellation token is canceled.</summary>
         internal sealed class CancellationStopCoordinator : IAsyncDisposable
         {
             /// <summary>The parent observable that owns this subscription.</summary>
@@ -503,14 +492,8 @@ internal void LinkExternalCancellation(CancellationToken external) =>
                 _lifecycle.LinkExternalCancellation(external);
 
             /// <summary>Hands the stop delegate the callback that ends the sequence.</summary>
-            /// <remarks>
-            /// The completion runs on whichever thread calls the callback, not on a waiter parked behind it.
-            /// The caller of a synchronous <c>notify(...)</c> has every right to expect the sequence to have
-            /// ended by the time it returns, and where the downstream observer completes synchronously it now
-            /// does. The previous shape signalled a <c>TaskCompletionSource</c> whose continuations were
-            /// forced asynchronous, so the completion was merely queued and the caller could observe the
-            /// sequence still running.
-            /// </remarks>
+            /// <remarks>Completion runs on the thread that invokes the callback, so a synchronous <c>notify</c> ends the
+            /// sequence before it returns whenever the downstream observer completes synchronously.</remarks>
             internal void AwaitStopThenComplete()
             {
                 Volatile.Write(ref _stopRegistration, _parent._stopSignal(Stop));
@@ -611,7 +594,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
                 () => subscription.SubscribeSourcesAsync(cancellationToken));
         }
 
-        /// <summary>Manages the subscription lifetime and completes when the task finishes. Composes <see cref="TakeUntilLifecycle{T}"/> for the shared plumbing.</summary>
+        /// <summary>Manages the subscription lifetime and completes the sequence when the task finishes.</summary>
         internal sealed class TaskStopCoordinator : IAsyncDisposable
         {
             /// <summary>The parent observable that owns this subscription.</summary>
@@ -718,10 +701,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
                 async () => await subscription.SubscribeSourcesAsync(cancellationToken).ConfigureAwait(false));
         }
 
-        /// <summary>
-        /// Manages subscriptions to both the source and signal observables, completing when the signal
-        /// fires. Composes <see cref="TakeUntilLifecycle{T}"/> for the shared plumbing.
-        /// </summary>
+        /// <summary>Manages subscriptions to both the source and the signal observable, completing when the signal fires.</summary>
         internal sealed class AsyncStopCoordinator : IAsyncDisposable
         {
             /// <summary>The parent observable that owns this subscription.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntilOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntilOptions.cs
index 5de8ab08..83a8a4bd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntilOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntilOptions.cs
@@ -5,16 +5,12 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides configuration options for controlling the behavior of the TakeUntil operator.</summary>
-/// <remarks>This type allows customization of how the source sequence responds to failures in the 'other'
-/// sequence when using TakeUntil. It is immutable and thread-safe.</remarks>
 [System.Diagnostics.DebuggerDisplay("TakeUntilOptions: SourceFailsWhenOtherFails = {SourceFailsWhenOtherFails}")]
 public sealed record TakeUntilOptions
 {
     /// <summary>Gets the default configuration options for the TakeUntil operation.</summary>
-    /// <remarks>Use this property to obtain a standard set of options when no customization is required. The
-    /// returned instance is immutable and can be shared safely across multiple operations.</remarks>
     public static TakeUntilOptions Default { get; } = new();
 
-    /// <summary>Gets a value indicating whether the source operation fails when another related operation fails.</summary>
+    /// <summary>Gets a value indicating whether a failure of the other sequence also fails the result sequence.</summary>
     public bool SourceFailsWhenOtherFails { get; init; }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
index 514f24ea..69d099ba 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
@@ -5,8 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides TakeWhile extension methods for asynchronous observable sequences.</summary>
-/// <remarks>TakeWhile emits elements from the source sequence as long as a predicate is satisfied,
-/// then completes the sequence when the predicate returns false.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>TakeWhile operators for an observable source sequence.</summary>
@@ -42,10 +40,7 @@ public IObservableAsync<T> TakeWhile(Func<T, bool> predicate)
         }
     }
 
-    /// <summary>
-    /// Synchronous-predicate <c>TakeWhile</c> as a single-observer-layer observable. Forwards while
-    /// the predicate holds; on the first miss signals downstream completion and stops.
-    /// </summary>
+    /// <summary>Forwards values while the predicate holds; the first miss completes the sequence and stops.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="predicate">The take-while predicate.</param>
@@ -108,7 +103,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>Async-predicate <c>TakeWhile</c> as a single-observer-layer observable with a sync-completion fast path.</summary>
+    /// <summary>Forwards values while the asynchronous predicate holds; the first miss completes the sequence.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="predicate">The async take-while predicate.</param>
@@ -133,7 +128,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return sink;
         }
 
-        /// <summary>Per-subscription observer with an async predicate sync-completion fast path.</summary>
+        /// <summary>Per-subscription observer that skips the await when the predicate completes synchronously.</summary>
         /// <param name="downstream">The downstream observer.</param>
         /// <param name="predicate">The async take-while predicate.</param>
         /// <param name="subscribeToken">The subscribe-time cancellation token.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
index 444de697..52af3b00 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class enable the addition of side effects, such as logging or resource
-/// management, to asynchronous observable sequences without modifying their elements or control flow. These methods are
-/// intended to be used as part of a fluent query or processing pipeline for asynchronous observables.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Side-effect (Tap/Do) operators that invoke callbacks for each notification of an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
index 48617333..5ea985e0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
@@ -10,35 +10,30 @@ namespace ReactiveUI.Primitives.Async;
 /// Provides a mechanism for registering a global handler to process unhandled exceptions that occur during
 /// application execution.
 /// </summary>
-/// <remarks>Use this class to specify a custom action to be invoked when an unhandled exception is
-/// encountered. By default, unhandled exceptions are written to the console. Registering a handler allows
-/// applications to perform custom logging, cleanup, or user notification in response to unexpected errors. This
-/// class does not handle exceptions of type OperationCanceledException.</remarks>
+/// <remarks>The process-wide default writes the exception to <see cref="System.Diagnostics.Trace"/>. Register a
+/// handler to log, clean up or notify instead. Cancellation is treated as normal flow and never reaches the
+/// handler.</remarks>
 public static class UnhandledExceptionHandler
 {
     /// <summary>The currently registered handler action invoked when an unhandled exception occurs.</summary>
     private static Action<Exception> _unhandledException = TraceUnhandledException;
 
-    /// <summary>Gets the currently registered handler. Used for save/restore in tests.</summary>
+    /// <summary>Gets the handler that <see cref="ReportUnhandledException"/> routes to.</summary>
     internal static Action<Exception> CurrentHandler => _unhandledException;
 
     /// <summary>Registers a handler to be invoked when an unhandled exception occurs.</summary>
-    /// <param name="unhandledExceptionHandler">An action to execute when an unhandled exception is encountered. The exception instance is passed as a
-    /// parameter to the handler. Cannot be null.</param>
-    /// <remarks>Registering a new handler replaces any previously registered handler. The handler
-    /// will be called for each unhandled exception that occurs after registration.</remarks>
+    /// <param name="unhandledExceptionHandler">The action that receives each unhandled exception. Cannot be null.</param>
+    /// <remarks>There is one handler per process and registration replaces it, so a library that registers here takes
+    /// the sink away from the host application. A handler that throws has its exception swallowed.</remarks>
     public static void Register(Action<Exception> unhandledExceptionHandler) =>
         _unhandledException = unhandledExceptionHandler;
 
     /// <summary>Invokes the application's unhandled exception handler for exceptions that are not operation cancellations.</summary>
     /// <param name="e">The exception to be processed by the unhandled exception handler. Cannot be null.</param>
-    /// <remarks>OperationCanceledException instances are ignored and not passed to the
-    /// handler.</remarks>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST1429:Handle, rethrow, or narrow this catch; an empty catch of the base exception hides failures",
-        Justification =
-            "This is the last-resort handler; if the registered handler itself throws there is no further sink to route to without recursing.")]
+        Justification = "This is the last-resort sink, so rethrowing a handler's own failure would have nowhere to go but back here.")]
     internal static void ReportUnhandledException(Exception e)
     {
         if (e is OperationCanceledException)
@@ -56,11 +51,8 @@ internal static void ReportUnhandledException(Exception e)
         }
     }
 
-    /// <summary>Handles unhandled exceptions by writing an error message to the console output.</summary>
+    /// <summary>The default handler: writes the exception to <see cref="System.Diagnostics.Trace"/> as an error.</summary>
     /// <param name="exception">The exception that was not handled. Cannot be null.</param>
-    /// <remarks>This method is intended to be used as a default handler for unhandled exceptions in
-    /// an application. It writes the exception details to the standard console output for diagnostic
-    /// purposes.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static void TraceUnhandledException(Exception exception) =>
         System.Diagnostics.Trace.TraceError("UnhandleException: {0}", exception);
diff --git a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
index dc90ed64..3ae4e3f2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
@@ -9,38 +9,31 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>Represents an asynchronous observer that processes notifications of type <typeparamref name="T"/> using asynchronous methods.</summary>
+/// <summary>Base class for an asynchronous observer: handles the notification gate, cancellation linking and disposal
+/// so a derived sink only has to implement the three <c>Core</c> methods.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
-/// <remarks>Implement this abstract class to handle asynchronous event streams or push-based data sources, where
-/// notifications may arrive concurrently or in rapid succession. The observer provides asynchronous methods for
-/// handling new data, errors, and completion signals, and supports proper resource cleanup via asynchronous disposal.
-/// Instances are not thread-safe for concurrent notification handling; notifications are processed sequentially, and
-/// reentrant calls are detected and reported as unhandled exceptions.</remarks>
+/// <remarks>One notification runs at a time. A reentrant call from the thread that holds the gate is allowed, but an
+/// overlapping call from another thread is a contract violation: the notification is dropped and a
+/// <see cref="ConcurrentWitnessCallsException"/> goes to <see cref="UnhandledExceptionHandler"/>.</remarks>
 [System.Diagnostics.DebuggerDisplay("WitnessAsync: Disposed = {_disposed}, CallState = {_callState}")]
 public abstract class WitnessAsync<T> : IObserverAsync<T>, IReentrantAsyncDisposable
 {
-    /// <summary>Lazily-created CTS that signals disposal to in-flight operations. Stays
-    /// <see langword="null"/> until someone requests <see cref="InternalDisposedToken"/>,
-    /// <see cref="LinkExternalCancellation"/> wires a real token, or <see cref="DisposeAsync"/>
-    /// is called. Terminal observers (most user-facing sinks) never trigger creation and save
-    /// the ~72 B per instance the CTS would cost.</summary>
+    /// <summary>Signals disposal to in-flight operations; created on the first request for a dispose token, so a
+    /// terminal sink that never needs one does not pay for it.</summary>
     private CancellationTokenSource? _disposeCts;
 
-    /// <summary>Disposal latch. Set independently of <see cref="_disposeCts"/> so the lazy-CTS
-    /// path can detect post-dispose state before the CTS has been materialized.</summary>
+    /// <summary>Disposal latch, set independently of <see cref="_disposeCts"/> so the lazy path can report
+    /// post-dispose state with no source in existence.</summary>
     private int _disposed;
 
-    /// <summary>Set when disposal is requested from within this observer's own in-flight notification
-    /// (see <see cref="IReentrantAsyncDisposable.DisposeFromNotificationAsync"/>). Tells
-    /// <see cref="DisposeAsyncCore"/> to skip the in-flight-call wait, which would otherwise self-join on the
-    /// very call awaiting the dispose once its continuation has hopped threads. Monotonic: only ever set, never
-    /// cleared, since disposal happens once.</summary>
+    /// <summary>Set when disposal is requested from inside this observer's own notification, telling
+    /// <see cref="DisposeAsyncCore"/> to skip the in-flight-call wait that would self-join on the caller once its
+    /// continuation hops threads.</summary>
     private int _disposeFromNotification;
 
-    /// <summary>Packed call-state: high 32 bits hold the managed-thread ID of the thread
-    /// currently inside <c>OnNext/OnError/OnCompleted</c>; low 32 bits hold the in-flight call
-    /// depth. Updated lock-free via <see cref="Interlocked.CompareExchange(ref long, long, long)"/>.
-    /// Replaces a monitor gate + two separate <c>int</c> fields, saving ~24 B per observer.</summary>
+    /// <summary>Packed call state: the high 32 bits hold the managed thread ID inside
+    /// <c>OnNext/OnError/OnCompleted</c>, the low 32 bits the in-flight call depth, updated lock-free through
+    /// <see cref="Interlocked.CompareExchange(ref long, long, long)"/>.</summary>
     private long _callState;
 
     /// <summary>Completion source that is set when all in-flight calls finish after disposal has been requested.</summary>
@@ -52,12 +45,8 @@ public abstract class WitnessAsync<T> : IObserverAsync<T>, IReentrantAsyncDispos
     /// <summary>Registration created by <see cref="LinkExternalCancellation(CancellationToken)"/> so the link can be released when the observer disposes.</summary>
     private CancellationTokenRegistration _externalLinkRegistration;
 
-    /// <summary>
-    /// The external token last passed to <see cref="LinkExternalCancellation(CancellationToken)"/>. Cached so
-    /// <see cref="TryEnterOnSomethingCall(CancellationToken, out LinkedTokenScope)"/> can treat it as a
-    /// fast-path-equal token: its cancellation already propagates to <see cref="_disposeCts"/>, so combining
-    /// it again per emission would allocate a redundant linked CTS.
-    /// </summary>
+    /// <summary>The token last passed to <see cref="LinkExternalCancellation(CancellationToken)"/>, cached because its
+    /// cancellation reaches <see cref="_disposeCts"/> anyway, so a call carrying it needs no linked source.</summary>
     private CancellationToken _externalLinkedToken;
 
     /// <summary>Initializes a new instance of the <see cref="WitnessAsync{T}"/> class.</summary>
@@ -74,19 +63,19 @@ protected WitnessAsync()
     protected WitnessAsync(CancellationToken externalLink) => LinkExternalCancellation(externalLink);
 
     /// <summary>
-    /// Gets the cancellation token that fires when this observer disposes, so a sibling operator can wire it
-    /// into a downstream observer's link chain (letting the downstream's hot-path equality check skip the
-    /// per-emission linked CTS allocation). Lazily materializes the backing <see cref="CancellationTokenSource"/>.
+    /// Gets the cancellation token that fires when this observer disposes, for an operator to link into a downstream
+    /// observer's dispose chain. Reading it creates the backing <see cref="CancellationTokenSource"/>.
     /// </summary>
     public CancellationToken InternalDisposedToken => GetOrCreateDisposeCts().Token;
 
     /// <summary>Gets a value indicating whether this observer has been disposed.</summary>
     internal bool HasDisposed => Volatile.Read(ref _disposed) != 0;
 
-    /// <summary>Asynchronously processes the next value in the sequence.</summary>
+    /// <summary>Delivers a value to <see cref="OnNextAsyncCore"/>, dropping it silently when this observer is disposed,
+    /// the token is cancelled, or another thread holds the notification gate.</summary>
     /// <param name="value">The value to be processed.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
-    /// <returns>A task that represents the asynchronous operation.</returns>
+    /// <returns>A task that completes once the core handler and its bookkeeping have run.</returns>
     public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
     {
         if (!TryEnterOnSomethingCall(cancellationToken, out var scope))
@@ -120,10 +109,11 @@ public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
         return OnNextAsyncSlow(core, scope);
     }
 
-    /// <summary>Handles an error by attempting to resume processing asynchronously.</summary>
+    /// <summary>Routes a non-terminal error to <see cref="OnErrorResumeAsyncCore"/>, never propagating a failure back
+    /// to the producer.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
-    /// <returns>A task that represents the asynchronous error handling operation.</returns>
+    /// <returns>A task that completes once the error has been handled.</returns>
     public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken)
     {
         if (!TryEnterOnSomethingCall(cancellationToken, out var scope))
@@ -131,10 +121,8 @@ public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellat
             return default;
         }
 
-        // RouteObserverErrorAsync is an async ValueTask method — any sync or async exception
-        // it raises is captured into the returned ValueTask and surfaces through the await in
-        // OnErrorResumeAsyncSlow. A try/catch around the invocation expression itself would be
-        // dead code in modern C# async semantics.
+        // RouteObserverErrorAsync is an async method, so a synchronous throw is captured into the returned
+        // ValueTask too and surfaces at the await in OnErrorResumeAsyncSlow; a try/catch here is dead code.
         var core = RouteObserverErrorAsync(error, scope.Token);
 
         if (core.IsCompletedSuccessfully)
@@ -147,14 +135,11 @@ public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellat
         return OnErrorResumeAsyncSlow(core, scope);
     }
 
-    /// <summary>
-    /// Asynchronously performs completion logic when the operation has finished, handling any finalization or cleanup
-    /// tasks required.
-    /// </summary>
+    /// <summary>Delivers the terminal result to <see cref="OnCompletedAsyncCore"/> and then disposes this observer.</summary>
     /// <param name="result">The result of the completed operation, containing information about its outcome.</param>
-    /// <returns>A task that represents the asynchronous completion operation.</returns>
-    /// <remarks>If an unhandled exception occurs during completion, it is passed to the unhandled exception
-    /// handler. This method ensures that necessary resources are released after completion.</remarks>
+    /// <returns>A task that completes once the core handler has run and this observer is torn down.</returns>
+    /// <remarks>A failure from the core handler goes to <see cref="UnhandledExceptionHandler"/>; disposal runs either
+    /// way.</remarks>
     [DebuggerStepThrough]
     public ValueTask OnCompletedAsync(Result result)
     {
@@ -186,10 +171,9 @@ public ValueTask OnCompletedAsync(Result result)
 
     /// <summary>Asynchronously releases the resources used by the object.</summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>Call this method to clean up resources when the object is no longer needed. This method is
-    /// safe to call multiple times; subsequent calls after disposal will have no effect. Any unhandled exceptions that
-    /// occur during disposal are captured and reported but do not prevent the completion of the dispose
-    /// operation.</remarks>
+    /// <remarks>Idempotent. Disposal waits out a notification in flight on another thread, and a failure while
+    /// releasing the source subscription is reported to <see cref="UnhandledExceptionHandler"/> rather than
+    /// thrown.</remarks>
     [DebuggerStepThrough]
     public async ValueTask DisposeAsync()
     {
@@ -216,11 +200,8 @@ public ValueTask AssignSourceSubscriptionAsync(IAsyncDisposable? value) =>
         SingleAssignmentDisposableAsync.AssignDisposableAsync(ref _sourceSubscription, value);
 
     /// <summary>
-    /// Internal wrapper around <see cref="LinkExternalCancellation(CancellationToken)"/> so sibling operators
-    /// (in their <c>SubscribeAsyncCore</c>) can wire an upstream observer's dispose token into this observer's
-    /// link chain. Combined with the cached <see cref="_externalLinkedToken"/> fast-path inside
-    /// <see cref="TryEnterOnSomethingCall(CancellationToken, out LinkedTokenScope)"/>, this turns chained
-    /// operator pipelines into per-emission allocation-free flows.
+    /// Makes an upstream observer's disposal dispose this observer too, so an operator chain tears down from the top
+    /// and its emissions need no linked cancellation source.
     /// </summary>
     /// <param name="upstream">The upstream observer's dispose token.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -270,9 +251,9 @@ internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out L
         }
     }
 
-    /// <summary>Exits a notification call, decrementing counters and signalling completion if disposal is pending.</summary>
-    /// <returns><see langword="true"/> if the caller should proceed with disposal; <see langword="false"/> if
-    /// disposal was already signalled to a waiting <see cref="DisposeAsync"/> call.</returns>
+    /// <summary>Leaves a notification call, releasing a <see cref="DisposeAsync"/> that is waiting on the last one.</summary>
+    /// <returns><see langword="true"/> when the caller should proceed with disposal itself; <see langword="false"/>
+    /// when a waiting <see cref="DisposeAsync"/> call was signalled instead.</returns>
     [DebuggerStepThrough]
     internal bool ExitOnSomethingCall()
     {
@@ -306,7 +287,8 @@ internal bool ExitOnSomethingCall()
         }
     }
 
-    /// <summary>Internal error-resume handler that delegates to <see cref="OnErrorResumeAsyncCore"/> and routes unhandled or cancelled errors to the <see cref="UnhandledExceptionHandler"/>.</summary>
+    /// <summary>Runs <see cref="OnErrorResumeAsyncCore"/>, sending anything it throws — and the original error when the
+    /// call is cancelled — to <see cref="UnhandledExceptionHandler"/>.</summary>
     /// <param name="error">The exception that triggered error handling.</param>
     /// <param name="cancellationToken">A cancellation token for the operation.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
@@ -332,32 +314,27 @@ internal async ValueTask RouteObserverErrorAsync(Exception error, CancellationTo
         }
     }
 
-    /// <summary>Performs asynchronous completion logic when the operation has finished processing the specified result.</summary>
+    /// <summary>Handles the sequence's terminal result. Called at most once, before this observer is disposed.</summary>
     /// <param name="result">The result of the operation to be processed during completion.</param>
-    /// <returns>A ValueTask that represents the asynchronous completion operation.</returns>
+    /// <returns>A task that completes when the result has been handled.</returns>
     protected abstract ValueTask OnCompletedAsyncCore(Result result);
 
     /// <summary>
-    /// Links an external cancellation token into this observer's dispose chain. When <paramref name="external"/>
-    /// is cancelled, the observer disposes — propagating cancellation through the linked token that subclasses
-    /// receive in their <c>OnNextAsyncCore</c> / <c>OnErrorResumeAsyncCore</c> arguments. This eliminates the
-    /// need to allocate a per-emission linked <see cref="CancellationTokenSource"/>. Each observer supports at
-    /// most one link; calling this method again replaces the previous registration.
+    /// Links an external cancellation token into this observer's dispose chain: cancelling <paramref name="external"/>
+    /// disposes the observer and cancels the token handed to <c>OnNextAsyncCore</c> and
+    /// <c>OnErrorResumeAsyncCore</c>. An observer holds at most one link, and a second call replaces it.
     /// </summary>
     /// <param name="external">The external token whose cancellation should trigger this observer's disposal.</param>
     [DebuggerStepThrough]
     protected void LinkExternalCancellation(CancellationToken external)
     {
-        // No-op fast path: token can't fire, so the dispose chain doesn't need it. Skip CTS
-        // materialization entirely — terminal observers that get CancellationToken.None
-        // pay nothing.
+        // A token that cannot fire adds nothing to the dispose chain, so skip creating the source entirely.
         if (!external.CanBeCanceled)
         {
             return;
         }
 
-        // External token already cancelled — materialize the CTS only to mark it cancelled
-        // (so future InternalDisposedToken consumers see the cancelled state).
+        // A cancelled token needs the source created only to hold the cancelled state for later token requests.
         if (external.IsCancellationRequested)
         {
             Volatile.Write(ref _disposed, 1);
@@ -383,16 +360,14 @@ protected void LinkExternalCancellation(CancellationToken external)
         _externalLinkedToken = external;
     }
 
-    /// <summary>Performs application-defined tasks associated with asynchronously releasing unmanaged resources.</summary>
+    /// <summary>Performs the observer's asynchronous teardown.</summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>Override this method to provide custom asynchronous resource cleanup logic in a derived
-    /// class. This method is called by DisposeAsync to perform the actual resource release.</remarks>
+    /// <remarks>An override must call the base implementation: it claims disposal for the first caller, waits out a
+    /// notification in flight on another thread, and releases the cancellation link and source subscription.</remarks>
     [DebuggerStepThrough]
     protected virtual async ValueTask DisposeAsyncCore()
     {
-        // First-disposer wins the race. Lazy-CTS observers set the _disposed flag without
-        // necessarily materializing a CTS; only callers that previously requested the token
-        // need the cancellation broadcast.
+        // First disposer wins; the latch moves whether or not a dispose source exists.
         if (Interlocked.Exchange(ref _disposed, 1) != 0)
         {
             return;
@@ -407,18 +382,13 @@ protected virtual async ValueTask DisposeAsyncCore()
         {
             TaskCompletionSource<object?> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            // Publish with an interlocked exchange rather than a release store: the re-read below must not
-            // be reordered ahead of the publish. ExitOnSomethingCall decrements the count under a full-fence
-            // CAS and only then reads this field, so once the publish is fenced, an Exit that still reads a
-            // null TCS must already have made its decrement visible to the re-read — one of the two sides
-            // always signals. A plain Volatile.Write leaves that store/load pair unordered and both sides
-            // can miss: Exit sees no TCS while this thread still sees a non-zero count, and the await below
-            // then never completes.
+            // Interlocked rather than a release store, so the re-read below cannot be reordered ahead of this
+            // publish. ExitOnSomethingCall decrements under a full-fence CAS and only then reads this field, so
+            // with the publish fenced, an Exit that reads a null source has made its decrement visible here and
+            // one of the two sides always signals. Unfenced, both can miss and the await below never completes.
             _ = Interlocked.Exchange(ref _allCallsCompletedTcs, tcs);
 
-            // Re-read after publishing the TCS — Exit may have raced past us and decremented
-            // the count to zero before our publish became visible. Self-signal so the awaiter
-            // doesn't deadlock.
+            // Exit may have dropped the count to zero before the publish became visible, so self-signal.
             var stateAfter = Volatile.Read(ref _callState);
             if ((int)stateAfter == 0)
             {
@@ -428,9 +398,7 @@ protected virtual async ValueTask DisposeAsyncCore()
             allOnSomethingCallsCompleted = tcs.Task;
         }
 
-        // Materialized CTS holders need cancellation propagated; lazy holders skip this step
-        // (any future InternalDisposedToken request will create a pre-cancelled CTS via
-        // GetOrCreateDisposeCts's post-disposed branch).
+        // Only an existing source needs the cancellation broadcast; a later token request builds one pre-cancelled.
         var cts = Volatile.Read(ref _disposeCts);
         if (cts is not null)
         {
@@ -440,26 +408,24 @@ protected virtual async ValueTask DisposeAsyncCore()
         await CompleteDisposeAfterCancelAsync(allOnSomethingCallsCompleted).ConfigureAwait(false);
     }
 
-    /// <summary>Handles an error by providing an asynchronous mechanism to resume execution after an exception occurs.</summary>
+    /// <summary>Handles a non-terminal error; the sequence may deliver more values afterwards.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous error handling operation.</param>
-    /// <returns>A ValueTask that represents the asynchronous operation of resuming execution after the error.</returns>
-    /// <remarks>Override this method to implement custom error recovery or resumption logic in derived
-    /// classes. The method is called when an error occurs and allows the operation to continue or perform cleanup
-    /// asynchronously.</remarks>
+    /// <returns>A task that completes when the error has been handled.</returns>
+    /// <remarks>An exception thrown from an override is reported to <see cref="UnhandledExceptionHandler"/> instead of
+    /// reaching the producer.</remarks>
     protected abstract ValueTask OnErrorResumeAsyncCore(Exception error, CancellationToken cancellationToken);
 
     /// <summary>Processes the next value in the asynchronous sequence.</summary>
     /// <param name="value">The value to be processed.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
-    /// <returns>A ValueTask that represents the asynchronous operation.</returns>
+    /// <returns>A task that completes when the value has been handled.</returns>
+    /// <remarks>An exception thrown from an override is fed to <see cref="OnErrorResumeAsyncCore"/>, so the sequence
+    /// survives a failed value; a cancellation is swallowed.</remarks>
     protected abstract ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken);
 
-    /// <summary>
-    /// Finishes the teardown after this caller won the cancellation race. Separated from
-    /// <see cref="DisposeAsyncCore"/> so the race-loser branch is just the absence of this
-    /// call, with no <c>return;</c> sequence point to mark uncovered.
-    /// </summary>
+    /// <summary>Awaits any in-flight notifications, then releases the cancellation link, the dispose source and the
+    /// source subscription.</summary>
     /// <param name="allOnSomethingCallsCompleted">Optional gate awaited for in-flight On* calls.</param>
     /// <returns>A task representing the asynchronous teardown.</returns>
     private async ValueTask CompleteDisposeAfterCancelAsync(Task? allOnSomethingCallsCompleted)
@@ -486,11 +452,9 @@ private async ValueTask CompleteDisposeAfterCancelAsync(Task? allOnSomethingCall
         }
     }
 
-    /// <summary>Returns the dispose task on the race-winner path (<see cref="ExitOnSomethingCall"/>
-    /// reports the last in-flight On* call just exited), or a completed default <see cref="ValueTask"/>
-    /// otherwise. Isolated from coverage because the race-winner branch is only reachable when a
-    /// concurrent <see cref="DisposeAsync"/> set the in-flight gate while this On* call was running.</summary>
-    /// <returns>The dispose task on race-winner, or default otherwise.</returns>
+    /// <summary>Chains into <see cref="DisposeAsync"/> when this exiting call owns disposal, which happens only when a
+    /// concurrent <see cref="DisposeAsync"/> raised the in-flight gate while the notification was running.</summary>
+    /// <returns>The dispose task when this caller owns disposal; otherwise a completed task.</returns>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private ValueTask CompleteOrChainDispose() =>
         ExitOnSomethingCall() ? DisposeAsync() : default;
@@ -521,9 +485,8 @@ private async ValueTask OnNextAsyncSlow(ValueTask core, LinkedTokenScope scope)
     }
 
     /// <summary>
-    /// Async continuation for <see cref="OnNextAsync"/> when <see cref="OnNextAsyncCore"/> threw synchronously.
-    /// Routes the error through <see cref="RouteObserverErrorAsync"/> off the fast path so the
-    /// caller-visible <see cref="OnNextAsync"/> stays state-machine free in the common case.
+    /// Routes a synchronous throw from <see cref="OnNextAsyncCore"/> through <see cref="RouteObserverErrorAsync"/>,
+    /// out of line so <see cref="OnNextAsync"/> itself needs no state machine.
     /// </summary>
     /// <param name="error">The exception thrown by the core.</param>
     /// <param name="scope">The linked-token scope to release on completion.</param>
@@ -583,10 +546,9 @@ private async ValueTask OnCompletedAsyncSlow(ValueTask core, LinkedTokenScope sc
         }
     }
 
-    /// <summary>Builds the <see cref="LinkedTokenScope"/> for the current call, allocating a
-    /// linked CTS only when the caller token isn't already one of the fast-path equivalents
-    /// (<see cref="CancellationToken.None"/>, our own dispose token if materialized, or the
-    /// upstream token already linked via <see cref="LinkExternalCancellation"/>).</summary>
+    /// <summary>Builds the <see cref="LinkedTokenScope"/> for one call, allocating a linked source only when the
+    /// caller's token is none of <see cref="CancellationToken.None"/>, this observer's own dispose token, or the token
+    /// linked through <see cref="LinkExternalCancellation"/> — each of which cancels the call anyway.</summary>
     /// <param name="cancellationToken">The caller-supplied cancellation token.</param>
     /// <returns>A scope whose <c>Token</c> drives the in-flight call's cancellation.</returns>
     private LinkedTokenScope BuildLinkedTokenScope(CancellationToken cancellationToken)
@@ -604,19 +566,14 @@ private LinkedTokenScope BuildLinkedTokenScope(CancellationToken cancellationTok
         return new(linkedCts, linkedCts.Token);
     }
 
-    /// <summary>Returns the existing <see cref="_disposeCts"/> or lazily creates it. If <see cref="_disposed"/>
-    /// was set before this call (the observer was disposed before any token was requested), the
-    /// freshly-created CTS is cancelled immediately so its <see cref="CancellationToken.IsCancellationRequested"/>
-    /// matches the post-dispose state callers expect.</summary>
-    /// <returns>The dispose CTS, freshly cancelled if disposal was already signaled.</returns>
+    /// <summary>Returns the dispose source, creating it on first request.</summary>
+    /// <returns>The dispose source, cancelled when this observer is disposed.</returns>
     private CancellationTokenSource GetOrCreateDisposeCts() =>
         Volatile.Read(ref _disposeCts) ?? MaterializeDisposeCts();
 
-    /// <summary>Creates and publishes the dispose CTS on first request, discarding the freshly-created instance
-    /// if another thread published one first, and pre-cancelling it when disposal was already signaled.</summary>
-    /// <returns>The published dispose CTS.</returns>
-    /// <remarks>The compare-exchange-lost branch is only reachable when two threads materialize the CTS
-    /// concurrently; isolated here and excluded from coverage as race-only.</remarks>
+    /// <summary>Creates and publishes the dispose source, discarding this instance when another thread wins the
+    /// publish, and cancelling it when the observer is disposed before any token was requested.</summary>
+    /// <returns>The published dispose source.</returns>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private CancellationTokenSource MaterializeDisposeCts()
     {
@@ -637,9 +594,8 @@ private CancellationTokenSource MaterializeDisposeCts()
     }
 
     /// <summary>
-    /// A lightweight scope that wraps an optional <see cref="CancellationTokenSource"/> and exposes the
-    /// effective <see cref="CancellationToken"/>. When no linked source is needed (e.g. the caller token
-    /// is <see cref="CancellationToken.None"/>), the scope avoids allocating a linked CTS entirely.
+    /// Pairs one notification call's effective cancellation token with the linked source backing it, if one was
+    /// needed, so disposing the scope releases that source.
     /// </summary>
     /// <param name="Cts">The linked CTS to dispose, or <see langword="null"/> if no allocation was needed.</param>
     /// <param name="Token">The effective cancellation token for the notification call.</param>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
index 9b9b729c..ff33b05b 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
@@ -8,9 +8,8 @@ namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
 /// Single-source sink that folds every observed value through an immutable value-type <typeparamref name="TAggregator"/>
-/// and emits the aggregate result once the source completes. The accumulator is advanced functionally through a
-/// constrained (devirtualized, allocation-free) call, so each concrete aggregate operator shares this one
-/// implementation without a base class or per-value indirection.
+/// and emits the aggregate result once the source completes. The accumulator is advanced functionally: each value
+/// yields a replacement accumulator rather than mutating the current one.
 /// </summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 /// <typeparam name="TResult">The terminal result type.</typeparam>
@@ -52,7 +51,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, _aggregator.Result, this, ref _done);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AllPredicateWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AllPredicateWitness.cs
index e15937c2..a0f06d89 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AllPredicateWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AllPredicateWitness.cs
@@ -60,7 +60,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => EmitCompleted(true);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AnyPredicateWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AnyPredicateWitness.cs
index 85ebf3dd..c12d0b8a 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AnyPredicateWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AnyPredicateWitness.cs
@@ -44,7 +44,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, false, this, ref _done);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AnyWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AnyWitness.cs
index b7f1d936..bab7f8a1 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AnyWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AnyWitness.cs
@@ -36,7 +36,7 @@ public sealed class AnyWitness<T> : IObserver<T>, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, false, this, ref _done);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AppendDelegateWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AppendDelegateWitness.cs
index 95909734..fca3f0c7 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AppendDelegateWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AppendDelegateWitness.cs
@@ -71,7 +71,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AppendWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AppendWitness.cs
index 2b333565..2efdcddc 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AppendWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AppendWitness.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Observer for append.</summary>
+/// <summary>Sink that forwards source values and emits one trailing value before completing.</summary>
 /// <typeparam name="T">The source value type.</typeparam>
 /// <param name="observer">The downstream observer.</param>
 /// <param name="value">The appended value.</param>
@@ -44,7 +44,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, _value, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
index 688f06f4..679e0776 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
@@ -36,10 +36,10 @@ public IDisposable Subscribe(IObserver<T> observer)
 
     /// <summary>Drives a single subscription's pump and coordinates single-owner enumerator disposal.</summary>
     /// <remarks>
-    /// Enumerator disposal is single-owner via an interlocked claim: whichever of the pump's
-    /// <c>finally</c> and <see cref="Dispose"/> wins disposes the enumerator exactly once. The disposer
-    /// disposes immediately when it wins, so a non-cooperative enumerator (one that ignores cancellation
-    /// in <see cref="IAsyncEnumerator{T}.MoveNextAsync"/>) is still torn down promptly without waiting on it.
+    /// Enumerator disposal is single-owner through an interlocked claim: whichever of the pump's
+    /// <c>finally</c> and <see cref="Dispose"/> wins the claim disposes the enumerator exactly once. The
+    /// winner disposes without awaiting <see cref="IAsyncEnumerator{T}.MoveNextAsync"/>, so an enumerator
+    /// that ignores cancellation is torn down promptly rather than at its own pace.
     /// </remarks>
     private sealed class Subscription : IDisposable
     {
@@ -91,12 +91,9 @@ public void Dispose()
             }
             catch (ObjectDisposedException)
             {
-                // The pump already completed and disposed the cancellation source.
+                // The pump completed and disposed the cancellation source.
             }
 
-            // Dispose the enumerator immediately when this path wins ownership, rather than waiting
-            // on MoveNextAsync, so a non-cooperative enumerator (one that ignores cancellation) is
-            // still torn down promptly. The pump's finally disposes it only if it wins the race.
             if (TryClaimEnumerator(out var enumerator))
             {
                 FireAndForgetDispose(enumerator);
@@ -107,13 +104,10 @@ public void Dispose()
 
         /// <summary>Disposes an enumerator without surfacing the resulting task to the caller.</summary>
         /// <param name="enumerator">The enumerator to dispose.</param>
-        /// <remarks>
-        /// The disposer cannot await, so disposal runs detached; the local method observes the task to
-        /// prevent unobserved-fault tear-downs, swallowing the <see cref="NotSupportedException"/> raised
-        /// by enumerators that only permit disposal from the enumeration path.
-        /// </remarks>
         private static void FireAndForgetDispose(IAsyncEnumerator<T> enumerator)
         {
+            // Disposal runs detached because IDisposable.Dispose cannot await it; the local method keeps
+            // the resulting task observed.
             _ = ObserveAsync(enumerator);
 
             static async Task ObserveAsync(IAsyncEnumerator<T> enumerator)
@@ -155,8 +149,8 @@ private async Task PumpAsync()
                 Volatile.Write(ref _enumerator, enumerator);
                 while (!_cts.IsCancellationRequested && await enumerator.MoveNextAsync().ConfigureAwait(false))
                 {
-                    // Re-check after the await: disposal may have torn down the observer while the
-                    // element was in flight, so a buffered value must not reach a stopped observer.
+                    // Re-check after the await: disposal may have torn the subscription down while the
+                    // element was in flight, and a buffered value must not reach a stopped observer.
                     if (_cts.IsCancellationRequested)
                     {
                         break;
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
index d134b943..8a0fd093 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
@@ -47,7 +47,6 @@ public void OnNext(T value)
         var buffer = _buffer;
         if (idx == 0)
         {
-            // Window starts: allocate exactly one array of the known window size.
             buffer = new T[_count];
             _buffer = buffer;
         }
@@ -65,13 +64,12 @@ public void OnNext(T value)
             return;
         }
 
-        // The window is full: hand the buffer over and reset to the skip *before* the hand-off. The
-        // observer may throw, and it must never be able to leave this sink holding an index into a
-        // buffer it has already released — the next value would index into null.
+        // Reset to the skip *before* the hand-off: the observer may throw, and the sink must never be left
+        // holding an index into a buffer it has released, because the next value would index into null.
         _buffer = null;
         _index = 0 - _skip;
 
-        // The window is full, so the array is exactly the right size; emit it directly.
+        // A full window is exactly the right size, so it needs no trimming.
         Emit(buffer!);
     }
 
@@ -114,7 +112,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
@@ -122,8 +120,8 @@ public void OnCompleted()
     /// <inheritdoc/>
     public void Dispose()
     {
-        // Latching here is what makes the sink terminal on every teardown path, including the one taken
-        // when the downstream observer throws out of Emit: a source that ignores disposal is then a no-op.
+        // Latching here makes the sink terminal on every teardown path, including disposal from Emit when
+        // the downstream observer throws, so a source that ignores disposal cannot push another value in.
         Volatile.Write(ref _done, 1);
         SinkSubscription.Dispose(ref _subscription);
     }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/CallbackWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/CallbackWitness.cs
index a7f772cc..d904bae3 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/CallbackWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/CallbackWitness.cs
@@ -47,7 +47,6 @@ public CallbackWitness(Action<T> onNext, Action<Exception>? onError, Action<Resu
 
     /// <summary>Rethrows the supplied exception without losing its stack information.</summary>
     /// <param name="error">The exception to rethrow.</param>
-    /// <remarks>Excluded from coverage: the unreachable sequence point after <see cref="ExceptionDispatchInfo"/> rethrow cannot be credited by cobertura.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private static void Rethrow(Exception error) => ExceptionDispatchInfo.Capture(error).Throw();
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/CollectArrayWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/CollectArrayWitness.cs
index 5f3b1c8b..0e4cbe0d 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/CollectArrayWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/CollectArrayWitness.cs
@@ -36,7 +36,7 @@ public sealed class CollectArrayWitness<T> : IObserver<T>, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, [.. _values], this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/CollectListWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/CollectListWitness.cs
index 0ad6e09c..681ddc59 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/CollectListWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/CollectListWitness.cs
@@ -36,7 +36,7 @@ public sealed class CollectListWitness<T> : IObserver<T>, IDisposable
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, _values, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ContainsWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/ContainsWitness.cs
index 971081b6..6e81eb35 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ContainsWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ContainsWitness.cs
@@ -64,7 +64,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => EmitCompleted(false);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DefaultIfEmptyWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/DefaultIfEmptyWitness.cs
index e3bd8665..00dfe5c8 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DefaultIfEmptyWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DefaultIfEmptyWitness.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Observer for default-if-empty.</summary>
+/// <summary>Sink that forwards source values, emitting a single fallback value when the source completes empty.</summary>
 /// <typeparam name="T">The source value type.</typeparam>
 /// <param name="observer">The downstream observer.</param>
 /// <param name="defaultValue">Value emitted for an empty source.</param>
@@ -62,7 +62,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DisposedMarker.cs b/src/ReactiveUI.Primitives.Core/Advanced/DisposedMarker.cs
index 2173c853..4b6b301c 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DisposedMarker.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DisposedMarker.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Disposable marker for disposed sinks.</summary>
+/// <summary>No-op disposable used as the sentinel value for a released subscription slot.</summary>
 public sealed class DisposedMarker : IDisposable
 {
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DisposedWitness{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/DisposedWitness{T}.cs
index 45f79723..551ac196 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DisposedWitness{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DisposedWitness{T}.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Observer that rejects every notification because the subscription has already been disposed.</summary>
+/// <summary>Observer that throws <see cref="ObjectDisposedException"/> from every notification, standing in for a disposed subscription.</summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 public sealed class DisposedWitness<T> : IObserver<T>
 {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByCountAggregator.cs b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByCountAggregator.cs
index ec35c879..e12843b4 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByCountAggregator.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByCountAggregator.cs
@@ -14,7 +14,7 @@ public readonly record struct
     /// <summary>The selector that projects each value to its distinctness key.</summary>
     private readonly Func<T, TKey> _keySelector;
 
-    /// <summary>The set of keys that have already been observed.</summary>
+    /// <summary>The set of keys observed so far.</summary>
     private readonly HashSet<TKey> _seen;
 
     /// <summary>Initializes a new instance of the <see cref="DistinctByCountAggregator{T,TKey}"/> struct.</summary>
@@ -27,7 +27,7 @@ public DistinctByCountAggregator(Func<T, TKey> keySelector, IEqualityComparer<TK
 
     /// <summary>Initializes a new instance of the <see cref="DistinctByCountAggregator{T,TKey}"/> struct.</summary>
     /// <param name="keySelector">The key selector.</param>
-    /// <param name="seen">The set of keys that have already been observed.</param>
+    /// <param name="seen">The set of keys observed so far.</param>
     /// <param name="result">The current accumulated count.</param>
     private DistinctByCountAggregator(Func<T, TKey> keySelector, HashSet<TKey> seen, int result)
     {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByLongCountAggregator.cs b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByLongCountAggregator.cs
index 2dd240f2..578fe421 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByLongCountAggregator.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByLongCountAggregator.cs
@@ -14,7 +14,7 @@ public readonly record struct
     /// <summary>The selector that projects each value to its distinctness key.</summary>
     private readonly Func<T, TKey> _keySelector;
 
-    /// <summary>The set of keys that have already been observed.</summary>
+    /// <summary>The set of keys observed so far.</summary>
     private readonly HashSet<TKey> _seen;
 
     /// <summary>Initializes a new instance of the <see cref="DistinctByLongCountAggregator{T,TKey}"/> struct.</summary>
@@ -27,7 +27,7 @@ public DistinctByLongCountAggregator(Func<T, TKey> keySelector, IEqualityCompare
 
     /// <summary>Initializes a new instance of the <see cref="DistinctByLongCountAggregator{T,TKey}"/> struct.</summary>
     /// <param name="keySelector">The key selector.</param>
-    /// <param name="seen">The set of keys that have already been observed.</param>
+    /// <param name="seen">The set of keys observed so far.</param>
     /// <param name="result">The current accumulated count.</param>
     private DistinctByLongCountAggregator(Func<T, TKey> keySelector, HashSet<TKey> seen, long result)
     {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByWitness.cs
index 62f8ab8b..743f60c9 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DistinctByWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DistinctByWitness.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Observer for distinct-by.</summary>
+/// <summary>Sink that forwards the first value seen for each key the selector produces.</summary>
 /// <typeparam name="T">The source value type.</typeparam>
 /// <typeparam name="TKey">The key type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("DistinctByWitness: Done = {_done}, SeenKeys = {_seen.Count}")]
@@ -65,7 +65,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this, ref _done);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/DistinctWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/DistinctWitness.cs
index 261734cc..090aa5f8 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/DistinctWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/DistinctWitness.cs
@@ -9,14 +9,14 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <summary>Sink that forwards the first occurrence of each value.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="observer">The downstream observer.</param>
-/// <param name="seen">The set used to track already-observed values.</param>
+/// <param name="seen">The set that records which values have been observed.</param>
 [System.Diagnostics.DebuggerDisplay("DistinctWitness: Seen = {_seen.Count}, Subscription = {_subscription}")]
 public sealed class DistinctWitness<T>(IObserver<T> observer, HashSet<T> seen) : IObserver<T>, IDisposable
 {
     /// <summary>The downstream observer.</summary>
     private readonly IObserver<T> _observer = observer;
 
-    /// <summary>The set of values already observed.</summary>
+    /// <summary>The set of values observed so far.</summary>
     private readonly HashSet<T> _seen = seen;
 
     /// <summary>The upstream subscription.</summary>
@@ -49,7 +49,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/EmptyWitness{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/EmptyWitness{T}.cs
index 7e91ee30..1633f09a 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/EmptyWitness{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/EmptyWitness{T}.cs
@@ -67,17 +67,17 @@ public EmptyWitness(Action<T> onNext, Action<Exception> onError, Action onComple
         _onCompleted = onCompleted;
     }
 
-    /// <summary>Calls the action implementing <see cref="IObserver{T}.OnCompleted()"/>.</summary>
+    /// <summary>Invokes the completion callback, doing nothing when none was supplied.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => (_onCompleted ?? nop)();
 
-    /// <summary>Calls the action implementing <see cref="IObserver{T}.OnError(Exception)"/>.</summary>
-    /// <param name="error">Error notification.</param>
+    /// <summary>Invokes the error callback, swallowing the error when none was supplied.</summary>
+    /// <param name="error">The terminal error.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnError(Exception error) => (_onError ?? nope)(error);
 
-    /// <summary>Calls the action implementing <see cref="IObserver{T}.OnNext(T)"/>.</summary>
-    /// <param name="value">Value notification.</param>
+    /// <summary>Invokes the value callback.</summary>
+    /// <param name="value">The observed value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnNext(T value) => _onNext(value);
 }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/FoldWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/FoldWitness.cs
index 604e6d3d..6a390231 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/FoldWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/FoldWitness.cs
@@ -53,7 +53,7 @@ public void OnNext(TSource value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/FromEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/FromEnumerableSignal{T}.cs
index 61c52d97..d2b6d180 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/FromEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/FromEnumerableSignal{T}.cs
@@ -32,14 +32,15 @@ public FromEnumerableSignal(IEnumerable<T> values, CancellationToken cancellatio
         _cancellationToken = cancellationToken;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns><see langword="false"/>.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The subscription.</returns>
+    /// <summary>Enumerates the source into <paramref name="observer"/> on the calling thread, completing it at the end.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; enumeration has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -80,11 +81,12 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The subscription.</returns>
+    /// <summary>Enumerates the source into the callbacks on the calling thread, invoking <paramref name="onCompleted"/> at the end.</summary>
+    /// <param name="onNext">Invoked for each value.</param>
+    /// <param name="onError">Never invoked; enumeration faults propagate to the caller.</param>
+    /// <param name="onCompleted">Invoked once the source is drained, unless cancellation stops enumeration first.</param>
+    /// <returns>An empty disposable; enumeration has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> or <paramref name="onCompleted"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
@@ -110,9 +112,9 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Attempts to expose the backing sequence when it is already indexable and cannot be cancelled.</summary>
-    /// <param name="values">The indexable values.</param>
-    /// <returns><see langword="true"/> when values can be read without enumeration allocations.</returns>
+    /// <summary>Exposes the backing sequence directly when it is an indexable list and no cancellation token was supplied.</summary>
+    /// <param name="values">The indexable values, or an empty list when the sequence cannot be exposed.</param>
+    /// <returns><see langword="true"/> when the values can be read without enumerating.</returns>
     public bool TryGetReadOnlyValues(out IReadOnlyList<T> values)
     {
         if (_cancellationToken.CanBeCanceled)
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs b/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
index d14a4926..a7f1fd99 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
@@ -7,12 +7,12 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <summary>
 /// An immutable value-type accumulator for a single-source aggregate sink: each <see cref="Add"/> folds a value
 /// into the running state and returns the next accumulator, while <see cref="Result"/> yields the terminal value.
-/// Implemented as a <see langword="readonly record struct"/> so <see cref="AggregateWitness{T,TResult,TAggregator}"/>
-/// can advance it through a constrained, devirtualized, allocation-free call rather than an interface or delegate dispatch.
+/// Implement it as a <see langword="readonly record struct"/> so
+/// <see cref="AggregateWitness{T,TResult,TAggregator}"/> can fold without allocating per value.
 /// </summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 /// <typeparam name="TResult">The terminal result type.</typeparam>
-/// <typeparam name="TSelf">The implementing accumulator type, returned by <see cref="Add"/> so folding stays allocation-free.</typeparam>
+/// <typeparam name="TSelf">The implementing accumulator type, returned by <see cref="Add"/>.</typeparam>
 public interface IAggregator<in T, out TResult, TSelf>
     where TSelf : IAggregator<T, TResult, TSelf>
 {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/IInlineSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/IInlineSignal{T}.cs
index b159ab28..5f52a7d2 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/IInlineSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/IInlineSignal{T}.cs
@@ -4,14 +4,14 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the IInlineSignal interface.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>A signal that accepts callbacks directly, so a subscriber needs no intermediate observer.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 public interface IInlineSignal<T> : IObservable<T>
 {
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes the supplied callbacks to the signal.</summary>
+    /// <param name="onNext">Invoked for each value.</param>
+    /// <param name="onError">Invoked with the terminal error.</param>
+    /// <param name="onCompleted">Invoked when the signal completes.</param>
+    /// <returns>A handle that detaches the callbacks when disposed.</returns>
     IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted);
 }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/IRequireCurrentThread.cs b/src/ReactiveUI.Primitives.Core/Advanced/IRequireCurrentThread.cs
index cb88ea51..7a4a537f 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/IRequireCurrentThread.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/IRequireCurrentThread.cs
@@ -4,13 +4,11 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Marks a sequencer that must run on the current thread.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <summary>A signal that reports whether it has to be subscribed to from the calling thread.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 public interface IRequireCurrentThread<out T> : IObservable<T>
 {
-    /// <summary>Determines whether [is required subscribe on current thread].</summary>
-    /// <returns>
-    ///   <c>true</c> if [is required subscribe on current thread]; otherwise, <c>false</c>.
-    /// </returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns><see langword="true"/> when the signal is bound to the subscribing thread.</returns>
     bool IsRequiredSubscribeOnCurrentThread();
 }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/IgnoreValuesWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/IgnoreValuesWitness.cs
index 591687c1..0f449289 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/IgnoreValuesWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/IgnoreValuesWitness.cs
@@ -35,7 +35,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
index 2e2ee0ba..3a9848db 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
@@ -7,26 +7,27 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmediateReturnSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Signal that emits one value and completes synchronously inside <c>Subscribe</c>.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ImmediateReturnSignal: Value = {_value}")]
 public sealed class ImmediateReturnSignal<T> : IRequireCurrentThread<T>, IInlineSignal<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The value emitted to every subscriber.</summary>
     private readonly T _value;
 
     /// <summary>Initializes a new instance of the <see cref="ImmediateReturnSignal{T}"/> class.</summary>
     /// <param name="value">The value.</param>
     public ImmediateReturnSignal(T value) => _value = value;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the value to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -36,11 +37,11 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with the value, then <paramref name="onCompleted"/>, before returning.</summary>
+    /// <param name="onNext">Invoked with the value.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the value.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         onNext(_value);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
index 7ca197b6..8c80ae1c 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
@@ -7,8 +7,8 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the immediate Throw signal fast path.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Signal that delivers a terminal error synchronously inside <c>Subscribe</c>.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ImmediateThrowSignal: Error = {_error}")]
 public sealed class ImmediateThrowSignal<T> : IRequireCurrentThread<T>, IInlineSignal<T>
 {
@@ -19,14 +19,15 @@ public sealed class ImmediateThrowSignal<T> : IRequireCurrentThread<T>, IInlineS
     /// <param name="error">The terminal error.</param>
     public ImmediateThrowSignal(Exception error) => _error = error;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Faults <paramref name="observer"/> with the stored error before returning.</summary>
+    /// <param name="observer">The observer to fault.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -35,11 +36,11 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onError"/> with the stored error before returning.</summary>
+    /// <param name="onNext">Never invoked.</param>
+    /// <param name="onError">Invoked with the stored error.</param>
+    /// <param name="onCompleted">Never invoked.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         onError(_error);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
index 2b97c2de..bacd6d05 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
@@ -7,12 +7,11 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmutableEmptySignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Signal that completes synchronously inside <c>Subscribe</c> without emitting a value.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 public sealed class ImmutableEmptySignal<T> : IRequireCurrentThread<T>, IInlineSignal<T>
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The shared instance; the signal carries no per-subscription state.</summary>
     public static readonly ImmutableEmptySignal<T> Instance = new();
 
     /// <summary>Initializes a new instance of the <see cref="ImmutableEmptySignal{T}"/> class.</summary>
@@ -20,14 +19,15 @@ private ImmutableEmptySignal()
     {
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Completes <paramref name="observer"/> before returning.</summary>
+    /// <param name="observer">The observer to complete.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -36,11 +36,11 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onCompleted"/> before returning.</summary>
+    /// <param name="onNext">Never invoked.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked before this method returns.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         onCompleted();
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableNeverSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableNeverSignal{T}.cs
index 00f13ef7..04b57410 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableNeverSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableNeverSignal{T}.cs
@@ -7,22 +7,21 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmutableNeverSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
+/// <summary>Signal that never emits a value and never terminates.</summary>
+/// <typeparam name="T">The value type.</typeparam>
 public sealed class ImmutableNeverSignal<T> : IRequireCurrentThread<T>
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The shared instance; the signal carries no per-subscription state.</summary>
     public static readonly ImmutableNeverSignal<T> Instance = new();
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Accepts the observer without ever notifying it.</summary>
+    /// <param name="observer">The observer, which receives nothing.</param>
+    /// <returns>An empty disposable; there is no subscription to release.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) =>
         EmptyDisposable.Instance;
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnFalseSignal.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnFalseSignal.cs
index b6f1d90a..aece6b9b 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnFalseSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnFalseSignal.cs
@@ -7,11 +7,10 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmutableReturnFalseSignal class.</summary>
+/// <summary>Signal that emits <see langword="false"/> and completes synchronously inside <c>Subscribe</c>.</summary>
 public sealed class ImmutableReturnFalseSignal : IRequireCurrentThread<bool>, IInlineSignal<bool>
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The shared instance; the signal carries no per-subscription state.</summary>
     public static readonly ImmutableReturnFalseSignal Instance = new();
 
     /// <summary>Initializes a new instance of the <see cref="ImmutableReturnFalseSignal"/> class.</summary>
@@ -19,14 +18,14 @@ private ImmutableReturnFalseSignal()
     {
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits <see langword="false"/> to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(IObserver<bool> observer)
     {
         observer.OnNext(false);
@@ -34,11 +33,11 @@ public IDisposable Subscribe(IObserver<bool> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with <see langword="false"/>, then <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked with <see langword="false"/>.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the value.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<bool> onNext, Action<Exception> onError, Action onCompleted)
     {
         onNext(false);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnInt32Signal.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnInt32Signal.cs
index 1764e0db..b113386a 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnInt32Signal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnInt32Signal.cs
@@ -7,18 +7,17 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmutableReturnInt32Signal class.</summary>
+/// <summary>Signal that emits a single <see cref="int"/> and completes synchronously inside <c>Subscribe</c>.</summary>
 [System.Diagnostics.DebuggerDisplay("ImmutableReturnInt32Signal: Value = {_x}")]
 public sealed class ImmutableReturnInt32Signal : IRequireCurrentThread<int>, IInlineSignal<int>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The lowest value with a cached instance.</summary>
     private const int MinCachedValue = -1;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The highest value with a cached instance.</summary>
     private const int MaxCachedValue = 9;
 
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The instances cached for values from <see cref="MinCachedValue"/> to <see cref="MaxCachedValue"/>.</summary>
     private static readonly ImmutableReturnInt32Signal[] Caches =
     [
         new(-1),
@@ -34,29 +33,29 @@ public sealed class ImmutableReturnInt32Signal : IRequireCurrentThread<int>, IIn
         new(9)
     ];
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The value emitted to every subscriber.</summary>
     private readonly int _x;
 
     /// <summary>Initializes a new instance of the <see cref="ImmutableReturnInt32Signal"/> class.</summary>
-    /// <param name="x">The x value.</param>
+    /// <param name="x">The value to emit.</param>
     public ImmutableReturnInt32Signal(int x) => _x = x;
 
-    /// <summary>Executes the GetInt32Signals operation.</summary>
-    /// <param name="x">The x value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Returns a signal emitting <paramref name="x"/>, reusing a cached instance for small values.</summary>
+    /// <param name="x">The value to emit.</param>
+    /// <returns>A signal that emits <paramref name="x"/> and completes.</returns>
     public static IObservable<int> GetInt32Signals(int x) =>
         x is >= MinCachedValue and <= MaxCachedValue
             ? Caches[x - MinCachedValue]
             : new ImmediateReturnSignal<int>(x);
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the value to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(IObserver<int> observer)
     {
         observer.OnNext(_x);
@@ -64,11 +63,11 @@ public IDisposable Subscribe(IObserver<int> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with the value, then <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked with the value.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the value.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<int> onNext, Action<Exception> onError, Action onCompleted)
     {
         onNext(_x);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnTrueSignal.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnTrueSignal.cs
index 82dcce97..12344a36 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnTrueSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableReturnTrueSignal.cs
@@ -7,11 +7,10 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the ImmutableReturnTrueSignal class.</summary>
+/// <summary>Signal that emits <see langword="true"/> and completes synchronously inside <c>Subscribe</c>.</summary>
 public sealed class ImmutableReturnTrueSignal : IRequireCurrentThread<bool>, IInlineSignal<bool>
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>The shared instance; the signal carries no per-subscription state.</summary>
     public static readonly ImmutableReturnTrueSignal Instance = new();
 
     /// <summary>Initializes a new instance of the <see cref="ImmutableReturnTrueSignal"/> class.</summary>
@@ -19,14 +18,14 @@ private ImmutableReturnTrueSignal()
     {
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits <see langword="true"/> to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(IObserver<bool> observer)
     {
         observer.OnNext(true);
@@ -34,11 +33,11 @@ public IDisposable Subscribe(IObserver<bool> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with <see langword="true"/>, then <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked with <see langword="true"/>.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the value.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<bool> onNext, Action<Exception> onError, Action onCompleted)
     {
         onNext(true);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/KeepNotNullWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/KeepNotNullWitness.cs
index d1c7739b..a13a15d7 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/KeepNotNullWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/KeepNotNullWitness.cs
@@ -49,7 +49,7 @@ public void OnNext(T? value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/KeepTypeWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/KeepTypeWitness.cs
index 62d6b954..27ee1fc8 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/KeepTypeWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/KeepTypeWitness.cs
@@ -48,7 +48,7 @@ public void OnNext(object? value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/RangeConcatSignal.cs b/src/ReactiveUI.Primitives.Core/Advanced/RangeConcatSignal.cs
index 1a554c22..b0344896 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/RangeConcatSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/RangeConcatSignal.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Concatenates synchronous integer ranges without outer observable/coordinator overhead.</summary>
+/// <summary>Signal that emits several integer ranges back to back, synchronously inside <c>Subscribe</c>.</summary>
 [System.Diagnostics.DebuggerDisplay("RangeConcatSignal: Ranges = {_ranges.Length}")]
 public sealed class RangeConcatSignal : IRequireCurrentThread<int>, IInlineSignal<int>
 {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/RangeSignal.cs b/src/ReactiveUI.Primitives.Core/Advanced/RangeSignal.cs
index a398359c..84cf8b77 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/RangeSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/RangeSignal.cs
@@ -7,13 +7,13 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the RangeSignal class.</summary>
+/// <summary>Signal that emits a contiguous run of integers, synchronously inside <c>Subscribe</c>.</summary>
 [System.Diagnostics.DebuggerDisplay("RangeSignal: Start = {Start}, Count = {Count}")]
 public sealed class RangeSignal : IRequireCurrentThread<int>, IInlineSignal<int>
 {
     /// <summary>Initializes a new instance of the <see cref="RangeSignal"/> class.</summary>
-    /// <param name="start">The start value.</param>
-    /// <param name="count">The count value.</param>
+    /// <param name="start">The first value emitted.</param>
+    /// <param name="count">The number of values emitted.</param>
     public RangeSignal(int start, int count)
     {
         Start = start;
@@ -26,14 +26,15 @@ public RangeSignal(int start, int count)
     /// <summary>Gets the number of values emitted by the range.</summary>
     public int Count { get; }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the whole range to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the range has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<int> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -47,11 +48,12 @@ public IDisposable Subscribe(IObserver<int> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the whole range to <paramref name="onNext"/>, then invokes <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked for each value in the range.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the last value.</param>
+    /// <returns>An empty disposable; the range has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(Action<int> onNext, Action<Exception> onError, Action onCompleted)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/RangeZipSignal{TResult}.cs b/src/ReactiveUI.Primitives.Core/Advanced/RangeZipSignal{TResult}.cs
index 78346985..aa3c6277 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/RangeZipSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/RangeZipSignal{TResult}.cs
@@ -7,21 +7,21 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Zips two synchronous integer ranges without coordinator queues.</summary>
+/// <summary>Signal that pairs two integer ranges position by position, synchronously inside <c>Subscribe</c>.</summary>
 /// <typeparam name="TResult">The result value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("RangeZipSignal: Count = {_count}, LeftStart = {_leftStart}, RightStart = {_rightStart}")]
 public sealed class RangeZipSignal<TResult> : IRequireCurrentThread<TResult>, IInlineSignal<TResult>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The first value of the left range.</summary>
     private readonly int _leftStart;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The first value of the right range.</summary>
     private readonly int _rightStart;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The number of pairs emitted, the shorter of the two ranges.</summary>
     private readonly int _count;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The projection applied to each pair.</summary>
     private readonly Func<int, int, TResult> _selector;
 
     /// <summary>Initializes a new instance of the <see cref="RangeZipSignal{TResult}"/> class.</summary>
@@ -36,14 +36,15 @@ public RangeZipSignal(RangeSignal left, RangeSignal right, Func<int, int, TResul
         _selector = selector;
     }
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits every projected pair to <paramref name="observer"/> and completes it before returning.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; both ranges are drained by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<TResult> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -57,11 +58,12 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits every projected pair to <paramref name="onNext"/>, then invokes <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked for each projected pair.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the last pair.</param>
+    /// <returns>An empty disposable; both ranges are drained by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(Action<TResult> onNext, Action<Exception> onError, Action onCompleted)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ReduceWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/ReduceWitness.cs
index e863145c..6c975474 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ReduceWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ReduceWitness.cs
@@ -41,7 +41,7 @@ public sealed class ReduceWitness<TSource, TAccumulate>(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, _current, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/RepeatSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/RepeatSignal{T}.cs
index db15364c..a96805cb 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/RepeatSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/RepeatSignal{T}.cs
@@ -7,27 +7,28 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Represents the RepeatSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
-/// <param name="value">The value.</param>
-/// <param name="count">The count value.</param>
+/// <summary>Signal that emits one value a fixed number of times, synchronously inside <c>Subscribe</c>.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="value">The value to emit.</param>
+/// <param name="count">The number of times to emit the value.</param>
 [System.Diagnostics.DebuggerDisplay("RepeatSignal: Value = {_value}, Count = {_count}")]
 public sealed class RepeatSignal<T>(T value, int count) : IRequireCurrentThread<T>, IInlineSignal<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The value to emit.</summary>
     private readonly T _value = value;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The number of times to emit the value.</summary>
     private readonly int _count = count;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
+    /// <returns>Always <see langword="false"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool IsRequiredSubscribeOnCurrentThread() => false;
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Emits the value the configured number of times to <paramref name="observer"/>, then completes it.</summary>
+    /// <param name="observer">The observer to notify.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -41,11 +42,12 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the Subscribe operation.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <param name="onError">The onError value.</param>
-    /// <param name="onCompleted">The onCompleted value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Invokes <paramref name="onNext"/> with the value the configured number of times, then <paramref name="onCompleted"/>.</summary>
+    /// <param name="onNext">Invoked once per repetition.</param>
+    /// <param name="onError">Never invoked.</param>
+    /// <param name="onCompleted">Invoked after the last repetition.</param>
+    /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs b/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
index 258dfcd1..d4448eb4 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
@@ -7,17 +7,16 @@
 namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
-/// Shared single-upstream-subscription management for sink observers. Operating on a caller-owned
-/// <see cref="IDisposable"/> field through a <see langword="ref"/> parameter lets each sink implement
-/// <see cref="IObserver{T}"/> directly — with no shared base class, and therefore no virtual-dispatch
-/// overhead on the hot notification path — while still sharing the assign-once / dispose-once teardown.
+/// Assign-once, dispose-once management of a sink's single upstream subscription. Each helper takes the
+/// caller-owned <see cref="IDisposable"/> field by <see langword="ref"/>, so a sink can implement
+/// <see cref="IObserver{T}"/> directly without deriving from a shared base class.
 /// </summary>
 public static class SinkSubscription
 {
     /// <summary>Sentinel stored once a sink is disposed so any late subscription is torn down immediately.</summary>
     private static readonly IDisposable DisposedSentinel = new DisposedMarker();
 
-    /// <summary>Assigns the upstream subscription, disposing it immediately if the sink already holds one or has been disposed.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming value when the field holds a subscription or the sink has been disposed.</summary>
     /// <param name="subscription">The caller-owned subscription field.</param>
     /// <param name="value">The upstream subscription to assign.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs b/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
index ba238925..160d0185 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
@@ -5,10 +5,9 @@
 namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
-/// Shared terminal-forwarding helpers for single-source sink observers. Each sink computes a
-/// single result and forwards it downstream exactly once, disposing itself afterwards. Centralizing the
-/// forward-then-dispose <c>using</c> scope — and the <c>done</c> latch that guards it — keeps the
-/// individual sinks to their distinguishing accumulation logic and removes the otherwise-identical terminal boilerplate.
+/// Terminal-forwarding helpers for single-source sink observers: deliver one terminal notification
+/// downstream and dispose the sink afterwards, optionally latching a caller-owned <c>done</c> flag so only
+/// the first terminal call reaches the observer.
 /// </summary>
 public static class SinkTerminal
 {
@@ -30,7 +29,7 @@ public static void Fault<TResult>(IObserver<TResult> observer, Exception error,
     /// <param name="observer">The downstream observer.</param>
     /// <param name="error">The error to forward.</param>
     /// <param name="sink">The sink to dispose once the error has been delivered.</param>
-    /// <param name="done">The caller-owned terminal latch; ignored once already set.</param>
+    /// <param name="done">The caller-owned terminal latch; the call is a no-op when it is set.</param>
     public static void Fault<TResult>(IObserver<TResult> observer, Exception error, IDisposable sink, ref bool done)
     {
         if (done)
@@ -61,7 +60,7 @@ public static void Complete<TResult>(IObserver<TResult> observer, TResult value,
     /// <param name="observer">The downstream observer.</param>
     /// <param name="value">The single terminal value to emit.</param>
     /// <param name="sink">The sink to dispose once completion has been delivered.</param>
-    /// <param name="done">The caller-owned terminal latch; ignored once already set.</param>
+    /// <param name="done">The caller-owned terminal latch; the call is a no-op when it is set.</param>
     public static void Complete<TResult>(IObserver<TResult> observer, TResult value, IDisposable sink, ref bool done)
     {
         if (done)
@@ -89,7 +88,7 @@ public static void Complete<TResult>(IObserver<TResult> observer, IDisposable si
     /// <typeparam name="TResult">The downstream result type.</typeparam>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="sink">The sink to dispose once completion has been delivered.</param>
-    /// <param name="done">The caller-owned terminal latch; ignored once already set.</param>
+    /// <param name="done">The caller-owned terminal latch; the call is a no-op when it is set.</param>
     public static void Complete<TResult>(IObserver<TResult> observer, IDisposable sink, ref bool done)
     {
         if (done)
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SkipWhileWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/SkipWhileWitness.cs
index daf4f90e..d652e8de 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SkipWhileWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SkipWhileWitness.cs
@@ -19,7 +19,7 @@ public sealed class SkipWhileWitness<T>(IObserver<T> observer, Func<T, bool> pre
     /// <summary>The predicate that determines whether to keep skipping values.</summary>
     private readonly Func<T, bool> _predicate = predicate;
 
-    /// <summary>A value indicating whether the skipping phase is still active.</summary>
+    /// <summary>A value indicating whether the sink is in its skipping phase.</summary>
     private bool _skipping = true;
 
     /// <summary>The upstream subscription.</summary>
@@ -53,7 +53,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SkipWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/SkipWitness.cs
index 72a9610b..afff21d4 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SkipWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SkipWitness.cs
@@ -50,7 +50,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/StatefulWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/StatefulWitness.cs
index 74313c37..036deec5 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/StatefulWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/StatefulWitness.cs
@@ -58,7 +58,6 @@ public StatefulWitness(
     /// <summary>Rethrows the supplied exception without losing its stack information.</summary>
     /// <param name="error">The exception to rethrow.</param>
     /// <param name="state">Unused callback state.</param>
-    /// <remarks>Excluded from coverage: the unreachable sequence point after <see cref="ExceptionDispatchInfo"/> rethrow cannot be credited by cobertura.</remarks>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private static void Rethrow(Exception error, TState state)
     {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
index 15c992b0..d2f17bc4 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
@@ -28,7 +28,7 @@ public static void Release(ref IDisposable? slot)
         current.Dispose();
     }
 
-    /// <summary>Stores a subscription into an empty slot, disposing it instead if the slot is already released.</summary>
+    /// <summary>Stores a subscription into an empty slot, disposing it instead when the slot is occupied or released.</summary>
     /// <param name="slot">The target slot.</param>
     /// <param name="subscription">The subscription to store.</param>
     public static void Assign(ref IDisposable? slot, IDisposable subscription)
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
index 62599da0..05968d3d 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
@@ -7,10 +7,9 @@
 namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
-/// Observer that serializes notifications behind a gate so downstream operators always observe the
-/// single-threaded <c>OnNext*</c> then <c>OnError</c>|<c>OnCompleted</c> grammar they depend on, even when the
-/// upstream source delivers concurrently. Stateful sinks (counting, distinct, buffering) rely on that
-/// grammar; placing one of these ahead of them is the supported way to consume a non-conformant source.
+/// Observer that serializes notifications behind a gate, so downstream operators observe the single-threaded
+/// <c>OnNext*</c> then <c>OnError</c>|<c>OnCompleted</c> grammar even when the upstream source delivers
+/// concurrently. Place one ahead of a stateful sink to consume a source that does not honour that grammar.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("SynchronizeWitness: Observer = {_observer}, Subscription = {_subscription}")]
@@ -68,7 +67,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/TakeWhileWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/TakeWhileWitness.cs
index 1b8f6bcb..62f3a26c 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/TakeWhileWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/TakeWhileWitness.cs
@@ -65,7 +65,7 @@ public void OnError(Exception error)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => Complete();
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/TakeWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/TakeWitness.cs
index 18405486..0fcf92cb 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/TakeWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/TakeWitness.cs
@@ -26,7 +26,7 @@ public sealed class TakeWitness<T>(IObserver<T> observer, int count) : IObserver
     /// <summary>Non-zero after completion, error, or disposal.</summary>
     private int _stopped;
 
-    /// <summary>Sets the upstream subscription.</summary>
+    /// <summary>Assigns the upstream subscription so the sink can release it once the count is reached.</summary>
     /// <param name="subscription">Upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => _subscription.Create(subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/TapWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/TapWitness.cs
index 66d95268..364c0a7c 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/TapWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/TapWitness.cs
@@ -69,7 +69,7 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UnfoldSignal{TState,TResult}.cs b/src/ReactiveUI.Primitives.Core/Advanced/UnfoldSignal{TState,TResult}.cs
index 396fad81..c1fa6b15 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UnfoldSignal{TState,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UnfoldSignal{TState,TResult}.cs
@@ -7,13 +7,13 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Finite state expansion signal.</summary>
-/// <typeparam name="TState">State type.</typeparam>
-/// <typeparam name="TResult">Result type.</typeparam>
-/// <param name="initialState">Initial state.</param>
-/// <param name="condition">Loop condition.</param>
-/// <param name="iterate">State iterator.</param>
-/// <param name="resultSelector">Result selector.</param>
+/// <summary>Signal that walks a state machine synchronously, emitting one projected value per iteration.</summary>
+/// <typeparam name="TState">The state type.</typeparam>
+/// <typeparam name="TResult">The emitted value type.</typeparam>
+/// <param name="initialState">The state the walk starts from.</param>
+/// <param name="condition">Evaluated before each iteration; emission stops when it returns <see langword="false"/>.</param>
+/// <param name="iterate">Produces the next state from the current one.</param>
+/// <param name="resultSelector">Projects the current state to the emitted value.</param>
 [System.Diagnostics.DebuggerDisplay("UnfoldSignal: InitialState = {_initialState}, Condition = {_condition}")]
 public sealed class UnfoldSignal<TState, TResult>(
     TState initialState,
@@ -21,16 +21,16 @@ public sealed class UnfoldSignal<TState, TResult>(
     Func<TState, TState> iterate,
     Func<TState, TResult> resultSelector) : IRequireCurrentThread<TResult>, IInlineSignal<TResult>
 {
-    /// <summary>Initial state.</summary>
+    /// <summary>The state the walk starts from.</summary>
     private readonly TState _initialState = initialState;
 
-    /// <summary>Loop condition.</summary>
+    /// <summary>The continuation condition, evaluated before each iteration.</summary>
     private readonly Func<TState, bool> _condition = condition;
 
-    /// <summary>State iterator.</summary>
+    /// <summary>The transition from the current state to the next.</summary>
     private readonly Func<TState, TState> _iterate = iterate;
 
-    /// <summary>Result selector.</summary>
+    /// <summary>The projection from state to emitted value.</summary>
     private readonly Func<TState, TResult> _resultSelector = resultSelector;
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UniqueByWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/UniqueByWitness.cs
index 7182af77..03199651 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UniqueByWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UniqueByWitness.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <typeparam name="TKey">The key type.</typeparam>
 /// <param name="observer">The downstream observer.</param>
 /// <param name="keySelector">The key projection.</param>
-/// <param name="comparer">The comparer used to compare adjacent keys.</param>
+/// <param name="comparer">The comparer applied to adjacent keys.</param>
 [System.Diagnostics.DebuggerDisplay("UniqueByWitness: HasLast = {_hasLast}, Last = {_last}")]
 public sealed class UniqueByWitness<T, TKey>(
     IObserver<T> observer,
@@ -24,7 +24,7 @@ public sealed class UniqueByWitness<T, TKey>(
     /// <summary>The key projection.</summary>
     private readonly Func<T, TKey> _keySelector = keySelector;
 
-    /// <summary>The comparer used to compare adjacent keys.</summary>
+    /// <summary>The comparer applied to adjacent keys.</summary>
     private readonly IEqualityComparer<TKey> _comparer = comparer;
 
     /// <summary>A value indicating whether a previous key has been observed.</summary>
@@ -66,7 +66,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UniqueWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/UniqueWitness.cs
index 63ef5653..464bf21f 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UniqueWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UniqueWitness.cs
@@ -9,14 +9,14 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <summary>Sink that suppresses adjacent duplicate values.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="observer">The downstream observer.</param>
-/// <param name="comparer">The comparer used to compare adjacent values.</param>
+/// <param name="comparer">The comparer applied to adjacent values.</param>
 [System.Diagnostics.DebuggerDisplay("UniqueWitness: HasLast = {_hasLast}, Last = {_last}")]
 public sealed class UniqueWitness<T>(IObserver<T> observer, IEqualityComparer<T> comparer) : IObserver<T>, IDisposable
 {
     /// <summary>The downstream observer.</summary>
     private readonly IObserver<T> _observer = observer;
 
-    /// <summary>The comparer used to compare adjacent values.</summary>
+    /// <summary>The comparer applied to adjacent values.</summary>
     private readonly IEqualityComparer<T> _comparer = comparer;
 
     /// <summary>A value indicating whether a previous value has been observed.</summary>
@@ -57,7 +57,7 @@ public void OnNext(T value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => SinkTerminal.Complete(_observer, this);
 
-    /// <summary>Assigns the upstream subscription, disposing it if one is already held.</summary>
+    /// <summary>Assigns the upstream subscription, disposing the incoming one when this sink holds a subscription or has been disposed.</summary>
     /// <param name="subscription">The upstream subscription.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription);
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
index 893e439c..f0b69257 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
@@ -7,21 +7,24 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>Resource-scoped signal.</summary>
-/// <typeparam name="TResource">Resource type.</typeparam>
-/// <typeparam name="T">Value type.</typeparam>
-/// <param name="resourceFactory">Resource factory.</param>
-/// <param name="signalFactory">Signal factory.</param>
+/// <summary>
+/// Signal that creates a resource for each subscription and disposes it once the inner signal terminates or
+/// the subscription is disposed. A fault from either factory is delivered to the observer as an error.
+/// </summary>
+/// <typeparam name="TResource">The resource type, disposed with the subscription.</typeparam>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="resourceFactory">Creates the resource, once per subscription.</param>
+/// <param name="signalFactory">Creates the signal that consumes the resource.</param>
 [System.Diagnostics.DebuggerDisplay("UseSignal: ResourceFactory = {_resourceFactory}, SignalFactory = {_signalFactory}")]
 public sealed class UseSignal<TResource, T>(
     Func<TResource> resourceFactory,
     Func<TResource, IObservable<T>> signalFactory) : IObservable<T>
     where TResource : IDisposable
 {
-    /// <summary>Resource factory.</summary>
+    /// <summary>Creates the resource, once per subscription.</summary>
     private readonly Func<TResource> _resourceFactory = resourceFactory;
 
-    /// <summary>Signal factory.</summary>
+    /// <summary>Creates the signal that consumes the resource.</summary>
     private readonly Func<TResource, IObservable<T>> _signalFactory = signalFactory;
 
     /// <inheritdoc/>
@@ -74,7 +77,7 @@ private sealed class UseWitness(IObserver<T> observer, TResource resource) : IOb
         /// <summary>Non-zero once stopped.</summary>
         private int _stopped;
 
-        /// <summary>Assigns the inner subscription.</summary>
+        /// <summary>Stores the inner subscription, disposing it when the sink has stopped or holds one.</summary>
         /// <param name="subscription">Inner subscription.</param>
         public void SetSubscription(IDisposable subscription)
         {
@@ -166,7 +169,7 @@ private void Stop()
             Release();
         }
 
-        /// <summary>Releases owned resources.</summary>
+        /// <summary>Detaches the observer, then disposes the inner subscription and the resource.</summary>
         private void Release()
         {
             _observer = EmptyWitness<T>.Instance;
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/Witness.cs b/src/ReactiveUI.Primitives.Core/Advanced/Witness.cs
index 067e310d..062cc56a 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/Witness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/Witness.cs
@@ -49,7 +49,7 @@ public static IObserver<T> Create<T>(Action<T> onNext, Action onCompleted) =>
     /// <param name="onError">Callback invoked for terminal errors.</param>
     /// <param name="onCompleted">Callback invoked for completion.</param>
     /// <returns>An observer backed by the supplied callbacks.</returns>
-    /// <exception cref="ArgumentExceptionHelper">Any callback is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException">Any callback is <see langword="null"/>.</exception>
     public static IObserver<T> Create<T>(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
@@ -74,7 +74,7 @@ public static IObserver<T> Safe<T>(IObserver<T> observer) =>
     /// <param name="observer">Observer to protect.</param>
     /// <param name="cancel">Cancellation resource disposed on terminal signals or callback exceptions.</param>
     /// <returns>A safe observer wrapper.</returns>
-    /// <exception cref="ArgumentExceptionHelper"><paramref name="observer"/> or <paramref name="cancel"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> or <paramref name="cancel"/> is <see langword="null"/>.</exception>
     public static IObserver<T> Safe<T>(IObserver<T> observer, IDisposable cancel)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
index 925d6f1a..df70de30 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Provides the base implementation for a scheduled unit of work that is ordered by an absolute due time.</summary>
 /// <typeparam name="TAbsolute">
-/// The type used to represent absolute time. The type must be comparable so scheduled items can be ordered.
+/// The absolute-time representation, which must be comparable so scheduled items can be ordered.
 /// </typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, IComparable<ScheduledItem<TAbsolute>>,
@@ -30,11 +30,10 @@ public sealed class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, ICompa
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ScheduledItem{TAbsolute}"/> class with the due time, comparer,
-    /// and invocation callback. The callback supplies the work performed by <see cref="Invoke"/> and replaces what a
-    /// derived <c>InvokeCore</c> override used to provide.
+    /// and the callback that supplies the work performed by <see cref="Invoke"/>.
     /// </summary>
     /// <param name="dueTime">The absolute time at which this item is due to run.</param>
-    /// <param name="comparer">The comparer used to order due-time values.</param>
+    /// <param name="comparer">The comparer that orders due-time values.</param>
     /// <param name="invokeCore">
     /// The work performed when the item runs. It receives this scheduled item (so callers can deregister it) and
     /// returns a disposable that cancels any work that outlives the invocation.
@@ -55,8 +54,8 @@ public ScheduledItem(
 
     /// <summary>Gets a value indicating whether this work item has been canceled or disposed.</summary>
     /// <remarks>
-    /// Once this property becomes <see langword="true"/>, calls to <see cref="Invoke"/> will not start new work.
-    /// If the work has already started and returned a disposable resource, that resource is disposed.
+    /// Once this is <see langword="true"/>, <see cref="Invoke"/> starts no new work, and a disposable returned by
+    /// work that has begun is disposed as soon as it is available.
     /// </remarks>
     public bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
 
@@ -72,10 +71,6 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> and <paramref name="right"/> do not refer to the same
     /// object; otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// Equality operators use reference equality. They do not compare <see cref="DueTime"/> values and are therefore
-    /// intentionally different from the ordering behavior used by <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     public static bool operator !=(ScheduledItem<TAbsolute>? left, ScheduledItem<TAbsolute>? right) =>
         !ReferenceEquals(left, right);
 
@@ -86,9 +81,6 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> is ordered before <paramref name="right"/> by due time;
     /// otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// This operator uses the same due-time ordering as <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     public static bool operator <(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) < 0;
 
@@ -99,9 +91,6 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> is ordered before or equal to <paramref name="right"/> by
     /// due time; otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// This operator uses the same due-time ordering as <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     public static bool operator <=(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) <= 0;
 
@@ -112,10 +101,6 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> and <paramref name="right"/> refer to the same object;
     /// otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// Equality operators use reference equality. They do not compare <see cref="DueTime"/> values and are therefore
-    /// intentionally different from the ordering behavior used by <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(ScheduledItem<TAbsolute>? left, ScheduledItem<TAbsolute>? right) =>
         ReferenceEquals(left, right);
@@ -127,9 +112,6 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> is ordered after <paramref name="right"/> by due time;
     /// otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// This operator uses the same due-time ordering as <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     public static bool operator >(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) > 0;
 
@@ -140,17 +122,13 @@ public ScheduledItem(
     /// <see langword="true"/> when <paramref name="left"/> is ordered after or equal to <paramref name="right"/> by
     /// due time; otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// This operator uses the same due-time ordering as <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/>.
-    /// </remarks>
     public static bool operator >=(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) >= 0;
 
-    /// <summary>Cancels this scheduled work item.</summary>
-    /// <remarks>
-    /// Canceling prevents work that has not started from running. If the work has already started and the invocation
-    /// callback returned a disposable resource, that resource is disposed as soon as it is available.
-    /// </remarks>
+    /// <summary>
+    /// Cancels this scheduled work item: work that has not started does not run, and a disposable returned by work
+    /// that has begun is disposed as soon as it is available.
+    /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Cancel() => Dispose();
 
@@ -162,11 +140,10 @@ public ScheduledItem(
     /// greater than <see langword="null"/>.
     /// </returns>
     /// <remarks>
-    /// This comparison controls scheduling order. It does not imply object equality; <see cref="Equals(object?)"/> and
-    /// the equality operators use reference identity.
+    /// Ordering is by due time and says nothing about equality: <see cref="Equals(object?)"/> and the equality
+    /// operators compare reference identity instead.
     /// </remarks>
     public int CompareTo(ScheduledItem<TAbsolute>? other) =>
-        // MSDN: By definition, any object compares greater than null, and two null references compare equal to each other.
         other is null ? 1 : _comparer.Compare(DueTime, other.DueTime);
 
     /// <summary>Compares this scheduled item with another object by due time.</summary>
@@ -210,10 +187,6 @@ public void Dispose()
     /// <see langword="true"/> when <paramref name="obj"/> is the same object instance; otherwise,
     /// <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// Equality is based on reference identity, not on <see cref="DueTime"/>. Use
-    /// <see cref="CompareTo(ScheduledItem{TAbsolute}?)"/> to compare scheduling order.
-    /// </remarks>
     public override bool Equals(object? obj) => ReferenceEquals(this, obj);
 
     /// <summary>Returns a hash code based on this scheduled item's object identity.</summary>
@@ -222,9 +195,8 @@ public void Dispose()
 
     /// <summary>Runs this scheduled work item if it has not been canceled.</summary>
     /// <remarks>
-    /// The implementation calls the invocation callback once and stores the disposable it returns. If cancellation
-    /// happens before, during, or immediately after invocation, the returned disposable is disposed to propagate
-    /// cancellation to any work created by the invocation.
+    /// The callback runs once and the disposable it returns is stored. Cancellation before, during, or immediately
+    /// after the call disposes that disposable, so cancellation reaches work the callback created.
     /// </remarks>
     public void Invoke()
     {
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs b/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
index 9add5054..b2c6b61f 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>Efficient scheduler queue that maintains scheduled items sorted by absolute time.</summary>
+/// <summary>Scheduler queue that keeps scheduled items ordered by absolute due time.</summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <remarks>This type is not thread safe; users should ensure proper synchronization.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -20,15 +20,15 @@ public class SequencerQueue<TAbsolute>
     /// <summary>Priority queue storing scheduled work.</summary>
     private readonly PriorityQueue<ScheduledItem<TAbsolute>> _queue;
 
-    /// <summary>Initializes a new instance of the <see cref="SequencerQueue{TAbsolute}"/> class. Creates a new scheduler queue with a default initial capacity.</summary>
+    /// <summary>Initializes a new instance of the <see cref="SequencerQueue{TAbsolute}"/> class with a default initial capacity.</summary>
     public SequencerQueue()
         : this(DefaultCapacity)
     {
     }
 
-    /// <summary>Initializes a new instance of the <see cref="SequencerQueue{TAbsolute}"/> class. Creates a new scheduler queue with the specified initial capacity.</summary>
+    /// <summary>Initializes a new instance of the <see cref="SequencerQueue{TAbsolute}"/> class with the specified initial capacity.</summary>
     /// <param name="capacity">Initial capacity of the scheduler queue.</param>
-    /// <exception cref="ArgumentOutOfRangeExceptionHelper"><paramref name="capacity"/> is less than zero.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than zero.</exception>
     public SequencerQueue(int capacity)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfNegative(capacity);
diff --git a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
index 447ba338..2dca23fb 100644
--- a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
@@ -43,7 +43,7 @@ public ConnectableSignal(IObservable<T> source, ISignal<T> hub)
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Subscribes the hub to the source if it is not already connected.</summary>
+    /// <summary>Subscribes the hub to the source, returning the live handle when a connection is open.</summary>
     /// <returns>A handle that disconnects the source subscription.</returns>
     public IDisposable Connect()
     {
@@ -54,9 +54,7 @@ public IDisposable Connect()
                 return Scope.Empty;
             }
 
-            // Allocate the connection only on the first connect. A dedicated disposable type
-            // avoids the closure (and extra anonymous-disposable wrapper) that Scope.Create
-            // would allocate.
+            // A dedicated disposable type for the handle, so connecting captures no closure.
             if (_connection?.Value is { } activeConnection)
             {
                 return activeConnection;
diff --git a/src/ReactiveUI.Primitives.Core/ExceptionExtensions.cs b/src/ReactiveUI.Primitives.Core/ExceptionExtensions.cs
index 96feb0af..ef15344f 100644
--- a/src/ReactiveUI.Primitives.Core/ExceptionExtensions.cs
+++ b/src/ReactiveUI.Primitives.Core/ExceptionExtensions.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives;
 
-/// <summary>Exception helper methods.</summary>
+/// <summary>Extension methods for rethrowing exceptions.</summary>
 public static class ExceptionExtensions
 {
     /// <summary>Throwing operators for an exception.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Optional.cs b/src/ReactiveUI.Primitives.Core/Optional.cs
index a84cd639..18339261 100644
--- a/src/ReactiveUI.Primitives.Core/Optional.cs
+++ b/src/ReactiveUI.Primitives.Core/Optional.cs
@@ -7,22 +7,18 @@
 
 namespace ReactiveUI.Primitives;
 
-/// <summary>Represents an optional value that may or may not be present.</summary>
+/// <summary>
+/// Represents an optional value, letting an API distinguish an absent value from a default one without using
+/// <see langword="null"/>. A <see langword="null"/> value is treated as absent.
+/// </summary>
 /// <typeparam name="T">The type of the value that may be contained by the optional.</typeparam>
-/// <remarks>Use this struct to indicate the presence or absence of a value without resorting to null references.
-/// When an instance has a value, the HasValue property is <see langword="true"/> and the Value property returns the
-/// contained value. If no value is present, HasValue is <see langword="false"/> and accessing Value throws an
-/// exception. This pattern is useful for APIs that need to distinguish between an explicit 'no value' state and a
-/// default value.</remarks>
 [System.Diagnostics.DebuggerDisplay("Optional: HasValue = {HasValue}, Value = {_value}")]
 public readonly record struct Optional<T>
 {
     /// <summary>The underlying value, or <see langword="default"/> when no value is present.</summary>
     private readonly T? _value;
 
-    /// <summary>Initializes a new instance of the <see cref="Optional{T}"/> struct.</summary>
-    /// <remarks>After using this constructor, the HasValue property is set to false, indicating that the
-    /// <see cref="Optional{T}"/>  instance does not contain a value.</remarks>
+    /// <summary>Initializes a new instance of the <see cref="Optional{T}"/> struct with no value.</summary>
     public Optional() => (_value, HasValue) = (default, false);
 
     /// <summary>Initializes a new instance of the <see cref="Optional{T}"/> struct.</summary>
@@ -36,8 +32,6 @@ private Optional([AllowNull] T value, bool hasValue) =>
         (_value, HasValue) = hasValue && value is not null ? (value, true) : (default, false);
 
     /// <summary>Gets an empty instance of the <see cref="Optional{T}"/> type that contains no value.</summary>
-    /// <remarks>Use this property to represent the absence of a value in a type-safe manner. The returned
-    /// instance has no value set and IsPresent is false.</remarks>
     public static Optional<T> Empty => new();
 
     /// <summary>Gets an empty optional value.</summary>
@@ -47,9 +41,7 @@ private Optional([AllowNull] T value, bool hasValue) =>
     public bool HasValue { get; }
 
     /// <summary>Gets the value contained in the optional object.</summary>
-    /// <remarks>Accessing this property when the optional object does not have a value will throw an
-    /// exception. Use the HasValue property to determine whether a value is present before accessing this
-    /// property.</remarks>
+    /// <exception cref="InvalidOperationException"><see cref="HasValue"/> is <see langword="false"/>.</exception>
     [NotNull]
     public T? Value => HasValue
         ? _value!
@@ -65,12 +57,12 @@ private Optional([AllowNull] T value, bool hasValue) =>
     /// <returns>The optional value.</returns>
     public static implicit operator Optional<T>([AllowNull] T value) => ToOptional(value);
 
-    /// <summary>Explicit cast from option to value.</summary>
-    /// <param name="value">The value.</param>
-    /// <returns>The optional value.</returns>
+    /// <summary>Explicit cast from the optional to the value.</summary>
+    /// <param name="value">The optional value.</param>
+    /// <returns>The contained value.</returns>
     public static explicit operator T?(in Optional<T> value) => FromOptional(value);
 
-    /// <summary>Creates the specified value.</summary>
+    /// <summary>Creates an optional value, treating a <see langword="null"/> value as absent.</summary>
     /// <param name="value">The value.</param>
     /// <returns>The optional value.</returns>
     public static Optional<T> Create([AllowNull] T value) => new(value);
diff --git a/src/ReactiveUI.Primitives.Core/Result.cs b/src/ReactiveUI.Primitives.Core/Result.cs
index b6a6914f..9206c34d 100644
--- a/src/ReactiveUI.Primitives.Core/Result.cs
+++ b/src/ReactiveUI.Primitives.Core/Result.cs
@@ -7,18 +7,13 @@
 
 namespace ReactiveUI.Primitives;
 
-/// <summary>Represents the outcome of an operation, indicating success or failure and providing error details when applicable.</summary>
-/// <remarks>The <see cref="Result"/> struct is used to encapsulate the result of an operation, including whether
-/// it succeeded and, if not, the exception that caused the failure. Use the <see cref="Success"/> property for
-/// successful results and <see cref="Failure(Exception)"/> to create failed results. The <see cref="IsSuccess"/> and
-/// <see cref="IsFailure"/> properties allow callers to check the operation's status before accessing error information
-/// or propagating exceptions. This struct is immutable and thread-safe.</remarks>
+/// <summary>Represents the outcome of an operation, indicating success or failure and carrying the failure exception.</summary>
 [System.Diagnostics.DebuggerDisplay("Result: IsSuccess = {IsSuccess}, Exception = {Exception}")]
 public readonly record struct Result
 {
-    /// <summary>Initializes a new instance of the <see cref="Result"/> struct. Initializes a new instance of the Result class with the specified exception.</summary>
-    /// <param name="exception">The exception that represents the error condition for this result. Cannot be null.</param>
-    /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="exception"/> is null.</exception>
+    /// <summary>Initializes a new instance of the <see cref="Result"/> struct representing a failure.</summary>
+    /// <param name="exception">The exception that caused the failure.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="exception"/> is <see langword="null"/>.</exception>
     public Result(Exception exception)
     {
         ArgumentExceptionHelper.ThrowIfNull(exception);
@@ -33,24 +28,22 @@ public Result(Exception exception)
     public Exception? Exception { get; }
 
     /// <summary>Gets a value indicating whether the operation completed successfully without an exception.</summary>
-    /// <remarks>If <see langword="false"/>, the <c>Exception</c> property is guaranteed to be non-null,
-    /// providing details about the failure.</remarks>
+    /// <remarks>When <see langword="false"/>, <see cref="Exception"/> is non-null.</remarks>
     [MemberNotNullWhen(false, nameof(Exception))]
     public bool IsSuccess => Exception is null;
 
     /// <summary>Gets a value indicating whether the operation has failed.</summary>
-    /// <remarks>When <see langword="true"/>, the <c>Exception</c> property is guaranteed to be non-null. Use
-    /// this property to check for failure before accessing error details.</remarks>
+    /// <remarks>When <see langword="true"/>, <see cref="Exception"/> is non-null.</remarks>
     [MemberNotNullWhen(true, nameof(Exception))]
     public bool IsFailure => Exception is not null;
 
     /// <summary>Creates a failed result that encapsulates the specified exception.</summary>
-    /// <param name="exception">The exception that describes the failure. Cannot be null.</param>
-    /// <returns>A result representing a failure, containing the provided exception.</returns>
+    /// <param name="exception">The exception that describes the failure.</param>
+    /// <returns>A result representing a failure, containing the supplied exception.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="exception"/> is <see langword="null"/>.</exception>
     public static Result Failure(Exception exception) => new(exception);
 
-    /// <summary>Throws the associated exception if the result represents a failure.</summary>
-    /// <remarks>Excluded from coverage: the unreachable sequence point after <see cref="ExceptionDispatchInfo"/> rethrow cannot be credited by cobertura.</remarks>
+    /// <summary>Rethrows the failure exception, preserving its original stack trace; a no-op on success.</summary>
     [ExcludeFromCodeCoverage]
     public void TryThrow()
     {
@@ -66,7 +59,5 @@ public void TryThrow()
     /// <summary>Returns a string that represents the result status of the operation.</summary>
     /// <returns>A string indicating "Success" if the operation was successful; otherwise, a string in the format
     /// "Failure{exception message}" containing the associated exception message.</returns>
-    /// <remarks>This method provides a concise textual representation of the operation's outcome, which can
-    /// be useful for logging or debugging purposes.</remarks>
     public override string ToString() => IsSuccess ? "Success" : $"Failure{{{Exception.Message}}}";
 }
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
index 7dea08ce..79c5db64 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
@@ -26,8 +26,8 @@ internal static class ActivationExtensionsEmitter
     /// <param name="models">The overloads to emit, in request order.</param>
     /// <returns>The generated source.</returns>
     /// <remarks>
-    /// The overloads join the same partial class as the placeholder they displace, so a call site resolves to the
-    /// concrete overload without the consumer importing anything new: a non-generic candidate beats the generic
+    /// The overloads join the same partial class as the placeholder they displace, so a call site binds to the
+    /// concrete overload without the consumer importing anything: a non-generic candidate beats the generic
     /// placeholder outright.
     /// </remarks>
     internal static string Emit(ImmutableArray<ActivationModel> models)
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
index e25c691c..fa50f9e4 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
@@ -4,23 +4,17 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
-/// <summary>The API a consumer writes against, injected before anything is scanned.</summary>
+/// <summary>The API a consumer writes against, emitted into every compilation.</summary>
 /// <remarks>
-/// <para>
 /// This is what makes the generator opt-in without a package-level runtime dependency: the placeholder
-/// <c>Events&lt;T&gt;</c> gives a call site something to bind to while it is being typed, and the generated
-/// overload for the receiver's own type displaces it once the type resolves. The attribute has to exist here too,
-/// because a static host has no receiver to hang a call off.
-/// </para>
-/// <para>
-/// Nothing here is annotated, and it deliberately carries no <c>#nullable</c> directive. Post-initialization
-/// output is produced before anything about the consumer is known, including the language version, so this is the
-/// one generated file that cannot ask whether the consumer could compile an annotation - and it has no reason to.
-/// </para>
+/// <c>Events&lt;T&gt;</c> gives a call site something to bind to while it is being typed, and the generated overload
+/// for the receiver's own type displaces it once the type resolves. The attribute has to exist here too because a
+/// static host has no receiver to hang a call off, and nothing here is annotated, so this is the one generated file
+/// that carries no <c>#nullable</c> directive.
 /// </remarks>
 internal static class ActivationSource
 {
-    /// <summary>The source injected during post-initialization.</summary>
+    /// <summary>The source text added to every compilation.</summary>
     internal const string Text = """
         // <auto-generated />
         namespace ReactiveUI.Primitives.ObservableEvents
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
index 9987ec8d..056298b1 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
@@ -9,10 +9,10 @@ namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
 /// <summary>Builds the wrapper class and generated file names, from the identity of the host they belong to.</summary>
 /// <remarks>
-/// A readable name alone is not enough to key generated output on. Sanitizing punctuation out of a fully qualified
-/// name maps distinct hosts onto the same identifier - <c>Samples.A_B.C</c> and <c>Samples.A.B_C</c> both flatten to
-/// <c>Samples_A_B_C</c> - so a hash of the unflattened identity is appended to keep them apart, while the readable
-/// half is kept so a generated file is still recognisable in a build log.
+/// Sanitizing punctuation out of a fully qualified name maps distinct hosts onto the same identifier -
+/// <c>Samples.A_B.C</c> and <c>Samples.A.B_C</c> both flatten to <c>Samples_A_B_C</c> - so a hash of the unflattened
+/// identity is appended to keep them apart, while the readable half keeps a generated file recognisable in a build
+/// log.
 /// </remarks>
 internal static class GeneratedNames
 {
@@ -77,8 +77,8 @@ private static void AppendSanitized(PooledStringBuilder builder, string identity
         var start = 0;
         var end = identity.Length;
 
-        // Leading and trailing punctuation would sanitize to underscores that carry no information, and a
-        // generated name reads better without them; the hash still separates identities that differ only there.
+        // Leading and trailing punctuation would sanitize to uninformative underscores; the hash still separates
+        // identities that differ only there.
         while (start < end && !char.IsLetterOrDigit(identity[start]))
         {
             start++;
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/InstanceWrapperEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/InstanceWrapperEmitter.cs
index 698d9d1a..7af6fb34 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/InstanceWrapperEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/InstanceWrapperEmitter.cs
@@ -19,10 +19,6 @@ internal static class InstanceWrapperEmitter
     /// <param name="model">The host to wrap.</param>
     /// <param name="provider">The observable implementation to write against.</param>
     /// <returns>The generated source.</returns>
-    /// <remarks>
-    /// The host is held in a field rather than resubscribed from a captured expression, so every property on one
-    /// wrapper observes the same instance the consumer handed it.
-    /// </remarks>
     internal static string Emit(InstanceTargetModel model, ObservableProvider provider)
     {
         var events = model.Events.AsArray();
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
index 4338bcdd..d5e9ceb3 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
@@ -8,17 +8,9 @@ namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
 /// <summary>A fluent builder for generated source, backed by thread-local pooled character buffers.</summary>
 /// <remarks>
-/// <para>
-/// Emission builds a great many short fragments - a payload type here, a handler parameter list there - and one
-/// large file per target. Accumulating into a pooled <c>char[]</c> lets the same buffers carry every fragment and
-/// every file in a pass, so the steady state is a handful of arrays rather than a builder and its grown chunk
-/// chain per fragment.
-/// </para>
-/// <para>
 /// The free list is thread-local rather than a shared pool: source-output callbacks run concurrently, fragment
-/// builders nest inside file builders, and nothing here outlives the call that rented it. Returning is what buys
-/// the reuse; forgetting to costs reuse, never correctness.
-/// </para>
+/// builders nest inside file builders, and nothing here outlives the call that rented it. Returning a buffer is what
+/// buys the reuse; forgetting to costs reuse, never correctness.
 /// </remarks>
 internal sealed class PooledStringBuilder
 {
@@ -97,8 +89,8 @@ internal PooledStringBuilder Append(char value)
     /// <param name="value">The value to append; the only callers pass a name length, so it is never negative.</param>
     /// <returns>This builder, for chaining.</returns>
     /// <remarks>
-    /// Formats digits straight into the buffer. These appends sit in the per-event loop that builds the mangled
-    /// static property names, where going through <c>ToString</c> would allocate a string per name segment.
+    /// Formats digits straight into the buffer; these appends sit in the per-event loop that builds the mangled
+    /// static property names, where <c>ToString</c> would allocate a string per name segment.
     /// </remarks>
     internal PooledStringBuilder Append(int value)
     {
@@ -122,7 +114,6 @@ internal PooledStringBuilder Append(int value)
     /// <summary>Appends another builder's content, then returns that builder's buffer to the pool.</summary>
     /// <param name="other">The fragment builder to drain; it must not be appended to afterwards.</param>
     /// <returns>This builder, for chaining.</returns>
-    /// <remarks>Copies buffer to buffer, so a nested fragment joins its file without materializing a string.</remarks>
     internal PooledStringBuilder Append(PooledStringBuilder other)
     {
         if (other._position != 0)
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
index 66e27960..58448aef 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
@@ -57,9 +57,8 @@ internal static void AppendFooter(PooledStringBuilder builder, string namespaceN
     /// <param name="provider">The observable implementation to write against.</param>
     /// <param name="indent">The indentation the property sits at.</param>
     /// <remarks>
-    /// The handler is a local function rather than a lambda so a delegate returning <c>Task</c> or
-    /// <c>ValueTask</c> can satisfy its own signature; the subscription is torn down through the provider's own
-    /// disposable factory, so the wrapper never holds the handler alive past the subscription.
+    /// The handler is emitted as a local function rather than a lambda so a delegate returning <c>Task</c> or
+    /// <c>ValueTask</c> can satisfy its own signature.
     /// </remarks>
     internal static void AppendEventProperty(
         PooledStringBuilder builder,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
index 07f09c69..db30e7cc 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
@@ -21,8 +21,7 @@ internal static class StaticEventsEmitter
     /// <returns>The generated source.</returns>
     /// <remarks>
     /// A static event has no instance to hang an extension method off, so it is reached through a class named the
-    /// same in every namespace. The class is partial, so a consumer can add to it and so that two requested hosts
-    /// in one namespace do not fight over the declaration.
+    /// same in every namespace, left partial so a consumer can add to it.
     /// </remarks>
     internal static string Emit(StaticNamespaceModel model, ObservableProvider provider)
     {
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Constants.cs b/src/ReactiveUI.Primitives.ObservableEvents/Constants.cs
index 99d23f09..4c32064b 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Constants.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Constants.cs
@@ -20,7 +20,7 @@ internal static class Constants
     /// <summary>The same attribute written with the suffix the language lets a user leave off.</summary>
     internal const string StaticRequestAttributeQualifiedName = "GenerateStaticEventObservablesAttribute";
 
-    /// <summary>The hint name of the activation API emitted during post-initialization.</summary>
+    /// <summary>The hint name of the file carrying the activation API.</summary>
     internal const string ActivationHintName = "ObservableEvents.Activation.g.cs";
 
     /// <summary>The hint name of the file carrying every generated activation overload.</summary>
@@ -39,11 +39,6 @@ internal static class Constants
     internal const string GeneratedFileHeader = "// <auto-generated />\n";
 
     /// <summary>The directive that puts a generated file in a nullable-aware context.</summary>
-    /// <remarks>
-    /// Emitted only where the consumer's language version allows it, and always together with the annotations on
-    /// the generated handler signatures: the directive is what makes those annotations mean anything, and the
-    /// annotations are what make the handlers match the delegates they are assigned to.
-    /// </remarks>
     internal const string NullableEnableDirective = "#nullable enable\n";
 
     /// <summary>The lean signal factory host, whose presence selects the lean provider.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
index 6f0bfec7..59211884 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
@@ -13,17 +13,11 @@ namespace ReactiveUI.Primitives.ObservableEvents;
 
 /// <summary>Generates observable wrappers for the event-bearing types a consumer asks for.</summary>
 /// <remarks>
-/// <para>
-/// Two things ask for generation. An <c>Events()</c> call names its receiver, which is what makes the API
-/// discoverable from the call site; an assembly attribute names a static host, which has no receiver to call
-/// through. Both converge on the same extraction and the same emitter.
-/// </para>
-/// <para>
-/// Everything that leaves a semantic transform is a model of strings that compares by value, and every output is
-/// keyed on the smallest model that decides it: one wrapper per host, one file per namespace of static events, one
-/// file of activation overloads. An edit to one host's events therefore re-emits that host's file and nothing else,
-/// and an edit anywhere else re-emits nothing at all.
-/// </para>
+/// Generation is requested either by an <c>Events()</c> call, whose receiver names the host, or by an assembly
+/// attribute naming a static host; both converge on the same extraction and the same emitters. Everything leaving a
+/// semantic transform is a model of strings that compares by value, and every output is keyed on the smallest model
+/// that decides it - one wrapper per host, one file per namespace of static events, one file of activation
+/// overloads - so an edit to one host's events re-emits that host's file alone.
 /// </remarks>
 [Generator(LanguageNames.CSharp)]
 public sealed class EventGenerator : IIncrementalGenerator
@@ -33,9 +27,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         RegisterActivationOutput(in context);
 
-        // Which observable library is referenced decides every type name in the generated source, but nothing about
-        // which events exist. Resolving it here, into a value the pipeline can compare, keeps the far more
-        // expensive extraction from re-running when only the reference set moves.
+        // Which observable library is referenced decides every type name in the generated source but nothing about
+        // which events exist, so resolving it separately keeps extraction from re-running when references move.
         var provider = context.CompilationProvider
             .Select(static (compilation, _) => ProviderResolver.Resolve(compilation))
             .WithTrackingName(GeneratorStepNames.Provider);
@@ -67,12 +60,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     /// <summary>Registers the activation API a consumer writes against.</summary>
     /// <param name="context">The generator initialization context.</param>
     /// <remarks>
-    /// Deliberately an ordinary source output rather than post-initialization output, even though it depends on
-    /// nothing and could be produced before anything is scanned. Post-initialization source is added to the
-    /// compilation the pipeline then runs against, which makes that compilation new on every single run and throws
-    /// away every semantic result cached against the previous one - so a driver that has already generated
-    /// re-binds every call site from scratch, whether or not anything changed. One inert post-initialization file
-    /// is enough to cost that, so this generator emits none.
+    /// An ordinary source output rather than post-initialization output: post-initialization source is added to the
+    /// compilation the pipeline then runs against, making that compilation new on every run and discarding every
+    /// semantic result cached against the one it replaces. One inert post-initialization file costs that, so this
+    /// generator registers none.
     /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void RegisterActivationOutput(in IncrementalGeneratorInitializationContext context) =>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
index 8cedc9b1..d2f22bd4 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
@@ -6,10 +6,8 @@ namespace ReactiveUI.Primitives.ObservableEvents;
 
 /// <summary>The names the pipeline's steps are tracked under.</summary>
 /// <remarks>
-/// Tracking is what makes the caching testable: a driver told to track steps records, for every run, whether each
-/// step recomputed its value and whether that value differed from last time. Without names on the steps a
-/// regression that quietly reintroduces a symbol into a model - and so defeats the caching entirely - still
-/// produces correct output and would go unnoticed.
+/// A driver told to track steps reports, per run, whether each named step recomputed and whether its value changed,
+/// which is how a test asserts that the models compare by value and the caching holds.
 /// </remarks>
 internal static class GeneratorStepNames
 {
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
index 3d09f98d..f528e8cb 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
@@ -125,7 +125,7 @@ public override IDisposable Schedule<TState>(
 
         // The timer roots itself while armed through the callback's target (the work item), which stores the
         // timer; the item's Dispose cancels and releases it.
-        item.AttachTimer(new(static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
+        item.AttachTimer(new Timer(static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
         return item;
     }
 
@@ -181,8 +181,7 @@ public void Dispose()
     /// <param name="item">Work item to execute on the next event-loop turn.</param>
     internal void Enqueue(IReadyWorkItem item)
     {
-        _ready.Enqueue(item);
-        _ = Interlocked.Increment(ref _readyCount);
+        QueueReady(item);
         PostDrain();
 
         // A disposal that raced the enqueue above may have drained the queue before this item joined it. Re-check
@@ -196,6 +195,32 @@ internal void Enqueue(IReadyWorkItem item)
         ReleaseReady();
     }
 
+    /// <summary>
+    /// Adds a work item to the ready queue without arming a drain. Internal rather than private so a test can order an
+    /// enqueue, a disposal and a drain as explicit steps instead of racing them across threads.
+    /// </summary>
+    /// <param name="item">Work item to add to the ready queue.</param>
+    internal void QueueReady(IReadyWorkItem item)
+    {
+        _ready.Enqueue(item);
+        _ = Interlocked.Increment(ref _readyCount);
+    }
+
+    /// <summary>
+    /// Runs one batch: every item the ready count promised, stopping early if a concurrent drain took one first.
+    /// Internal rather than private so a test can run a drain pass at the point in a sequence it chooses.
+    /// </summary>
+    internal void RunReadyBatch()
+    {
+        for (var remaining = Volatile.Read(ref _readyCount);
+             remaining > 0 && _ready.TryDequeue(out var item);
+             remaining--)
+        {
+            _ = Interlocked.Decrement(ref _readyCount);
+            item.Run();
+        }
+    }
+
     /// <summary>
     /// Cancels and drops every ready item. The items are the handles their callers hold, so disposing them releases
     /// the caller's work instead of stranding it in a queue nothing will ever drain again.
@@ -291,18 +316,6 @@ private void RunDrain()
         PostDrain();
     }
 
-    /// <summary>Runs one batch: every item the ready count promised, stopping early if a concurrent drain took one first.</summary>
-    private void RunReadyBatch()
-    {
-        for (var remaining = Volatile.Read(ref _readyCount);
-             remaining > 0 && _ready.TryDequeue(out var item);
-             remaining--)
-        {
-            _ = Interlocked.Decrement(ref _readyCount);
-            item.Run();
-        }
-    }
-
     /// <summary>
     /// A cancellable scheduled work item carrying closure-free state and the scheduler passed back to the action;
     /// also the target that roots a delayed one-shot timer. The run/cancel handshake lives in the shared
@@ -312,8 +325,12 @@ private void RunReadyBatch()
     /// <typeparam name="TState">The scheduled state type.</typeparam>
     internal sealed class StatefulWorkItem<TState> : DispatchWorkItemBase<TState>, IReadyWorkItem
     {
-        /// <summary>Timer driving a delayed item; <see langword="null"/> for immediate work.</summary>
-        private Timer? _timer;
+        /// <summary>
+        /// Release handle for the one-shot timer driving a delayed item; <see langword="null"/> for immediate work.
+        /// Typed as the cancellation the item actually performs rather than the timer itself, so a test can hand it a
+        /// recording handle and observe the release directly.
+        /// </summary>
+        private IDisposable? _timer;
 
         /// <summary>Initializes a new instance of the <see cref="StatefulWorkItem{TState}"/> class.</summary>
         /// <param name="scheduler">The scheduler passed back to the scheduled action.</param>
@@ -340,7 +357,7 @@ public void Dispose()
 
         /// <summary>Stores the one-shot timer so the caller's disposable cancels and releases it.</summary>
         /// <param name="timer">The armed timer.</param>
-        internal void AttachTimer(Timer timer)
+        internal void AttachTimer(IDisposable timer)
         {
             Volatile.Write(ref _timer, timer);
             if (!IsDisposed)
diff --git a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
index afec21ba..1493e25b 100644
--- a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
+++ b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
@@ -10,9 +10,9 @@
 namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
-/// Coalescing engine shared by UI-thread sequencers: it batches dispatcher posts and shares delayed scheduling.
-/// A sealed sequencer holds one inline and injects its platform <c>post</c> (and optionally <c>scheduleDelayed</c>)
-/// delegates plus the cached drain callback; immediate work is queued and drained one batch per post.
+/// Coalescing engine shared by UI-thread sequencers. A sequencer holds one inline and supplies its platform
+/// <c>post</c> delegate, an optional <c>scheduleDelayed</c> delegate and a cached drain callback; immediate work is
+/// queued and drained one batch per post.
 /// </summary>
 [SuppressMessage(
     "Performance",
@@ -82,7 +82,7 @@ public DispatchSequencerState(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static TimeSpan DelayUntil(long dueTimestamp) => Sequencer.TimeUntil(dueTimestamp);
 
-    /// <summary>Executes the work item on the current (dispatcher) thread unless it has already been cancelled.</summary>
+    /// <summary>Executes the work item on the current (dispatcher) thread unless it has been cancelled.</summary>
     /// <param name="item">The work item to execute.</param>
     public static void RunIfActive(IWorkItem item)
     {
@@ -188,15 +188,10 @@ public void RunDrain()
         }
     }
 
-    /// <summary>
-    /// Cancels and drops every ready work item. The items are the handles their callers hold, so disposing them
-    /// releases the caller's work instead of stranding it in a queue nothing will ever drain again.
-    /// </summary>
+    /// <summary>Cancels and drops every ready work item, disposing each so its caller's handle is released.</summary>
     /// <remarks>
-    /// Internal rather than public because only a sequencer that can retire its own dispatcher needs it: the platform
-    /// dispatchers (WPF, WinForms, WinUI, MAUI, Blazor) outlive the sequencer that posts to them and keep draining, so
-    /// they never release a queue. <see cref="WasmSequencer"/> owns the timer that is its dispatcher, and once that is
-    /// disposed nothing can drain the queue again — so it, alone, hands the queued work back.
+    /// Only <see cref="WasmSequencer"/> calls this: it owns the timer that is its dispatcher, so disposal leaves
+    /// nothing able to drain the queue, whereas the platform dispatchers outlive the sequencer and keep draining.
     /// </remarks>
     internal void ReleaseQueued()
     {
@@ -210,8 +205,7 @@ internal void ReleaseQueued()
         }
     }
 
-    // The only trigger for this path is the real shared thread-pool timer coming due, so no deterministic test can
-    // reach it without waiting on a live OS timer; that timer race is exactly what flaked, so exclude it from coverage.
+    // Only the live shared thread-pool timer coming due reaches this path, so coverage excludes it.
     /// <summary>Parks delayed work on the shared thread-pool timer, which marshals it back to the dispatcher when due.</summary>
     /// <param name="item">Work item to execute once due.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
@@ -220,8 +214,7 @@ internal void ReleaseQueued()
     private readonly void ScheduleOnSharedTimer(IWorkItem item, long dueTimestamp) =>
         ThreadPoolSequencer.Instance.Schedule(new MarshalOnDueWorkItem(_owner, item), dueTimestamp);
 
-    // Constructed only by ScheduleOnSharedTimer and run only by the shared thread-pool timer, so it shares that
-    // path's lack of a deterministic trigger; exclude it from coverage.
+    // Constructed and run only by the shared thread-pool timer path, so coverage excludes it too.
     /// <summary>Work item used by the shared timer path to marshal delayed work back to the dispatcher.</summary>
     /// <param name="owner">Owning dispatch sequencer.</param>
     /// <param name="item">Work item to marshal.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index 1d37ecd6..e5b8b8fa 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -36,7 +36,7 @@ private CurrentThreadSequencer()
     /// <summary>Gets the singleton instance of the current thread scheduler.</summary>
     public static CurrentThreadSequencer Instance => StaticInstance.Value;
 
-    /// <summary>Gets a value indicating whether gets a value that indicates whether the caller must call a Schedule method.</summary>
+    /// <summary>Gets a value indicating whether the caller must schedule work instead of running it inline, true when the current thread is outside any scheduled call.</summary>
     [EditorBrowsable(EditorBrowsableState.Advanced)]
     public static bool IsScheduleRequired => !_running;
 
@@ -53,7 +53,7 @@ private CurrentThreadSequencer()
 
     /// <summary>Schedules an action to be executed on the current-thread trampoline.</summary>
     /// <param name="action">Action to execute.</param>
-    /// <returns>The disposable object used to cancel queued work, or an empty disposable when the action has already run.</returns>
+    /// <returns>The disposable object used to cancel queued work, or an empty disposable when the action ran inline.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="action"/> is <see langword="null"/>.</exception>
     public IDisposable Schedule(Action action)
     {
@@ -105,7 +105,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         SequencerQueue<long>? queue;
 
-        // There is no timed task and no task is currently running
+        // Nothing is running on this thread, so the item runs inline rather than through the trampoline.
         if (!_running)
         {
             SetRunning(true);
@@ -116,7 +116,6 @@ public void Schedule(IWorkItem item, long dueTimestamp)
                 Thread.Sleep(dueTime);
             }
 
-            // execute directly without queueing
             try
             {
                 if (!Sequencer.IsCancelled(item))
@@ -131,10 +130,8 @@ public void Schedule(IWorkItem item, long dueTimestamp)
                 throw;
             }
 
-            // did recursive tasks arrive?
+            // Work the item scheduled recursively runs on the same trampoline before returning.
             queue = GetQueue();
-
-            // yes, run those in the queue as well
             if (queue is not null)
             {
                 try
@@ -157,14 +154,13 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         queue = GetQueue();
 
-        // if there is a task running or there is a queue
+        // Work is running on this thread, so the item joins the trampoline queue, created on first use.
         if (queue is null)
         {
             queue = new(InitialQueueCapacity);
             SetQueue(queue);
         }
 
-        // queue up more work
         ScheduledItem<long> si = new(dueTimestamp, Comparer<long>.Default, _ =>
         {
             if (!Sequencer.IsCancelled(item))
diff --git a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
index 87df50ba..f17d94db 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
@@ -35,7 +35,7 @@ private ImmediateSequencer()
 
     /// <summary>Schedules an action to run immediately.</summary>
     /// <param name="action">Action to execute.</param>
-    /// <returns>An empty disposable because the action has already run.</returns>
+    /// <returns>An empty disposable; the action runs before this method returns.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="action"/> is <see langword="null"/>.</exception>
     public IDisposable Schedule(Action action)
     {
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
index ee9d2696..d0bc349b 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
@@ -144,14 +144,7 @@ public void Execute()
             DisposeIfRaced(disposable);
         }
 
-        /// <summary>
-        /// Race-only cleanup: releases what the action returned when <see cref="Dispose"/> latched the
-        /// flag after the store above claimed the slot. Single-threaded this can never fire - a completed
-        /// <see cref="Dispose"/> leaves the slot holding <see cref="EmptyDisposable.Instance"/>, so the
-        /// compare-exchange takes the already-claimed branch instead and never reaches here. Only a real
-        /// concurrent disposal lands in this window, so it is excluded rather than chased with a
-        /// timing-dependent test.
-        /// </summary>
+        /// <summary>Releases what the scheduled action returned when a concurrent <see cref="Dispose"/> latches the cancellation flag after the slot is claimed.</summary>
         /// <param name="disposable">The disposable the scheduled action returned.</param>
         [ExcludeFromCodeCoverage]
         private void DisposeIfRaced(IDisposable disposable)
@@ -250,7 +243,7 @@ private sealed class RescheduleHandoff
             /// <summary>Gets or sets a value indicating whether the disposable was added to the collection.</summary>
             public bool IsAdded { get; set; }
 
-            /// <summary>Gets or sets a value indicating whether the rescheduled work item already ran.</summary>
+            /// <summary>Gets or sets a value indicating whether the rescheduled work item has run.</summary>
             public bool IsDone { get; set; }
         }
     }
diff --git a/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs b/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
index 90c7c608..fd187d0c 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
@@ -149,14 +149,7 @@ public IDisposable Schedule(Action action)
         /// <summary>Schedules an action to be executed after the specified relative due time.</summary>
         /// <param name="dueTime">Relative time after which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         public IDisposable Schedule(TimeSpan dueTime, Action action)
         {
@@ -170,14 +163,7 @@ public IDisposable Schedule(TimeSpan dueTime, Action action)
         /// <summary>Schedules an action to be executed at the specified absolute due time.</summary>
         /// <param name="dueTime">Absolute time at which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         public IDisposable Schedule(DateTimeOffset dueTime, Action action)
         {
@@ -188,9 +174,9 @@ public IDisposable Schedule(DateTimeOffset dueTime, Action action)
             return scheduler.Schedule(action, dueTime, static (_, a) => Sequencer.Invoke(a));
         }
 
-        /// <summary>Schedules the specified action.</summary>
-        /// <param name="action">The action.</param>
-        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
+        /// <summary>Schedules a recursive action, which receives a delegate that schedules its next invocation.</summary>
+        /// <param name="action">Action to execute; its argument schedules the next iteration.</param>
+        /// <returns>The disposable object used to cancel the recursive work (best effort).</returns>
         public IDisposable Schedule(Action<Action> action)
         {
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -206,7 +192,7 @@ public IDisposable Schedule(Action<Action> action)
         /// <param name="action">Action to execute.</param>
         /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
-        /// <remarks>The naming of this method differs from <c>Schedule</c> because otherwise the signature would cause ambiguities.</remarks>
+        /// <remarks>Named <c>ScheduleAction</c> because a <c>Schedule</c> overload taking state plus an action would be ambiguous with the others.</remarks>
         public IDisposable ScheduleAction<TState>(TState state, Action<TState> action)
         {
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -228,7 +214,6 @@ public IDisposable ScheduleAction<TState>(TState state, Action<TState> action)
         /// <param name="action">Action to execute.</param>
         /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> or <paramref name="action"/> is <c>null</c>.</exception>
-        /// <remarks>The naming of this method differs from <c>Schedule</c> because otherwise the signature would cause ambiguities.</remarks>
         internal IDisposable ScheduleAction<TState>(TState state, Func<TState, IDisposable> action)
         {
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -245,14 +230,7 @@ internal IDisposable ScheduleAction<TState>(TState state, Func<TState, IDisposab
         /// <param name="state">A state object to be passed to <paramref name="action" />.</param>
         /// <param name="dueTime">Relative time after which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         internal IDisposable ScheduleAction<TState>(TState state, TimeSpan dueTime, Action<TState> action)
         {
@@ -268,14 +246,7 @@ internal IDisposable ScheduleAction<TState>(TState state, TimeSpan dueTime, Acti
         /// <param name="state">A state object to be passed to <paramref name="action" />.</param>
         /// <param name="dueTime">Relative time after which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         internal IDisposable ScheduleAction<TState>(TState state, TimeSpan dueTime, Func<TState, IDisposable> action)
         {
@@ -291,14 +262,7 @@ internal IDisposable ScheduleAction<TState>(TState state, TimeSpan dueTime, Func
         /// <param name="state">A state object to be passed to <paramref name="action" />.</param>
         /// <param name="dueTime">Relative time after which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         internal IDisposable ScheduleAction<TState>(TState state, DateTimeOffset dueTime, Action<TState> action)
         {
@@ -314,14 +278,7 @@ internal IDisposable ScheduleAction<TState>(TState state, DateTimeOffset dueTime
         /// <param name="state">A state object to be passed to <paramref name="action" />.</param>
         /// <param name="dueTime">Relative time after which to execute the action.</param>
         /// <param name="action">Action to execute.</param>
-        /// <returns>
-        /// The disposable object used to cancel the scheduled action (best effort).
-        /// </returns>
-        /// <exception cref="ArgumentNullException">
-        /// scheduler
-        /// or
-        /// action.
-        /// </exception>
+        /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
         internal IDisposable ScheduleAction<TState>(
             TState state,
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
index 12a06f08..cc5161d5 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
@@ -17,7 +17,6 @@ public SynchronizationContextSequencer(SynchronizationContext context) =>
 
     /// <summary>Gets a sequencer for the current synchronization context.</summary>
     /// <exception cref="InvalidOperationException">There is no current synchronization context.</exception>
-    /// <remarks>Coverage excludes the getter because the ambient context cannot be changed safely by parallel tests.</remarks>
     public static SynchronizationContextSequencer Current
     {
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -61,7 +60,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         ThreadPoolSequencer.Instance.Schedule(new DelayedPostWorkItem(this, item), dueTimestamp);
     }
 
-    /// <summary>Executes work when it has not already been cancelled.</summary>
+    /// <summary>Executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     private static void ExecutePosted(IWorkItem item)
     {
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
index 2bb0438f..c67d9449 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
@@ -5,9 +5,8 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>
-/// Thread-safe wrapper around <see cref="SequencerQueue{TAbsolute}"/> used by the virtual-time sequencers. Bundling
-/// the queue with its lock lets the self-removal callback synchronize through a reference without capturing the
-/// owning struct's <c>this</c>.
+/// Thread-safe wrapper around <see cref="SequencerQueue{TAbsolute}"/> that pairs the queue with its lock, so the
+/// virtual-time self-removal callback synchronizes through one reference instead of capturing the owning struct.
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 internal sealed class SynchronizedSequencerQueue<TAbsolute>
diff --git a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
index a35446ff..cd26e04d 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
@@ -21,10 +21,7 @@ public sealed class TaskPoolSequencer : ISequencer
     public TaskPoolSequencer(TaskFactory taskFactory) =>
         _taskFactory = taskFactory ?? throw new ArgumentNullException(nameof(taskFactory));
 
-    /// <summary>Gets the instance.</summary>
-    /// <value>
-    /// The instance.
-    /// </value>
+    /// <summary>Gets the shared sequencer backed by <see cref="Task.Factory"/>.</summary>
     public static TaskPoolSequencer Instance { get; } = new(Task.Factory);
 
     /// <summary>Gets the default task-pool scheduler.</summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index b09e7490..defeae76 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -29,17 +29,12 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
     private readonly Timer _timer;
 
     /// <summary>
-    /// Non-zero once <see cref="Dispose"/> has released the timer and the queue. Written under <see cref="_gate"/>
-    /// so every path that touches the timer is ordered against disposal, but read without it on the immediate path,
-    /// which never goes near the timer.
+    /// Non-zero once <see cref="Dispose"/> has released the timer and the queue; written under <see cref="_gate"/> so
+    /// timer paths are ordered against disposal, and read unlocked on the immediate path, which ignores the timer.
     /// </summary>
     private int _isDisposed;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class. Callers use <see cref="Instance"/>;
-    /// this is internal so a test can own an isolated sequencer it may dispose without shutting the shared singleton
-    /// down for every other test.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class; callers use <see cref="Instance"/>.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Correctness",
         "SST2403:Do not let 'this' escape from a constructor",
@@ -95,8 +90,8 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         lock (_gate)
         {
-            // Tested under the same gate disposal takes, so an item that makes it into the queue is one disposal is
-            // guaranteed to see and release. It can never be enqueued behind an already-released timer.
+            // Checked under the gate disposal takes, so an item that reaches the queue is one disposal will see and
+            // release; it can never land behind a released timer.
             ObjectDisposedExceptionHelper.ThrowIf(IsDisposed, this);
 
             _queue.Enqueue(new(item, dueTimestamp));
@@ -105,15 +100,15 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     }
 
     /// <summary>
-    /// Releases the delay timer this sequencer owns and cancels the delayed work still queued behind it. Scheduling
-    /// through a disposed sequencer throws <see cref="ObjectDisposedException"/> rather than accepting work that
-    /// could never become due. Work the thread pool has already picked up runs to completion.
+    /// Releases the delay timer this sequencer owns and cancels the delayed work queued behind it. Scheduling through
+    /// a disposed sequencer throws <see cref="ObjectDisposedException"/> rather than accepting work that could never
+    /// become due. Work the thread pool has picked up runs to completion.
     /// </summary>
     public void Dispose()
     {
-        // Under the gate: every arm of the timer happens under it too, so the timer can never be re-armed after it
-        // is released here. Timer.Dispose does not wait for an in-flight callback, so a drain blocked on the gate
-        // cannot deadlock this — it simply observes the disposed flag once it gets in.
+        // Arming the timer takes this gate too, so it cannot be re-armed after the release below. Timer.Dispose does
+        // not wait for an in-flight callback, so a drain blocked on the gate observes the disposed flag rather than
+        // deadlocking here.
         lock (_gate)
         {
             if (IsDisposed)
@@ -127,7 +122,7 @@ public void Dispose()
         }
     }
 
-    /// <summary>Executes a work item when it has not already been cancelled.</summary>
+    /// <summary>Executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     private static void ExecuteQueued(IWorkItem item)
     {
@@ -186,10 +181,7 @@ private bool TryDequeueDueNoLock(out TimedWorkItem item)
         return false;
     }
 
-    /// <summary>
-    /// Cancels and drops every queued delayed item. The items are the handles their callers hold, so disposing them
-    /// releases the caller's work instead of stranding it in a queue nothing will ever drain again.
-    /// </summary>
+    /// <summary>Cancels and drops every queued delayed item, disposing each so its caller's handle is released.</summary>
     private void ReleaseQueuedNoLock()
     {
         while (_queue.TryDequeue(out var pending))
@@ -206,8 +198,8 @@ private void ArmTimerNoLock()
     {
         if (IsDisposed)
         {
-            // Disposal released the timer and the queue under this same gate. A drain that is still unwinding on
-            // the timer's callback thread lands here, and must not re-arm a timer that no longer exists.
+            // Disposal released the timer and the queue under this same gate, so a drain unwinding on the timer's
+            // callback thread lands here and must not re-arm a released timer.
             return;
         }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
index b6837bc6..4cc6cfab 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
@@ -389,21 +389,19 @@ public async Task ShiftAndExpireAliasesUseTimeBasedOperators()
     /// <returns>The completed task result.</returns>
     private static async Task<T> DrainUntilComplete<T>(Task<T> task, QueuedSequencer sequencer)
     {
-        const int MaxIterations = 1_000;
-        const int PollDelayMilliseconds = 1;
-        const int TimeoutSeconds = 5;
-        for (var i = 0; i < MaxIterations; i++)
+        while (true)
         {
+            // Capture the arrival signal before draining so work queued during the drain is not missed.
+            var queued = sequencer.WorkArrived;
             sequencer.DrainAll();
+
             if (task.IsCompleted)
             {
                 return await task.ConfigureAwait(false);
             }
 
-            await Task.Delay(PollDelayMilliseconds).ConfigureAwait(false);
+            _ = await Task.WhenAny(task, queued).ConfigureAwait(false);
         }
-
-        return await task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds)).ConfigureAwait(false);
     }
 
     /// <summary>Reads a short async enumerable sequence for factory alias coverage.</summary>
@@ -527,6 +525,9 @@ private sealed class QueuedSequencer : ISequencer
         /// <summary>The queue of scheduled work items awaiting drain.</summary>
         private readonly ConcurrentQueue<IWorkItem> _items = new();
 
+        /// <summary>Signals the arrival of a work item; replaced with a fresh source on every arrival.</summary>
+        private TaskCompletionSource _arrival = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
         /// <inheritdoc/>
         public DateTimeOffset Now => FixedNow;
 
@@ -536,11 +537,17 @@ private sealed class QueuedSequencer : ISequencer
         /// <summary>Gets the number of scheduled work items.</summary>
         public int ScheduleCount { get; private set; }
 
+        /// <summary>Gets a task that completes when the next work item is scheduled.</summary>
+        public Task WorkArrived => Volatile.Read(ref _arrival).Task;
+
         /// <inheritdoc/>
         public void Schedule(IWorkItem item)
         {
             ScheduleCount++;
             _items.Enqueue(item);
+            IgnoredResult.Of(
+                Interlocked.Exchange(ref _arrival, new(TaskCreationOptions.RunContinuationsAsynchronously))
+                    .TrySetResult());
         }
 
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
index 66c7faf8..1406e851 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
@@ -28,7 +28,7 @@ public async Task AsyncContextRenamedMembersExposeDefaultAndSequencerSchedulerPa
         await Assert.That(AsyncContext.Default.UsesDefaultSequencer).IsTrue();
         await Assert.That(sequencerContext.UsesDefaultSequencer).IsFalse();
         await Assert.That(AsyncContext.From(new SynchronizationContext()).UsesDefaultSequencer).IsFalse();
-        await Assert.That(AsyncContext.From(NewThreadTaskScheduler.Instance).UsesDefaultSequencer).IsFalse();
+        await Assert.That(AsyncContext.From(CustomTaskScheduler.Instance).UsesDefaultSequencer).IsFalse();
         await Assert.That(syncSequencerContext.SynchronizationContext).IsSameReferenceAs(syncSequencer);
         await Assert.That(sequencerContext.IsSameAsCurrentAsyncContext()).IsFalse();
         await Assert.That(scheduler.Sequencer).IsSameReferenceAs(sequencer);
@@ -67,7 +67,7 @@ public async Task AsyncContextSwitcherBranchesCoverCustomSchedulersAndCancellati
         canceledAwaitable.OnCompleted(() => cancellationCallbacks++);
         await Assert.That(cancellationCallbacks).IsEqualTo(1);
         TaskCompletionSource scheduled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var schedulerAwaitable = AsyncContext.From(NewThreadTaskScheduler.Instance)
+        var schedulerAwaitable = AsyncContext.From(CustomTaskScheduler.Instance)
             .SwitchContextAsync(true, CancellationToken.None);
         schedulerAwaitable.OnCompleted(scheduled.SetResult);
         await scheduled.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
index d16f55b3..34bdf2e3 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
@@ -69,19 +69,26 @@ public async Task WhenMergeObservableOfObservables_ThenFlattens()
     public async Task WhenMergeWithMaxConcurrency_ThenRespectsLimit()
     {
         const int SourceCount = 5;
-        const int WorkDelayMilliseconds = 50;
         const int ConcurrencyLimit = 2;
         var activeConcurrency = 0;
         var maxConcurrency = 0;
+
+        // Each job parks until the gate opens, so the limit is observed with every slot occupied.
+        TaskCompletionSource limitReached = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource releaseJobs = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var source = SignalAsync.Range(1, SourceCount).Select(i => SignalAsync.CreateAsBackgroundJob<int>(async (obs, ct) =>
         {
             lock (_gate)
             {
                 activeConcurrency++;
                 maxConcurrency = Math.Max(maxConcurrency, activeConcurrency);
+                if (activeConcurrency == ConcurrencyLimit)
+                {
+                    IgnoredResult.Of(limitReached.TrySetResult());
+                }
             }
 
-            await Task.Delay(WorkDelayMilliseconds, ct);
+            await releaseJobs.Task;
             lock (_gate)
             {
                 activeConcurrency--;
@@ -90,7 +97,10 @@ public async Task WhenMergeWithMaxConcurrency_ThenRespectsLimit()
             await obs.OnNextAsync(i, ct);
             await obs.OnCompletedAsync(Result.Success);
         }));
-        var result = await source.Merge(ConcurrencyLimit).ToListAsync();
+        var merged = source.Merge(ConcurrencyLimit).ToListAsync().AsTask();
+        await limitReached.Task;
+        IgnoredResult.Of(releaseJobs.TrySetResult());
+        var result = await merged;
         await Assert.That(result).Count().IsEqualTo(SourceCount);
         await Assert.That(maxConcurrency).IsLessThanOrEqualTo(ConcurrencyLimit);
     }
@@ -121,7 +131,6 @@ public async Task WhenMergeObservableOfObservablesOuterErrors_ThenFailurePropaga
     [Test]
     public async Task WhenMergeWithMaxConcurrencySubscriptionThrows_ThenErrorPropagates()
     {
-        const int CompletionTimeoutSeconds = 2;
         var failing = SignalAsync.Create<int>(static (_, _) =>
         {
             try
@@ -134,15 +143,14 @@ public async Task WhenMergeWithMaxConcurrencySubscriptionThrows_ThenErrorPropaga
             }
         });
         var source = new[] { failing }.ToAsyncSignal();
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await source.Merge(1).SubscribeAsync(static (_, _) => default, null, result =>
         {
-            completionResult = result;
+            IgnoredResult.Of(completed.TrySetResult(result));
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
-        await Assert.That(completionResult).IsNotNull();
-        await Assert.That(completionResult!.Value.IsFailure).IsTrue();
+        var completionResult = await completed.Task;
+        await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
     /// <summary>Verifies that merging an enumerable of observables where one inner source errors propagates the failure.</summary>
@@ -422,8 +430,6 @@ public async Task WhenMergeEnumerableInnerCompletesAsynchronously_ThenAwaitsSubs
     [Test]
     public async Task WhenMergeEnumerableBeginSubscribingThrows_ThenCatchBlockHandled()
     {
-        const int CompletionTimeoutSeconds = 5;
-
         // BeginSubscribing contains an async void path that catches exceptions
         // We exercise this by ensuring an error during inner subscription is caught
         static IEnumerable<IObservableAsync<int>> ThrowingEnumerable()
@@ -432,7 +438,7 @@ static IEnumerable<IObservableAsync<int>> ThrowingEnumerable()
             throw new InvalidOperationException("enumeration boom");
         }
 
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> items = [];
         await using var sub = await ThrowingEnumerable().Merge().SubscribeAsync(
             (x, _) =>
@@ -443,12 +449,11 @@ static IEnumerable<IObservableAsync<int>> ThrowingEnumerable()
             null,
             result =>
             {
-                completionResult = result;
+                IgnoredResult.Of(completed.TrySetResult(result));
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult is not null, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
-        await Assert.That(completionResult).IsNotNull();
-        await Assert.That(completionResult!.Value.IsFailure).IsTrue();
+        var completionResult = await completed.Task;
+        await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
     /// <summary>Tests that MergeEnumerable cancellation during inner subscription is handled.</summary>
@@ -515,10 +520,9 @@ public async Task WhenMergeEmptyEnumerable_ThenReturnsEmpty()
     [Test]
     public async Task WhenMergeWithError_ThenErrorPropagated()
     {
-        const int CompletionTimeoutSeconds = 5;
         IObservableAsync<int>[] sources =
             [SignalAsync.Return(1), SignalAsync.Throw<int>(new InvalidOperationException("fail"))];
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> items = [];
         await using var sub = await sources.Merge().SubscribeAsync(
             (x, _) =>
@@ -529,12 +533,11 @@ public async Task WhenMergeWithError_ThenErrorPropagated()
             null,
             result =>
             {
-                completionResult = result;
+                IgnoredResult.Of(completed.TrySetResult(result));
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
-        await Assert.That(completionResult).IsNotNull();
-        await Assert.That(completionResult!.Value.IsFailure).IsTrue();
+        var completionResult = await completed.Task;
+        await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
     /// <summary>Verifies that MergeEnumerable forwards errors from a source that throws during subscribe.</summary>
@@ -542,19 +545,17 @@ public async Task WhenMergeWithError_ThenErrorPropagated()
     [Test]
     public async Task WhenMergeEnumerableSourceThrowsDuringSubscribe_ThenCompletesWithFailure()
     {
-        const int CompletionTimeoutSeconds = 5;
         var throwingSource = SignalAsync.Create<int>(static (_, _) =>
             ValueTask.FromException<IAsyncDisposable>(new InvalidOperationException(SubscribeBoomMessage)));
         IObservableAsync<int>[] sources = [throwingSource];
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await sources.Merge().SubscribeAsync(static (_, _) => default, null, result =>
         {
-            completionResult = result;
+            IgnoredResult.Of(completed.TrySetResult(result));
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
-        await Assert.That(completionResult).IsNotNull();
-        await Assert.That(completionResult!.Value.IsFailure).IsTrue();
+        var completionResult = await completed.Task;
+        await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
     /// <summary>
@@ -565,7 +566,6 @@ public async Task WhenMergeEnumerableSourceThrowsDuringSubscribe_ThenCompletesWi
     [Test]
     public async Task WhenMergeEnumerableInnerSubscribeThrowsTaskCanceled_ThenHandledGracefully()
     {
-        const int SettleTimeoutSeconds = 2;
         var canceledSource = SignalAsync.Create<int>(static (_, _) =>
             ValueTask.FromException<IAsyncDisposable>(new TaskCanceledException("subscribe canceled")));
         List<int> items = [];
@@ -580,7 +580,6 @@ public async Task WhenMergeEnumerableInnerSubscribeThrowsTaskCanceled_ThenHandle
 
         // The TaskCanceledException catch returns early without signaling completion,
         // so the sequence yields nothing (graceful early return).
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, TimeSpan.FromSeconds(SettleTimeoutSeconds));
         await Assert.That(items).IsEmpty();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
index e451d0dc..e52e1bac 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
@@ -18,9 +18,6 @@ public class ConcurrentSignalBaseTests
     /// <summary>Value forwarded by the <c>OnNext</c> fan-out tests.</summary>
     private const int ForwardedValue = 42;
 
-    /// <summary>Delay in milliseconds used to force the slow-path branch.</summary>
-    private const int SlowPathDelayMilliseconds = 5;
-
     /// <summary>Verifies that <c>ForwardOnNextConcurrently</c> with an empty observer list returns immediately.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -251,13 +248,14 @@ private static CallbackWitnessAsync<int> MakeSync(IntCapture capture) =>
             return default;
         });
 
-    /// <summary>Creates an OnNext observer that delays before capturing — forces the slow path.</summary>
+    /// <summary>Creates an OnNext observer that suspends before capturing — forces the slow path.</summary>
     /// <param name="capture">The capture sink.</param>
     /// <returns>An observer whose <c>OnNextAsync</c> completes asynchronously.</returns>
     private static CallbackWitnessAsync<int> MakeSlow(IntCapture capture) =>
-        new(async (x, ct) =>
+        new(async (x, _) =>
         {
-            await Task.Delay(SlowPathDelayMilliseconds, ct).ConfigureAwait(false);
+            // Yielding guarantees the returned ValueTask is incomplete when the fan-out inspects it.
+            await Task.Yield();
             capture.Value = x;
         });
 
@@ -271,13 +269,13 @@ private static Func<Exception, CancellationToken, ValueTask> MakeErrorSync(Error
             return default;
         };
 
-    /// <summary>OnErrorResume handler that delays before recording — forces the slow path.</summary>
+    /// <summary>OnErrorResume handler that suspends before recording — forces the slow path.</summary>
     /// <param name="capture">The capture sink.</param>
     /// <returns>An OnErrorResume delegate.</returns>
     private static Func<Exception, CancellationToken, ValueTask> MakeErrorSlow(ErrorCapture capture) =>
-        async (ex, ct) =>
+        async (ex, _) =>
         {
-            await Task.Delay(SlowPathDelayMilliseconds, ct).ConfigureAwait(false);
+            await Task.Yield();
             capture.Error = ex;
         };
 
@@ -291,13 +289,13 @@ private static Func<Result, ValueTask> MakeCompletedSync(ResultCapture capture)
             return default;
         };
 
-    /// <summary>OnCompleted handler that delays before recording — forces the slow path.</summary>
+    /// <summary>OnCompleted handler that suspends before recording — forces the slow path.</summary>
     /// <param name="capture">The capture sink.</param>
     /// <returns>An OnCompleted delegate.</returns>
     private static Func<Result, ValueTask> MakeCompletedSlow(ResultCapture capture) =>
         async r =>
         {
-            await Task.Delay(SlowPathDelayMilliseconds, CancellationToken.None).ConfigureAwait(false);
+            await Task.Yield();
             capture.Result = r;
         };
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
new file mode 100644
index 00000000..e5c64fdd
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
@@ -0,0 +1,38 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>
+/// A <see cref="TaskScheduler"/> that is not <see cref="TaskScheduler.Default"/> and runs each queued task
+/// on the thread pool. Used to exercise the code paths that branch on a caller-supplied scheduler.
+/// </summary>
+internal sealed class CustomTaskScheduler : TaskScheduler
+{
+    /// <summary>Singleton instance.</summary>
+    internal static readonly CustomTaskScheduler Instance = new();
+
+    /// <summary>Initializes a new instance of the <see cref="CustomTaskScheduler"/> class.</summary>
+    private CustomTaskScheduler()
+    {
+    }
+
+    /// <inheritdoc/>
+    protected override void QueueTask(Task task) =>
+        ThreadPool.UnsafeQueueUserWorkItem(
+            static state => IgnoredResult.Of(state.Scheduler.ExecuteQueued(state.Work)),
+            (Scheduler: this, Work: task),
+            false);
+
+    /// <inheritdoc/>
+    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
+
+    /// <inheritdoc/>
+    protected override IEnumerable<Task>? GetScheduledTasks() => null;
+
+    /// <summary>Runs a queued task on the pool thread that picked it up.</summary>
+    /// <param name="task">The queued task.</param>
+    /// <returns><see langword="true"/> when the task was executed.</returns>
+    private bool ExecuteQueued(Task task) => TryExecuteTask(task);
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
index c46ea95e..5637fc99 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
@@ -798,13 +798,13 @@ public void WhenToDisposableAsyncNull_ThenThrowsArgumentNull() =>
         Assert.Throws<ArgumentNullException>(static () => ((IDisposable)null!).ToDisposableAsync());
 
     /// <summary>
-    /// Verifies that the CAS retry loop in SetDisposableAsync is exercised
-    /// when another thread mutates _current between the Volatile.Read and the
-    /// CompareExchange, forcing the loop to re-read and retry.
+    /// Verifies that concurrent SetDisposableAsync calls account for every disposable: each
+    /// replaced occupant is disposed as it leaves the slot and the final occupant is disposed
+    /// by the slot itself, whichever order the compare-exchanges land in.
     /// </summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenSerialCASRetryLoop_ThenAllDisposablesAccountedFor()
+    public async Task WhenSerialSetConcurrently_ThenAllDisposablesAccountedFor()
     {
         SingleReplaceableDisposableAsync serial = new();
         StrongBox<int> disposedCount = new();
@@ -815,16 +815,13 @@ IAsyncDisposable MakeDisposable() => DisposableAsync.Create(disposedCount, stati
             return default;
         });
 
-        // Bounded contention: enough parallel sets to race on CAS, small enough to run
-        // deterministically on any CI runner. Previous 20x10 layout produced unbounded
-        // variance (observed: 3s → 15s → never completed) and could timeout the suite.
+        // Bounded contention: enough parallel sets to overlap on the CAS, few enough that the
+        // total disposal count stays small. The count below holds for every interleaving.
         const int Parallelism = 4;
         const int IterationsPerTask = 5;
         const int ExpectedDisposedCount = Parallelism * IterationsPerTask;
-        Barrier barrier = new(Parallelism);
         var tasks = Enumerable.Range(0, Parallelism).Select(_ => Task.Run(async () =>
         {
-            barrier.SignalAndWait();
             for (var i = 0; i < IterationsPerTask; i++)
             {
                 await serial.SetDisposableAsync(MakeDisposable());
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
index cf96858e..40ce0ccc 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
@@ -138,7 +138,7 @@ public async Task WhenRetryOnTransientError_ThenSucceedsAfterRetry()
                 await obs.OnNextAsync(SuccessValue, ct);
                 await obs.OnCompletedAsync(Result.Success);
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         var result = await source.Retry(RetryCount).ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SuccessValue]);
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
@@ -232,7 +232,7 @@ public async Task WhenRetryWithCountZero_ThenPropagatesErrorImmediately()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         await using var sub = await source.Retry(0).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -259,7 +259,7 @@ public async Task WhenRetryCountExhausted_ThenPropagatesLastError()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         await using var sub = await source.Retry(RetryCount).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -284,7 +284,7 @@ public async Task WhenRetryWithCountOne_ThenRetriesOnceAndPropagates()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         await using var sub = await source.Retry(1).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -489,7 +489,7 @@ public async Task WhenRetryParameterless_ThenRetriesUntilSuccess()
                 await obs.OnNextAsync(SuccessValue, ct);
                 await obs.OnCompletedAsync(Result.Success);
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         var result = await source.Retry().ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SuccessValue]);
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
index 31c3a7e1..045e69b5 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
@@ -18,9 +18,6 @@ public class FactorySignalTests
     /// <summary>Hoisted source array used by tests (was inline literal).</summary>
     private static readonly int[] Sequence123 = [1, 2, 3];
 
-    /// <summary>Maximum time a test waits for an emission or completion to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Delay before the single-shot timer fires.</summary>
     private static readonly TimeSpan SingleShotDelay = TimeSpan.FromMilliseconds(50);
 
@@ -85,15 +82,12 @@ public async Task WhenThrow_ThenCompletesWithException()
     public void WhenThrowNullException_ThenThrowsArgumentNull() =>
         Assert.Throws<ArgumentNullException>(static () => SignalAsync.Throw<int>(null!));
 
-    /// <summary>Tests Never does not complete within timeout.</summary>
+    /// <summary>Tests Never neither emits nor completes, including once its subscription token is cancelled.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenNever_ThenDoesNotCompleteWithinTimeout()
+    public async Task WhenNever_ThenNeitherEmitsNorCompletes()
     {
-        const int ObservationWindowMs = 250;
-        const int SubscriptionCancelledAfterMs = 200;
-
-        using CancellationTokenSource cts = new(SubscriptionCancelledAfterMs);
+        using CancellationTokenSource cts = new();
         List<int> items = [];
         var completed = false;
         await using var sub = await SignalAsync.Never<int>().SubscribeAsync(
@@ -109,7 +103,7 @@ public async Task WhenNever_ThenDoesNotCompleteWithinTimeout()
                 return default;
             },
             cts.Token);
-        await Task.Delay(ObservationWindowMs);
+        await cts.CancelAsync();
         await Assert.That(items).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
@@ -253,7 +247,7 @@ static async (observer, ct) =>
                 await observer.OnNextAsync(SentinelValue, ct);
                 await observer.OnCompletedAsync(Result.Success);
             },
-            NewThreadTaskScheduler.Instance);
+            CustomTaskScheduler.Instance);
         var result = await source.ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SentinelValue]);
     }
@@ -277,14 +271,20 @@ public async Task WhenTimerPeriodic_ThenEmitsMultipleValues()
         const int MinimumEmissions = 2;
         var source = SignalAsync.Timer(PeriodicDueTime, PeriodicInterval);
         List<long> items = [];
+        TaskCompletionSource minimumReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await source.SubscribeAsync(
             (x, _) =>
             {
                 items.Add(x);
+                if (items.Count >= MinimumEmissions)
+                {
+                    IgnoredResult.Of(minimumReceived.TrySetResult());
+                }
+
                 return default;
             },
             null);
-        await AsyncTestHelpers.WaitForConditionAsync(() => items.Count >= MinimumEmissions, WaitTimeout);
+        await minimumReceived.Task;
         await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinimumEmissions);
         await Assert.That(items[0]).IsEqualTo(0L);
     }
@@ -374,6 +374,7 @@ public async Task WhenIntervalWithCancellation_ThenEmitsPeriodicValues()
         using CancellationTokenSource cts = new();
         var source = SignalAsync.Interval(PeriodicInterval);
         List<long> items = [];
+        TaskCompletionSource minimumReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var received = false;
         try
         {
@@ -381,14 +382,18 @@ public async Task WhenIntervalWithCancellation_ThenEmitsPeriodicValues()
                 (x, _) =>
                 {
                     items.Add(x);
+                    if (items.Count >= MinimumEmissions)
+                    {
+                        IgnoredResult.Of(minimumReceived.TrySetResult());
+                    }
+
                     return default;
                 },
                 null,
                 null,
                 cts.Token);
-            received = await AsyncTestHelpers.WaitForConditionAsync(
-                () => items.Count >= MinimumEmissions,
-                WaitTimeout);
+            await minimumReceived.Task;
+            received = true;
         }
         catch (OperationCanceledException)
         {
@@ -450,7 +455,7 @@ public async Task WhenSubscribeAsyncWithOnNextAsyncOnly_ThenReceivesItems()
             IgnoredResult.Of(received.TrySetResult());
             return default;
         });
-        await received.Task.WaitAsync(WaitTimeout);
+        await received.Task;
         await Assert.That(items).IsCollectionEqualTo([EmittedValue]);
     }
 
@@ -471,7 +476,7 @@ public async Task WhenSubscribeAsyncWithOnNextAsyncAndCancellationToken_ThenRece
                 return default;
             },
             cts.Token);
-        await received.Task.WaitAsync(WaitTimeout);
+        await received.Task;
         await Assert.That(items).IsCollectionEqualTo([EmittedValue]);
     }
 
@@ -492,7 +497,7 @@ public async Task WhenSubscribeAsyncSyncOverloadWithError_ThenInvokesOnErrorResu
             ex => errorReceived.TrySetResult(ex),
             null,
             CancellationToken.None);
-        var error = await errorReceived.Task.WaitAsync(WaitTimeout);
+        var error = await errorReceived.Task;
         await Assert.That(error).IsTypeOf<InvalidOperationException>();
         await Assert.That(error.Message).IsEqualTo("sync error");
     }
@@ -508,7 +513,7 @@ public async Task WhenSubscribeAsyncSyncOverloadWithCompletion_ThenInvokesOnComp
             null,
             r => completedResult.TrySetResult(r),
             CancellationToken.None);
-        var result = await completedResult.Task.WaitAsync(WaitTimeout);
+        var result = await completedResult.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -524,7 +529,7 @@ public async Task WhenSubscribeAsyncWithNullOnErrorResume_ThenCompletesNormally(
             null,
             _ => completed.TrySetResult(),
             CancellationToken.None);
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(items).IsCollectionEqualTo([SentinelValue]);
     }
 
@@ -544,7 +549,7 @@ public async Task WhenSubscribeAsyncWithNullOnCompleted_ThenCompletesNormally()
             static _ => { },
             null,
             CancellationToken.None);
-        await received.Task.WaitAsync(WaitTimeout);
+        await received.Task;
         await Assert.That(items).IsCollectionEqualTo([SentinelValue]);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/NewThreadTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/NewThreadTaskScheduler.cs
deleted file mode 100644
index 2e25ab02..00000000
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/NewThreadTaskScheduler.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-namespace ReactiveUI.Primitives.Async.Tests;
-
-/// <summary>
-/// A <see cref="TaskScheduler"/> that launches each queued task on its own dedicated background thread.
-/// Provides deterministic concurrency for tests that need real parallel execution without competing for
-/// limited <see cref="ThreadPool"/> resources (which can deadlock when many tests run in parallel and each
-/// blocks waiting on inner work that also needs a pool thread).
-/// </summary>
-internal sealed class NewThreadTaskScheduler : TaskScheduler
-{
-    /// <summary>Singleton instance.</summary>
-    internal static readonly NewThreadTaskScheduler Instance = new();
-
-    /// <summary>Initializes a new instance of the <see cref="NewThreadTaskScheduler"/> class.</summary>
-    private NewThreadTaskScheduler()
-    {
-    }
-
-    /// <inheritdoc/>
-    protected override void QueueTask(Task task) =>
-        new Thread(state => TryExecuteTask((Task)state!)) { IsBackground = true, Name = "NewThreadTaskScheduler" }
-            .Start(task);
-
-    /// <inheritdoc/>
-    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
-
-    /// <inheritdoc/>
-    protected override IEnumerable<Task>? GetScheduledTasks() => null;
-}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
index a664806e..ae1a4e6a 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
@@ -22,18 +22,15 @@ public sealed class ObserverAsyncDisposeTests
     /// </summary>
     private const int DisposeRaceAttempts = 256;
 
-    /// <summary>Maximum time a reentrant dispose may take before it is treated as a deadlock.</summary>
-    private static readonly TimeSpan DeadlockTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the reentrant dispose path lets an observer dispose itself from within its own in-flight
     /// notification without deadlocking, even after the notification continuation has hopped to a different thread.</summary>
-    /// <returns>A task that completes when disposal finishes; faults on timeout if a self-join deadlock occurs.</returns>
+    /// <returns>A task that completes when disposal finishes; a self-join deadlock leaves it pending.</returns>
     [Test]
     public async Task WhenDisposedReentrantlyFromOwnNotificationAfterThreadHop_ThenDoesNotDeadlock()
     {
         SelfDisposingObserver observer = new();
 
-        await observer.OnNextAsync(1, CancellationToken.None).AsTask().WaitAsync(DeadlockTimeout);
+        await observer.OnNextAsync(1, CancellationToken.None);
 
         await Assert.That(observer.HasDisposed).IsTrue();
     }
@@ -51,7 +48,7 @@ public async Task WhenFirstAsyncResolvesDuringHoppedNotification_ThenCompletes()
             return DisposableAsync.Empty;
         });
 
-        var value = await source.FirstAsync().AsTask().WaitAsync(DeadlockTimeout);
+        var value = await source.FirstAsync();
 
         await Assert.That(value).IsEqualTo(EmittedValue);
     }
@@ -81,19 +78,19 @@ public async Task WhenLinkedToItsOwnDisposeToken_ThenExternalLinkStillDisposesTh
     /// <summary>Verifies that disposing an observer from one thread while a notification is still in flight on
     /// another never hangs, including when that notification's call count drops to zero inside the disposer's
     /// publish-then-recheck window — the case the disposer must self-signal to avoid waiting forever.</summary>
-    /// <returns>A task that completes when every attempt has disposed; faults on timeout if a wait deadlocks.</returns>
+    /// <returns>A task that completes when every attempt has disposed; a deadlocked wait leaves it pending.</returns>
     [Test]
     public async Task WhenDisposedFromAnotherThreadAsNotificationExits_ThenDoesNotDeadlock()
     {
         for (var attempt = 0; attempt < DisposeRaceAttempts; attempt++)
         {
-            SpinningObserver observer = new();
+            ParkedNotificationObserver observer = new();
             var notification = Task.Run(async () =>
                 await observer.OnNextAsync(EmittedValue, CancellationToken.None));
 
-            await observer.Entered.WaitAsync(DeadlockTimeout);
-            await observer.DisposeAsync().AsTask().WaitAsync(DeadlockTimeout);
-            await notification.WaitAsync(DeadlockTimeout);
+            await observer.Entered;
+            await observer.DisposeAsync();
+            await notification;
 
             await Assert.That(observer.HasDisposed).IsTrue();
         }
@@ -121,33 +118,24 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
         protected override ValueTask OnCompletedAsyncCore(Result result) => default;
     }
 
-    /// <summary>Observer whose notification stays in flight, spinning, until disposal releases it — so the call
-    /// exits within nanoseconds of the disposer starting, rather than parking and exiting long afterwards.</summary>
-    private sealed class SpinningObserver : WitnessAsync<int>
+    /// <summary>Observer whose notification stays in flight until disposal releases it, so the call exits while the
+    /// disposer is inside its publish-then-recheck window rather than long before or long after it.</summary>
+    private sealed class ParkedNotificationObserver : WitnessAsync<int>
     {
-        /// <summary>Upper bound on the spin the in-flight notification performs while waiting to be released.</summary>
-        private const int MaxReleaseSpins = 10_000_000;
-
         /// <summary>Completes once the notification has been entered and the in-flight call count is non-zero.</summary>
         private readonly TaskCompletionSource _entered = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        /// <summary>Non-zero once disposal has released the spinning notification.</summary>
-        private int _released;
+        /// <summary>Completes when disposal releases the parked notification.</summary>
+        private readonly TaskCompletionSource _released = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         /// <summary>Gets a task that completes once the notification is in flight.</summary>
         internal Task Entered => _entered.Task;
 
         /// <inheritdoc/>
-        protected override ValueTask OnNextAsyncCore(int value, CancellationToken cancellationToken)
+        protected override async ValueTask OnNextAsyncCore(int value, CancellationToken cancellationToken)
         {
             IgnoredResult.Of(_entered.TrySetResult());
-
-            for (var spin = 0; spin < MaxReleaseSpins && Volatile.Read(ref _released) == 0; spin++)
-            {
-                Thread.SpinWait(1);
-            }
-
-            return default;
+            await _released.Task.ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
@@ -160,7 +148,8 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
         /// <inheritdoc/>
         protected override ValueTask DisposeAsyncCore()
         {
-            Volatile.Write(ref _released, 1);
+            // Release before the base waits on in-flight calls: the notification exits as the gate is published.
+            IgnoredResult.Of(_released.TrySetResult());
             return base.DisposeAsyncCore();
         }
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
index 9998669b..3cac112f 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
@@ -285,7 +285,7 @@ public async Task WhenPartitionSourceErrorResume_ThenBothBranchesReceiveError()
         InvalidOperationException expected = new("partition-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await Task.WhenAll(evenTcs.Task, oddTcs.Task).WaitAsync(WaitTimeout);
+        await Task.WhenAll(evenTcs.Task, oddTcs.Task);
         await Assert.That(evenError).IsSameReferenceAs(expected);
         await Assert.That(oddError).IsSameReferenceAs(expected);
     }
@@ -319,7 +319,7 @@ public async Task WhenPartitionLateBranchSubscribesAfterCompletion_ThenCachedTer
                 return default;
             });
 
-        await lateCompleted.Task.WaitAsync(WaitTimeout);
+        await lateCompleted.Task;
         await Assert.That(lateValues).IsEmpty();
     }
 
@@ -375,7 +375,7 @@ public async Task WhenScanWithInitialSourceErrorResumes_ThenForwardsDownstream()
         InvalidOperationException expected = new("scan-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(values).IsCollectionEqualTo([ScanSeed]);
     }
@@ -403,7 +403,7 @@ public async Task WhenThrottleDistinctSourceErrorResumes_ThenForwardsDownstream(
         InvalidOperationException expected = new("throttle-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -430,7 +430,7 @@ public async Task WhenDebounceUntilSourceErrorResumes_ThenForwardsDownstream()
         InvalidOperationException expected = new("debounce-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -457,7 +457,7 @@ public async Task WhenForEachSourceErrorResumes_ThenForwardsDownstream()
         InvalidOperationException expected = new("foreach-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -484,7 +484,7 @@ public async Task WhenDropIfBusySourceErrorResumes_ThenForwardsDownstream()
         InvalidOperationException expected = new("dropifbusy-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -509,7 +509,7 @@ public async Task WhenDropIfBusySyncActionAsyncDownstream_ThenAwaitForwardSlowPa
             });
 
         await signal.OnNextAsync(One, CancellationToken.None);
-        await emittedTcs.Task.WaitAsync(WaitTimeout);
+        await emittedTcs.Task;
 
         // After the slow path resets _isBusy, a second emission must also flow through.
         TaskCompletionSource secondTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -522,7 +522,7 @@ public async Task WhenDropIfBusySyncActionAsyncDownstream_ThenAwaitForwardSlowPa
             });
 
         await signal.OnNextAsync(Two, CancellationToken.None);
-        await secondTcs.Task.WaitAsync(WaitTimeout);
+        await secondTcs.Task;
 
         await Assert.That(values).Contains(One);
     }
@@ -550,7 +550,7 @@ public async Task WhenScanWithInitialAsyncSourceErrorResumes_ThenForwardsDownstr
         InvalidOperationException expected = new("scan-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -665,8 +665,7 @@ public async Task WhenDebounceUntilSecondEmissionSupersedesFirst_ThenStaleDelayD
         await signal.OnNextAsync(One, CancellationToken.None);
         await signal.OnNextAsync(Two, CancellationToken.None);
 
-        await emitted.Task.WaitAsync(WaitTimeout);
-        await Task.Delay(ThrottleWindowMilliseconds);
+        await emitted.Task;
 
         await Assert.That(values).IsCollectionEqualTo([Two]);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
index d0425c8b..3763de44 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
@@ -14,9 +14,6 @@ public partial class TakeUntilOperatorTests
     /// <summary>String literal "subscribe failed" used by multiple tests.</summary>
     private const string SubscribeFailedMessage = "subscribe failed";
 
-    /// <summary>How long a test waits to prove that an ignored second stop notification never surfaces.</summary>
-    private static readonly TimeSpan SecondNotificationSettleWindow = TimeSpan.FromMilliseconds(250);
-
     /// <summary>Tests that CompletionSignalDelegate failure signal with SourceFailsWhenOtherFails=true completes with failure.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -209,7 +206,7 @@ public async Task WhenTakeUntilTokenCanceledDuringEmission_ThenEmissionStops()
         await source.OnNextAsync(1, CancellationToken.None);
         await source.OnNextAsync(SecondItem, CancellationToken.None);
         await cts.CancelAsync();
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(items).Contains(1);
         await Assert.That(items).Contains(SecondItem);
         await Assert.That(completionResult.IsSuccess).IsTrue();
@@ -266,7 +263,7 @@ public async Task WhenTaskStopSignalCompletesMidStream_ThenStopsEmissions()
         await source.OnNextAsync(1, CancellationToken.None);
         await source.OnNextAsync(SecondItem, CancellationToken.None);
         tcs.SetResult();
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(items).Contains(1);
         await Assert.That(items).Contains(SecondItem);
         await Assert.That(completionResult.IsSuccess).IsTrue();
@@ -394,25 +391,32 @@ public async Task WhenCancellationStopSignal_ThenStopsWhenCanceled()
     public async Task WhenTakeUntilCompletionDelegate_ThenStopsWhenSignalCompletes()
     {
         var signal = Signal.Create<int>();
+        Action<Result>? notifyStop = null;
         List<int> items = [];
+        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await signal.Values.TakeUntil((CompletionSignalDelegate)CompletionSignal).SubscribeAsync(
             (x, _) =>
             {
                 items.Add(x);
                 return default;
             },
-            null);
+            null,
+            _ =>
+            {
+                IgnoredResult.Of(completed.TrySetResult());
+                return default;
+            });
         await signal.OnNextAsync(1, CancellationToken.None);
         await Assert.That(items).Contains(1);
 
-        static IAsyncDisposable CompletionSignal(Action<Result> notifyStop)
+        notifyStop!(Result.Success);
+        await completed.Task;
+        await signal.OnNextAsync(SecondItem, CancellationToken.None);
+        await Assert.That(items).IsCollectionEqualTo([1]);
+
+        IAsyncDisposable CompletionSignal(Action<Result> notify)
         {
-            const int Delay = 100;
-            _ = Task.Run(async () =>
-            {
-                await Task.Delay(Delay);
-                notifyStop(Result.Success);
-            });
+            notifyStop = notify;
             return DisposableAsync.Empty;
         }
     }
@@ -426,17 +430,14 @@ static IAsyncDisposable CompletionSignal(Action<Result> notifyStop)
     public async Task WhenTakeUntilCompletionDelegateFailsAndOptionFalse_ThenErrorResumeForwarded()
     {
         var source = Signal.Create<int>();
+        Action<Result>? notifyStop = null;
         Exception? errorResumed = null;
         List<int> items = [];
+        TaskCompletionSource errorForwarded = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await source.Values.TakeUntil(
             stop =>
             {
-                // Signal failure after a brief delay
-                _ = Task.Run(async () =>
-                {
-                    await Task.Yield();
-                    stop(Result.Failure(new InvalidOperationException("signal fail")));
-                });
+                notifyStop = stop;
                 return DisposableAsync.Empty;
             },
             new TakeUntilOptions { SourceFailsWhenOtherFails = false }).SubscribeAsync(
@@ -448,10 +449,12 @@ public async Task WhenTakeUntilCompletionDelegateFailsAndOptionFalse_ThenErrorRe
             (ex, _) =>
             {
                 errorResumed = ex;
+                IgnoredResult.Of(errorForwarded.TrySetResult());
                 return default;
             });
         await source.OnNextAsync(1, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => errorResumed is not null, WaitTimeout);
+        notifyStop!(Result.Failure(new InvalidOperationException("signal fail")));
+        await errorForwarded.Task;
         await Assert.That(errorResumed).IsNotNull();
         await Assert.That(errorResumed!.Message).IsEqualTo("signal fail");
     }
@@ -467,16 +470,18 @@ public async Task WhenTaskStopSignalFailsAndOptionFalse_ThenErrorResumeForwarded
         var source = Signal.Create<int>();
         TaskCompletionSource<bool> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
         Exception? errorResumed = null;
+        TaskCompletionSource errorForwarded = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await source.Values
             .TakeUntil(tcs.Task, new TakeUntilOptions { SourceFailsWhenOtherFails = false }).SubscribeAsync(
                 static (_, _) => default,
                 (ex, _) =>
                 {
                     errorResumed = ex;
+                    IgnoredResult.Of(errorForwarded.TrySetResult());
                     return default;
                 });
         tcs.SetException(new InvalidOperationException("task fail"));
-        await AsyncTestHelpers.WaitForConditionAsync(() => errorResumed is not null, WaitTimeout);
+        await errorForwarded.Task;
         await Assert.That(errorResumed).IsNotNull();
         await Assert.That(errorResumed!.Message).IsEqualTo("task fail");
     }
@@ -511,7 +516,7 @@ public async Task WhenTakeUntilCompletionDelegateWithCancellableToken_ThenLinked
         using CancellationTokenSource cts = new();
         var source = Signal.Create<int>();
         List<int> values = [];
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         CompletionSignalDelegate stopSignal = static _ => DisposableAsync.Empty;
         await using var sub = await source.Values.TakeUntil(stopSignal, null, cts.Token).SubscribeAsync(
             (x, _) =>
@@ -522,15 +527,15 @@ public async Task WhenTakeUntilCompletionDelegateWithCancellableToken_ThenLinked
             null,
             result =>
             {
-                completionResult = result;
+                IgnoredResult.Of(completed.TrySetResult(result));
                 return default;
             });
         const int Sentinel = 31;
         await source.OnNextAsync(Sentinel, CancellationToken.None);
         await cts.CancelAsync();
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(values).IsCollectionEqualTo([Sentinel]);
-        await Assert.That(completionResult).IsNotNull();
+        await Assert.That(completionResult.IsSuccess).IsTrue();
     }
 
     /// <summary>Verifies the <c>TakeUntil(other, options, cancellationToken)</c> overload wraps the
@@ -560,7 +565,7 @@ public async Task WhenTakeUntilOtherWithOptionsAndCancellableToken_ThenCancellat
                 });
         await source.OnNextAsync(1, CancellationToken.None);
         await cts.CancelAsync();
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(values).IsCollectionEqualTo([1]);
         await Assert.That(completionResult.IsSuccess).IsTrue();
     }
@@ -589,7 +594,7 @@ public async Task WhenTakeUntilOtherWithOptionsAndUncancellableToken_ThenOtherFa
                 });
         await source.OnNextAsync(1, CancellationToken.None);
         await other.OnCompletedAsync(Result.Failure(new InvalidOperationException("other failed")));
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
@@ -620,7 +625,7 @@ public async Task WhenTaskStopSignalWithOptionsAndCancellableToken_ThenCancellat
                 });
         await source.OnNextAsync(1, CancellationToken.None);
         await cts.CancelAsync();
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(values).IsCollectionEqualTo([1]);
         await Assert.That(completionResult.IsSuccess).IsTrue();
     }
@@ -649,7 +654,7 @@ public async Task WhenTaskStopSignalWithOptionsAndUncancellableToken_ThenTaskFai
                 });
         await source.OnNextAsync(1, CancellationToken.None);
         stopTask.SetException(new InvalidOperationException("task failed"));
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
@@ -674,13 +679,10 @@ public async Task WhenTakeUntilCompletionDelegateNotifiesBeforeReturning_ThenSto
                 return default;
             });
 
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
-        var released = await AsyncTestHelpers.WaitForConditionAsync(
-            () => registration.DisposeCount == 1,
-            WaitTimeout);
+        var completionResult = await completed.Task;
+        await registration.Disposed;
 
         await Assert.That(completionResult.IsSuccess).IsTrue();
-        await Assert.That(released).IsTrue();
         await Assert.That(registration.DisposeCount).IsEqualTo(1);
 
         IAsyncDisposable StopSignal(Action<Result> notify)
@@ -721,14 +723,12 @@ public async Task WhenTakeUntilCompletionDelegateNotifiesTwice_ThenSecondNotific
             });
 
         notifyStop!(Result.Success);
-        await firstCompletion.Task.WaitAsync(WaitTimeout);
+        await firstCompletion.Task;
 
+        // The coordinator latches the first stop, so a second notification is dropped where it is raised
+        // and queues no further work to observe.
         notifyStop!(Result.Failure(new InvalidOperationException("second stop")));
-        var leaked = await AsyncTestHelpers.WaitForConditionAsync(
-            () => errors.Count > 0 || completions.Count > 1,
-            SecondNotificationSettleWindow);
 
-        await Assert.That(leaked).IsFalse();
         await Assert.That(completions).Count().IsEqualTo(1);
         await Assert.That(completions[0].IsSuccess).IsTrue();
         await Assert.That(errors).IsEmpty();
@@ -737,16 +737,23 @@ public async Task WhenTakeUntilCompletionDelegateNotifiesTwice_ThenSecondNotific
     /// <summary>An <see cref = "IAsyncDisposable"/> that records how many times it has been disposed.</summary>
     private sealed class DisposeCountingAsyncDisposable : IAsyncDisposable
     {
+        /// <summary>Signals the first disposal so a test can await it instead of polling the count.</summary>
+        private readonly TaskCompletionSource _disposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
         /// <summary>The number of times <see cref = "DisposeAsync"/> has been called.</summary>
         private int _disposeCount;
 
         /// <summary>Gets the number of times <see cref = "DisposeAsync"/> has been called.</summary>
         internal int DisposeCount => Volatile.Read(ref _disposeCount);
 
+        /// <summary>Gets a task that completes on the first disposal.</summary>
+        internal Task Disposed => _disposed.Task;
+
         /// <inheritdoc/>
         public ValueTask DisposeAsync()
         {
             _ = Interlocked.Increment(ref _disposeCount);
+            IgnoredResult.Of(_disposed.TrySetResult());
             return default;
         }
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
index 874dae2d..1415c0ca 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
@@ -132,10 +132,10 @@ public async Task WhenThrottleWithSpacedItems_ThenAllAreEmitted()
         const int SpacingDelayMillis = 75;
         const int SecondValue = 2;
         await signal.OnNextAsync(1, CancellationToken.None);
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
         await Task.Delay(SpacingDelayMillis);
         await signal.OnNextAsync(SecondValue, CancellationToken.None);
-        await secondReceived.Task.WaitAsync(WaitTimeout);
+        await secondReceived.Task;
         await Assert.That(results).IsCollectionEqualTo([1, SecondValue]);
     }
 
@@ -357,7 +357,7 @@ public async Task WhenThrottleWithCustomTimeProvider_ThenUsesTimerPath()
         await signal.OnNextAsync(1, CancellationToken.None);
         await signal.OnNextAsync(SecondValue, CancellationToken.None);
         await signal.OnNextAsync(LastValue, CancellationToken.None);
-        await resultReceived.Task.WaitAsync(WaitTimeout);
+        await resultReceived.Task;
         await signal.OnCompletedAsync(Result.Success);
         await Assert.That(results).Count().IsEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(LastValue);
@@ -391,7 +391,7 @@ public async Task WhenThrottleWithCustomTimeProviderValueSuperseded_ThenOlderVal
         // Emit two values rapidly; first should be superseded
         await signal.OnNextAsync(FirstValue, CancellationToken.None);
         await signal.OnNextAsync(LastValue, CancellationToken.None);
-        await resultReceived.Task.WaitAsync(WaitTimeout);
+        await resultReceived.Task;
         await signal.OnCompletedAsync(Result.Success);
         await Assert.That(results).Count().IsEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(LastValue);
@@ -450,7 +450,7 @@ public async Task WhenThrottleOnErrorResume_ThenCancelsTimerAndForwardsError()
 
         // Immediately send an error before the throttle timer fires
         await signal.OnErrorResumeAsync(new InvalidOperationException(TestErrorMessage), CancellationToken.None);
-        await errorReceived.Task.WaitAsync(WaitTimeout);
+        await errorReceived.Task;
 
         // Error should be forwarded, and the pending value should NOT be emitted
         await Assert.That(errors).Count().IsEqualTo(1);
@@ -500,7 +500,7 @@ public async Task WhenTimeoutSourceEmitsErrorResume_ThenForwardsAndCancelsTimer(
             });
         InvalidOperationException testError = new(TestErrorMessage);
         await source.EmitError(testError);
-        await errorReceived.Task.WaitAsync(WaitTimeout);
+        await errorReceived.Task;
         await Assert.That(errors).Count().IsEqualTo(1);
         await Assert.That(errors[0]).IsTypeOf<InvalidOperationException>();
         await Assert.That(errors[0].Message).IsEqualTo(TestErrorMessage);
@@ -532,7 +532,7 @@ public async Task WhenDelaySourceEmitsErrorResume_ThenErrorForwarded()
         InvalidOperationException expectedError = new("resume error");
         await source.EmitError(expectedError);
         await source.Complete(Result.Success);
-        await completed.Task.WaitAsync(CompletionWaitTimeout);
+        await completed.Task;
         await Assert.That(errors).Count().IsEqualTo(1);
         await Assert.That(errors[0]).IsSameReferenceAs(expectedError);
     }
@@ -569,7 +569,7 @@ public async Task WhenThrottleValueSuperseded_ThenOlderValueDropped()
         // Wait for the throttled value to arrive before completing
         await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, CompletionWaitTimeout);
         await signal.OnCompletedAsync(Result.Success);
-        await completed.Task.WaitAsync(CompletionWaitTimeout);
+        await completed.Task;
 
         // Only the last value (2) should have been emitted
         await Assert.That(results).Contains(LastValue);
@@ -700,7 +700,7 @@ public async Task WhenIntervalCancelled_ThenStops()
             null,
             null,
             cts.Token);
-        await cancelled.Task.WaitAsync(CompletionWaitTimeout);
+        await cancelled.Task;
         await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinItemCount);
     }
 
@@ -729,7 +729,7 @@ public async Task WhenTimerWithPeriodCancelled_ThenStops()
                 null,
                 null,
                 cts.Token);
-        await cancelled.Task.WaitAsync(CompletionWaitTimeout);
+        await cancelled.Task;
         await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinItemCount);
     }
 
@@ -772,7 +772,7 @@ public async Task WhenThrottleReceivesRapidValues_ThenOnlyEmitsLatest()
 
         await Assert.That(manualProvider.TimerCount).IsEqualTo(LastValue);
         manualProvider.FireAll();
-        await completed.Task.WaitAsync(CompletionWaitTimeout);
+        await completed.Task;
         await Assert.That(items).Contains(LastValue);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
index 686a3baa..7df6bbc4 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
@@ -11,17 +11,14 @@ namespace ReactiveUI.Primitives.Avalonia.Reactive.Tests;
 /// <summary>Tests for <see cref="AvaloniaScheduler"/> against a pumped Avalonia headless dispatcher.</summary>
 public sealed class AvaloniaSchedulerTests
 {
-    /// <summary>Maximum time to wait for dispatcher work.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Delay used to exercise the native dispatcher-timer path.</summary>
     private static readonly TimeSpan DelayedDueTime = TimeSpan.FromMilliseconds(50);
 
     /// <summary>Delay used for work that is cancelled before its timer fires.</summary>
     private static readonly TimeSpan CancellationDueTime = TimeSpan.FromMilliseconds(100);
 
-    /// <summary>Time allowed to prove cancelled dispatcher work remains inactive.</summary>
-    private static readonly TimeSpan CancellationWaitTime = TimeSpan.FromMilliseconds(150);
+    /// <summary>Delay for work that falls due after the cancelled work, on the same dispatcher and priority.</summary>
+    private static readonly TimeSpan FollowingDueTime = TimeSpan.FromMilliseconds(200);
 
     /// <summary>Verifies constructor validation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
@@ -45,8 +42,11 @@ static async () =>
     /// <summary>Verifies immediate scheduler work is posted to and executed on the selected dispatcher thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread() =>
-        await AvaloniaTestSession.Instance.Dispatch(
+    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    {
+        // The session only awaits a dispatched delegate that returns a result, so the facts to assert come back
+        // out of the dispatch; an assertion left inside it past the first await is never observed.
+        var (dispatcherThreadId, executionThreadId) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
                 var dispatcherThreadId = Environment.CurrentManagedThreadId;
@@ -57,16 +57,19 @@ static async () =>
                 _ = scheduler.Schedule(
                     () => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
-                var executionThreadId = await completion.Task.WaitAsync(WaitTimeout);
-                await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+                return (DispatcherThreadId: dispatcherThreadId, ExecutionThreadId: await completion.Task);
             },
             CancellationToken.None);
 
+        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+    }
+
     /// <summary>Verifies delayed scheduler work runs on a timer bound to the selected dispatcher.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnDispatcherThread() =>
-        await AvaloniaTestSession.Instance.Dispatch(
+    public async Task DelayedScheduleExecutesOnDispatcherThread()
+    {
+        var (dispatcherThreadId, executionThreadId, priority) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
                 var dispatcherThreadId = Environment.CurrentManagedThreadId;
@@ -78,20 +81,27 @@ static async () =>
                     DelayedDueTime,
                     () => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
-                var executionThreadId = await completion.Task.WaitAsync(WaitTimeout);
-                await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
-                await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Normal);
+                return (
+                    DispatcherThreadId: dispatcherThreadId,
+                    ExecutionThreadId: await completion.Task,
+                    scheduler.Priority);
             },
             CancellationToken.None);
 
+        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+        await Assert.That(priority).IsEqualTo(DispatcherPriority.Normal);
+    }
+
     /// <summary>Verifies disposing delayed work stops its dispatcher timer before execution.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleCanBeCancelled() =>
-        await AvaloniaTestSession.Instance.Dispatch(
+    public async Task DelayedScheduleCanBeCancelled()
+    {
+        var executed = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
                 AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
+                TaskCompletionSource following = new(TaskCreationOptions.RunContinuationsAsynchronously);
                 var executed = false;
 
                 var disposable = scheduler.Schedule(
@@ -99,8 +109,16 @@ static async () =>
                     () => executed = true);
                 disposable.Dispose();
 
-                await Task.Delay(CancellationWaitTime);
-                await Assert.That(executed).IsFalse();
+                // The following work is due after the cancelled work and shares its dispatcher and priority, so the
+                // dispatcher passes the cancelled due time first: the follower running means the cancelled action was
+                // skipped rather than merely still pending.
+                _ = scheduler.Schedule(FollowingDueTime, following.SetResult);
+
+                await following.Task;
+                return executed;
             },
             CancellationToken.None);
+
+        await Assert.That(executed).IsFalse();
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
index abbd90c9..b69dfef7 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
@@ -9,27 +9,27 @@ namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 /// <summary>Edge-case coverage for <c>DropIfBusyObservable&lt;T&gt;</c>.</summary>
 public class DropIfBusyObservableTests
 {
-    /// <summary>Delay used to let fire-and-forget async continuations settle.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies a handler completion after source completion does not emit the value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenHandlerCompletesAfterSourceDone_ThenValueDropped()
     {
         Subject<int> subject = new();
-        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The release gate completes its continuations inline, so the handler's tail runs here.
+        TaskCompletionSource release = new();
+        TaskCompletionSource handlerResumed = new();
         List<int> values = [];
         var completed = false;
-        using var sub = subject.DropIfBusy(async _ => await release.Task.ConfigureAwait(false))
-            .Subscribe(values.Add, () => completed = true);
+        using var sub = subject.DropIfBusy(async _ =>
+        {
+            await release.Task.ConfigureAwait(false);
+            handlerResumed.SetResult();
+        }).Subscribe(values.Add, () => completed = true);
         subject.OnNext(1);
         subject.OnCompleted();
         release.SetResult();
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        await handlerResumed.Task;
         await Assert.That(values).IsEmpty();
         await Assert.That(completed).IsTrue();
     }
@@ -40,7 +40,9 @@ public async Task WhenHandlerCompletesAfterSourceDone_ThenValueDropped()
     public async Task WhenHandlerThrowsAfterSourceDone_ThenErrorDropped()
     {
         Subject<int> subject = new();
-        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The release gate completes its continuations inline, so the handler throws here.
+        TaskCompletionSource release = new();
         InvalidOperationException expected = new("late-handler");
         Exception? caught = null;
         var completed = false;
@@ -55,7 +57,6 @@ public async Task WhenHandlerThrowsAfterSourceDone_ThenErrorDropped()
         subject.OnNext(1);
         subject.OnCompleted();
         release.SetResult();
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
         await Assert.That(caught).IsNull();
         await Assert.That(completed).IsTrue();
     }
@@ -81,8 +82,8 @@ public async Task WhenSourceErrorsBeforeDone_ThenForwardsError()
     public async Task WhenHandlerThrowsBeforeDone_ThenForwardsError()
     {
         Subject<int> subject = new();
-        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<Exception> error = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource release = new();
+        TaskCompletionSource<Exception> error = new();
         InvalidOperationException expected = new("handler");
         using var sub = subject.DropIfBusy(async _ =>
         {
@@ -93,7 +94,7 @@ public async Task WhenHandlerThrowsBeforeDone_ThenForwardsError()
             ex => error.TrySetResult(ex));
         subject.OnNext(1);
         release.SetResult();
-        var caught = await error.Task.WaitAsync(GuardTimeout).ConfigureAwait(false);
+        var caught = await error.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
index 32b7e7e6..47b1c064 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
@@ -7,6 +7,7 @@
 using System.Reactive.Subjects;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
@@ -18,8 +19,8 @@ namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 /// notifications past the terminal to verify the guard silently drops them.</summary>
 public class OperatorAfterTerminalGuardTests
 {
-    /// <summary>Settle window used to let scheduler-marshalled tests fire any racing emission.</summary>
-    private const int SettleDelayMilliseconds = 50;
+    /// <summary>Retry delay handed to the retry operators under test.</summary>
+    private const int RetryDelayMilliseconds = 50;
 
     /// <summary>Tick window for fast-scheduler tests.</summary>
     private const int TickWindow = 100;
@@ -30,9 +31,6 @@ public class OperatorAfterTerminalGuardTests
     /// <summary>Second sentinel value used in after-terminal pushes.</summary>
     private const int SecondValue = 2;
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies <c>OnErrorRetry</c>'s sink silently drops events after a downstream
     /// completion has set the <c>_disposed</c> latch — and that a second dispose hits the
     /// <c>Interlocked.Exchange != 0</c> idempotency guard in <see cref = "IDisposable.Dispose"/>.</summary>
@@ -65,7 +63,7 @@ public async Task WhenRetryWithDelaySourceErrorAfterDispose_ThenDropped()
     {
         SyncDirectSource<int> source = new();
         Exception? caught = null;
-        var sub = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(SettleDelayMilliseconds)).Subscribe(
+        var sub = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(RetryDelayMilliseconds)).Subscribe(
             static _ => { },
             ex => caught = ex);
         sub.Dispose();
@@ -84,7 +82,7 @@ public async Task WhenRetryWithDelaySourceErrorAfterDispose_ThenDropped()
     [Test]
     public async Task WhenRetryWithDelayDisposedDuringDelay_ThenSubscribeToSourceGuardSkipsRetry()
     {
-        const int LongDelayMs = 250;
+        VirtualClock scheduler = new();
         var subscribeCount = 0;
         var source = Observable.Create<int>(o =>
         {
@@ -92,14 +90,18 @@ public async Task WhenRetryWithDelayDisposedDuringDelay_ThenSubscribeToSourceGua
             o.OnError(new InvalidOperationException("retry-after-dispose"));
             return EmptyDisposable.Instance;
         });
-        var sub = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(LongDelayMs)).Subscribe(static _ => { });
+        var sub = new RetryWithDelayObservable<int>(
+            source,
+            int.MaxValue,
+            static _ => TimeSpan.FromTicks(TickWindow),
+            scheduler).Subscribe(static _ => { });
 
         // First subscribe ran; source errored synchronously and a retry has been scheduled.
         sub.Dispose();
 
-        // Wait past the delay window so the scheduled callback fires while _disposed = true,
+        // Moving past the delay window fires the scheduled callback while _disposed = true,
         // hitting the SubscribeToSource _disposed guard rather than re-subscribing.
-        await Task.Delay(LongDelayMs + LongDelayMs);
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
         await Assert.That(subscribeCount).IsEqualTo(1);
     }
 
@@ -108,8 +110,8 @@ public async Task WhenRetryWithDelayDisposedDuringDelay_ThenSubscribeToSourceGua
     [Test]
     public async Task WhenRetryWithBackoffDisposedDuringDelay_ThenSubscribeToSourceGuardSkipsRetry()
     {
-        const int LongDelayMs = 250;
         const int RetryAttempts = 10;
+        VirtualClock scheduler = new();
         var subscribeCount = 0;
         var source = Observable.Create<int>(o =>
         {
@@ -120,10 +122,10 @@ public async Task WhenRetryWithBackoffDisposedDuringDelay_ThenSubscribeToSourceG
         var sub = source.OnErrorRetry<int, InvalidOperationException>(
             static _ => { },
             RetryAttempts,
-            TimeSpan.FromMilliseconds(LongDelayMs),
-            TaskPoolSequencer.Default).Subscribe(static _ => { });
+            TimeSpan.FromTicks(TickWindow),
+            scheduler).Subscribe(static _ => { });
         sub.Dispose();
-        await Task.Delay(LongDelayMs + LongDelayMs);
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
         await Assert.That(subscribeCount).IsEqualTo(1);
     }
 
@@ -404,7 +406,7 @@ public async Task WhenRetryWithBackoffSourceErrorAfterDispose_ThenDropped()
     {
         SyncDirectSource<int> source = new();
         Exception? caught = null;
-        var sub = source.RetryWithBackoff(1, TimeSpan.FromMilliseconds(SettleDelayMilliseconds)).Subscribe(
+        var sub = source.RetryWithBackoff(1, TimeSpan.FromMilliseconds(RetryDelayMilliseconds)).Subscribe(
             static _ => { },
             ex => caught = ex);
         sub.Dispose();
@@ -461,14 +463,14 @@ public async Task WhenScheduledSourceActionThrows_ThenForwardsError()
     public async Task WhenSubscribeSynchronousOmitsErrorAndCompletedCallbacks_ThenNullPathsTaken()
     {
         Subject<int> subject = new();
-        TaskCompletionSource processed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource processed = new();
         using var sub = subject.SubscribeSynchronous(value =>
         {
             _ = processed.TrySetResult();
             return default;
         });
         subject.OnNext(1);
-        await processed.Task.WaitAsync(GuardTimeout);
+        await processed.Task;
 
         // Subject silently terminates without invoking the optional callbacks.
         subject.OnError(new InvalidOperationException("ignored"));
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
index 40edd587..5d0f1bdb 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
@@ -10,18 +10,6 @@ namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 [System.Diagnostics.DebuggerDisplay("ScanWithInitialTests: {nameof(ScanWithInitialTests),nq}")]
 public partial class ScanWithInitialTests
 {
-    /// <summary>Spin iterations used to widen the interleaving window in contention tests.</summary>
-    private const int InterleavingSpinIterations = 100;
-
-#if NET9_0_OR_GREATER
-
-    /// <summary>Synchronization gate used by tests.</summary>
-    private readonly Lock _gate = new();
-#else
-    /// <summary>Synchronization gate used by tests.</summary>
-    private readonly object _gate = new();
-#endif
-
     /// <summary>Tests that <see cref = "ScanWithInitialObservable{TSource, TAccumulate}"/> emits the initial value immediately upon subscription.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -96,60 +84,48 @@ public async Task AccumulatorError_PropagatesError()
         await Assert.That(errors).IsCollectionEqualTo([exception]);
     }
 
-    /// <summary>Tests that <see cref = "ScanWithInitialObservable{TSource, TAccumulate}"/> is thread-safe.</summary>
+    /// <summary>Tests that a terminal notification raised from inside an emission completes the
+    /// sink exactly once and stops accumulating, which is the interleaving the sink's gate and
+    /// <c>_done</c> latch exist to serialize.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    [SuppressMessage(
-        "Concurrency",
-        "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification = "Test is synchronous.")]
-    public async Task Observable_IsThreadSafe()
+    public async Task OnCompletedDuringEmission_CompletesOnceAndStopsAccumulating()
     {
         // Arrange
         Subject<int> source = new();
         const int Initial = 0;
-        Func<int, int, int> accumulator = static (acc, x) =>
-        {
-            Thread.SpinWait(InterleavingSpinIterations);
-            return acc + x;
-        };
+        const int EmissionsBeforeCompletion = 3;
+        const int EmissionCount = 100;
+        Func<int, int, int> accumulator = static (acc, x) => acc + x;
         ScanWithInitialObservable<int, int> observable = new(source, Initial, accumulator);
         List<int> results = [];
         var completedCount = 0;
-        const int ContendedEmissionCount = 100;
-        const int CompletionDelayMilliseconds = 50;
 
         // Act
         using (observable.Subscribe(
                    x =>
                    {
-                       lock (_gate)
+                       results.Add(x);
+                       if (results.Count == EmissionsBeforeCompletion)
                        {
-                           results.Add(x);
+                           // Re-enter the sink with the terminal notification from inside its own emission.
+                           source.OnCompleted();
                        }
                    },
                    static _ => { },
-                   () => Interlocked.Increment(ref completedCount)))
+                   () => completedCount++))
         {
-            var t1 = Task.Run(() =>
-            {
-                for (var i = 0; i < ContendedEmissionCount; i++)
-                {
-                    source.OnNext(i);
-                }
-            });
-            var t2 = Task.Run(async () =>
+            for (var i = 0; i < EmissionCount; i++)
             {
-                await Task.Delay(CompletionDelayMilliseconds);
-                source.OnCompleted();
-            });
-            await Task.WhenAll(t1, t2);
+                source.OnNext(i);
+            }
         }
 
         // Assert
-        // We can't easily assert the exact sequence due to the non-thread-safe Subject,
-        // but we can assert that it didn't crash and the state remains consistent.
-        // The lock in ScanWithInitialSink ensures that OnNext doesn't race with OnCompleted internally.
-        await Assert.That(completedCount).IsEqualTo(1);
+        using (Assert.Multiple())
+        {
+            await Assert.That(completedCount).IsEqualTo(1);
+            await Assert.That(results).Count().IsEqualTo(EmissionsBeforeCompletion);
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
index 81ae9fe1..e1539579 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
@@ -17,18 +17,12 @@ public class SelectAsyncConcurrentObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
     /// <summary>Max concurrency used for two-in-flight tests.</summary>
     private const int MaxConcurrencyTwo = 2;
 
     /// <summary>Max concurrency used for four-in-flight tests.</summary>
     private const int MaxConcurrencyFour = 4;
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>SelectAsyncConcurrent</c> forwards selector exceptions.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -36,14 +30,14 @@ public async Task WhenSelectAsyncConcurrentSelectorThrows_ThenForwardsError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> faulted = new();
         InvalidOperationException expected = new(SelectorErrorMessage);
         using var sub = subject.SelectAsyncConcurrent(_ => Task.FromException<int>(expected), MaxConcurrencyTwo)
             .Subscribe(
                 static _ => { },
                 ex => faulted.TrySetResult(ex));
         subject.OnNext(TriggerValue);
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -69,21 +63,25 @@ public async Task WhenSelectAsyncConcurrentDisposedMidFlight_ThenSuppressesEmiss
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> selectorResumed = new();
         List<int> results = [];
         var completed = false;
         var sub = subject.SelectAsyncConcurrent(
             async x =>
             {
                 await gate.Task.ConfigureAwait(false);
+                _ = selectorResumed.TrySetResult(true);
                 return x;
             },
             MaxConcurrencyTwo).Subscribe(results.Add, () => completed = true);
         subject.OnNext(TriggerValue);
         subject.OnCompleted();
         sub.Dispose();
-        _ = gate.TrySetResult(true);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        gate.SetResult(true);
+        await selectorResumed.Task;
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
@@ -96,9 +94,9 @@ public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCom
         const int First = 1;
         const int Second = 2;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> gate = new();
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SelectAsyncConcurrent(
             async x =>
             {
@@ -110,11 +108,11 @@ public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCom
         subject.OnNext(Second);
         subject.OnCompleted();
 
-        // The selector is gated; nothing should have emitted yet.
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        // Both selectors are parked on the gate, so nothing can have emitted or completed.
         await Assert.That(completed.Task.IsCompleted).IsFalse();
-        _ = gate.TrySetResult(true);
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        await Assert.That(results).IsEmpty();
+        gate.SetResult(true);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
 
         // Downstream OnNext from this operator is serialized inside the sink's lock, so the
@@ -140,7 +138,6 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
index e664cd06..d6b1fa38 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
@@ -17,12 +17,6 @@ public class SelectAsyncSequentialObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>SelectAsyncSequential</c> forwards selector exceptions and stops draining the queue afterwards.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -31,7 +25,7 @@ public async Task WhenSelectAsyncSequentialSelectorThrows_ThenForwardsErrorAndSt
         const int First = 1;
         const int Second = 2;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> faulted = new();
         List<int> results = [];
         InvalidOperationException expected = new(SelectorErrorMessage);
         using var sub = subject
@@ -39,7 +33,7 @@ public async Task WhenSelectAsyncSequentialSelectorThrows_ThenForwardsErrorAndSt
             .Subscribe(results.Add, ex => faulted.TrySetResult(ex));
         subject.OnNext(First);
         subject.OnNext(Second);
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(results).IsEmpty();
     }
@@ -66,19 +60,23 @@ public async Task WhenSelectAsyncSequentialDisposedMidFlight_ThenSuppressesEmiss
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> selectorResumed = new();
         List<int> results = [];
         var completed = false;
         var sub = subject.SelectAsyncSequential(async x =>
         {
             await gate.Task.ConfigureAwait(false);
+            _ = selectorResumed.TrySetResult(true);
             return x;
         }).Subscribe(results.Add, () => completed = true);
         subject.OnNext(TriggerValue);
         subject.OnCompleted();
         sub.Dispose();
-        _ = gate.TrySetResult(true);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        gate.SetResult(true);
+        await selectorResumed.Task;
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
@@ -90,9 +88,9 @@ public async Task WhenSelectAsyncSequentialCompletesWhileProcessing_ThenDeferred
     {
         const int Value = 42;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> gate = new();
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SelectAsyncSequential(async x =>
         {
             await gate.Task.ConfigureAwait(false);
@@ -101,11 +99,11 @@ public async Task WhenSelectAsyncSequentialCompletesWhileProcessing_ThenDeferred
         subject.OnNext(Value);
         subject.OnCompleted();
 
-        // Completion must not fire while selector is gated.
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        // The selector is parked on the gate, so nothing can have emitted or completed.
         await Assert.That(completed.Task.IsCompleted).IsFalse();
-        _ = gate.TrySetResult(true);
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        await Assert.That(results).IsEmpty();
+        gate.SetResult(true);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
         await Assert.That(results).IsCollectionEqualTo([Value]);
     }
@@ -126,7 +124,6 @@ public async Task WhenEventsAfterTerminated_ThenDropped()
         source.Observer.OnCompleted();
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(caught).IsNull();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
index 8bb576dc..5f6c67db 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
@@ -17,21 +17,12 @@ public class SelectLatestAsyncObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
-    /// <summary>Poll interval in milliseconds used while waiting for an emission.</summary>
-    private const int PollIntervalMilliseconds = 10;
-
     /// <summary>Multiplier applied by the gated selector whose result is expected never to be delivered.</summary>
     private const int SuppressedProjectionMultiplier = 2;
 
     /// <summary>Multiplier applied inside the projection selector.</summary>
     private const int ProjectionMultiplier = 10;
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>SelectLatestAsync</c> forwards selector exceptions.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -39,13 +30,13 @@ public async Task WhenSelectLatestAsyncSelectorThrows_ThenForwardsError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> faulted = new();
         InvalidOperationException expected = new(SelectorErrorMessage);
         using var sub = subject.SelectLatestAsync(_ => Task.FromException<int>(expected)).Subscribe(
             static _ => { },
             ex => faulted.TrySetResult(ex));
         subject.OnNext(TriggerValue);
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -71,21 +62,23 @@ public async Task WhenSelectLatestAsyncDisposedMidFlight_ThenSuppressesEmissionA
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> selectorResumed = new();
         List<int> results = [];
         var completed = false;
         var sub = subject.SelectLatestAsync(async x =>
         {
             await gate.Task.ConfigureAwait(false);
+            _ = selectorResumed.TrySetResult(true);
             return x * SuppressedProjectionMultiplier;
         }).Subscribe(results.Add, () => completed = true);
         subject.OnNext(TriggerValue);
         subject.OnCompleted();
         sub.Dispose();
-        _ = gate.TrySetResult(true);
-
-        // Give the awaited continuation a chance to attempt delivery.
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        gate.SetResult(true);
+        await selectorResumed.Task;
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
@@ -98,14 +91,18 @@ public async Task WhenSelectLatestAsyncNewerArrives_ThenOlderResultDropped()
         const int Slow = 1;
         const int Fast = 2;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> slowGate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The gate completes its continuations inline, so releasing it runs the stale projection's tail here.
+        TaskCompletionSource<bool> slowGate = new();
+        TaskCompletionSource<bool> slowResumed = new();
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SelectLatestAsync(async x =>
         {
             if (x == Slow)
             {
                 await slowGate.Task.ConfigureAwait(false);
+                _ = slowResumed.TrySetResult(true);
             }
 
             return x * ProjectionMultiplier;
@@ -113,15 +110,12 @@ public async Task WhenSelectLatestAsyncNewerArrives_ThenOlderResultDropped()
         subject.OnNext(Slow);
         subject.OnNext(Fast);
 
-        // Wait for the fast projection to complete and emit.
-        while (results.Count == 0)
-        {
-            await Task.Delay(PollIntervalMilliseconds).ConfigureAwait(false);
-        }
-
-        _ = slowGate.TrySetResult(true);
+        // The Fast projection is ungated, so its result is already delivered.
+        await Assert.That(results).IsCollectionEqualTo([Fast * ProjectionMultiplier]);
+        slowGate.SetResult(true);
+        await slowResumed.Task;
         subject.OnCompleted();
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
 
         // Only the latest (Fast) projection's result should appear.
         await Assert.That(results).IsCollectionEqualTo([Fast * ProjectionMultiplier]);
@@ -133,12 +127,12 @@ public async Task WhenSelectLatestAsyncNewerArrives_ThenOlderResultDropped()
     public async Task WhenSelectLatestAsyncSourceCompletesWithNoValues_ThenForwardsCompletion()
     {
         Subject<int> subject = new();
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SelectLatestAsync(Task.FromResult).Subscribe(
             static _ => { },
             () => completed.TrySetResult(true));
         subject.OnCompleted();
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
     }
 
@@ -158,7 +152,6 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(completedCount).IsLessThanOrEqualTo(1);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
index e09fcf02..9b269275 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
@@ -17,12 +17,6 @@ public class SubscribeAsyncObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Settle delay in milliseconds used to confirm completion is deferred.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that values are handled in order and completion fires.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -32,7 +26,7 @@ public async Task WhenSubscribeAsyncProcessesValues_ThenInOrder()
         const int Second = 2;
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SubscribeSynchronous(
             x =>
             {
@@ -44,7 +38,7 @@ public async Task WhenSubscribeAsyncProcessesValues_ThenInOrder()
         subject.OnNext(First);
         subject.OnNext(Second);
         subject.OnCompleted();
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
         await Assert.That(results).IsCollectionEqualTo([First, Second]);
     }
@@ -56,12 +50,12 @@ public async Task WhenSubscribeAsyncHandlerThrows_ThenForwardsToOnError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> faulted = new();
         InvalidOperationException expected = new(HandlerFailedMessage);
         using var sub =
             subject.SubscribeSynchronous(_ => ValueTask.FromException(expected), ex => faulted.TrySetResult(ex));
         subject.OnNext(TriggerValue);
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -102,17 +96,20 @@ public async Task WhenSubscribeAsyncCompletesWhileProcessing_ThenDeferredComplet
     {
         const int Value = 7;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        // The gate completes its continuations inline, so releasing it drains the pump before control returns.
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> completed = new();
         using var sub = subject.SubscribeSynchronous(
             async _ => await gate.Task.ConfigureAwait(false),
             () => completed.TrySetResult(true));
         subject.OnNext(Value);
         subject.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        // The handler is parked on the gate, so completion cannot have been signalled yet.
         await Assert.That(completed.Task.IsCompleted).IsFalse();
-        _ = gate.TrySetResult(true);
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        gate.SetResult(true);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
     }
 
@@ -123,8 +120,8 @@ public async Task WhenSubscribeAsyncCompletesWhileProcessingWithoutCallback_Then
     {
         const int Value = 7;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<bool> handled = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> handled = new();
         using var sub = subject.SubscribeSynchronous(async value =>
         {
             await gate.Task.ConfigureAwait(false);
@@ -132,9 +129,10 @@ public async Task WhenSubscribeAsyncCompletesWhileProcessingWithoutCallback_Then
         });
         subject.OnNext(Value);
         subject.OnCompleted();
-        _ = gate.TrySetResult(true);
-        var done = await handled.Task.WaitAsync(GuardTimeout);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        // Releasing the gate resumes the handler inline, so the null-completion path runs here.
+        gate.SetResult(true);
+        var done = await handled.Task;
         await Assert.That(done).IsTrue();
     }
 
@@ -145,8 +143,8 @@ public async Task WhenSubscribeAsyncDisposedDuringInFlight_ThenSuppressesComplet
     {
         const int Value = 7;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<bool> handlerStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> handlerStarted = new();
         Exception? caught = null;
         var completedCount = 0;
         var sub = subject.SubscribeSynchronous(
@@ -159,11 +157,12 @@ public async Task WhenSubscribeAsyncDisposedDuringInFlight_ThenSuppressesComplet
             ex => caught = ex,
             () => completedCount++);
         subject.OnNext(Value);
-        await handlerStarted.Task.WaitAsync(GuardTimeout);
+        await handlerStarted.Task;
         subject.OnCompleted();
         sub.Dispose();
-        _ = gate.TrySetResult(true);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        // Releasing the gate lets the handler throw inline, so the suppressed terminal paths run here.
+        gate.SetResult(true);
         await Assert.That(caught).IsNull();
         await Assert.That(completedCount).IsEqualTo(0);
     }
@@ -208,7 +207,6 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
@@ -226,7 +224,6 @@ public async Task WhenOnCompletedAfterError_ThenDropped()
         using var sub = source.SubscribeSynchronous(static _ => default, ex => caught = ex, () => completedCount++);
         source.Observer.OnError(expected);
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(completedCount).IsEqualTo(0);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
index 32d0bc2b..376fd170 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
@@ -8,9 +8,6 @@ namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 /// on the sink that only fire when the upstream pushes events past its own completion.</summary>
 public class SynchronizeAsyncObservableTests
 {
-    /// <summary>Settle delay to confirm nothing fires.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
     /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
     /// arriving after the source has already completed are silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -27,7 +24,6 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
@@ -66,7 +62,6 @@ public async Task WhenSyncSignalDisposedTwice_ThenSecondDisposeIsNoOp()
             processed++;
         });
         source.Observer.OnNext(1);
-        await Task.Delay(SettleDelayMilliseconds);
         await Assert.That(processed).IsEqualTo(1);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
index 24507290..04722e09 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
@@ -2,8 +2,9 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Collections.Concurrent;
 using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
@@ -15,20 +16,14 @@ public class ThrottleUntilTrueObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Throttle window in milliseconds for tests.</summary>
-    private const int ThrottleWindowMilliseconds = 50;
+    /// <summary>Throttle window in virtual ticks.</summary>
+    private const int ThrottleWindowTicks = 50;
 
-    /// <summary>Long throttle window in milliseconds used by the dispose-before-fire test.</summary>
-    private const int LongThrottleWindowMilliseconds = 500;
-
-    /// <summary>Settle delay in milliseconds used to confirm a throttled emission never fires.</summary>
-    private const int SettleDelayMilliseconds = 150;
+    /// <summary>Virtual ticks to advance to take the clock one tick past the throttle window.</summary>
+    private const int AdvancePastWindowTicks = ThrottleWindowTicks + 1;
 
     /// <summary>Throttle window for tests.</summary>
-    private static readonly TimeSpan ThrottleWindow = TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds);
-
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan ThrottleWindow = TimeSpan.FromTicks(ThrottleWindowTicks);
 
     /// <summary>Verifies that elements matching the predicate emit immediately.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -36,28 +31,28 @@ public class ThrottleUntilTrueObservableTests
     public async Task WhenThrottleUntilTruePredicateTrue_ThenEmitsImmediately()
     {
         const int MatchingValue = 1;
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
-        TaskCompletionSource<int> emitted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static x => x == MatchingValue)
-            .Subscribe(v => emitted.TrySetResult(v));
+        List<int> emitted = [];
+        using var sub = Throttled(subject, scheduler, static x => x == MatchingValue).Subscribe(emitted.Add);
         subject.OnNext(MatchingValue);
-        var got = await emitted.Task.WaitAsync(GuardTimeout);
-        await Assert.That(got).IsEqualTo(MatchingValue);
+        await Assert.That(emitted).IsCollectionEqualTo([MatchingValue]);
     }
 
-    /// <summary>Verifies that non-matching elements are throttled but eventually emit.</summary>
+    /// <summary>Verifies that non-matching elements are held until the throttle window elapses.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenThrottleUntilTruePredicateFalse_ThenEmitsAfterDelay()
+    public async Task WhenThrottleUntilTruePredicateFalse_ThenEmitsAfterWindow()
     {
         const int NonMatchingValue = 99;
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
-        TaskCompletionSource<int> emitted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => false)
-            .Subscribe(v => emitted.TrySetResult(v));
+        List<int> emitted = [];
+        using var sub = Throttled(subject, scheduler, static _ => false).Subscribe(emitted.Add);
         subject.OnNext(NonMatchingValue);
-        var got = await emitted.Task.WaitAsync(GuardTimeout);
-        await Assert.That(got).IsEqualTo(NonMatchingValue);
+        await Assert.That(emitted).IsEmpty();
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+        await Assert.That(emitted).IsCollectionEqualTo([NonMatchingValue]);
     }
 
     /// <summary>Verifies that a later throttled value replaces an earlier still-pending one.</summary>
@@ -67,24 +62,14 @@ public async Task WhenThrottleUntilTrueFastReplacements_ThenLatestWins()
     {
         const int Earlier = 1;
         const int Later = 2;
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
-        ConcurrentQueue<int> emissions = new();
-        TaskCompletionSource laterArrived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => false).Subscribe(v =>
-        {
-            emissions.Enqueue(v);
-            _ = v == Later && laterArrived.TrySetResult();
-        });
+        List<int> emissions = [];
+        using var sub = Throttled(subject, scheduler, static _ => false).Subscribe(emissions.Add);
         subject.OnNext(Earlier);
         subject.OnNext(Later);
-
-        // Later's timer is never superseded, so it always fires; wait on that deterministically
-        // rather than racing the wall-clock window. Under scheduling pressure Earlier's timer may
-        // still slip through first, so assert the invariant the operator guarantees: whatever the
-        // intermediate emissions, the final value observed is the latest one.
-        await laterArrived.Task.WaitAsync(GuardTimeout);
-        var observed = emissions.ToArray();
-        await Assert.That(observed[^1]).IsEqualTo(Later);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+        await Assert.That(emissions).IsCollectionEqualTo([Later]);
     }
 
     /// <summary>Verifies that source errors are forwarded.</summary>
@@ -92,10 +77,11 @@ public async Task WhenThrottleUntilTrueFastReplacements_ThenLatestWins()
     [Test]
     public async Task WhenThrottleUntilTrueSourceErrors_ThenForwardsError()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         Exception? caught = null;
         InvalidOperationException expected = new(SourceErrorMessage);
-        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => true).Subscribe(
+        using var sub = Throttled(subject, scheduler, static _ => true).Subscribe(
             static _ => { },
             ex => caught = ex);
         subject.OnError(expected);
@@ -108,9 +94,10 @@ public async Task WhenThrottleUntilTrueSourceErrors_ThenForwardsError()
     public async Task WhenThrottleUntilTrueSourceCompletes_ThenForwardsCompletion()
     {
         const int IgnoredAfterCompletion = 9;
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         var completed = false;
-        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => true).Subscribe(
+        using var sub = Throttled(subject, scheduler, static _ => true).Subscribe(
             static _ => { },
             () => completed = true);
         subject.OnCompleted();
@@ -124,16 +111,15 @@ public async Task WhenThrottleUntilTrueSourceCompletes_ThenForwardsCompletion()
     public async Task WhenThrottleUntilTrueDisposedBeforeFire_ThenNoEmission()
     {
         const int NonMatchingValue = 1;
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         List<int> results = [];
-        var sub = subject
-            .ThrottleUntilTrue(TimeSpan.FromMilliseconds(LongThrottleWindowMilliseconds), static _ => false)
-            .Subscribe(results.Add);
+        var sub = Throttled(subject, scheduler, static _ => false).Subscribe(results.Add);
         subject.OnNext(NonMatchingValue);
         sub.Dispose();
 
-        // Wait past the throttle window to confirm nothing fires.
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        // Moving past the throttle window confirms the cancelled timer never fires.
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
         await Assert.That(results).IsEmpty();
     }
 
@@ -143,11 +129,12 @@ public async Task WhenThrottleUntilTrueDisposedBeforeFire_ThenNoEmission()
     [Test]
     public async Task WhenEventsAfterCompleted_ThenDropped()
     {
+        VirtualClock scheduler = new();
         SyncDirectSource<int> source = new();
         List<int> values = [];
         Exception? caught = null;
         var completedCount = 0;
-        using var sub = source.ThrottleUntilTrue(ThrottleWindow, static _ => true)
+        using var sub = Throttled(source, scheduler, static _ => true)
             .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
         source.Observer.OnCompleted();
         source.Observer.OnNext(1);
@@ -157,4 +144,15 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
     }
+
+    /// <summary>Builds the operator over a clock the test advances, so no emission depends on wall time.</summary>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="scheduler">The virtual clock timing throttled emissions.</param>
+    /// <param name="predicate">The bypass predicate.</param>
+    /// <returns>The throttled sequence.</returns>
+    private static IObservable<int> Throttled(
+        IObservable<int> source,
+        VirtualClock scheduler,
+        Func<int, bool> predicate) =>
+        new ThrottleUntilTrueObservable<int>(source, ThrottleWindow, predicate, scheduler);
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
index 9184b3ff..561a3fb2 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
@@ -20,15 +20,6 @@ public class WhileObservableTests
     /// <summary>Number of inline iterations to run.</summary>
     private const int IterationCount = 3;
 
-    /// <summary>Settle delay in milliseconds used to confirm a disposed loop stops ticking.</summary>
-    private const int SettleDelayMilliseconds = 50;
-
-    /// <summary>Maximum tolerated extra iterations after Dispose() returns.</summary>
-    private const int MaxStragglerIterations = 10;
-
-    /// <summary>Longest a test waits for an asynchronous signal before failing.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that the inline form runs until the predicate returns <c>false</c>.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -52,14 +43,18 @@ public async Task WhenWhileInline_ThenRunsUntilPredicateFalseAndCompletes()
     public async Task WhenWhileWithScheduler_ThenRunsUntilPredicateFalse()
     {
         var remaining = IterationCount;
-        TaskCompletionSource<int> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var emitted = 0;
+        var completed = false;
+        ManualSequencer sequencer = new();
 
-        using var sub = ReactiveExtensions.While(() => remaining > 0, () => remaining--, TaskPoolSequencer.Default)
-            .Subscribe(_ => emitted++, () => completed.TrySetResult(emitted));
+        using var sub = ReactiveExtensions.While(() => remaining > 0, () => remaining--, sequencer)
+            .Subscribe(_ => emitted++, () => completed = true);
 
-        var final = await completed.Task.WaitAsync(GuardTimeout);
-        await Assert.That(final).IsEqualTo(IterationCount);
+        // Nothing runs until the queued work is drained, proving every iteration went through the scheduler.
+        await Assert.That(emitted).IsEqualTo(0);
+        sequencer.RunAll();
+        await Assert.That(emitted).IsEqualTo(IterationCount);
+        await Assert.That(completed).IsTrue();
     }
 
     /// <summary>Verifies that an exception thrown by the predicate is forwarded.</summary>
@@ -96,36 +91,54 @@ public async Task WhenWhileActionThrows_ThenForwardsError()
     public async Task WhenWhileScheduledThenDisposed_ThenIterationStops()
     {
         var ran = 0;
-        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        ManualSequencer sequencer = new();
 
-        var sub = ReactiveExtensions.While(
-                static () => true,
-                () => SignalFirstIteration(ref ran, gate),
-                TaskPoolSequencer.Default)
+        var sub = ReactiveExtensions.While(static () => true, () => ran++, sequencer)
             .Subscribe(static _ => { });
 
-        await gate.Task.WaitAsync(GuardTimeout);
-        sub.Dispose();
-
-        var snapshot = Volatile.Read(ref ran);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
-        var later = Volatile.Read(ref ran);
+        // One iteration, which arms the next one.
+        sequencer.RunNext();
+        await Assert.That(ran).IsEqualTo(1);
 
-        // The loop may execute a few more iterations between Dispose() being called
-        // and the next disposal-check, but it must not keep ticking forever.
-        await Assert.That(later - snapshot).IsLessThanOrEqualTo(MaxStragglerIterations);
+        sub.Dispose();
+        sequencer.RunAll();
+        await Assert.That(ran).IsEqualTo(1);
     }
 
-    /// <summary>Increments <paramref name="counter"/> and signals <paramref name="gate"/> on the first iteration.</summary>
-    /// <param name="counter">Shared iteration counter.</param>
-    /// <param name="gate">Completion source signalled after the first iteration.</param>
-    private static void SignalFirstIteration(ref int counter, TaskCompletionSource<bool> gate)
+    /// <summary>A sequencer that queues every work item so the test decides when each iteration runs.</summary>
+    private sealed class ManualSequencer : ISequencer
     {
-        if (Interlocked.Increment(ref counter) != 1)
+        /// <summary>Work items scheduled and not yet run.</summary>
+        private readonly Queue<IWorkItem> _pending = new();
+
+        /// <summary>Gets the sequencer's notion of current time, which never moves.</summary>
+        public DateTimeOffset Now => DateTimeOffset.UnixEpoch;
+
+        /// <summary>Gets the sequencer's monotonic timestamp, which never moves.</summary>
+        public long Timestamp => 0;
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item) => _pending.Enqueue(item);
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item, long dueTimestamp) => Schedule(item);
+
+        /// <summary>Runs the oldest queued work item, if any.</summary>
+        internal void RunNext()
         {
-            return;
+            if (_pending.Count > 0)
+            {
+                _pending.Dequeue().Execute();
+            }
         }
 
-        _ = gate.TrySetResult(true);
+        /// <summary>Drains the queue, including work items queued by the items it runs.</summary>
+        internal void RunAll()
+        {
+            while (_pending.Count > 0)
+            {
+                _pending.Dequeue().Execute();
+            }
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
index e2b4753f..c1c28aea 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
@@ -234,7 +234,6 @@ public async Task AsyncAndSequentialHelpersEmitExpectedValues()
         const int SequentialMultiplier = 2;
         const int ConcurrentMultiplier = 3;
         const int MaxConcurrency = 2;
-        const int DelayMilliseconds = 50;
         const int SequentialResult = 4;
         const int ConcurrentResult = 6;
         Subject<int> source = new();
@@ -245,8 +244,8 @@ public async Task AsyncAndSequentialHelpersEmitExpectedValues()
         using var conSub = source
             .SelectAsyncConcurrent(static x => Task.FromResult(x * ConcurrentMultiplier), MaxConcurrency)
             .Subscribe(concurrent.Add);
+        // Both selectors return an already-completed task, so their projections land inside OnNext.
         source.OnNext(InputValue);
-        await Task.Delay(DelayMilliseconds);
         List<RxVoid> runAll = [];
         using var runAllSub = new[] { Observable.Return(RxVoid.Default), Observable.Return(RxVoid.Default) }.RunAll()
             .Subscribe(runAll.Add);
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
index 5e276b92..722bd928 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
@@ -19,9 +19,6 @@ public partial class ReactiveExtensionsTests
     /// <summary>String literal "initial" used by multiple tests.</summary>
     private const string InitialValueLiteral = "initial";
 
-    /// <summary>Stabilization window for scheduler-driven assertions.</summary>
-    private const int SchedulerStabilizeMilliseconds = 100;
-
     /// <summary>Value at which the <c>TakeUntil</c>/<c>WaitUntil</c> predicates trip.</summary>
     private const int PredicateThreshold = 5;
 
@@ -42,7 +39,9 @@ public partial class ReactiveExtensionsTests
     [Test]
     public async Task SyncronizeAsync_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When
+        // Given, When. The six handlers can run concurrently, so the counters use Interlocked;
+        // awaiting WhenAll is what establishes that every handler ran, because each one bumps
+        // itterations in its finally before its task completes.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
@@ -53,16 +52,8 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
         {
             try
             {
-                if (x.Value)
-                {
-                    await Task.Delay(LongDelayMilliseconds);
-                    _ = Interlocked.Increment(ref result);
-                }
-                else
-                {
-                    await Task.Delay(ShortDelayMilliseconds);
-                    _ = Interlocked.Decrement(ref result);
-                }
+                await Task.Yield();
+                _ = x.Value ? Interlocked.Increment(ref result) : Interlocked.Decrement(ref result);
             }
             finally
             {
@@ -78,13 +69,13 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
         subject.OnNext(true);
         subject.OnNext(false);
         await Task.WhenAll(tasks);
-        while (itterations < SampleValue6)
-        {
-            _ = Thread.Yield();
-        }
 
         // Then
-        await Assert.That(result).IsZero();
+        using (Assert.Multiple())
+        {
+            await Assert.That(Volatile.Read(ref result)).IsZero();
+            await Assert.That(Volatile.Read(ref itterations)).IsEqualTo(SampleValue6);
+        }
     }
 
     /// <summary>Tests OnNext with params.</summary>
@@ -490,9 +481,9 @@ public async Task WhenSubscribeAsyncWithAllHandlers_ThenInvokesAll()
             });
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
-        await allReceived.Task.WaitAsync(WaitTimeout);
+        await allReceived.Task;
         subject.OnCompleted();
-        await completionSource.Task.WaitAsync(WaitTimeout);
+        await completionSource.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
@@ -592,9 +583,10 @@ public async Task WhenOnErrorRetryNonMatchingExceptionType_ThenOnErrorCallbackSk
             observer.OnError(failure);
             return EmptyDisposable.Instance;
         });
-        using var sub = source.OnErrorRetry<int, NotSupportedException>(caught.Add, 1, TimeSpan.Zero, Sequencer.Default)
+        VirtualClock scheduler = new();
+        using var sub = source.OnErrorRetry<int, NotSupportedException>(caught.Add, 1, TimeSpan.Zero, scheduler)
             .Subscribe(values.Add, static _ => { });
-        await Task.Delay(TimeSpan.FromMilliseconds(SchedulerStabilizeMilliseconds));
+        scheduler.AdvanceBy(1);
         await Assert.That(caught).IsEmpty();
         await Assert.That(values.Count).IsGreaterThanOrEqualTo(1);
     }
@@ -626,7 +618,7 @@ public async Task WhenRetryWithBackoffTwoArgOverload_ThenRetriesUntilSuccess()
         const int MaxRetries = 3;
         using var sub = source.RetryWithBackoff(MaxRetries, TimeSpan.FromMilliseconds(1))
             .Subscribe(values.Add, () => done.TrySetResult(values));
-        var captured = await done.Task.WaitAsync(WaitTimeout);
+        var captured = await done.Task;
         await Assert.That(captured).IsCollectionEqualTo([SuccessAttempt]);
     }
 
@@ -649,7 +641,7 @@ public async Task WhenBufferUntilInactiveTwoArgOverload_ThenFlushesBufferOnCompl
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
         subject.OnCompleted();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(results.Count).IsGreaterThanOrEqualTo(1);
         await Assert.That(results[^1]).IsCollectionEqualTo([1, SampleValue2]);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
index d913cb55..028728a6 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
@@ -5,7 +5,6 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
-using ReactiveUI.Primitives.Async.Tests;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
 
@@ -467,10 +466,15 @@ public async Task WhenSyncTimerCalledWithoutScheduler_ThenProducesTicks()
     {
         const int TickPeriodMilliseconds = 50;
         List<DateTime> results = [];
+        TaskCompletionSource firstTick = new();
         using var sub = ReactiveExtensions.SyncTimer(TimeSpan.FromMilliseconds(TickPeriodMilliseconds))
             .Take(SampleValue2)
-            .Subscribe(results.Add);
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+            .Subscribe(tick =>
+            {
+                results.Add(tick);
+                _ = firstTick.TrySetResult();
+            });
+        await firstTick.Task;
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
     }
 
@@ -484,7 +488,7 @@ public async Task WhenStartActionWithNullScheduler_ThenExecutesAction()
         using var sub = ReactiveExtensions.Start(() => executed = true, null).Subscribe(
             static _ => { },
             completed.SetResult);
-        await completed.Task.WaitAsync(LongWaitTimeout);
+        await completed.Task;
         await Assert.That(executed).IsTrue();
     }
 
@@ -497,7 +501,7 @@ public async Task WhenStartFuncWithNullScheduler_ThenReturnsResult()
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
-    /// <summary>Tests ScheduleSafe with TimeSpan and null scheduler uses Thread.Sleep path.</summary>
+    /// <summary>Tests ScheduleSafe with a TimeSpan and a null scheduler takes the inline blocking path.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenScheduleSafeWithTimeSpanAndNullScheduler_ThenSleepsAndExecutes()
@@ -679,7 +683,7 @@ public async Task WhenUsingWithActionAndNullScheduler_ThenDisposesObject()
         using var sub = stream.Using<MemoryStream>(_ => executed = true, null).Subscribe(
             static _ => { },
             completed.SetResult);
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(executed).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
index 656efef9..31d41428 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
@@ -21,7 +21,7 @@ public async Task WhenSelectAsyncWithCancellationToken_ThenProjectsValues()
                 results.Add,
                 () => tcs.TrySetResult(true));
 
-        await tcs.Task.WaitAsync(WaitTimeout);
+        await tcs.Task;
 
         await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
     }
@@ -40,7 +40,7 @@ public async Task WhenSelectAsyncSimple_ThenProjectsValues()
                 results.Add,
                 () => tcs.TrySetResult(true));
 
-        await tcs.Task.WaitAsync(WaitTimeout);
+        await tcs.Task;
 
         await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
     }
@@ -59,7 +59,7 @@ public async Task WhenSelectAsyncSequential_ThenProcessesInOrder()
                 results.Add,
                 () => tcs.TrySetResult(true));
 
-        await tcs.Task.WaitAsync(WaitTimeout);
+        await tcs.Task;
 
         await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
     }
@@ -69,20 +69,19 @@ public async Task WhenSelectAsyncSequential_ThenProcessesInOrder()
     [Test]
     public async Task WhenSelectLatestAsync_ThenEmitsLatestResult()
     {
-        const int AsyncDelayMs = 10;
         var source = ExpectedSequence123.ToObservable();
         List<int> results = [];
         TaskCompletionSource<bool> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         _ = source.SelectLatestAsync(static async x =>
         {
-            await Task.Delay(AsyncDelayMs);
+            await Task.Yield();
             return x * SampleValue2;
         }).Subscribe(
             results.Add,
             () => tcs.TrySetResult(true));
 
-        await tcs.Task.WaitAsync(WaitTimeout);
+        await tcs.Task;
 
         // Switch means only the latest survives; with sources 1,2,3 and selector x*2, expect [6].
         await Assert.That(results).IsNotEmpty();
@@ -101,12 +100,12 @@ public async Task WhenSelectAsyncConcurrent_ThenProcessesConcurrently()
         _ = source.SelectAsyncConcurrent(
             static async x =>
             {
-                await Task.Delay(1);
+                await Task.Yield();
                 return x * SampleValue2;
             },
             MaxConcurrency).Subscribe(results.Add, () => tcs.TrySetResult(true));
 
-        await tcs.Task.WaitAsync(WaitTimeout);
+        await tcs.Task;
 
         results.Sort();
         await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
index 4f3c3d71..43b6f892 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
@@ -17,25 +17,18 @@ public partial class ReactiveExtensionsTests
     [Test]
     public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. SubscribeSynchronous dispatches each OnNext concurrently on the thread
-        // pool, so result / itterations need Interlocked for the read-modify-write to be safe.
+        // Given, When. SubscribeSynchronous queues each OnNext and drains the queue one handler at
+        // a time; each handler resumes on a pool thread, so the counters use Interlocked. The
+        // alternating +1 / -1 handlers cancel out once all six have run.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
+        TaskCompletionSource allHandled = new();
         using var disposable = subject.SubscribeSynchronous(async x =>
         {
-            if (x)
-            {
-                await Task.Delay(LongDelayMilliseconds);
-                _ = Interlocked.Increment(ref result);
-            }
-            else
-            {
-                await Task.Delay(ShortDelayMilliseconds);
-                _ = Interlocked.Decrement(ref result);
-            }
-
-            _ = Interlocked.Increment(ref itterations);
+            await Task.Yield();
+            _ = x ? Interlocked.Increment(ref result) : Interlocked.Decrement(ref result);
+            _ = Interlocked.Increment(ref itterations) == SampleValue6 && allHandled.TrySetResult();
         });
         subject.OnNext(true);
         subject.OnNext(false);
@@ -43,10 +36,7 @@ public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
         subject.OnNext(false);
         subject.OnNext(true);
         subject.OnNext(false);
-        while (Volatile.Read(ref itterations) < SampleValue6)
-        {
-            _ = Thread.Yield();
-        }
+        await allHandled.Task;
 
         // Then
         await Assert.That(Volatile.Read(ref result)).IsZero();
@@ -58,8 +48,8 @@ public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
     public async Task SynchronizeSynchronous_RunsWithAsyncTasksInSubscriptions()
     {
         // Given, When. SynchronizeSynchronous dispatches each OnNext through an independent
-        // Continuation so the six HandleAsync invocations run concurrently on the thread pool —
-        // the int read-modify-write therefore needs Interlocked. The test asserts pair-wise
+        // Continuation so the six HandleAsync invocations can run concurrently — the int
+        // read-modify-write therefore needs Interlocked. The test asserts pair-wise
         // (+1, -1) sums to zero after WhenAll completes.
         var result = 0;
         var itterations = 0;
@@ -71,16 +61,8 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
         {
             try
             {
-                if (x.Value)
-                {
-                    await Task.Delay(LongDelayMilliseconds);
-                    _ = Interlocked.Increment(ref result);
-                }
-                else
-                {
-                    await Task.Delay(ShortDelayMilliseconds);
-                    _ = Interlocked.Decrement(ref result);
-                }
+                await Task.Yield();
+                _ = x.Value ? Interlocked.Increment(ref result) : Interlocked.Decrement(ref result);
             }
             finally
             {
@@ -98,7 +80,11 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
         await Task.WhenAll(tasks);
 
         // Then
-        await Assert.That(Volatile.Read(ref result)).IsZero();
+        using (Assert.Multiple())
+        {
+            await Assert.That(Volatile.Read(ref result)).IsZero();
+            await Assert.That(Volatile.Read(ref itterations)).IsEqualTo(SampleValue6);
+        }
     }
 
     /// <summary>Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.</summary>
@@ -106,25 +92,18 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
     [Test]
     public async Task SubscribeAsync_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. SubscribeAsync dispatches each OnNext concurrently, so the integer
-        // read-modify-write needs Interlocked and the polling read needs Volatile.
+        // Given, When. SubscribeAsync queues each OnNext and drains the queue one handler at a
+        // time; each handler resumes on a pool thread, so the counters use Interlocked. The
+        // alternating +1 / -1 handlers cancel out once all six have run.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
+        TaskCompletionSource allHandled = new();
         using var disposable = subject.SubscribeAsync(async x =>
         {
-            if (x)
-            {
-                await Task.Delay(LongDelayMilliseconds);
-                _ = Interlocked.Increment(ref result);
-            }
-            else
-            {
-                await Task.Delay(ShortDelayMilliseconds);
-                _ = Interlocked.Decrement(ref result);
-            }
-
-            _ = Interlocked.Increment(ref itterations);
+            await Task.Yield();
+            _ = x ? Interlocked.Increment(ref result) : Interlocked.Decrement(ref result);
+            _ = Interlocked.Increment(ref itterations) == SampleValue6 && allHandled.TrySetResult();
         });
         subject.OnNext(true);
         subject.OnNext(false);
@@ -132,10 +111,7 @@ public async Task SubscribeAsync_RunsWithAsyncTasksInSubscriptions()
         subject.OnNext(false);
         subject.OnNext(true);
         subject.OnNext(false);
-        while (Volatile.Read(ref itterations) < SampleValue6)
-        {
-            _ = Thread.Yield();
-        }
+        await allHandled.Task;
 
         // Then
         await Assert.That(Volatile.Read(ref result)).IsZero();
@@ -147,38 +123,41 @@ public async Task SubscribeAsync_RunsWithAsyncTasksInSubscriptions()
     public async Task WithLimitedConcurrency_LimitsConcurrentTasks()
     {
         const int MaxConcurrency = 3;
+        var inFlight = 0;
         var maxConcurrent = 0;
-        var currentConcurrent = 0;
+        Queue<TaskCompletionSource<int>> pulled = new();
+        List<int> results = [];
+        var completed = false;
 
+        // Each task only finishes when the test completes its gate, so the pull count the limiter
+        // holds open is observable exactly rather than sampled while real tasks overlap.
         IEnumerable<Task<int>> CreateTasks()
         {
             for (var i = 1; i <= SampleValue10; i++)
             {
-                var value = i;
-                yield return Task.Run(async () =>
-                {
-                    lock (_gate)
-                    {
-                        currentConcurrent++;
-                        maxConcurrent = Math.Max(maxConcurrent, currentConcurrent);
-                    }
-
-                    await Task.Delay(SampleValue10);
-                    lock (_gate)
-                    {
-                        currentConcurrent--;
-                    }
-
-                    return value;
-                });
+                TaskCompletionSource<int> gate = new();
+                pulled.Enqueue(gate);
+                inFlight++;
+                maxConcurrent = Math.Max(maxConcurrent, inFlight);
+                yield return gate.Task;
             }
         }
 
-        var results = await CreateTasks().WithLimitedConcurrency(MaxConcurrency).ToList();
+        using var sub = CreateTasks().WithLimitedConcurrency(MaxConcurrency)
+            .Subscribe(results.Add, () => completed = true);
+        var next = 0;
+        while (pulled.Count > 0)
+        {
+            var gate = pulled.Dequeue();
+            inFlight--;
+            gate.SetResult(++next);
+        }
+
         using (Assert.Multiple())
         {
             await Assert.That(results).Count().IsEqualTo(SampleValue10);
             await Assert.That(maxConcurrent).IsLessThanOrEqualTo(MaxConcurrency);
+            await Assert.That(completed).IsTrue();
         }
     }
 
@@ -228,7 +207,9 @@ IEnumerable<Task<int>> FaultingTasks()
     [Test]
     public async Task WithLimitedConcurrency_DisposeBeforeTaskContinuation_DropsWork()
     {
-        TaskCompletionSource<int> task = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        // The limiter attaches its continuation with ExecuteSynchronously, so SetResult runs the
+        // dropped-work path inline before it returns.
+        TaskCompletionSource<int> task = new();
         List<int> values = [];
         Exception? caught = null;
         var completed = false;
@@ -236,7 +217,6 @@ public async Task WithLimitedConcurrency_DisposeBeforeTaskContinuation_DropsWork
             .Subscribe(values.Add, ex => caught = ex, () => completed = true);
         sub.Dispose();
         task.SetResult(SampleValue10);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
         await Assert.That(completed).IsFalse();
@@ -269,7 +249,6 @@ public async Task WithLimitedConcurrency_NullTaskEntry_ThenNoNotifications()
         var completed = false;
         using var sub = tasks.WithLimitedConcurrency(1)
             .Subscribe(values.Add, ex => caught = ex, () => completed = true);
-        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
         await Assert.That(completed).IsFalse();
@@ -337,7 +316,7 @@ public async Task SubscribeAsync_WithOnNextAndOnError_HandlesError()
             caughtException = ex;
             _ = errorSource.TrySetResult(true);
         });
-        await errorSource.Task.WaitAsync(WaitTimeout);
+        await errorSource.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1]);
@@ -365,7 +344,7 @@ public async Task SubscribeSynchronous_WithFullCallbacks_ExecutesAll()
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
         subject.OnCompleted();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
@@ -392,9 +371,9 @@ public async Task SubscribeSynchronous_WithOnNextAndOnError_HandlesError()
             },
             _ => errorHandled.TrySetResult());
         subject.OnNext(1);
-        await onNextCompleted.Task.WaitAsync(WaitTimeout);
+        await onNextCompleted.Task;
         subject.OnError(new InvalidOperationException());
-        await errorHandled.Task.WaitAsync(WaitTimeout);
+        await errorHandled.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1]);
@@ -420,7 +399,7 @@ public async Task SubscribeSynchronous_WithOnNextAndOnCompleted_CompletesCorrect
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
         subject.OnCompleted();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
@@ -446,7 +425,7 @@ public async Task SubscribeSynchronous_WithOnlyOnNext_ProcessesValues()
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
         subject.OnNext(SampleValue3);
-        await allReceived.Task.WaitAsync(WaitTimeout);
+        await allReceived.Task;
         await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
     }
 
@@ -468,7 +447,7 @@ public async Task SubscribeAsync_WithOnNextAndOnCompleted_CompletesCorrectly()
         using var subscription = source.SubscribeAsync(
             async v =>
             {
-                await Task.Delay(1);
+                await Task.Yield();
                 results.Add(v);
             },
             () =>
@@ -476,7 +455,7 @@ public async Task SubscribeAsync_WithOnNextAndOnCompleted_CompletesCorrectly()
                 completed = true;
                 _ = completionSource.TrySetResult(true);
             });
-        await completionSource.Task.WaitAsync(WaitTimeout);
+        await completionSource.Task;
         using (Assert.Multiple())
         {
             await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
index 50c50f5c..4d38931a 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
@@ -3,24 +3,21 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Subjects;
-using ReactiveUI.Primitives.Async.Tests;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
 /// <summary>Tests for ReactiveExtensionsTests.</summary>
 public partial class ReactiveExtensionsTests
 {
-    /// <summary>Throttle/debounce window in milliseconds used by the real-time (non-virtual) throttle tests.</summary>
-    private const int ThrottleWindowMilliseconds = 100;
+    /// <summary>Throttle window in virtual ticks used by the real-time-free throttle tests.</summary>
+    private const int ThrottleWindowTicks = 100;
 
-    /// <summary>Longest a real-time test waits for a slow scheduled signal before failing.</summary>
-    private static readonly TimeSpan LongWaitTimeout = TimeSpan.FromSeconds(30);
+    /// <summary>Window used by the throttle tests that run on the default sequencer and await their emission.</summary>
+    private static readonly TimeSpan DefaultSequencerWindow = TimeSpan.FromMilliseconds(200);
 
-    /// <summary>Window used by the real-time throttle tests that poll for their result rather than advancing a clock.</summary>
-    private static readonly TimeSpan PolledThrottleWindow = TimeSpan.FromMilliseconds(200);
-
-    /// <summary>Debounce window used by the real-time <c>DebounceUntil</c> test.</summary>
+    /// <summary>Debounce window used by the default-sequencer <c>DebounceUntil</c> test.</summary>
     private static readonly TimeSpan DebounceWindow = TimeSpan.FromMilliseconds(500);
 
     /// <summary>Tests DebounceImmediate emits first immediately.</summary>
@@ -44,15 +41,14 @@ public async Task DebounceImmediate_EmitsFirstImmediately()
     [Test]
     public async Task ThrottleFirst_EmitsFirstImmediately_IgnoresSubsequentWithinWindow()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         List<int> results = [];
-
-        // Throttle window of 100 ms
-        _ = subject.ThrottleFirst(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds)).Subscribe(results.Add);
+        _ = subject.ThrottleFirst(TimeSpan.FromTicks(ThrottleWindowTicks), scheduler).Subscribe(results.Add);
         subject.OnNext(1); // Should be emitted immediately
         subject.OnNext(SampleValue2); // Should be ignored (within throttle window)
         subject.OnNext(SampleValue3); // Should be ignored (within throttle window)
-        await Task.Delay(ThrottleWaitMilliseconds); // Wait for throttle window to pass
+        scheduler.AdvanceBy(ThrottleWindowTicks + 1); // Move past the throttle window
         subject.OnNext(SampleValue4); // Should be emitted
 
         // Verify results
@@ -66,11 +62,11 @@ public async Task DropIfBusy_DropsWhenBusy()
     {
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource<object> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource processed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<object> release = new();
+        TaskCompletionSource processed = new();
         _ = subject.DropIfBusy(async x =>
         {
-            await release.Task;
+            await release.Task.ConfigureAwait(false);
             results.Add(x);
             processed.SetResult();
         }).Subscribe();
@@ -78,7 +74,7 @@ public async Task DropIfBusy_DropsWhenBusy()
         subject.OnNext(SampleValue2); // Should drop
         subject.OnNext(SampleValue3); // Should drop
         release.SetResult(new()); // Complete the async action
-        await processed.Task.WaitAsync(WaitTimeout);
+        await processed.Task;
         await Assert.That(results).IsCollectionEqualTo([1]);
     }
 
@@ -210,22 +206,22 @@ public async Task WhenDebounceUntilWithScheduler_ThenUsesSchedulerForDelay()
     [Test]
     public async Task WhenThrottleUntilTruePredicateFalse_ThenAppliesThrottle()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource<int> throttledArrived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = subject.ThrottleUntilTrue(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), static x => x > PredicateThreshold)
-            .Subscribe(value =>
-        {
-            results.Add(value);
-            _ = value == 1 && throttledArrived.TrySetResult(value);
-        });
+        using var sub = new ThrottleUntilTrueObservable<int>(
+            subject,
+            TimeSpan.FromTicks(ThrottleWindowTicks),
+            static x => x > PredicateThreshold,
+            scheduler).Subscribe(results.Add);
 
         // Predicate true: immediate.
         subject.OnNext(SampleValue10);
 
-        // Predicate false: throttled — wait on the event instead of racing a fixed delay.
+        // Predicate false: held until the clock passes the throttle window.
         subject.OnNext(1);
-        await throttledArrived.Task.WaitAsync(WaitTimeout);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10]);
+        scheduler.AdvanceBy(ThrottleWindowTicks + 1);
         await Assert.That(results).Contains(SampleValue10);
         await Assert.That(results).Contains(1);
     }
@@ -237,11 +233,16 @@ public async Task WhenThrottleDistinctWithoutScheduler_ThenThrottlesAndDeduplica
     {
         Subject<int> subject = new();
         List<int> results = [];
-        using var sub = subject.ThrottleDistinct(PolledThrottleWindow).Subscribe(results.Add);
+        TaskCompletionSource emitted = new();
+        using var sub = subject.ThrottleDistinct(DefaultSequencerWindow).Subscribe(value =>
+        {
+            results.Add(value);
+            _ = value == SampleValue2 && emitted.TrySetResult();
+        });
         subject.OnNext(1);
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Contains(SampleValue2), LongWaitTimeout);
+        await emitted.Task;
         await Assert.That(results).Contains(SampleValue2);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
index b59351e2..6985f799 100644
--- a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using Microsoft.Maui.Dispatching;
 using ReactiveUI.Primitives.Concurrency;
@@ -18,6 +17,9 @@ public sealed class MauiDispatcherSequencerTests
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
+    /// <summary>Due time far enough out that the delay reaching the dispatcher is positive whatever the call costs.</summary>
+    private static readonly TimeSpan FutureDueTime = TimeSpan.FromHours(1);
+
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -66,8 +68,8 @@ public async Task DelayedScheduleUsesDispatchDelayed()
         MauiDispatcherSequencer sequencer = new(dispatcher);
         var executed = false;
 
-        var due = sequencer.Timestamp + Stopwatch.Frequency; // ~1 second into the future.
-        sequencer.Schedule(new DelegateWorkItem(() => executed = true), due);
+        // The relative overload converts the due time against the sequencer's own clock, so the test needs none.
+        _ = sequencer.Schedule(FutureDueTime, () => executed = true);
 
         await Assert.That(executed).IsTrue();
         await Assert.That(dispatcher.DispatchDelayedCount).IsEqualTo(1);
@@ -83,7 +85,8 @@ public async Task PastDueTimestampUsesImmediatePath()
         MauiDispatcherSequencer sequencer = new(dispatcher);
         var executed = false;
 
-        var due = sequencer.Timestamp - Stopwatch.Frequency; // already elapsed.
+        // A timestamp read before the call cannot be later than the monotonic clock the sequencer reads inside it.
+        var due = sequencer.Timestamp;
         sequencer.Schedule(new DelegateWorkItem(() => executed = true), due);
 
         await Assert.That(executed).IsTrue();
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
index 7eb3c4a4..763765f9 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
@@ -4,7 +4,6 @@
 
 using System.Reactive.Disposables;
 using ReactiveUI.Primitives.Reactive.Concurrency;
-using Timer = System.Threading.Timer;
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
@@ -14,39 +13,27 @@ public sealed class WasmSchedulerTests
     /// <summary>State payload used to verify state threading.</summary>
     private const int StatePayload = 42;
 
-    /// <summary>Minimum periodic ticks a test observes before disposing.</summary>
-    private const int MinimumTicks = 2;
+    /// <summary>Periodic ticks a test drives before disposing; more than one, so threaded state is observable.</summary>
+    private const int PeriodicTickCount = 2;
 
-    /// <summary>Threads that enqueue concurrently in the single-flight drain test.</summary>
-    private const int ProducerCount = 4;
+    /// <summary>Items queued ahead of a single drain pass in the exactly-once dispatch test.</summary>
+    private const int BatchItemCount = 2000;
 
-    /// <summary>Items each producer enqueues in the single-flight drain test.</summary>
-    private const int ItemsPerProducer = 500;
+    /// <summary>Sentinel <see cref="Array.FindIndex{T}(T[], Predicate{T})"/> returns when no element matches.</summary>
+    private const int NoMatch = -1;
 
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
-    /// <summary>Longest a test waits for scheduled work before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Due time of a work item that is expected to run after its delay elapses.</summary>
     private static readonly TimeSpan DelayedDueTime = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>Due time of a work item that is disposed before it becomes due, so it must never run.</summary>
-    private static readonly TimeSpan CancellationDueTime = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>How long a test waits past <see cref="CancellationDueTime"/> to prove a cancelled item did not run.</summary>
-    private static readonly TimeSpan CancellationObservationWindow = TimeSpan.FromMilliseconds(250);
-
-    /// <summary>Period between ticks of a periodic work item.</summary>
-    private static readonly TimeSpan TickPeriod = TimeSpan.FromMilliseconds(10);
-
-    /// <summary>How long a test waits after disposing a periodic item to prove no further ticks arrive.</summary>
-    private static readonly TimeSpan PostDisposeObservationWindow = TimeSpan.FromMilliseconds(100);
-
     /// <summary>A positive due time or period, so a null action is the only invalid argument under test.</summary>
     private static readonly TimeSpan ValidInterval = TimeSpan.FromMilliseconds(100);
 
+    /// <summary>A due time no test waits out, so the only run a delayed item sees is the one the test drives.</summary>
+    private static readonly TimeSpan UnreachableDueTime = TimeSpan.FromHours(1);
+
     /// <summary>A period no test waits out, so the only tick a periodic item sees is the one the test drives.</summary>
     private static readonly TimeSpan UnreachablePeriod = TimeSpan.FromHours(1);
 
@@ -64,9 +51,9 @@ public async Task ScheduleRejectsNullAction()
         var scheduler = WasmScheduler.Default;
 
         await Assert.That(() => scheduler.Schedule(0, null!)).ThrowsExactly<ArgumentNullException>();
-        await Assert.That(() => scheduler.Schedule(0, TimeSpan.FromMilliseconds(1), null!))
+        await Assert.That(() => scheduler.Schedule(0, ValidInterval, null!))
             .ThrowsExactly<ArgumentNullException>();
-        await Assert.That(() => scheduler.SchedulePeriodic(0, TimeSpan.FromMilliseconds(1), null!))
+        await Assert.That(() => scheduler.SchedulePeriodic(0, ValidInterval, null!))
             .ThrowsExactly<ArgumentNullException>();
     }
 
@@ -93,7 +80,7 @@ public async Task ImmediateScheduleExecutes()
             return Disposable.Empty;
         });
 
-        await Assert.That(await executed.Task.WaitAsync(WaitTimeout)).IsEqualTo(StatePayload);
+        await Assert.That(await executed.Task).IsEqualTo(StatePayload);
     }
 
     /// <summary>Verifies a burst of immediate work executes in FIFO order.</summary>
@@ -119,49 +106,38 @@ public async Task ImmediateBurstExecutesInOrder()
             });
         }
 
-        _ = await done.Task.WaitAsync(WaitTimeout);
+        _ = await done.Task;
         await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
     }
 
-    /// <summary>Verifies a disposed immediate work item never runs while later work still does.</summary>
+    /// <summary>Verifies an item disposed while it waits in the ready queue is skipped while later work still runs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposedImmediateItemIsSkipped()
     {
-        // Park the single event-loop drain on a gate item so the dispose below is guaranteed to happen before the
-        // cancelled item is ever run. Without this the immediate drain races the synchronous Dispose on a
-        // multi-threaded runtime (it never can on single-threaded WebAssembly, which the type targets).
-        TaskCompletionSource gateEntered = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using ManualResetEventSlim release = new(false);
-        _ = WasmScheduler.Default.Schedule(0, (_, _) =>
-        {
-            _ = gateEntered.TrySetResult();
-            _ = release.Wait(WaitTimeout);
-            return Disposable.Empty;
-        });
-
-        await gateEntered.Task.WaitAsync(WaitTimeout);
-
-        TaskCompletionSource<bool> markerRan = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var scheduler = CreateIsolatedScheduler();
         var cancelledRan = false;
-
-        var cancelled = WasmScheduler.Default.Schedule(0, (_, _) =>
+        var markerRan = false;
+        WasmScheduler.StatefulWorkItem<int> cancelled = new(scheduler, 0, (_, _) =>
         {
             cancelledRan = true;
             return Disposable.Empty;
         });
-        cancelled.Dispose();
-        _ = WasmScheduler.Default.Schedule(0, (_, _) =>
+        WasmScheduler.StatefulWorkItem<int> marker = new(scheduler, 0, (_, _) =>
         {
-            _ = markerRan.TrySetResult(true);
+            markerRan = true;
             return Disposable.Empty;
         });
 
-        // Let the drain proceed: it runs the gate, then the (now disposed) cancelled item, then the marker.
-        release.Set();
+        // Queue both without arming a drain, so the dispose lands while a drain has reached neither item.
+        scheduler.QueueReady(cancelled);
+        scheduler.QueueReady(marker);
+        cancelled.Dispose();
+
+        scheduler.RunReadyBatch();
 
-        _ = await markerRan.Task.WaitAsync(WaitTimeout);
         await Assert.That(cancelledRan).IsFalse();
+        await Assert.That(markerRan).IsTrue();
     }
 
     /// <summary>Verifies delayed work executes and zero due time uses the immediate path.</summary>
@@ -183,25 +159,31 @@ public async Task DelayedScheduleExecutes()
             return Disposable.Empty;
         });
 
-        await Assert.That(await delayed.Task.WaitAsync(WaitTimeout)).IsTrue();
-        await Assert.That(await immediate.Task.WaitAsync(WaitTimeout)).IsTrue();
+        await Assert.That(await delayed.Task).IsTrue();
+        await Assert.That(await immediate.Task).IsTrue();
     }
 
-    /// <summary>Verifies disposing a delayed work item before it is due cancels it.</summary>
+    /// <summary>Verifies disposing a delayed work item before it is due cancels it, so a late callback is dropped.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposedDelayedItemDoesNotRun()
     {
         var ran = false;
+        var subscription = (WasmScheduler.StatefulWorkItem<int>)WasmScheduler.Default.Schedule(
+            0,
+            UnreachableDueTime,
+            (_, _) =>
+            {
+                ran = true;
+                return Disposable.Empty;
+            });
 
-        var subscription = WasmScheduler.Default.Schedule(0, CancellationDueTime, (_, _) =>
-        {
-            ran = true;
-            return Disposable.Empty;
-        });
         subscription.Dispose();
 
-        await Task.Delay(CancellationObservationWindow);
+        // The due time never elapses on its own, so this is the run a timer callback already in flight would deliver.
+        subscription.Run();
+
+        await Assert.That(subscription.IsDisposed).IsTrue();
         await Assert.That(ran).IsFalse();
     }
 
@@ -210,26 +192,28 @@ public async Task DisposedDelayedItemDoesNotRun()
     [Test]
     public async Task SchedulePeriodicTicksAndStopsOnDispose()
     {
-        TaskCompletionSource<bool> reachedTwo = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var count = 0;
+        var subscription = (WasmScheduler.PeriodicWorkItem<int>)WasmScheduler.Default.SchedulePeriodic(
+            0,
+            UnreachablePeriod,
+            state =>
+            {
+                count = state + 1;
+                return count;
+            });
 
-        var subscription = WasmScheduler.Default.SchedulePeriodic(0, TickPeriod, state =>
+        for (var tick = 0; tick < PeriodicTickCount; tick++)
         {
-            count = state + 1;
-            if (count >= MinimumTicks)
-            {
-                _ = reachedTwo.TrySetResult(true);
-            }
+            subscription.Tick();
+        }
 
-            return count;
-        });
+        // The count only reaches the tick total if each tick received the state the previous one returned.
+        await Assert.That(count).IsEqualTo(PeriodicTickCount);
 
-        _ = await reachedTwo.Task.WaitAsync(WaitTimeout);
         subscription.Dispose();
-        var snapshot = Volatile.Read(ref count);
+        subscription.Tick();
 
-        await Task.Delay(PostDisposeObservationWindow);
-        await Assert.That(Volatile.Read(ref count)).IsEqualTo(snapshot);
+        await Assert.That(count).IsEqualTo(PeriodicTickCount);
     }
 
     /// <summary>Verifies a zero period is clamped instead of rejected and still ticks.</summary>
@@ -245,7 +229,7 @@ public async Task SchedulePeriodicClampsZeroPeriod()
             return state;
         });
 
-        await Assert.That(await ticked.Task.WaitAsync(WaitTimeout)).IsTrue();
+        await Assert.That(await ticked.Task).IsTrue();
         subscription.Dispose();
     }
 
@@ -267,7 +251,7 @@ public async Task DisposeReleasesDrainTimerAndIsIdempotent()
     public async Task DisposedDelayedItemDisposeIsIdempotent()
     {
         var subscription =
-            WasmScheduler.Default.Schedule(0, TimeSpan.FromMinutes(1), static (_, _) => Disposable.Empty);
+            WasmScheduler.Default.Schedule(0, UnreachableDueTime, static (_, _) => Disposable.Empty);
 
         subscription.Dispose();
 
@@ -279,7 +263,7 @@ public async Task DisposedDelayedItemDisposeIsIdempotent()
     [Test]
     public async Task DisposedPeriodicItemDisposeIsIdempotent()
     {
-        var subscription = WasmScheduler.Default.SchedulePeriodic(0, TimeSpan.FromMinutes(1), static state => state);
+        var subscription = WasmScheduler.Default.SchedulePeriodic(0, UnreachablePeriod, static state => state);
 
         subscription.Dispose();
 
@@ -292,8 +276,7 @@ public async Task DisposedPeriodicItemDisposeIsIdempotent()
     public async Task SelfCancellingImmediateActionDisposesReturnedDisposable()
     {
         using var scheduler = CreateIsolatedScheduler();
-        TaskCompletionSource returnedDisposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var returned = Disposable.Create(returnedDisposed, static source => source.TrySetResult());
+        BooleanDisposable returned = new();
 
         // Build the item and publish the handle it cancels through before anything can run it. Scheduling normally
         // arms the drain inside Schedule and only then returns the handle, so the action is free to run first and
@@ -310,10 +293,10 @@ public async Task SelfCancellingImmediateActionDisposesReturnedDisposable()
             });
 
         subscription = item;
-        scheduler.Enqueue(item);
+        scheduler.QueueReady(item);
+        scheduler.RunReadyBatch();
 
-        await returnedDisposed.Task.WaitAsync(WaitTimeout);
-        await Assert.That(returnedDisposed.Task.IsCompletedSuccessfully).IsTrue();
+        await Assert.That(returned.IsDisposed).IsTrue();
     }
 
     /// <summary>Verifies that scheduling with a null action returns proper exception.</summary>
@@ -358,24 +341,24 @@ public async Task ScheduleAfterDisposeThrowsObjectDisposedException()
 
         await Assert.That(() => scheduler.Schedule(0, (_, _) =>
         {
-            _ = Interlocked.Increment(ref ran);
+            ran++;
             return Disposable.Empty;
         })).ThrowsExactly<ObjectDisposedException>();
 
-        await Assert.That(() => scheduler.Schedule(0, DelayedDueTime, (_, _) =>
+        await Assert.That(() => scheduler.Schedule(0, UnreachableDueTime, (_, _) =>
         {
-            _ = Interlocked.Increment(ref ran);
+            ran++;
             return Disposable.Empty;
         })).ThrowsExactly<ObjectDisposedException>();
 
-        await Assert.That(() => scheduler.SchedulePeriodic(0, TickPeriod, state =>
+        await Assert.That(() => scheduler.SchedulePeriodic(0, UnreachablePeriod, state =>
         {
-            _ = Interlocked.Increment(ref ran);
+            ran++;
             return state;
         })).ThrowsExactly<ObjectDisposedException>();
 
-        await Task.Delay(CancellationObservationWindow);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        // Each overload threw before it built an item, so there is nothing left that could run the actions.
+        await Assert.That(ran).IsEqualTo(0);
     }
 
     /// <summary>
@@ -387,32 +370,23 @@ await Assert.That(() => scheduler.SchedulePeriodic(0, TickPeriod, state =>
     public async Task DisposeCancelsWorkTheInFlightDrainHasNotReachedYet()
     {
         var scheduler = CreateIsolatedScheduler();
-        TaskCompletionSource gateEntered = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using ManualResetEventSlim release = new(false);
-
-        // Park the single drain inside the first item, so the second item is provably still queued when Dispose runs.
-        _ = scheduler.Schedule(0, (_, _) =>
-        {
-            _ = gateEntered.TrySetResult();
-            _ = release.Wait(WaitTimeout);
-            return Disposable.Empty;
-        });
-        await gateEntered.Task.WaitAsync(WaitTimeout);
-
         var queuedRan = 0;
-        var queued = scheduler.Schedule(0, (_, _) =>
+        WasmScheduler.StatefulWorkItem<int> queued = new(scheduler, 0, (_, _) =>
         {
-            _ = Interlocked.Increment(ref queuedRan);
+            queuedRan++;
             return Disposable.Empty;
         });
 
+        // Queue without arming a drain, so the item is provably still waiting when the disposal runs.
+        scheduler.QueueReady(queued);
+
         scheduler.Dispose();
 
-        // Let the parked drain resume: the item it never reached must have been cancelled by the disposal.
-        release.Set();
-        await Task.Delay(PostDisposeObservationWindow);
+        // The parked drain resuming: the item it never reached is gone from the queue the disposal released.
+        scheduler.RunReadyBatch();
 
-        await Assert.That(Volatile.Read(ref queuedRan)).IsEqualTo(0);
+        await Assert.That(queuedRan).IsEqualTo(0);
+        await Assert.That(queued.IsDisposed).IsTrue();
         await Assert.That(queued.Dispose).ThrowsNothing();
     }
 
@@ -432,27 +406,19 @@ public async Task AttachTimerReleasesATimerGivenToAnAlreadyCancelledItem()
             StatePayload,
             (_, _) =>
             {
-                _ = Interlocked.Increment(ref ran);
+                ran++;
                 return Disposable.Empty;
             });
 
         // Cancel before the delayed schedule reaches its AttachTimer call.
         item.Dispose();
 
-        var fired = 0;
-        await using Timer timer = new(
-            _ => Interlocked.Increment(ref fired),
-            null,
-            DelayedDueTime,
-            Timeout.InfiniteTimeSpan);
-
+        // Stands in for the one-shot timer, recording the release the item owes it.
+        BooleanDisposable timer = new();
         item.AttachTimer(timer);
 
-        // A timer still armed would have fired well inside this window; the released one never can.
-        await Task.Delay(CancellationObservationWindow);
-
-        await Assert.That(Volatile.Read(ref fired)).IsEqualTo(0);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        await Assert.That(timer.IsDisposed).IsTrue();
+        await Assert.That(ran).IsEqualTo(0);
     }
 
     /// <summary>
@@ -470,7 +436,7 @@ public async Task PeriodicTickThatLosesTheRaceToDisposeDoesNotRunTheAction()
             UnreachablePeriod,
             state =>
             {
-                _ = Interlocked.Increment(ref ticks);
+                ticks++;
                 return state;
             });
 
@@ -479,7 +445,7 @@ public async Task PeriodicTickThatLosesTheRaceToDisposeDoesNotRunTheAction()
         // The period never elapses on its own, so this is the tick a callback already in flight would have delivered.
         item.Tick();
 
-        await Assert.That(Volatile.Read(ref ticks)).IsEqualTo(0);
+        await Assert.That(ticks).IsEqualTo(0);
     }
 
     /// <summary>
@@ -498,7 +464,7 @@ public async Task EnqueueThatLosesTheRaceToDisposeReleasesTheItemItQueued()
             StatePayload,
             (_, _) =>
             {
-                _ = Interlocked.Increment(ref ran);
+                ran++;
                 return Disposable.Empty;
             });
 
@@ -509,47 +475,36 @@ public async Task EnqueueThatLosesTheRaceToDisposeReleasesTheItemItQueued()
 
         await Assert.That(item.IsDisposed).IsTrue();
 
-        await Task.Delay(PostDisposeObservationWindow);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        // A drain that arrives after the enqueue finds nothing to run, so the released item stays unrun.
+        scheduler.RunReadyBatch();
+
+        await Assert.That(ran).IsEqualTo(0);
     }
 
     /// <summary>
-    /// Verifies the single-flight drain latch dispatches every item exactly once when many threads enqueue at the same
-    /// time. Enqueues, drain posts and the running drain all interleave here, so a lost drain post would strand work
-    /// and a double-claimed latch would run an item twice.
+    /// Verifies a drain pass dispatches every queued item exactly once: an item the batch skips would be stranded,
+    /// and one it claims twice would run its action twice.
     /// </summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task ConcurrentSchedulingDispatchesEveryItemExactlyOnce()
+    public async Task DrainDispatchesEveryQueuedItemExactlyOnce()
     {
         using var scheduler = CreateIsolatedScheduler();
-        var ran = 0;
-        using CountdownEvent completed = new(ProducerCount * ItemsPerProducer);
-        var producers = new Task[ProducerCount];
+        var dispatches = new int[BatchItemCount];
 
-        for (var producer = 0; producer < ProducerCount; producer++)
+        for (var index = 0; index < BatchItemCount; index++)
         {
-            producers[producer] = Task.Run(() =>
+            scheduler.QueueReady(new WasmScheduler.StatefulWorkItem<int>(scheduler, index, (_, state) =>
             {
-                for (var item = 0; item < ItemsPerProducer; item++)
-                {
-                    _ = scheduler.Schedule(0, (_, _) =>
-                    {
-                        _ = Interlocked.Increment(ref ran);
-                        _ = completed.Signal();
-                        return Disposable.Empty;
-                    });
-                }
-            });
+                dispatches[state]++;
+                return Disposable.Empty;
+            }));
         }
 
-        await Task.WhenAll(producers);
-
-        await Assert.That(completed.Wait(WaitTimeout)).IsTrue();
+        scheduler.RunReadyBatch();
 
-        // Settle, then prove the latch never let a second drain re-run an item it had already dispatched.
-        await Task.Delay(PostDisposeObservationWindow);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(ProducerCount * ItemsPerProducer);
+        // Every slot holding exactly one dispatch rules out both a skipped and a doubled item.
+        await Assert.That(Array.FindIndex(dispatches, static count => count != 1)).IsEqualTo(NoMatch);
     }
 
     /// <summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
new file mode 100644
index 00000000..e7e5b0db
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
@@ -0,0 +1,93 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>
+/// An observer that records every callback and hands out tasks that complete when a callback arrives, so a test
+/// awaits the notification it is asserting on instead of giving a clock a budget to produce it.
+/// </summary>
+/// <typeparam name="T">The type of the observed values.</typeparam>
+internal sealed class AwaitableWitness<T> : IObserver<T>
+{
+    /// <summary>The recorded values, in arrival order.</summary>
+    private readonly ConcurrentQueue<T> _values = new();
+
+    /// <summary>The recorded errors, in arrival order.</summary>
+    private readonly ConcurrentQueue<Exception> _errors = new();
+
+    /// <summary>The value-count thresholds a caller is waiting on, keyed by threshold.</summary>
+    private readonly ConcurrentDictionary<int, TaskCompletionSource> _valueWaiters = new();
+
+    /// <summary>Produces the first observed error.</summary>
+    private readonly TaskCompletionSource<Exception> _firstError =
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    /// <summary>Completes when the sequence completes.</summary>
+    private readonly TaskCompletionSource _completion =
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    /// <summary>Gets a task that produces the first observed error.</summary>
+    internal Task<Exception> FirstError => _firstError.Task;
+
+    /// <summary>Gets a task that completes when the sequence completes.</summary>
+    internal Task Completion => _completion.Task;
+
+    /// <summary>Gets a snapshot of the recorded values.</summary>
+    internal IReadOnlyList<T> Values => [.. _values];
+
+    /// <summary>Gets a snapshot of the recorded errors.</summary>
+    internal IReadOnlyList<Exception> Errors => [.. _errors];
+
+    /// <summary>Gets the number of completion callbacks observed.</summary>
+    internal int Completions { get; private set; }
+
+    /// <summary>Gets a task that completes once the observed value count reaches a threshold.</summary>
+    /// <param name="count">The value count to wait for.</param>
+    /// <returns>A task that completes when at least <paramref name="count"/> values have been observed.</returns>
+    internal Task ValueCountReaching(int count)
+    {
+        var waiter = _valueWaiters.GetOrAdd(
+            count,
+            static _ => new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously));
+
+        // Re-check after registering: a value that arrived in between would otherwise never signal this waiter.
+        if (_values.Count >= count)
+        {
+            _ = waiter.TrySetResult();
+        }
+
+        return waiter.Task;
+    }
+
+    /// <inheritdoc/>
+    public void OnCompleted()
+    {
+        Completions++;
+        _ = _completion.TrySetResult();
+    }
+
+    /// <inheritdoc/>
+    public void OnError(Exception error)
+    {
+        _errors.Enqueue(error);
+        _ = _firstError.TrySetResult(error);
+    }
+
+    /// <inheritdoc/>
+    public void OnNext(T value)
+    {
+        _values.Enqueue(value);
+        var count = _values.Count;
+        foreach (var waiter in _valueWaiters)
+        {
+            if (waiter.Key <= count)
+            {
+                _ = waiter.Value.TrySetResult();
+            }
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs
new file mode 100644
index 00000000..e92862e3
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs
@@ -0,0 +1,27 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Awaitable adapters over a <see cref="CancellationToken"/>.</summary>
+internal static class CancellationTokenExtensions
+{
+    /// <summary>
+    /// Returns a task that stays pending until the token is cancelled and then throws
+    /// <see cref="OperationCanceledException"/>. It models work that only ever ends by cancellation, so a test can
+    /// hold a factory open for as long as it needs to without handing a deadline to a clock.
+    /// </summary>
+    /// <param name="token">The token whose cancellation ends the wait.</param>
+    /// <returns>A task that transitions to cancelled when <paramref name="token"/> is cancelled.</returns>
+    internal static async Task WhenCanceled(this CancellationToken token)
+    {
+        // No RunContinuationsAsynchronously: the awaiting body resumes inside Cancel, so the cancellation path
+        // has run by the time the caller's Cancel call returns.
+        TaskCompletionSource completion = new();
+        using var registration = token.Register(
+            static state => ((TaskCompletionSource)state!).TrySetCanceled(),
+            completion);
+        await completion.Task.ConfigureAwait(false);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
index ac35131a..6c479ba2 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
@@ -60,8 +60,8 @@ public partial class RxNamesTests
     /// <summary>The amount the virtual clock is advanced, comfortably past <see cref = "DueTicks"/>.</summary>
     private const long AdvanceTicks = 5;
 
-    /// <summary>The timeout in seconds used while waiting for ThreadPool-scheduled coverage branches.</summary>
-    private const int PollTimeoutSeconds = 2;
+    /// <summary>How far in the past the absolute due time of the default-scheduler operators is placed.</summary>
+    private const int ElapsedDueSeconds = 2;
 
     /// <summary>Source values 1..5.</summary>
     private static readonly int[] _oneToFive = [1, 2, 3, 4, 5];
@@ -439,62 +439,59 @@ await Assert
     [Test]
     public async Task AbsoluteTimeOperatorsUseDefaultScheduler()
     {
-        var dueTime = ThreadPoolSequencer.Instance.Now.AddSeconds(-PollTimeoutSeconds);
-        List<int> delayedScalar = [];
-        List<int> delayedRange = [];
-        List<int> delayedSubscriptionScalar = [];
-        List<int> delayedSubscriptionRange = [];
-        List<int> delayedExplicitRange = [];
-        List<int> delayedSubscriptionExplicitRange = [];
-        Exception? timeout = null;
-        Exception? explicitTimeout = null;
+        var dueTime = ThreadPoolSequencer.Instance.Now.AddSeconds(-ElapsedDueSeconds);
+        AwaitableWitness<int> delayedScalar = new();
+        AwaitableWitness<int> delayedRange = new();
+        AwaitableWitness<int> delayedSubscriptionScalar = new();
+        AwaitableWitness<int> delayedSubscriptionRange = new();
+        AwaitableWitness<int> delayedExplicitRange = new();
+        AwaitableWitness<int> delayedSubscriptionExplicitRange = new();
+        AwaitableWitness<int> timeout = new();
+        AwaitableWitness<int> explicitTimeout = new();
         const ISequencer? defaultScheduler = null;
 
         using var delayScalarSubscription = Signal.Emit(One)
             .Delay(dueTime)
-            .Subscribe(delayedScalar.Add);
+            .Subscribe(delayedScalar);
         using var delayRangeSubscription = Signal.Sequence(Two, Two)
             .Delay(dueTime)
-            .Subscribe(delayedRange.Add);
+            .Subscribe(delayedRange);
         using var delayExplicitRangeSubscription = Signal.Sequence(Two, Two)
             .Delay(dueTime, defaultScheduler)
-            .Subscribe(delayedExplicitRange.Add);
+            .Subscribe(delayedExplicitRange);
         using var subscriptionScalarSubscription = Signal.Emit(One)
             .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionScalar.Add);
+            .Subscribe(delayedSubscriptionScalar);
         using var subscriptionRangeSubscription = Signal.Sequence(Two, Two)
             .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionRange.Add);
+            .Subscribe(delayedSubscriptionRange);
         using var subscriptionExplicitRangeSubscription = Signal.Sequence(Two, Two)
             .DelaySubscription(dueTime, defaultScheduler)
-            .Subscribe(delayedSubscriptionExplicitRange.Add);
+            .Subscribe(delayedSubscriptionExplicitRange);
         using var timeoutSubscription = Signal.Silent<int>()
             .Timeout(dueTime)
-            .Subscribe(static _ => { }, captured => timeout = captured);
+            .Subscribe(timeout);
         using var explicitTimeoutSubscription = Signal.Silent<int>()
             .Timeout(dueTime, defaultScheduler)
-            .Subscribe(static _ => { }, captured => explicitTimeout = captured);
-
-        await TestPolling.SpinUntil(
-            () =>
-                delayedScalar.Count == One
-                && delayedRange.Count == Two
-                && delayedExplicitRange.Count == Two
-                && delayedSubscriptionScalar.Count == One
-                && delayedSubscriptionRange.Count == Two
-                && delayedSubscriptionExplicitRange.Count == Two
-                && timeout is not null
-                && explicitTimeout is not null,
-            TimeSpan.FromSeconds(PollTimeoutSeconds));
-
-        await Assert.That(delayedScalar.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedRange.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedExplicitRange.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionScalar.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedSubscriptionRange.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionExplicitRange.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(timeout).IsTypeOf<TimeoutException>();
-        await Assert.That(explicitTimeout).IsTypeOf<TimeoutException>();
+            .Subscribe(explicitTimeout);
+
+        await delayedScalar.ValueCountReaching(One);
+        await delayedRange.ValueCountReaching(Two);
+        await delayedExplicitRange.ValueCountReaching(Two);
+        await delayedSubscriptionScalar.ValueCountReaching(One);
+        await delayedSubscriptionRange.ValueCountReaching(Two);
+        await delayedSubscriptionExplicitRange.ValueCountReaching(Two);
+        var timedOut = await timeout.FirstError;
+        var explicitlyTimedOut = await explicitTimeout.FirstError;
+
+        await Assert.That(delayedScalar.Values.SequenceEqual([One])).IsTrue();
+        await Assert.That(delayedRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedSubscriptionScalar.Values.SequenceEqual([One])).IsTrue();
+        await Assert.That(delayedSubscriptionRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedSubscriptionExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(timedOut).IsTypeOf<TimeoutException>();
+        await Assert.That(explicitlyTimedOut).IsTypeOf<TimeoutException>();
     }
 
     /// <summary>Verifies the binary <c>Concat</c>/<c>Chain</c> overload concatenates two sequences identically.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs
index 5ba040c8..a2322486 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs
@@ -77,11 +77,11 @@ public async Task ParityAliasesCoverTaskObservableBranches()
         await Assert.That(observed).IsSameReferenceAs(expected);
 
         TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        List<int> pendingValues = [];
-        _ = pending.Task.ToObservable().Subscribe(pendingValues.Add);
+        AwaitableWitness<int> pendingWitness = new();
+        _ = pending.Task.ToObservable().Subscribe(pendingWitness);
         pending.SetResult(Two);
-        await TestPolling.SpinUntil(() => pendingValues.Count == One, TimeSpan.FromSeconds(One));
-        await Assert.That(pendingValues.SequenceEqual([Two])).IsTrue();
+        await pendingWitness.ValueCountReaching(One);
+        await Assert.That(pendingWitness.Values.SequenceEqual([Two])).IsTrue();
     }
 
     /// <summary>Verifies parity operators cover remaining public range and alias branches.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
index 5a3235a6..7190e35c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
@@ -46,9 +46,16 @@ static async IAsyncEnumerable<int> ThrowingAsyncEnumerable()
             throw new InvalidOperationException("async");
         }
 
+        TaskCompletionSource asyncFailed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         _ = Signal.FromAsyncEnumerable(ThrowingAsyncEnumerable())
-            .Subscribe(asyncValues.Add, ex => asyncErrors.Add(ex.Message));
-        await TestPolling.SpinUntil(() => asyncErrors.Count == 1, TimeSpan.FromSeconds(TimeoutSeconds));
+            .Subscribe(
+                asyncValues.Add,
+                ex =>
+                {
+                    asyncErrors.Add(ex.Message);
+                    _ = asyncFailed.TrySetResult();
+                });
+        await asyncFailed.Task;
         var firstFailure = await AssertTaskFault(
             static () => Signal.None<int>().FirstAsync(),
             typeof(InvalidOperationException));
@@ -73,8 +80,15 @@ static async IAsyncEnumerable<int> ThrowingAsyncEnumerable()
     /// <returns>A task that completes when the error has been observed.</returns>
     private static async Task ObserveTaskError(Task<int> task, List<string> errors)
     {
-        _ = Signal.FromTask(task).Subscribe(static _ => { }, ex => errors.Add(ex.GetType().Name));
-        await TestPolling.SpinUntil(() => errors.Count > 0, TimeSpan.FromSeconds(TimeoutSeconds));
+        TaskCompletionSource failed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        _ = Signal.FromTask(task).Subscribe(
+            static _ => { },
+            ex =>
+            {
+                errors.Add(ex.GetType().Name);
+                _ = failed.TrySetResult();
+            });
+        await failed.Task;
     }
 
     /// <summary>Asserts that a task factory faults with the expected exception type.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
index 6326329f..3a596db4 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
@@ -301,7 +301,7 @@ async IAsyncEnumerable<int> Values([EnumeratorCancellation] CancellationToken to
             try
             {
                 yield return FirstValue;
-                await Task.Delay(Timeout.InfiniteTimeSpan, token);
+                await token.WhenCanceled();
                 yield return SecondValue;
             }
             finally
@@ -319,9 +319,9 @@ async IAsyncEnumerable<int> Values([EnumeratorCancellation] CancellationToken to
             },
             static _ => { },
             static () => { });
-        await firstValueObserved.Task.WaitAsync(testToken).ConfigureAwait(false);
+        await firstValueObserved.Task.ConfigureAwait(false);
         subscription.Dispose();
-        await disposedSignal.Task.WaitAsync(testToken).ConfigureAwait(false);
+        await disposedSignal.Task.ConfigureAwait(false);
         await Assert.That(values.SequenceEqual(AsyncEnumerableBeforeDisposeExpected)).IsTrue();
         await Assert.That(disposed).IsTrue();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
index 1cd44430..2c768ce3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
@@ -12,9 +12,6 @@ namespace ReactiveUI.Primitives.Tests;
 /// </summary>
 public partial class SignalFactoriesTests
 {
-    /// <summary>The time allowed for a default-sequencer factory to produce its notification.</summary>
-    private static readonly TimeSpan DefaultSequencerTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>The timeout used by the expiry factory test.</summary>
     private static readonly TimeSpan ShortExpiry = TimeSpan.FromMilliseconds(20);
 
@@ -57,11 +54,11 @@ public async Task FromEnumerableHonorsACancellableTokenAndIgnoresAnUncancellable
     [Test]
     public async Task ExpireWithoutASequencerFailsASilentSequence()
     {
-        List<Exception> errors = [];
-        using var subscription = Signal.Expire(Signal.Silent<int>(), ShortExpiry)
-            .Subscribe(static _ => { }, errors.Add);
-        await TestPolling.SpinUntil(() => errors.Count == 1, DefaultSequencerTimeout);
-        await Assert.That(errors[0]).IsTypeOf<TimeoutException>();
+        AwaitableWitness<int> witness = new();
+        using var subscription = Signal.Expire(Signal.Silent<int>(), ShortExpiry).Subscribe(witness);
+        var error = await witness.FirstError;
+        await Assert.That(error).IsTypeOf<TimeoutException>();
+        await Assert.That(witness.Errors.Count).IsEqualTo(1);
     }
 
     /// <summary>Verifies the sequencer-free <c>Start</c> factories run their work and emit its outcome.</summary>
@@ -69,21 +66,21 @@ public async Task ExpireWithoutASequencerFailsASilentSequence()
     [Test]
     public async Task StartWithoutASequencerRunsTheWorkOnTheDefaultSequencer()
     {
-        List<int> functionValues = [];
-        using var functionSubscription = Signal.Start(static () => Two).Subscribe(functionValues.Add);
-        await TestPolling.SpinUntil(() => functionValues.Count == 1, DefaultSequencerTimeout);
-        await Assert.That(functionValues.SequenceEqual([Two])).IsTrue();
+        AwaitableWitness<int> functionWitness = new();
+        using var functionSubscription = Signal.Start(static () => Two).Subscribe(functionWitness);
+        await functionWitness.ValueCountReaching(1);
+        await Assert.That(functionWitness.Values.SequenceEqual([Two])).IsTrue();
         var actionRuns = 0;
-        List<RxVoid> actionValues = [];
+        AwaitableWitness<RxVoid> actionWitness = new();
 
         // A void method group is what selects Start(Action); a lambda over 'actionRuns++' is a
         // Func<int> and would bind to the generic Start<T> overload instead.
         void RunAction() => actionRuns++;
 
-        using var actionSubscription = Signal.Start(RunAction).Subscribe(actionValues.Add);
-        await TestPolling.SpinUntil(() => actionValues.Count == 1, DefaultSequencerTimeout);
+        using var actionSubscription = Signal.Start(RunAction).Subscribe(actionWitness);
+        await actionWitness.ValueCountReaching(1);
         await Assert.That(actionRuns).IsEqualTo(1);
-        await Assert.That(actionValues[0]).IsEqualTo(RxVoid.Default);
+        await Assert.That(actionWitness.Values[0]).IsEqualTo(RxVoid.Default);
     }
 
     /// <summary>Verifies the sequencer-free <c>Every</c> factory ticks on the default sequencer.</summary>
@@ -91,12 +88,13 @@ public async Task StartWithoutASequencerRunsTheWorkOnTheDefaultSequencer()
     [Test]
     public async Task EveryWithoutASequencerTicksOnTheDefaultSequencer()
     {
-        List<long> ticks = [];
-        using (Signal.Every(ShortExpiry).Subscribe(ticks.Add))
+        AwaitableWitness<long> witness = new();
+        using (Signal.Every(ShortExpiry).Subscribe(witness))
         {
-            await TestPolling.SpinUntil(() => ticks.Count >= Two, DefaultSequencerTimeout);
+            await witness.ValueCountReaching(Two);
         }
 
+        var ticks = witness.Values;
         await Assert.That(ticks[1]).IsGreaterThan(ticks[0]);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
index 9decea41..7380390c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
@@ -251,16 +251,16 @@ public async Task ScheduledSignalSendsToTheDefaultObserverWhileNoSubscriberIsPre
     [Test]
     public async Task FromAsyncWithAnUncancellableTokenStillCompletesWithItsResult()
     {
-        RecordingWitness<int> witness = new();
+        AwaitableWitness<int> witness = new();
 
         using var subscription = Signal
             .FromAsync(static _ => Task.FromResult(Seven), CancellationToken.None)
             .Subscribe(witness);
 
-        await TestPolling.SpinUntil(() => witness.Completed == 1, TimeSpan.FromSeconds(TimeoutSeconds));
+        await witness.Completion;
 
         await Assert.That(witness.Values.SequenceEqual(ExpectedSingleSeven)).IsTrue();
-        await Assert.That(witness.Completed).IsEqualTo(1);
+        await Assert.That(witness.Completions).IsEqualTo(1);
         await Assert.That(witness.Errors.Count).IsEqualTo(0);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
index 9ab1e57d..86d01d7e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
@@ -140,9 +140,6 @@ public async Task FactoryAliasesScheduledRangesTasksAndTimersCoverRemainderBranc
             .Subscribe(taskValues.Add, ex => taskErrors.Add(ex.GetType().Name));
         _ = Signal.FromTask(Task.FromCanceled<int>(new(true)))
             .Subscribe(taskValues.Add, ex => taskErrors.Add(ex.GetType().Name));
-        await TestPolling.SpinUntil(
-            () => taskValues.Count == One && taskErrors.Count == Two,
-            TimeSpan.FromSeconds(TimeoutSeconds));
         var disposedTaskSubscription = Signal.FromTask(Task.FromResult(NinetyNine))
             .Subscribe(_ => taskValues.Add(NinetyNine));
         disposedTaskSubscription.Dispose();
@@ -245,13 +242,13 @@ public async Task FromAsyncCancellableFactoryDisposalCancelsSubscriptionToken()
     {
         TaskCompletionSource<CancellationToken> observedToken = new(TaskCreationOptions.RunContinuationsAsynchronously);
         TaskCompletionSource canceled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> observer = new();
+        AwaitableWitness<int> observer = new();
         var subscription = Signal.FromAsync(async token =>
         {
             observedToken.SetResult(token);
             try
             {
-                await Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds), token).ConfigureAwait(false);
+                await token.WhenCanceled().ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -261,13 +258,13 @@ public async Task FromAsyncCancellableFactoryDisposalCancelsSubscriptionToken()
 
             return One;
         }).Subscribe(observer);
-        var token = await observedToken.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        var token = await observedToken.Task;
         subscription.Dispose();
-        await canceled.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        await canceled.Task;
         await Assert.That(token.IsCancellationRequested).IsTrue();
         await Assert.That(observer.Values.Count).IsEqualTo(0);
         await Assert.That(observer.Errors.Count).IsEqualTo(0);
-        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Completions).IsEqualTo(0);
     }
 
     /// <summary>Verifies that disposal suppresses a task result when the factory ignores cancellation.</summary>
@@ -277,19 +274,19 @@ public async Task FromAsyncCancellableFactoryDisposalSuppressesIgnoredCancellati
     {
         TaskCompletionSource subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         TaskCompletionSource<int> complete = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> observer = new();
+        AwaitableWitness<int> observer = new();
         var subscription = Signal.FromAsync(token =>
         {
             subscribed.SetResult();
             return complete.Task;
         }).Subscribe(observer);
-        await subscribed.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        await subscribed.Task;
         subscription.Dispose();
         complete.SetResult(NinetyNine);
         await Task.Yield();
         await Assert.That(observer.Values.Count).IsEqualTo(0);
         await Assert.That(observer.Errors.Count).IsEqualTo(0);
-        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Completions).IsEqualTo(0);
     }
 
     /// <summary>Verifies that external token cancellation remains a source error while subscribed.</summary>
@@ -299,21 +296,22 @@ public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserve
     {
         using CancellationTokenSource external = new();
         TaskCompletionSource<CancellationToken> observedToken = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> observer = new();
+        AwaitableWitness<int> observer = new();
         using var subscription = Signal.FromAsync(
             async token =>
             {
                 observedToken.SetResult(token);
-                await Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds), token).ConfigureAwait(false);
+                await token.WhenCanceled().ConfigureAwait(false);
                 return One;
             },
             external.Token).Subscribe(observer);
-        await observedToken.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        await observedToken.Task;
         await external.CancelAsync();
-        await TestPolling.SpinUntil(() => observer.Errors.Count == One, TimeSpan.FromSeconds(TimeoutSeconds));
-        await Assert.That(observer.Errors[0]).IsTypeOf<TaskCanceledException>();
+        var error = await observer.FirstError;
+        await Assert.That(error).IsTypeOf<TaskCanceledException>();
+        await Assert.That(observer.Errors.Count).IsEqualTo(One);
         await Assert.That(observer.Values.Count).IsEqualTo(0);
-        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Completions).IsEqualTo(0);
     }
 
     /// <summary>Verifies that external token cancellation forwards an error even when the task ignores the linked token.</summary>
@@ -324,7 +322,7 @@ public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserve
         using CancellationTokenSource external = new();
         TaskCompletionSource subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         TaskCompletionSource<int> complete = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> observer = new();
+        AwaitableWitness<int> observer = new();
         using var subscription = Signal.FromAsync(
             token =>
             {
@@ -332,15 +330,15 @@ public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserve
                 return complete.Task;
             },
             external.Token).Subscribe(observer);
-        await subscribed.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        await subscribed.Task;
         await external.CancelAsync();
-        await TestPolling.SpinUntil(() => observer.Errors.Count == One, TimeSpan.FromSeconds(TimeoutSeconds));
+        var error = await observer.FirstError;
         complete.SetResult(NinetyNine);
         await Task.Yield();
-        await Assert.That(observer.Errors[0]).IsTypeOf<TaskCanceledException>();
+        await Assert.That(error).IsTypeOf<TaskCanceledException>();
         await Assert.That(observer.Errors.Count).IsEqualTo(One);
         await Assert.That(observer.Values.Count).IsEqualTo(0);
-        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Completions).IsEqualTo(0);
     }
 
     /// <summary>Verifies that cancellable async factories emit the successful task result and complete.</summary>
@@ -430,13 +428,11 @@ public async Task FromAsyncCancellableFactoryCanceledTasksForwardObserverErrors(
     public async Task FromAsyncCancellableFactoryPendingTasksForwardTerminalContinuations()
     {
         TaskCompletionSource<int> successfulTask = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> successful = new();
+        AwaitableWitness<int> successful = new();
         using (Signal.FromAsync(_ => successfulTask.Task).Subscribe(successful))
         {
             successfulTask.SetResult(Seven);
-            await TestPolling.SpinUntil(
-                () => successful.Completed == One,
-                TimeSpan.FromSeconds(TimeoutSeconds));
+            await successful.Completion;
         }
 
         await Assert.That(successful.Values.SequenceEqual(ExpectedSingleSeven)).IsTrue();
@@ -444,34 +440,32 @@ await TestPolling.SpinUntil(
 
         InvalidOperationException expected = new("from-async-pending-fault");
         TaskCompletionSource<int> faultedTask = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> faulted = new();
+        AwaitableWitness<int> faulted = new();
         using (Signal.FromAsync(_ => faultedTask.Task).Subscribe(faulted))
         {
             faultedTask.SetException(expected);
-            await TestPolling.SpinUntil(
-                () => faulted.Errors.Count == One,
-                TimeSpan.FromSeconds(TimeoutSeconds));
+            await faulted.FirstError;
         }
 
+        await Assert.That(faulted.Errors.Count).IsEqualTo(One);
         await Assert.That(faulted.Errors[0]).IsSameReferenceAs(expected);
         await Assert.That(faulted.Values.Count).IsEqualTo(0);
-        await Assert.That(faulted.Completed).IsEqualTo(0);
+        await Assert.That(faulted.Completions).IsEqualTo(0);
 
         using CancellationTokenSource cancellation = new();
         await cancellation.CancelAsync();
         TaskCompletionSource<int> canceledTask = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> canceled = new();
+        AwaitableWitness<int> canceled = new();
         using (Signal.FromAsync(_ => canceledTask.Task).Subscribe(canceled))
         {
             canceledTask.SetCanceled(cancellation.Token);
-            await TestPolling.SpinUntil(
-                () => canceled.Errors.Count == One,
-                TimeSpan.FromSeconds(TimeoutSeconds));
+            await canceled.FirstError;
         }
 
+        await Assert.That(canceled.Errors.Count).IsEqualTo(One);
         await Assert.That(canceled.Errors[0]).IsTypeOf<TaskCanceledException>();
         await Assert.That(canceled.Values.Count).IsEqualTo(0);
-        await Assert.That(canceled.Completed).IsEqualTo(0);
+        await Assert.That(canceled.Completions).IsEqualTo(0);
     }
 
     /// <summary>Verifies direct timeout and runner factory APIs without extension method syntax.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
index 2caec3ad..a7ac4e1e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
@@ -75,9 +75,6 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The expected error type name from the expire-timeout branch.</summary>
     private static readonly string[] ExpectedTimeoutErrors = [nameof(TimeoutException)];
 
-    /// <summary>How long a disposed subscription is given to prove it forwards nothing after disposal.</summary>
-    private static readonly TimeSpan PostDisposalSettleDelay = TimeSpan.FromMilliseconds(50);
-
     /// <summary>The expected single true value emitted by the true signal.</summary>
     private static readonly bool[] ExpectedTrueValues = [true];
 
@@ -225,10 +222,10 @@ public async Task PrimitiveShortcutBranchesCoverCancelableFallbackAndPendingTask
         _ = Assert.Throws<ArgumentNullException>(static () => ((IObservable<int>)null!).ToSignal());
 
         TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingWitness<int> pendingSignal = new();
+        AwaitableWitness<int> pendingSignal = new();
         using var pendingSubscription = pending.Task.ToSignal().Subscribe(pendingSignal);
         pending.SetResult(Three);
-        await TestPolling.SpinUntil(() => pendingSignal.Values.Count == 1, TimeSpan.FromSeconds(One));
+        await pendingSignal.ValueCountReaching(1);
         await Assert.That(pendingSignal.Values.SequenceEqual([Three])).IsTrue();
 
         RecordingWitness<int> emptySwitch = new();
@@ -519,25 +516,21 @@ public async Task TaskChainDirectSignalKeepsPendingTasksInSourceOrder()
         TaskCompletionSource<int> first = new(TaskCreationOptions.RunContinuationsAsynchronously);
         TaskCompletionSource<int> second = new(TaskCreationOptions.RunContinuationsAsynchronously);
         Signal<Task<int>> source = new();
-        RecordingWitness<int> chained = new();
+        AwaitableWitness<int> chained = new();
 
         using var subscription = source.Chain().Subscribe(chained);
         source.OnNext(first.Task);
         source.OnNext(second.Task);
         source.OnCompleted();
 
+        // The later task finishes first; forwarding it out of turn would land Two ahead of One.
         second.SetResult(Two);
-        await Task.Yield();
-        await Assert.That(chained.Values.Count).IsEqualTo(0);
-
         first.SetResult(One);
-        await TestPolling.SpinUntil(
-            () => chained.Values.Count == Two && chained.Completed == One,
-            TimeSpan.FromSeconds(One));
+        await chained.Completion;
 
         await Assert.That(chained.Values.SequenceEqual(ExpectedOneTwo)).IsTrue();
         await Assert.That(chained.Errors.Count).IsEqualTo(0);
-        await Assert.That(chained.Completed).IsEqualTo(One);
+        await Assert.That(chained.Completions).IsEqualTo(One);
     }
 
     /// <summary>Verifies direct task-chain terminal and disposal paths.</summary>
@@ -590,7 +583,7 @@ public async Task TaskChainDirectSignalHandlesErrorsAndDisposal()
             pending.SetResult(Five);
         }
 
-        await Task.Delay(PostDisposalSettleDelay);
+        await Task.Yield();
         await Assert.That(disposed.Values.Count).IsEqualTo(0);
         await Assert.That(disposed.Errors.Count).IsEqualTo(0);
         await Assert.That(disposed.Completed).IsEqualTo(0);

From 86dc5bb4f8f204ca7659f1caece98422dedf9ba6 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 21:13:34 +1000
Subject: [PATCH 02/11] refactor(tests): drive scheduling tests from state, not
 the clock

- Replace delays, polling and thread rendezvous with awaited completion
  sources, virtual clocks and ordered calls into internal seams.
- Add seams for stepwise dispatch: WasmScheduler.QueueReady and
  RunReadyBatch, so enqueue, dispose and drain are explicit steps.
- Assert per-item dispatch counts where a total was checked before.
- Trim documentation to the contract: concise summaries, inline notes at
  the confusing line, and remarks only for non-obvious behaviour.
- Correct exception docs to the type thrown rather than the guard helper.
---
 src/Primitives.Async.Shared/AsyncContext.cs   |   68 +-
 .../Mixins/AsyncContextExtensions.cs          |    4 +-
 .../Observables/FromAsync.Reactive.cs         |    7 +-
 .../Observables/ToAsyncSignal.Reactive.cs     |    6 +-
 .../Operators/ContextSwitchSignalAsync.cs     |   11 +-
 .../Operators/WitnessOn.cs                    |    6 -
 .../Operators/Yield.cs                        |   10 +-
 .../Components/ReactiveComponentBase.cs       |    6 +-
 .../InvalidOperationExceptionHelper.cs        |   15 +-
 .../Internal/ScheduledDrainState.cs           |   19 +-
 .../ObservableSubscriptionExtensions.cs       |   10 +-
 .../Operators/AsSignalObservable.cs           |    5 +-
 .../Operators/BufferUntilIdleObservable.cs    |    5 +-
 .../Operators/ConflateObservable.cs           |  106 +-
 .../Operators/ForEachObservable.cs            |    5 +-
 .../Operators/FromArrayObservable.cs          |    5 +-
 .../Operators/ObserveOnObservable.cs          |   12 +-
 .../Operators/RetryBackoffPolicy.cs           |    5 +-
 .../Operators/RunAllObservable.cs             |   28 +-
 .../Operators/ScheduledSourceObservable.cs    |   15 +-
 .../Operators/ScheduledValueObservable.cs     |   10 +-
 .../Operators/StartFuncObservable.cs          |    5 +-
 .../Operators/SyncTimerObservable.cs          |   10 +-
 .../Operators/ThrottleDistinctObservable.cs   |    6 +-
 .../Operators/ThrottleObservable.cs           |   19 +-
 .../Operators/UsingFuncObservable.cs          |    5 +-
 .../Operators/WhileObservable.cs              |    5 +-
 .../ReactiveExtensions.Retry.cs               |    5 +-
 .../ReactiveExtensions.cs                     |   11 +-
 .../CoalescingDispatchScheduler.cs            |   24 +-
 .../DispatchWorkItemBase.cs                   |   12 +-
 .../Advanced/AsyncDeferSignal{T}.cs           |    2 +-
 .../Advanced/AutoShareSignal{T}.cs            |    7 +-
 .../Advanced/CreateSafeSignal{T}.cs           |    3 +-
 .../Advanced/EventHandlerScope.cs             |    6 +-
 .../Advanced/ExpireCoordinator{T}.cs          |   23 +-
 .../ForkJoinWitness{TLeft,TRight,TResult}.cs  |    3 +-
 .../Advanced/GuardedWitness{T}.cs             |    5 +-
 .../Advanced/IsEmptySignal{T}.cs              |    5 +-
 .../Advanced/MergeCoordinator{T}.cs           |    4 +-
 .../Advanced/ResumeSignal{T}.cs               |    5 +-
 .../Advanced/SubscriptionScheduling.cs        |    9 +-
 .../SwitchMapSignal{TSource,TResult}.cs       |    8 +-
 .../Advanced/SwitchWitness{T}.cs              |    5 +-
 .../Advanced/TaskInstanceSignal{T}.cs         |    2 +-
 src/Primitives.Shared/Advanced/TimerSlot.cs   |    6 +-
 .../Concurrency/SequencerWorkItemDisposal.cs  |    6 +-
 .../Core/SparkCompositeFormats.cs             |    6 +-
 src/Primitives.Shared/Core/Spark{T}.cs        |   10 +-
 ...SignalOperatorMixins.ChooseSwitchSelect.cs |    5 +-
 .../SignalOperatorMixins.CombineLatest.cs     |    5 +-
 .../SignalOperatorMixins.Coordinators.cs      |    9 +-
 .../SignalOperatorMixins.SchedulerSignals.cs  |  215 +--
 .../SignalOperatorMixins.StatefulSignals.cs   |   12 +-
 .../SignalOperatorMixins.Switch.cs            |   45 +-
 ...alOperatorMixins.SyncLatest.MultiSource.cs |   35 +-
 ...gnalOperatorMixins.SyncLatest.WideArity.cs |   35 +-
 src/Primitives.Shared/SignalOperatorMixins.cs |    5 +-
 ...alOperatorParityMixins.AggregateHelpers.cs |    7 +-
 ...atorParityMixins.BooleanTerminalHelpers.cs |    7 +-
 .../SignalOperatorParityMixins.FlatMap.cs     |    4 +-
 .../SignalOperatorParityMixins.Helpers.cs     |    4 +-
 .../SignalOperatorParityMixins.Probe.cs       |    4 +-
 ...rityMixins.RxNames.CombineLatest.Tuples.cs |    1 -
 ...yMixins.RxNames.CombineLatest.WideArity.cs |   35 +-
 ...ratorParityMixins.RxNames.CombineLatest.cs |   35 +-
 .../SignalOperatorParityMixins.cs             |    6 +-
 .../Signals/PrioritySemaphoreSignal{T}.cs     |    9 +-
 .../Signals/ReplaySignal{T}.cs                |    8 +-
 .../Signals/SignalExtensions{Recover}.cs      |    4 +-
 .../Signals/Signal{Create}.cs                 |   20 +-
 .../Signals/Signal{FromTask}.cs               |  145 +-
 .../Signals/TaskSignal{T}.cs                  |    6 +-
 .../Signals/TaskTerminalCompletion{T}.cs      |    6 +-
 .../Disposables/DisposableSlotHelper.cs       |   46 +-
 .../Disposables/Scope.cs                      |    2 +-
 .../Advanced/AsyncSerialGate.cs               |   73 +-
 .../Advanced/FlatMapCoordinator{TResult}.cs   |   18 +-
 .../Advanced/IReentrantAsyncDisposable.cs     |    4 +-
 .../Advanced/PooledDelaySource.cs             |   14 +-
 .../Advanced/SyncLatestCoordinatorBase.cs     |    6 +-
 .../SyncLatestWitness{TSource,TResult}.cs     |    5 +-
 .../Advanced/TakeUntilSourceWitness.cs        |    5 +-
 .../Advanced/TaskSignalSubscription{T}.cs     |    5 +-
 .../Advanced/TimerSignal.cs                   |    4 +-
 .../ConcurrencyRaceHelpers.cs                 |   14 +-
 .../ConcurrentWitnessCallsException.cs        |    5 +-
 .../ConnectableSignalAsync.cs                 |    9 +-
 .../ConnectableSignalAsyncHelper.cs           |    3 +-
 .../Disposables/DisposableAsync.cs            |    5 +-
 .../Disposables/DisposableAsyncSlot.cs        |   48 +-
 .../Disposables/MultipleDisposableAsync.cs    |   25 +-
 .../SingleAssignmentDisposableAsync.cs        |    3 +-
 .../SingleReplaceableDisposableAsync.cs       |   11 +-
 .../Helpers/DisposalHelper.cs                 |    2 -
 .../Helpers/FireAndForgetHelper.cs            |   10 +-
 .../Helpers/SubscriptionHelper.cs             |    8 +-
 .../IObserverAsync.cs                         |    5 +-
 .../Mixins/DisposableAsyncExtensions.cs       |    5 +-
 .../Mixins/SignalExtensions.cs                |   15 +-
 .../Observables/Create.cs                     |   10 +-
 .../Observables/Defer.cs                      |   17 +-
 .../Observables/Empty.cs                      |    5 +-
 .../Observables/Return.cs                     |    5 +-
 .../Observables/Timer.cs                      |   19 +-
 .../Observables/ToAsyncSignal.cs              |   18 +-
 .../Operators/Blend.cs                        |   54 +-
 .../Operators/Chain.cs                        |   10 +-
 .../Operators/ChainEnumerableSignal{T}.cs     |   19 +-
 .../Operators/ChainSignalSourcesSignal{T}.cs  |   34 +-
 .../Operators/CompletionSignalDelegate.cs     |    5 +-
 .../Operators/Distinct.cs                     |   20 +-
 .../Operators/Expire.cs                       |   43 +-
 .../Operators/FirstOrDefaultAsync.cs          |   20 +-
 .../Operators/FlatMap.cs                      |    5 +-
 .../Operators/Fold.cs                         |   10 +-
 .../Operators/GroupBy.cs                      |    5 +-
 .../Operators/Keep.cs                         |   20 +-
 .../Operators/KeepType.cs                     |    5 +-
 .../Operators/LastOrDefaultAsync.cs           |   20 +-
 .../Operators/Lead.cs                         |   10 +-
 .../Operators/Multicast.cs                    |   35 +-
 .../ParityHelpers.OperatorFusions.cs          |   47 +-
 .../Operators/ParityHelpers.Partition.cs      |   10 +-
 .../Operators/ParityHelpers.cs                |    5 +-
 .../Operators/Recover.cs                      |   10 +-
 .../Operators/ReduceAsync.cs                  |   60 +-
 .../Operators/RefCount.cs                     |   15 +-
 .../Operators/Shift.cs                        |    5 +-
 .../SignalAsyncExtensions.Catch.Rx.cs         |   10 +-
 .../SignalAsyncExtensions.CombineLatest.Rx.cs |    5 +-
 .../SignalAsyncExtensions.Delay.Rx.cs         |   10 +-
 ...AsyncExtensions.DistinctUntilChanged.Rx.cs |   15 +-
 .../SignalAsyncExtensions.Scan.Rx.cs          |    5 +-
 .../SignalAsyncExtensions.SelectMany.Rx.cs    |    5 +-
 .../Operators/SingleAsync.cs                  |   25 +-
 .../Operators/SingleOrDefaultAsync.cs         |   10 +-
 .../Operators/SkipWhile.cs                    |   10 +-
 .../Operators/SubscribeAsync.cs               |   20 +-
 .../Operators/SwitchTo.cs                     |   10 +-
 .../Operators/SwitchToSignal.cs               |   30 +-
 .../Operators/SyncLatest10.cs                 |   10 +-
 .../Operators/SyncLatest11.cs                 |   10 +-
 .../Operators/SyncLatest12.cs                 |   10 +-
 .../Operators/SyncLatest13.cs                 |   10 +-
 .../Operators/SyncLatest14.cs                 |   10 +-
 .../Operators/SyncLatest15.cs                 |   10 +-
 .../Operators/SyncLatest16.cs                 |   10 +-
 .../Operators/SyncLatest3.cs                  |   10 +-
 .../Operators/SyncLatest4.cs                  |   10 +-
 .../Operators/SyncLatest5.cs                  |   10 +-
 .../Operators/SyncLatest6.cs                  |   10 +-
 .../Operators/SyncLatest7.cs                  |   10 +-
 .../Operators/SyncLatest8.cs                  |   10 +-
 .../Operators/SyncLatest9.cs                  |   10 +-
 .../Operators/SyncLatestEnumerable.cs         |   11 +-
 .../Operators/TakeUntil.cs                    |   27 +-
 .../Operators/Tap.cs                          |   10 +-
 .../Operators/Throttle.cs                     |   71 +-
 .../Operators/ToAsyncEnumerable.cs            |   15 +-
 .../Operators/ToDictionaryAsync.cs            |   14 +-
 .../Operators/ToListAsync.cs                  |    3 -
 .../Operators/Unique.cs                       |   33 +-
 .../Operators/Using.cs                        |   19 +-
 .../PublicAPI/net10.0/PublicAPI.txt           |    6 +-
 .../PublicAPI/net11.0/PublicAPI.txt           |    6 +-
 .../PublicAPI/net462/PublicAPI.txt            |    6 +-
 .../PublicAPI/net472/PublicAPI.txt            |    6 +-
 .../PublicAPI/net48/PublicAPI.txt             |    6 +-
 .../PublicAPI/net481/PublicAPI.txt            |    6 +-
 .../PublicAPI/net8.0/PublicAPI.txt            |    6 +-
 .../PublicAPI/net9.0/PublicAPI.txt            |    6 +-
 .../Signals/Base/Concurrent.cs                |   27 +-
 ...yLatestSignalAsyncStateObserverLease{T}.cs |    3 -
 .../Base/ReplayLatestSignalAsyncState{T}.cs   |    6 +-
 .../Signals/Base/SerialBroadcastHelpers.cs    |   15 +-
 ...yLatestSignalAsyncStateObserverLease{T}.cs |    3 -
 ...tatelessReplayLatestSignalAsyncState{T}.cs |    6 +-
 .../ConcurrentReplayLatestSignalAsync.cs      |    9 +-
 .../Signals/ConcurrentSignalAsync.cs          |    4 +-
 ...currentStatelessReplayLatestSignalAsync.cs |   10 +-
 .../Signals/ConcurrentStatelessSignalAsync.cs |    5 +-
 .../Signals/ISignalAsync.cs                   |   11 +-
 .../Options/BehaviorSignalCreationOptions.cs  |    2 -
 .../Signals/Options/PublishingOption.cs       |   19 +-
 .../ReplayLatestSignalCreationOptions.cs      |   12 +-
 .../Signals/Options/SignalCreationOptions.cs  |   11 +-
 .../Signals/SerialReplayLatestSignalAsync.cs  |    6 +-
 .../Signals/SerialSignalAsync.cs              |    9 +-
 .../SerialStatelessReplayLatestSignalAsync.cs |   10 +-
 .../Signals/SerialStatelessSignalAsync.cs     |    4 +-
 .../Signals/Signal.cs                         |   28 +-
 .../UnhandledExceptionHandler.cs              |    5 +-
 .../WitnessAsync.cs                           |  202 ++-
 .../SequencerSchedulingExtensions.cs          |    6 +-
 .../PublicAPI/net10.0/PublicAPI.txt           |    1 -
 .../PublicAPI/net11.0/PublicAPI.txt           |    1 -
 .../PublicAPI/net462/PublicAPI.txt            |    1 -
 .../PublicAPI/net472/PublicAPI.txt            |    1 -
 .../PublicAPI/net48/PublicAPI.txt             |    1 -
 .../PublicAPI/net481/PublicAPI.txt            |    1 -
 .../PublicAPI/net8.0/PublicAPI.txt            |    1 -
 .../PublicAPI/net9.0/PublicAPI.txt            |    1 -
 .../PublicAPI/net10.0/PublicAPI.txt           |    1 -
 .../PublicAPI/net11.0/PublicAPI.txt           |    1 -
 .../PublicAPI/net462/PublicAPI.txt            |    1 -
 .../PublicAPI/net472/PublicAPI.txt            |    1 -
 .../PublicAPI/net48/PublicAPI.txt             |    1 -
 .../PublicAPI/net481/PublicAPI.txt            |    1 -
 .../PublicAPI/net8.0/PublicAPI.txt            |    1 -
 .../PublicAPI/net9.0/PublicAPI.txt            |    1 -
 .../Concurrency/AvaloniaScheduler.cs          |    1 +
 .../PublicAPI/net10.0/PublicAPI.txt           |    1 +
 .../PublicAPI/net11.0/PublicAPI.txt           |    1 +
 .../PublicAPI/net8.0/PublicAPI.txt            |    1 +
 .../PublicAPI/net9.0/PublicAPI.txt            |    1 +
 .../Concurrency/AvaloniaScheduler.cs          |    1 +
 .../Advanced/AsyncEnumerableSignal{T}.cs      |  104 +-
 .../Advanced/BufferWitness.cs                 |    6 +-
 .../Advanced/ImmediateThrowSignal{T}.cs       |    4 +-
 .../Advanced/ImmutableEmptySignal{T}.cs       |    4 +-
 .../Advanced/SynchronizeWitness.cs            |    3 +
 .../Concurrency/ScheduledItem.cs              |    5 +-
 .../Core/CoreCompositeFormats.cs              |    7 +-
 .../Signals/AsyncSignal.cs                    |   38 +-
 .../Signals/AwaitWitness.cs                   |    8 +-
 .../Signals/BehaviorSignalState{T}.cs         |   25 +-
 .../Signals/BehaviorSignal{T}.cs              |   19 +-
 .../Signals/Broadcaster{T}.cs                 |   16 +-
 .../Signals/CommandSignal{TResult}.cs         |  168 +--
 .../Signals/KeepSignal{T}.cs                  |   10 +-
 .../Signals/KeepWithSignal{T,TState}.cs       |    5 +-
 .../Signals/MapSignal{TSource,TResult}.cs     |   10 +-
 .../Signals/ObserverHandler.cs                |    5 +-
 ...ProjectedReadOnlyState{TSource,TResult}.cs |    5 +-
 .../Signals/ReadOnlyState{T}.cs               |    2 +-
 .../Signals/Signal{T}.cs                      |   54 +-
 .../SubscribeExtensions.cs                    |    5 +-
 .../ConcurrencyLimiter.cs                     |   13 +-
 .../Continuation.cs                           |    5 +-
 .../CurrentValueSubject.cs                    |   21 +-
 .../Internal/ConcurrencyRaceHelpers.cs        |   17 +-
 .../Internal/IndexedSubscribeHelper.cs        |   15 +-
 .../Internal/ObservableSubscribeExtensions.cs |    7 +-
 .../Internal/ReduceSinkState.cs               |   12 +-
 .../Operators/BooleanReduceObservable.cs      |    6 +-
 .../CatchAndReturnWithFactoryObservable.cs    |    5 +-
 .../Operators/DoOnDisposeObservable.cs        |    6 +-
 .../Operators/DropIfBusyObservable.cs         |   61 +-
 .../Operators/FilterRegexObservable.cs        |    2 +-
 .../FirstMatchFromCandidatesObservable.cs     |   36 +-
 .../Operators/PartitionObservable.cs          |    4 +-
 .../Operators/PropertyChangedObservable.cs    |    9 +-
 .../ReplayLastOnSubscribeObservable.cs        |    6 +-
 .../SelectAsyncConcurrentObservable.cs        |   77 +-
 .../SelectAsyncSequentialObservable.cs        |   67 +-
 .../Operators/SelectConstantObservable.cs     |    5 +-
 .../Operators/SelectLatestAsyncObservable.cs  |   81 +-
 .../Operators/SelectManyThenObservable.cs     |   15 +-
 .../Operators/ShuffleObservable.cs            |   27 +-
 .../Operators/SkipWhileNullObservable.cs      |    8 +-
 .../Operators/SubscribeAsyncObservable.cs     |   19 +-
 .../Operators/SynchronizeAsyncObservable.cs   |   56 +-
 .../Operators/TakeUntilInclusiveObservable.cs |    5 +-
 .../TimerSinkState.cs                         |    8 +-
 .../ActivationExtensionsEmitter.cs            |    7 +-
 .../CodeGeneration/ActivationSource.cs        |    9 +-
 .../CodeGeneration/GeneratedNames.cs          |    8 +-
 .../CodeGeneration/PooledStringBuilder.cs     |   22 +-
 .../CodeGeneration/SourceFileWriter.cs        |    6 +-
 .../CodeGeneration/StaticEventsEmitter.cs     |    6 +-
 .../EventGenerator.cs                         |   31 +-
 .../GeneratorStepNames.cs                     |    6 +-
 .../Helpers/EventExtractor.cs                 |   40 +-
 .../Helpers/EventRequest.cs                   |    6 +-
 .../Helpers/InstanceTargetExtractor.cs        |   20 +-
 .../Helpers/LanguageSupport.cs                |   12 +-
 .../Helpers/ProviderResolver.cs               |    8 +-
 .../Helpers/StaticTargetExtractor.cs          |   21 +-
 .../Helpers/SymbolHelpers.cs                  |   42 +-
 .../Helpers/TargetCollections.cs              |    7 +-
 .../Helpers/WellKnownTypes.cs                 |    6 +-
 .../Models/ActivationModel.cs                 |    6 +-
 .../Models/DiagnosticInfo.cs                  |    7 +-
 .../Models/EquatableArray.cs                  |   21 +-
 .../Models/EventModel.cs                      |    8 +-
 .../Models/InstanceTargetModel.cs             |    6 +-
 .../Models/LocationInfo.cs                    |    7 +-
 .../Models/ObservableProvider.cs              |    6 +-
 .../Models/StaticNamespaceModel.cs            |    6 +-
 .../SequencerSchedulingExtensions.cs          |    6 +-
 .../Concurrency/WasmScheduler.cs              |  192 +--
 .../Disposables/ContainerDisposable.cs        |   26 +-
 .../LinqExtensions.ContainerDisposable.cs     |    8 +-
 .../Platforms/android/HandlerSequencer.cs     |    5 +-
 .../Platforms/apple/NSRunloopSequencer.cs     |    5 +-
 .../Concurrency/DispatcherQueueSequencer.cs   |    1 +
 .../net10.0-windows10.0.19041.0/PublicAPI.txt |    1 +
 .../net11.0-windows10.0.19041.0/PublicAPI.txt |    1 +
 .../net8.0-windows10.0.19041.0/PublicAPI.txt  |    1 +
 .../net9.0-windows10.0.19041.0/PublicAPI.txt  |    1 +
 .../Concurrency/DispatcherQueueSequencer.cs   |    3 +-
 .../Properties/AssemblyInfo.cs                |    7 +
 .../Concurrency/DispatcherSequencer.cs        |    1 +
 .../PublicAPI/net10.0-windows/PublicAPI.txt   |    1 +
 .../PublicAPI/net11.0-windows/PublicAPI.txt   |    1 +
 .../PublicAPI/net462/PublicAPI.txt            |    1 +
 .../PublicAPI/net472/PublicAPI.txt            |    1 +
 .../PublicAPI/net48/PublicAPI.txt             |    1 +
 .../PublicAPI/net481/PublicAPI.txt            |    1 +
 .../PublicAPI/net8.0-windows/PublicAPI.txt    |    1 +
 .../PublicAPI/net9.0-windows/PublicAPI.txt    |    1 +
 .../Concurrency/DispatcherSequencer.cs        |    3 +-
 .../Properties/AssemblyInfo.cs                |    7 +
 .../Advanced/DispatchSequencerState.cs        |   34 +-
 .../Concurrency/CurrentThreadSequencer.cs     |   44 +-
 .../Concurrency/ImmediateSequencer.cs         |   18 +-
 .../Concurrency/Sequencer.cs                  |   11 +-
 .../SynchronizationContextSequencer.cs        |   20 +-
 .../Concurrency/TaskPoolSequencer.cs          |   22 +-
 .../Concurrency/ThreadPoolSequencer.cs        |  120 +-
 .../Concurrency/VirtualTimeMessages.cs        |    8 +-
 .../VirtualTimeState{TAbsolute,TRelative}.cs  |    9 +-
 .../Concurrency/WasmSequencer.cs              |   96 +-
 .../Platforms/android/HandlerSequencer.cs     |    5 +-
 .../Platforms/apple/NSRunloopSequencer.cs     |    5 +-
 .../AllocationProbe.cs                        |   14 +-
 .../ConnectableMulticastBenchmarks.cs         |    5 +-
 .../FactoryStateTimerBenchmarks.cs            |    6 +-
 .../OperatorCombineLatestBenchmarks.cs        |    7 +-
 .../OperatorPassThroughBenchmarks.cs          |    5 +-
 .../OperatorStatefulVariantBenchmarks.cs      |    7 +-
 .../OperatorTakeBufferRecoverBenchmarks.cs    |    5 +-
 ...eExtensionsComparisonBenchmarks.Helpers.cs |    4 +-
 .../SmokeBenchmarkRunner.cs                   |   19 +-
 .../SmokeParityValidator.cs                   |    7 +-
 .../TerminalAsyncVariantBenchmarks.cs         |    5 +-
 .../TimerSlotBenchmarks.cs                    |    7 +-
 .../CorpusSize.cs                             |    1 -
 .../EventCorpus.cs                            |   20 +-
 .../EventGeneratorDriverBenchmarks.cs         |   28 +-
 .../EventGeneratorGcProfileBenchmarks.cs      |   12 +-
 .../GeneratorHarness.cs                       |   19 +-
 .../DisposableBagTests.cs                     |    3 +-
 .../DisposableSlotHelperTests.cs              |   37 +-
 .../SequencerSchedulingTests.cs               |   16 +-
 .../AsyncPrimitiveContractTests.cs            |   46 +-
 .../AsyncRenameCoverageTests.cs               |   78 +-
 .../AsyncSerialGateTests.cs                   |   46 +-
 .../CombineLatestArityTests.Arity10.cs        |    6 +-
 .../CombineLatestArityTests.Arity11.cs        |    6 +-
 .../CombineLatestArityTests.Arity12.cs        |    6 +-
 .../CombineLatestArityTests.Arity13.cs        |    6 +-
 .../CombineLatestArityTests.Arity14.cs        |    6 +-
 .../CombineLatestArityTests.Arity15.cs        |    6 +-
 .../CombineLatestArityTests.Arity16.cs        |    6 +-
 .../CombineLatestArityTests.Arity9.cs         |    9 +-
 ...ombineLatestArityTests.DisposedViaError.cs |   28 +-
 .../CombineLatestEnumerableInternalsTests.cs  |    9 +-
 ...CombineLatestOperatorTests.Combines4To8.cs |   20 +-
 ...neLatestOperatorTests.EnumerableInitial.cs |    8 +-
 ...mbineLatestOperatorTests.EnumerableRest.cs |   48 +-
 .../CombineLatestOperatorTests.Misc.cs        |    3 +-
 ...ombineLatestOperatorTests.PerArity2And3.cs |   20 +-
 .../CombineLatestOperatorTests.PerArity4.cs   |   16 +-
 .../CombineLatestOperatorTests.PerArity5.cs   |   20 +-
 .../CombineLatestOperatorTests.PerArity6.cs   |   24 +-
 .../CombineLatestOperatorTests.PerArity7.cs   |   28 +-
 ...eLatestOperatorTests.PerArity8Completes.cs |   16 +-
 ...bineLatestOperatorTests.PerArity8Errors.cs |   16 +-
 .../CombineLatestOperatorTests.cs             |    3 -
 .../CombiningOperatorTests.Blend.cs           |   82 +-
 ...ngOperatorTests.BlendEnumerableDisposal.cs |  174 +--
 ...biningOperatorTests.BlendSignalDisposal.cs |  166 +--
 .../CombiningOperatorTests.Chain.cs           |    9 +-
 .../CombiningOperatorTests.Multicast.cs       |    5 +-
 .../CombiningOperatorTests.OnDispose.cs       |    6 +-
 ...CombiningOperatorTests.PrependStartWith.cs |   27 +-
 .../CombiningOperatorTests.Subscribe.cs       |   16 +-
 .../CombiningOperatorTests.SwitchTo.cs        |   11 +-
 .../CombiningOperatorTests.Zip.cs             |   16 +-
 .../ConcurrentSignalBaseTests.cs              |   74 +-
 .../CustomTaskScheduler.cs                    |    3 +
 .../DirectSource.cs                           |    6 +-
 .../DisposableAsyncSlotTests.cs               |   18 +
 .../DisposableTests.SingleAssignment.cs       |   87 ++
 .../DisposableTests.cs                        |  162 +--
 .../DisposalHelperTests.cs                    |   23 +
 .../ErrorHandlingOperatorTests.cs             |   31 +-
 .../ExpireOperatorTests.cs                    |  196 +--
 .../FactorySignalTests.cs                     |   85 +-
 .../FilteringOperatorTests.cs                 |   35 +-
 .../FireAndForgetHelperTests.cs               |   50 +
 .../FlatMapCoordinatorTests.cs                |    4 +-
 .../Internals/PooledDelaySourceTests.cs       |   69 +-
 .../IntervalOperatorTests.cs                  |   42 +-
 .../ManualTimeProvider.cs                     |  113 ++
 .../ObserveOnAsyncSignalTests.cs              |   15 +-
 .../ObserverAsyncDisposeTests.cs              |  210 ++-
 .../ParityHelpersFilterFusionsTests.cs        |   37 +-
 .../ParityHelpersOperatorFusionsTests.cs      |  234 +--
 .../ParityOperatorTests.ObserveOn.cs          |  115 ++
 .../ParityOperatorTests.cs                    |  149 +-
 .../ReactiveUI.Primitives.Async.Tests.csproj  |    4 -
 ...atestSignalAsyncStateObserverLeaseTests.cs |   68 +
 .../ResultAndInfrastructureTests.Multicast.cs |   72 +-
 .../SignalTests.BehaviorAndReplay.cs          |   26 +-
 .../SignalTests.CreationOptions.cs            |    6 +-
 .../SignalTests.MappedAndConcurrent.cs        |    6 +-
 .../SignalTests.cs                            |   24 +-
 ...atestSignalAsyncStateObserverLeaseTests.cs |   83 ++
 .../SyncLatestOperatorTests.HighArity.cs      |   10 +-
 .../SyncLatestOperatorTests.LowArity.cs       |   17 +-
 .../SyncLatestOperatorTests.cs                |   18 +-
 ...keUntilOperatorTests.CompletionDelegate.cs |    4 +-
 ...akeUntilOperatorTests.DisposalAndErrors.cs |   79 +-
 .../TakeUntilOperatorTests.cs                 |   34 +-
 .../TaskSignalSubscriptionTests.cs            |   13 +-
 .../TerminalOperatorTests.ElementSelection.cs |  507 +++++++
 ...TerminalOperatorTests.OverloadShortcuts.cs |    5 +-
 .../TerminalOperatorTests.ReduceCoverage.cs   |    2 +-
 .../TerminalOperatorTests.cs                  |  503 +------
 .../TimeBasedOperatorTests.cs                 | 1251 +++++------------
 ...TransformationOperatorTests.SideEffects.cs |  205 +++
 .../TransformationOperatorTests.cs            |  286 +---
 .../UnhandledExceptionCapture.cs              |   64 +-
 .../AvaloniaSchedulerTests.cs                 |   45 +-
 .../AvaloniaSchedulerTests.cs                 |   84 +-
 .../BlazorRendererSequencerTests.cs           |    9 +-
 .../CoalescingDispatchSchedulerTests.cs       |   59 +-
 .../BlazorRendererSequencerTests.cs           |    9 +-
 .../SequencerSchedulingExtensionsTests.cs     |   13 +-
 .../ContinuationTests.cs                      |   21 +-
 .../CurrentValueSubjectTests.MultiObserver.cs |   11 +-
 .../GlobalTestSetup.cs                        |   44 -
 .../Internal/FirstAsValueTaskHelperTests.cs   |    5 +-
 ...ptionExtensionsTests.SchedulerOverloads.cs |    5 +-
 .../ObservableSubscriptionExtensionsTests.cs  |   24 +-
 .../Operators/BooleanReduceObservableTests.cs |    4 +-
 ...atchAndReturnWithFactoryObservableTests.cs |    5 +-
 .../Operators/CatchIgnoreObservableTests.cs   |    4 +-
 .../Operators/ConflateObservableTests.cs      |   31 +-
 .../Operators/DetectStaleObservableTests.cs   |    4 +-
 .../Operators/DoOnDisposeObservableTests.cs   |    3 +-
 .../Operators/DropIfBusyObservableTests.cs    |   54 +-
 .../FirstMatchFromCandidatesAsyncPathTests.cs |   33 +-
 .../Operators/ForEachObservableTests.cs       |    9 +-
 .../Operators/HeartbeatObservableTests.cs     |    4 +-
 .../Operators/MinMaxObservableTests.cs        |    4 +-
 .../Operators/ObserveOnIfObservableTests.cs   |   19 +-
 .../Operators/ObserveOnObservableTests.cs     |    8 +-
 .../OperatorAfterTerminalGuardTests.cs        |   14 +-
 ...artitionObservableTests.MultiSubscriber.cs |    4 +-
 .../Operators/PartitionObservableTests.cs     |    7 +-
 .../PropertyChangedObservableTests.cs         |   16 +-
 ...RetryAndThrottleAndFactoryOperatorTests.cs |   23 +-
 .../Operators/RunAllObservableTests.cs        |   46 +-
 .../Operators/SampleLatestObservableTests.cs  |    5 +-
 .../ScanWithInitialTests.Terminal.cs          |    2 +-
 .../Operators/ScanWithInitialTests.cs         |    7 +-
 .../ScheduledAndDebounceSyncOperatorTests.cs  |   11 +-
 .../ScheduledSourceObservableTests.cs         |    4 +-
 .../SelectAsyncConcurrentObservableTests.cs   |   54 +-
 .../SelectAsyncSequentialObservableTests.cs   |   44 +-
 .../SelectLatestAsyncObservableTests.cs       |  103 +-
 .../SelectManyThenObservableTests.cs          |    4 +-
 .../Operators/SimpleSyncOperatorTests.cs      |   52 +-
 .../Operators/StartActionObservableTests.cs   |   19 +-
 .../Operators/StartFuncObservableTests.cs     |   19 +-
 .../SubscribeAsyncObservableTests.cs          |   51 +-
 .../Operators/SyncDirectSource.cs             |    9 +-
 .../SyncOperatorErrorForwardingTests.cs       |    4 +-
 .../SynchronizeAsyncObservableTests.cs        |   31 +-
 .../ThrottleAndWaitOperatorCoverageTests.cs   |    4 +-
 .../ThrottleDistinctObservableTests.cs        |   29 +-
 .../Operators/ThrottleFirstObservableTests.cs |    4 +-
 .../Operators/ThrottleObservableTests.cs      |   32 +-
 .../ThrottleUntilTrueObservableTests.cs       |   13 +-
 ...gActionObservableTests.SecondaryDispose.cs |   10 +-
 .../Operators/UsingActionObservableTests.cs   |   32 +-
 .../UsingAndSwitchIfEmptyEdgeTests.cs         |   26 +-
 .../Operators/UsingFuncObservableTests.cs     |    9 +-
 .../Operators/WhileObservableTests.cs         |   12 +-
 .../ReactiveExtensionsPortedTests.cs          |    3 +-
 .../ReactiveExtensionsTests.FusedSelect.cs    |    6 +-
 .../ReactiveExtensionsTests.Misc.cs           |   31 +-
 .../ReactiveExtensionsTests.Retry.cs          |  196 +--
 .../ReactiveExtensionsTests.Scheduling.cs     |   65 +-
 .../ReactiveExtensionsTests.SelectAsync.cs    |   36 +-
 .../ReactiveExtensionsTests.Synchronize.cs    |   69 +-
 .../ReactiveExtensionsTests.Throttle.cs       |   43 +-
 .../ReactiveExtensionsTests.cs                |   15 +-
 ...ctiveUI.Primitives.Extensions.Tests.csproj |    4 -
 .../MauiDispatcherSequencerTests.cs           |    2 +-
 .../MauiDispatcherSequencerTests.cs           |    8 +-
 .../EventGeneratorTests.Incremental.cs        |   31 +-
 .../EventGeneratorTests.Nullability.cs        |   11 +-
 .../EventGeneratorTests.StaticRequests.cs     |    5 -
 .../EventGeneratorTests.cs                    |    2 +-
 .../DispatchWorkItemBaseTests.cs              |    6 +-
 .../LinqExtensionsTests.cs                    |    6 +-
 ...ncerSchedulingExtensionsTests.Overloads.cs |   12 +-
 .../WasmSchedulerTests.cs                     |  222 ++-
 .../AsyncEnumerableSignalTests.cs             |   67 +-
 .../AsyncSignalTests.cs                       |  128 +-
 ...rSignalTests.cs => BehaviorSignalTests.cs} |   41 +-
 .../ChooseSwitchSelectTests.cs                |    7 +-
 .../CommandExecutionTests.cs                  |   17 +-
 .../CommandSignalTests.Results.cs             |   60 +
 .../CommandSignalTests.cs                     |  164 +--
 .../Common/AwaitableWitness.cs                |   41 +-
 .../Common/CancellationTokenExtensions.cs     |   28 +-
 .../Common/FirstInlineSequencer.cs            |   12 +-
 .../Common/ManualSequencer.cs                 |    6 +-
 .../Common/ManualTaskScheduler.cs             |   30 +
 .../Common/ManualThreadPool.cs                |   49 +
 .../Common/OrderingWitness.cs                 |    6 +-
 .../Common/TaskNotificationObserver.cs        |   41 +
 .../Common/TestPolling.cs                     |   33 -
 .../ConcurencyTests.cs                        |  153 --
 .../ConnectableSignalTests.cs                 |   56 +-
 ...ests.cs => DispatchSequencerStateTests.cs} |   86 +-
 .../DisposableTests.cs                        |   10 +-
 .../EverySignalTests.cs                       |  262 +---
 .../ExpireCoordinatorTests.cs                 |   19 +-
 .../FromAsyncTaskObservationTests.cs          |   79 ++
 .../LoopSignalTests.cs                        |   20 +-
 .../MergeCoordinatorTests.cs                  |   33 +
 .../OnErrorResumeNextSignalTests.cs           |    2 +-
 .../PrioritySemaphoreSignalTests.cs           |  385 ++---
 .../ReactiveUI.Primitives.Tests.csproj        |    4 -
 .../ReplaySignalTests.cs                      |   68 +-
 .../RxNamesTests.DynamicDataCompatibility.cs  |    1 -
 .../RxNamesTests.Helpers.cs                   |   10 +-
 .../RxNamesTests.Scheduling.cs                |   82 ++
 .../RxNamesTests.cs                           |   81 +-
 .../SafeWitnessTests.cs                       |    7 +-
 .../ScheduledSignalTests.cs                   |   42 +-
 .../SequencerTests.Cancellation.cs            |  113 ++
 .../SequencerTests.Pools.cs                   |  224 ++-
 .../SequencerTests.VirtualTime.cs             |    5 +-
 .../SequencerTests.WorkItems.cs               |   84 +-
 .../SequencerTests.cs                         |  130 +-
 .../SignalCreateTests.cs                      |   37 +-
 .../SignalDeferTests.cs                       |   11 +-
 .../SignalFactoriesTests.Behavior.cs          |    4 +-
 .../SignalFactoriesTests.Composition.cs       |    6 +-
 .../SignalFactoriesTests.DefaultSequencer.cs  |   41 +-
 .../SignalFactoriesTests.Scheduling.cs        |   15 +-
 .../SignalFactoriesTests.cs                   |   43 +-
 .../SignalFromTaskTest.cs                     | 1218 ----------------
 .../SignalOperatorMixinsTests.Advanced.cs     |    7 +-
 .../SignalOperatorMixinsTests.Behavior.cs     |    6 +-
 .../SignalOperatorMixinsTests.Delay.cs        |   90 +-
 ...SignalOperatorMixinsTests.Deterministic.cs |  313 +----
 ...lOperatorMixinsTests.PostTerminalGuards.cs |    9 +-
 .../SignalOperatorMixinsTests.Scheduling.cs   |  281 ++++
 .../SignalOperatorMixinsTests.cs              |   13 +-
 ...torParityMixinsTests.PostTerminalGuards.cs |    7 +-
 ...overageTests.cs => SignalTests.Aliases.cs} |   19 +-
 .../SignalTests.cs                            |    9 +-
 .../SinkObserverTests.cs                      |   13 +-
 .../StateSignalTests.cs                       |    9 +-
 ...ts.cs => SwitchWitnessTests.Generation.cs} |   62 +-
 .../SwitchWitnessTests.cs                     |  131 +-
 .../SyncLatestTests.cs                        |    6 +-
 ...izeTests.cs => SynchronizeWitnessTests.cs} |  172 +--
 .../TaskInstanceSignalTests.cs                |   85 ++
 .../TaskPoolSequencerTests.cs                 |  114 ++
 .../TaskSignalTests.FromTask.cs               |  239 ++++
 .../TaskSignalTests.Lifecycle.cs              |  162 +++
 .../TaskSignalTests.Observation.cs            |  194 +++
 .../TaskSignalTests.cs                        |    5 +-
 .../WasmSequencerTests.cs                     |  236 ++--
 .../WitnessTests.Helpers.cs                   |  155 ++
 .../WitnessTests.cs                           |  198 +--
 .../ControlSequencerTests.cs                  |   17 +-
 .../ControlSequencerTests.cs                  |   17 +-
 .../DispatcherQueueSequencerTests.cs          |   40 +-
 .../DispatcherQueueSequencerTests.cs          |   52 +-
 .../DispatcherSequencerTests.cs               |   26 +-
 .../DispatcherSequencerTests.cs               |   38 +-
 src/tests/Shared/AsyncTestHelpers.cs          |  130 --
 583 files changed, 8191 insertions(+), 12175 deletions(-)
 create mode 100644 src/ReactiveUI.Primitives.WinUI/Properties/AssemblyInfo.cs
 create mode 100644 src/ReactiveUI.Primitives.Wpf/Properties/AssemblyInfo.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.SingleAssignment.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/DisposalHelperTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/FireAndForgetHelperTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ManualTimeProvider.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.ObserveOn.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ReplayLatestSignalAsyncStateObserverLeaseTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/StatelessReplayLatestSignalAsyncStateObserverLeaseTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ElementSelection.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.SideEffects.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs
 rename src/tests/ReactiveUI.Primitives.Tests/{BehaviourSignalTests.cs => BehaviorSignalTests.cs} (89%)
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.Results.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/ManualTaskScheduler.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/ManualThreadPool.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/TaskNotificationObserver.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Tests/Common/TestPolling.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Tests/ConcurencyTests.cs
 rename src/tests/ReactiveUI.Primitives.Tests/{DispatchSequencerBaseTests.cs => DispatchSequencerStateTests.cs} (87%)
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/MergeCoordinatorTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
 rename src/tests/ReactiveUI.Primitives.Tests/{SignalAliasCoverageTests.cs => SignalTests.Aliases.cs} (93%)
 rename src/tests/ReactiveUI.Primitives.Tests/{GenerationSafetyTests.cs => SwitchWitnessTests.Generation.cs} (64%)
 rename src/tests/ReactiveUI.Primitives.Tests/{SynchronizeTests.cs => SynchronizeWitnessTests.cs} (67%)
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TaskInstanceSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Lifecycle.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Observation.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/WitnessTests.Helpers.cs
 delete mode 100644 src/tests/Shared/AsyncTestHelpers.cs

diff --git a/src/Primitives.Async.Shared/AsyncContext.cs b/src/Primitives.Async.Shared/AsyncContext.cs
index f18d77a0..67bc92bb 100644
--- a/src/Primitives.Async.Shared/AsyncContext.cs
+++ b/src/Primitives.Async.Shared/AsyncContext.cs
@@ -12,15 +12,8 @@ namespace ReactiveUI.Primitives.Async.Reactive;
 namespace ReactiveUI.Primitives.Async;
 #endif
 
-/// <summary>
-/// Represents an asynchronous execution context that encapsulates a specific SynchronizationContext or TaskScheduler
-/// for controlling the scheduling of asynchronous operations.
-/// </summary>
-/// <remarks>Use AsyncContext to capture and restore a particular synchronization or task scheduling environment
-/// when running asynchronous code. This is useful for ensuring that continuations or asynchronous callbacks execute on
-/// a desired context, such as a UI thread or a custom scheduler. An AsyncContext can be created from a
-/// SynchronizationContext, TaskScheduler, or ISequencer. The Default context represents the absence of a specific
-/// synchronization or scheduling context, and typically corresponds to the default task scheduler.</remarks>
+/// <summary>Represents an asynchronous execution context that encapsulates a specific SynchronizationContext or TaskScheduler for controlling the scheduling of asynchronous operations.</summary>
+/// <remarks>Contexts wrap a synchronization context, task scheduler, or sequencer. Default uses the default task scheduler.</remarks>
 [System.Diagnostics.DebuggerDisplay(
 "AsyncContext: SynchronizationContext = {SynchronizationContext}, TaskScheduler = {TaskScheduler}, Sequencer = {Sequencer}")]
 public sealed record AsyncContext
@@ -31,15 +24,10 @@ private AsyncContext()
     }
 
     /// <summary>Gets the default instance of the AsyncContext class.</summary>
-    /// <remarks>Use this property to access a shared, default AsyncContext instance when a custom context is
-    /// not required.</remarks>
     public static AsyncContext Default { get; } = new();
 
     /// <summary>Gets the synchronization context to use for marshaling callbacks and continuations.</summary>
-    /// <remarks>If this property is set, callbacks and continuations will be posted to the specified
-    /// synchronization context. If null, the default context is used, which may result in execution on a thread pool
-    /// thread. This property is typically used to ensure that asynchronous operations resume on a specific thread or
-    /// context, such as a UI thread.</remarks>
+    /// <remarks>A specified synchronization context receives posted continuations; otherwise the task scheduler determines execution.</remarks>
     public SynchronizationContext? SynchronizationContext { get; init; }
 
     /// <summary>Gets the task scheduler to use for scheduling tasks, or null to use the default scheduler.</summary>
@@ -57,9 +45,6 @@ private AsyncContext()
     /// <param name="synchronizationContext">The SynchronizationContext to associate with the AsyncContext. Cannot be null.</param>
     /// <returns>An AsyncContext instance configured to use the provided SynchronizationContext.</returns>
     /// <exception cref="ArgumentNullException">Thrown if synchronizationContext is null.</exception>
-    /// <remarks>The returned AsyncContext will have its TaskScheduler property set to null. Use this method
-    /// when you want to control asynchronous execution using a specific SynchronizationContext, such as for UI thread
-    /// synchronization.</remarks>
     public static AsyncContext From(SynchronizationContext synchronizationContext)
     {
         ArgumentExceptionHelper.ThrowIfNull(synchronizationContext);
@@ -98,12 +83,6 @@ public static AsyncContext From(ISequencer scheduler)
     /// <returns>An <see cref="AsyncContext"/> representing the current asynchronous context. If a <see
     /// cref="SynchronizationContext"/> is present, it is used; otherwise, the current <see cref="TaskScheduler"/> is
     /// used.</returns>
-    /// <remarks>
-    /// Use this method to capture the context for scheduling asynchronous operations that should continue on the same
-    /// logical thread or synchronization context. Coverage excludes this method because both inputs are ambient thread
-    /// state and cannot be changed safely by parallel tests.
-    /// </remarks>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static AsyncContext GetCurrent()
     {
         var currentSc = SynchronizationContext.Current;
@@ -118,19 +97,12 @@ public static AsyncContext GetCurrent()
     public AsyncContextSwitcherAwaitable SwitchContextAsync(bool forceYielding, CancellationToken cancellationToken) =>
         new(this, forceYielding, cancellationToken);
 
-    /// <summary>
-    /// Provides an awaitable that switches execution to a specified asynchronous context, optionally forcing a yield
-    /// and supporting cancellation.
-    /// </summary>
+    /// <summary>Provides an awaitable that switches execution to a specified asynchronous context, optionally forcing a yield and supporting cancellation.</summary>
     /// <param name="AsyncContext">The asynchronous context to which execution should be switched when awaited.</param>
     /// <param name="ForceYielding">true to always yield execution even if already in the target context; otherwise, false to avoid yielding if
     /// already in the specified context.</param>
     /// <param name="CancellationToken">A cancellation token that can be used to cancel the await operation before the continuation is scheduled.</param>
-    /// <remarks>Use this struct to ensure that code after an await resumes on a specific asynchronous
-    /// context, such as a particular SynchronizationContext or TaskScheduler. If cancellation is requested before the
-    /// continuation is scheduled, the continuation is invoked immediately and an OperationCanceledException will be
-    /// thrown when GetResult is called. This type is intended for advanced scenarios where precise control over
-    /// asynchronous context switching is required.</remarks>
+    /// <remarks>Cancellation invokes the continuation immediately; GetResult then throws OperationCanceledException.</remarks>
     [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
     public readonly record struct AsyncContextSwitcherAwaitable(
         AsyncContext AsyncContext,
@@ -140,26 +112,18 @@ public readonly record struct AsyncContextSwitcherAwaitable(
         /// <summary>Gets a value indicating whether the asynchronous operation has completed in the current context.</summary>
         public bool IsCompleted => !ForceYielding && AsyncContext.IsSameAsCurrentAsyncContext();
 
-        /// <summary>Checks whether the associated cancellation token has had cancellation requested and throws an exception if so.</summary>
-        /// <remarks>This method is typically used to observe cancellation requests and respond by
-        /// throwing an OperationCanceledException if cancellation has been signaled. If cancellation has not been
-        /// requested, the method returns normally.</remarks>
+        /// <summary>Throws if cancellation was requested.</summary>
+        /// <exception cref="OperationCanceledException">Cancellation was requested.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void GetResult() => CancellationToken.ThrowIfCancellationRequested();
 
-        /// <summary>
-        /// Returns an awaiter for this AsyncContextSwitcherAwaitable instance, enabling use of the await keyword to
-        /// asynchronously switch execution context.
-        /// </summary>
+        /// <summary>Returns an awaiter for this AsyncContextSwitcherAwaitable instance, enabling use of the await keyword to asynchronously switch execution context.</summary>
         /// <returns>An awaiter that can be used to await this instance and perform an asynchronous context switch.</returns>
         public AsyncContextSwitcherAwaitable GetAwaiter() => this;
 
         /// <summary>Schedules the specified continuation action to be invoked when the operation has completed.</summary>
         /// <param name="continuation">The action to execute when the operation is complete. Cannot be null.</param>
-        /// <remarks>If a synchronization context is available, the continuation is posted to it;
-        /// otherwise, the continuation is scheduled on the associated task scheduler or the default task scheduler. If
-        /// the operation has already been canceled, the continuation is invoked immediately on the current
-        /// thread.</remarks>
+        /// <remarks>Continuations use the synchronization context or task scheduler; cancellation invokes them immediately on the current thread.</remarks>
         public void OnCompleted(Action continuation)
         {
             ArgumentExceptionHelper.ThrowIfNull(continuation);
@@ -195,9 +159,7 @@ public void OnCompleted(Action continuation)
                 return;
             }
 
-            // Fast path for the default scheduler: bypass Task.Factory.StartNew (which allocates a
-            // Task per call) and queue the continuation directly to the threadpool. This is the
-            // path Yield takes by default, so the saving lands on the operator's hot path.
+            // Queue directly to avoid allocating a Task for each continuation.
             if (ts is null || ts == TaskScheduler.Default)
             {
                 _ = ThreadPool.UnsafeQueueUserWorkItem(static c => ((Action)c!).Invoke(), continuation);
@@ -214,12 +176,8 @@ private sealed class ContinuationWorkItem(Action continuation) : IWorkItem
         }
     }
 
-    /// <summary>Provides a custom TaskScheduler that schedules tasks using the specified IScheduler.</summary>
+    /// <summary>Routes task execution through the supplied sequencer.</summary>
     /// <param name="scheduler">The ISequencer used to schedule and execute tasks. Cannot be null.</param>
-    /// <remarks>This TaskScheduler enables integration of Task-based asynchronous code with reactive or
-    /// custom scheduling strategies by delegating task execution to the provided ISequencer. Tasks scheduled through
-    /// this TaskScheduler will be executed according to the policies of the specified ISequencer. This class is
-    /// intended for advanced scenarios where control over task scheduling is required.</remarks>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Performance",
         "CA1812:Avoid uninstantiated internal classes",
@@ -230,12 +188,12 @@ internal sealed class SequencerTaskScheduler(ISequencer scheduler) : TaskSchedul
         /// <summary>Gets the sequencer used by this task-scheduler adapter.</summary>
         internal ISequencer Sequencer => scheduler;
 
-        /// <summary>Internal accessor for the protected <see cref="GetScheduledTasks"/> override; used only by the test assembly.</summary>
+        /// <summary>Returns the adapter's scheduled-task enumeration.</summary>
         /// <returns>The result of the protected <see cref="GetScheduledTasks"/> implementation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal IEnumerable<Task>? GetScheduledTasksForTesting() => GetScheduledTasks();
 
-        /// <summary>Internal accessor for the protected <see cref="TryExecuteTaskInline"/> override; used only by the test assembly.</summary>
+        /// <summary>Attempts inline execution through the adapter.</summary>
         /// <param name="task">The task to attempt to execute inline.</param>
         /// <param name="taskWasPreviouslyQueued">Whether the task was previously queued.</param>
         /// <returns>The result of the protected <see cref="TryExecuteTaskInline"/> implementation.</returns>
diff --git a/src/Primitives.Async.Shared/Mixins/AsyncContextExtensions.cs b/src/Primitives.Async.Shared/Mixins/AsyncContextExtensions.cs
index 4d83c7cc..3ea4d942 100644
--- a/src/Primitives.Async.Shared/Mixins/AsyncContextExtensions.cs
+++ b/src/Primitives.Async.Shared/Mixins/AsyncContextExtensions.cs
@@ -18,9 +18,7 @@ public static class AsyncContextExtensions
         /// <summary>Determines whether the specified <see cref="AsyncContext"/> represents the current asynchronous context.</summary>
         /// <returns><see langword="true"/> if the specified <see cref="AsyncContext"/> matches the current <see
         /// cref="SynchronizationContext"/> or <see cref="TaskScheduler"/>; otherwise, <see langword="false"/>.</returns>
-        /// <remarks>This method compares the <see cref="SynchronizationContext"/>, <see cref="TaskScheduler"/>, or sequencer adapter
-        /// of the provided <see cref="AsyncContext"/> with the current context to determine equivalence. Use this method to
-        /// check if code is executing within the intended asynchronous environment.</remarks>
+        /// <remarks>A sequencer matches only when the current task scheduler wraps that same sequencer instance.</remarks>
         public bool IsSameAsCurrentAsyncContext()
         {
             ArgumentExceptionHelper.ThrowIfNull(context);
diff --git a/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs b/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
index fdfc2444..9fcba034 100644
--- a/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
+++ b/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
@@ -24,10 +24,7 @@ public static partial class SignalAsyncReactiveExtensions
     /// to cancel the operation.</param>
     extension(Func<CancellationToken, ValueTask> factory)
     {
-        /// <summary>
-        /// Creates an asynchronous observable sequence that executes the specified factory function and signals completion
-        /// when the operation finishes.
-        /// </summary>
+        /// <summary>Creates an asynchronous observable sequence that executes the specified factory function and signals completion when the operation finishes.</summary>
         /// <returns>An observable sequence that emits a single value of <see cref="RxVoid"/> when the factory function completes,
         /// followed by a completion notification.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="factory"/> is <see langword="null"/>.</exception>
@@ -37,7 +34,7 @@ public static partial class SignalAsyncReactiveExtensions
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "Names the asynchronous observable factory.")]
         public IObservableAsync<RxVoid> FromAsync()
         {
             ArgumentExceptionHelper.ThrowIfNull(factory);
diff --git a/src/Primitives.Async.Shared/Observables/ToAsyncSignal.Reactive.cs b/src/Primitives.Async.Shared/Observables/ToAsyncSignal.Reactive.cs
index 2905cb29..dce487a3 100644
--- a/src/Primitives.Async.Shared/Observables/ToAsyncSignal.Reactive.cs
+++ b/src/Primitives.Async.Shared/Observables/ToAsyncSignal.Reactive.cs
@@ -27,14 +27,12 @@ public static partial class SignalAsyncReactiveExtensions
         /// <summary>Converts the specified task into an asynchronous observable sequence that signals completion when the task finishes.</summary>
         /// <returns>An asynchronous observable sequence that emits a single value when the task completes successfully, followed by
         /// a completion notification.</returns>
-        /// <remarks>The returned observable emits a single unit value upon task completion and then signals
-        /// completion. If the task is canceled or fails, the observable will propagate the corresponding error. This method
-        /// is useful for integrating task-based operations into observable workflows.</remarks>
+        /// <remarks>Task failure or cancellation terminates the sequence with the corresponding error.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
-            Justification = "This is an existing method")]
+            Justification = "Names the asynchronous observable conversion.")]
         public IObservableAsync<RxVoid> ToAsyncSignal() => new TaskToAsyncSignal(task);
     }
 }
diff --git a/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs b/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
index b102a816..39136346 100644
--- a/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
+++ b/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
@@ -34,9 +34,7 @@ internal sealed class ContextSwitchWitness(
         AsyncContext asyncContext,
         bool forceYielding) : WitnessAsync<T>
     {
-        /// <summary>Slow path: switch to the target context then forward the value.
-        /// Exposed as <see langword="internal"/> so tests can invoke the slow-path body
-        /// directly without needing to race the current-context check.</summary>
+        /// <summary>Switches to the target context before forwarding the value.</summary>
         /// <param name = "value">The value to forward.</param>
         /// <param name = "cancellationToken">The cancellation token.</param>
         /// <returns>A task that completes after the context switch and downstream forward.</returns>
@@ -46,7 +44,7 @@ internal async ValueTask ForwardAfterContextSwitchAsync(T value, CancellationTok
             await observer.OnNextAsync(value, cancellationToken).ConfigureAwait(false);
         }
 
-        /// <summary>Slow path: switch to the target context then forward the error. Exposed as <see langword="internal"/> for direct unit testing.</summary>
+        /// <summary>Switches to the target context before forwarding the error.</summary>
         /// <param name = "error">The error to forward.</param>
         /// <param name = "cancellationToken">The cancellation token.</param>
         /// <returns>A task that completes after the context switch and downstream forward.</returns>
@@ -58,7 +56,7 @@ internal async ValueTask ForwardErrorAfterContextSwitchAsync(
             await observer.OnErrorResumeAsync(error, cancellationToken).ConfigureAwait(false);
         }
 
-        /// <summary>Slow path: switch to the target context then forward completion. Exposed as <see langword="internal"/> for direct unit testing.</summary>
+        /// <summary>Switches to the target context before forwarding completion.</summary>
         /// <param name = "result">The completion result.</param>
         /// <returns>A task that completes after the context switch and downstream forward.</returns>
         internal async ValueTask ForwardCompletionAfterContextSwitchAsync(Result result)
@@ -69,8 +67,7 @@ internal async ValueTask ForwardCompletionAfterContextSwitchAsync(Result result)
 
         /// <inheritdoc/>
         protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken) =>
-            // Fast path: already on the target context and no forced yield — skip the awaitable
-            // dance entirely and forward synchronously.
+            // A matching context needs no switch unless yielding is forced.
             !forceYielding && asyncContext.IsSameAsCurrentAsyncContext()
                 ? observer.OnNextAsync(value, cancellationToken)
                 : ForwardAfterContextSwitchAsync(value, cancellationToken);
diff --git a/src/Primitives.Async.Shared/Operators/WitnessOn.cs b/src/Primitives.Async.Shared/Operators/WitnessOn.cs
index ca885dce..32d900fc 100644
--- a/src/Primitives.Async.Shared/Operators/WitnessOn.cs
+++ b/src/Primitives.Async.Shared/Operators/WitnessOn.cs
@@ -15,9 +15,6 @@ namespace ReactiveUI.Primitives.Async;
 #endif
 
 /// <summary>Provides extension methods for controlling the execution context of asynchronous observable sequences.</summary>
-/// <remarks>The methods in this class allow you to specify the context on which observer callbacks are invoked
-/// for an asynchronous observable sequence. This is useful for ensuring that notifications are delivered on a
-/// particular synchronization or task context, such as a UI thread or a custom scheduler.</remarks>
 public static partial class SignalAsyncReactiveExtensions
 {
     /// <summary>Context-switching operators that control where observer callbacks are invoked for an observable source sequence.</summary>
@@ -79,9 +76,6 @@ public IObservableAsync<T> WitnessOn(TaskScheduler taskScheduler) =>
         /// <param name="scheduler">The scheduler on which to observe and deliver notifications to observers. Cannot be null.</param>
         /// <param name="forceYielding">true to force yielding to the scheduler even if already on the target context; otherwise, false.</param>
         /// <returns>An observable sequence whose notifications are delivered on the specified scheduler.</returns>
-        /// <remarks>Use this method to control the context (such as a UI thread or a specific task
-        /// scheduler) on which observers receive notifications. This is useful for ensuring thread safety or updating
-        /// UI elements from observable sequences.</remarks>
         public IObservableAsync<T> WitnessOn(ISequencer scheduler, bool forceYielding)
         {
             var asyncContext = AsyncContext.From(scheduler);
diff --git a/src/Primitives.Async.Shared/Operators/Yield.cs b/src/Primitives.Async.Shared/Operators/Yield.cs
index 109dff9b..f0a0ccd8 100644
--- a/src/Primitives.Async.Shared/Operators/Yield.cs
+++ b/src/Primitives.Async.Shared/Operators/Yield.cs
@@ -8,9 +8,6 @@ namespace ReactiveUI.Primitives.Async.Reactive;
 namespace ReactiveUI.Primitives.Async;
 #endif
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observables, enabling advanced composition and control over asynchronous data streams. These methods are intended
-/// for use with types that implement asynchronous observer patterns.</remarks>
 public static partial class SignalAsyncReactiveExtensions
 {
     /// <summary>Scheduler-yielding operators for an observable source sequence.</summary>
@@ -18,14 +15,9 @@ public static partial class SignalAsyncReactiveExtensions
     /// <param name = "source">The source observable sequence to yield from.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns an observable sequence that yields control to the current thread's scheduler before emitting items from
-        /// the source sequence.
-        /// </summary>
+        /// <summary>Returns an observable sequence that yields control to the current thread's scheduler before emitting items from the source sequence.</summary>
         /// <returns>An observable sequence that emits the same elements as the source, but yields control to the scheduler before
         /// each emission.</returns>
-        /// <remarks>This method can be used to ensure that the source sequence's emissions are scheduled
-        /// asynchronously, which may help avoid stack overflows or improve responsiveness in certain scenarios.</remarks>
         public IObservableAsync<T> Yield()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
index 9e168449..039ab19e 100644
--- a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
+++ b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
@@ -159,11 +159,7 @@ protected virtual void Dispose(bool disposing)
         _subscriptions.Dispose();
     }
 
-    /// <summary>
-    /// Runs a callback through the renderer and routes failures into Blazor's error handling
-    /// (<see cref="ComponentBase.DispatchExceptionAsync(Exception)"/>) so error boundaries observe them
-    /// instead of the fault being lost with the discarded task.
-    /// </summary>
+    /// <summary>Runs a renderer callback and forwards failures to Blazor error boundaries.</summary>
     /// <param name="callback">Callback to run on the renderer dispatcher.</param>
     /// <returns>A task that completes when the callback (or its failure dispatch) has finished.</returns>
     private async Task InvokeGuardedAsync(Action callback)
diff --git a/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs b/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
index 11581b65..74c18522 100644
--- a/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
+++ b/src/Primitives.Extensions.Shared/Internal/InvalidOperationExceptionHelper.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Throws <see cref="InvalidOperationException"/> when constructor-supplied operator state is missing at the
-/// point it is consumed, naming the captured member and the calling member in the message.
-/// </summary>
+/// <summary>Rejects missing operator state with the member and operation names.</summary>
 [ExcludeFromCodeCoverage]
 internal static class InvalidOperationExceptionHelper
 {
@@ -34,10 +31,7 @@ internal static void ThrowIfNull(
             $"'{memberName}' was not supplied to '{operation}'.");
     }
 
-    /// <summary>
-    /// Returns <paramref name="argument"/> when non-null and otherwise throws, shaped for use in a primary
-    /// constructor initializer.
-    /// </summary>
+    /// <summary>Returns the argument or throws if it is null.</summary>
     /// <typeparam name="T">The type of the argument.</typeparam>
     /// <param name="argument">The argument to validate.</param>
     /// <param name="memberName">The validated argument's name, captured from the <paramref name="argument"/> expression.</param>
@@ -60,10 +54,7 @@ internal static T Check<T>(
             $"'{memberName}' was not supplied to '{operation}'.");
     }
 
-    /// <summary>
-    /// Returns <paramref name="argument"/> when it is neither null nor empty and otherwise throws, shaped for use
-    /// in a primary constructor initializer.
-    /// </summary>
+    /// <summary>Returns the argument or throws if it is null or empty.</summary>
     /// <param name="argument">The argument to validate.</param>
     /// <param name="memberName">The validated argument's name, captured from the <paramref name="argument"/> expression.</param>
     /// <param name="operation">The calling member's name.</param>
diff --git a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
index 7271810a..c6dd7137 100644
--- a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
+++ b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
@@ -11,12 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Internal;
 namespace ReactiveUI.Primitives.Extensions.Internal;
 #endif
 
-/// <summary>
-/// Queue-and-single-drain marshaller composed by the synchronous scheduler-marshalling operator sinks
-/// (<c>ObserveOn</c>, <c>Conflate</c>): notifications are enqueued under the sink's gate and one drain pass is
-/// scheduled per burst rather than one scheduled action per item. The drain callback is capture-free, taking
-/// the sink through as an <see cref="IDrainTarget"/>.
-/// </summary>
+/// <summary>Queues notifications under the sink's gate and schedules one drain per burst.</summary>
 /// <typeparam name="T">The element type carried by <see cref="DrainNotificationKind.Next"/> notifications.</typeparam>
 /// <param name="scheduler">The scheduler each drain pass runs on.</param>
 /// <param name="target">The sink whose <see cref="IDrainTarget.Drain"/> the scheduled pass invokes.</param>
@@ -90,7 +85,7 @@ internal bool TryDequeue(out Notification notification)
         }
     }
 
-    /// <summary>Marks the sink terminated and drops any still-queued notifications. Locks the gate.</summary>
+    /// <summary>Marks the sink done, clears queued notifications, and returns its upstream handle; the caller must hold the gate.</summary>
     internal void Terminate()
     {
         lock (_gate)
@@ -100,12 +95,10 @@ internal void Terminate()
         }
     }
 
-    /// <summary>Marks the sink terminated without clearing the queue. Caller must hold the gate;
-    /// the still-queued notifications are abandoned because <see cref="TryDequeue"/> checks the done flag first.</summary>
+    /// <summary>Marks the sink done, clears queued notifications, and returns its upstream handle; the caller must hold the gate.</summary>
     internal void MarkDoneLocked() => _done = true;
 
-    /// <summary>Begins disposal under the gate, returning the upstream subscription so the caller disposes it
-    /// outside the gate, or <see langword="null"/> when the sink has terminated.</summary>
+    /// <summary>Begins disposal under the gate, returning the upstream subscription so the caller disposes it outside the gate, or <see langword="null"/> when the sink has terminated.</summary>
     /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
     internal IDisposable? BeginDispose()
     {
@@ -115,9 +108,7 @@ internal void Terminate()
         }
     }
 
-    /// <summary>Marks the sink done, clears the queue, and returns the upstream subscription for disposal outside
-    /// the gate. Caller must hold the gate and have confirmed <see cref="Done"/> is <see langword="false"/>, which
-    /// lets it retire its own scheduled-work slot atomically with the done transition.</summary>
+    /// <summary>Marks the sink done, clears queued notifications, and returns its upstream handle; the caller must hold the gate.</summary>
     /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
     internal IDisposable? BeginDisposeLocked()
     {
diff --git a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
index 48ea0223..071cfb63 100644
--- a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
@@ -11,10 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive;
 namespace ReactiveUI.Primitives.Extensions;
 #endif
 
-/// <summary>
-/// Provides extension methods that subscribe to a sequence and block the calling thread until it produces a
-/// value or terminates, returning the emitted value or the captured error.
-/// </summary>
+/// <summary>Provides extension methods that subscribe to a sequence and block the calling thread until it produces a value or terminates, returning the emitted value or the captured error.</summary>
 public static class ObservableSubscriptionExtensions
 {
     /// <summary>The default timeout used by the <c>WaitFor*</c> helpers when no override is supplied.</summary>
@@ -238,10 +235,7 @@ private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer
         return sink.Error;
     }
 
-    /// <summary>
-    /// Subscribes <paramref name="observer"/> to <paramref name="source"/> on <paramref name="scheduler"/>, or
-    /// inline when no scheduler is supplied.
-    /// </summary>
+    /// <summary>Subscribes <paramref name="observer"/> to <paramref name="source"/> on <paramref name="scheduler"/>, or inline when no scheduler is supplied.</summary>
     /// <typeparam name="T">The type of the elements in <paramref name="source"/>.</typeparam>
     /// <param name="source">The observable to subscribe to.</param>
     /// <param name="observer">The observer to receive notifications from the observable.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
index 25ad98c5..405cadbb 100644
--- a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Projection operator that emits <see cref="RxVoid.Default"/> for every source element without allocating a
-/// projection closure.
-/// </summary>
+/// <summary>Projection operator that emits <see cref="RxVoid.Default"/> for every source element without allocating a projection closure.</summary>
 /// <typeparam name="T">The element type of the source observable (ignored).</typeparam>
 /// <param name="source">The source observable whose values are ignored.</param>
 internal sealed class AsSignalObservable<T>(IObservable<T> source) : IObservable<RxVoid>
diff --git a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
index 42a334d3..9277f051 100644
--- a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Buffers elements and emits them when the stream has been idle for a specified duration. Backs both
-/// the <c>BufferUntilIdle</c> and <c>BufferUntilInactive</c> public operators.
-/// </summary>
+/// <summary>Buffers elements and emits them when the stream has been idle for a specified duration. Backs both the <c>BufferUntilIdle</c> and <c>BufferUntilInactive</c> public operators.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="idleTime">The duration of inactivity required to flush the buffer.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
index 3960cbf3..088a5359 100644
--- a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
@@ -33,11 +33,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Single observer that both marshals upstream notifications onto the scheduler thread, through the
-    /// <see cref="ScheduledDrainState{T}"/> queue and scheduled drain, and applies the conflate time-window
-    /// throttle to each <see cref="DrainNotificationKind.Next"/> notification.
-    /// </summary>
+    /// <summary>Delivers notifications on the scheduler and limits value emissions to the conflate interval.</summary>
     internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
     {
         /// <summary>The downstream observer.</summary>
@@ -61,8 +57,7 @@ internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
         /// <summary>Wall-clock timestamp of the last emission forwarded downstream.</summary>
         private DateTimeOffset _lastUpdateTime = DateTimeOffset.MinValue;
 
-        /// <summary>Set to <see langword="true"/> when an upstream OnCompleted is queued but a deferred
-        /// emission is still pending; the completion fires after that emission lands.</summary>
+        /// <summary>Set to <see langword="true"/> when an upstream OnCompleted is queued but a deferred emission is still pending; the completion fires after that emission lands.</summary>
         private bool _completionRequested;
 
         /// <summary>Initializes a new instance of the <see cref="ConflateSink"/> class.</summary>
@@ -147,18 +142,15 @@ void IDrainTarget.Drain()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void AttachSourceSubscription(IDisposable subscription) => _state.Attach(subscription);
 
-        /// <summary>Applies the throttle-window decision to a dequeued value, emitting it inline or scheduling a
-        /// deferred emission at the end of the window.</summary>
+        /// <summary>Emits a dequeued value immediately or defers it until the conflate interval ends.</summary>
         /// <param name="value">The value to forward.</param>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void ProcessNext(T value)
+        internal void ProcessNext(T value)
         {
             var currentUpdateTime = _scheduler.Now;
             bool scheduleRequired;
 
             lock (_gate)
             {
-                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
@@ -182,55 +174,12 @@ private void ProcessNext(T value)
             }
         }
 
-        /// <summary>Schedules a deferred emission of <paramref name="value"/> at the end of the throttle window, forwarding a pending completion once it lands.</summary>
-        /// <param name="value">The value to emit when the window elapses.</param>
-        private void ScheduleDeferredEmission(T value) =>
-            _updateScheduled.Disposable = _scheduler.Schedule(
-                (Sink: this, Value: value),
-                _lastUpdateTime + _minimumUpdatePeriod,
-                static (_, state) =>
-                {
-                    state.Sink.EmitDeferred(state.Value);
-                    return EmptyDisposable.Instance;
-                });
-
-        /// <summary>Emits a deferred value and forwards a pending completion once the value lands.</summary>
-        /// <param name="value">The deferred value.</param>
-        private void EmitDeferred(T value)
-        {
-            _downstream.OnNext(value);
-
-            lock (_gate)
-            {
-                _lastUpdateTime = _scheduler.Now;
-                _updateScheduled.Disposable = null;
-                if (_completionRequested)
-                {
-                    _state.MarkDoneLocked();
-                    _downstream.OnCompleted();
-                }
-            }
-        }
-
-        /// <summary>Emits <paramref name="value"/> immediately and records the emission time.</summary>
-        /// <param name="value">The value to emit.</param>
-        private void EmitInline(T value)
-        {
-            _downstream.OnNext(value);
-            lock (_gate)
-            {
-                _lastUpdateTime = _scheduler.Now;
-            }
-        }
-
         /// <summary>Forwards an error to downstream and terminates the sink.</summary>
         /// <param name="error">The error to forward.</param>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void ForwardError(Exception error)
+        internal void ForwardError(Exception error)
         {
             lock (_gate)
             {
-                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
@@ -244,12 +193,10 @@ private void ForwardError(Exception error)
         }
 
         /// <summary>Forwards completion, deferring it when a throttled emission is scheduled.</summary>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void ForwardCompleted()
+        internal void ForwardCompleted()
         {
             lock (_gate)
             {
-                // Race-only: a concurrent dispose can flip the done flag between the drain dequeue and this gate.
                 if (_state.Done)
                 {
                     return;
@@ -266,5 +213,46 @@ private void ForwardCompleted()
 
             _downstream.OnCompleted();
         }
+
+        /// <summary>Schedules a value for the end of the conflate interval.</summary>
+        /// <param name="value">The value to emit when the interval elapses.</param>
+        private void ScheduleDeferredEmission(T value) =>
+            _updateScheduled.Disposable = _scheduler.Schedule(
+                (Sink: this, Value: value),
+                _lastUpdateTime + _minimumUpdatePeriod,
+                static (_, state) =>
+                {
+                    state.Sink.EmitDeferred(state.Value);
+                    return EmptyDisposable.Instance;
+                });
+
+        /// <summary>Emits a deferred value before forwarding any pending completion.</summary>
+        /// <param name="value">The deferred value.</param>
+        private void EmitDeferred(T value)
+        {
+            _downstream.OnNext(value);
+
+            lock (_gate)
+            {
+                _lastUpdateTime = _scheduler.Now;
+                _updateScheduled.Disposable = null;
+                if (_completionRequested)
+                {
+                    _state.MarkDoneLocked();
+                    _downstream.OnCompleted();
+                }
+            }
+        }
+
+        /// <summary>Emits a value immediately and records the emission time.</summary>
+        /// <param name="value">The value to emit.</param>
+        private void EmitInline(T value)
+        {
+            _downstream.OnNext(value);
+            lock (_gate)
+            {
+                _lastUpdateTime = _scheduler.Now;
+            }
+        }
     }
 }
diff --git a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
index 529016f3..3e6cf57e 100644
--- a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Flattening operator that subscribes to an upstream sequence of <see cref="IEnumerable{T}"/> batches and emits
-/// each contained element individually.
-/// </summary>
+/// <summary>Flattening operator that subscribes to an upstream sequence of <see cref="IEnumerable{T}"/> batches and emits each contained element individually.</summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source observable of enumerables.</param>
 /// <param name="scheduler">An optional scheduler used to marshal source notifications onto.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
index b8a06fde..c41cbcbf 100644
--- a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Factory operator that emits each element of an <see cref="IEnumerable{T}"/> to a single subscriber and then
-/// completes, optionally marshalling the emission through a scheduler.
-/// </summary>
+/// <summary>Factory operator that emits each element of an <see cref="IEnumerable{T}"/> to a single subscriber and then completes, optionally marshalling the emission through a scheduler.</summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source enumerable whose elements are pumped on subscription.</param>
 /// <param name="scheduler">An optional scheduler used to dispatch the pump.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
index f17f3740..e274fa86 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
@@ -10,11 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Marshals every source notification onto the supplied <see cref="ISequencer"/>, preserving order: notifications
-/// are enqueued in <see cref="ScheduledDrainState{T}"/> and one drain pass is scheduled per burst rather than one
-/// scheduled action per item.
-/// </summary>
+/// <summary>Delivers source notifications in order on the supplied sequencer, scheduling one drain per burst.</summary>
 /// <typeparam name="T">The element type of the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="scheduler">The scheduler every notification is delivered on.</param>
@@ -39,11 +35,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Single observer that queues upstream notifications and drains them on the scheduler thread in
-    /// FIFO order. Terminal notifications travel through the same queue so they never overtake
-    /// still-queued values.
-    /// </summary>
+    /// <summary>Queues values and terminal notifications together for ordered delivery on the scheduler.</summary>
     private sealed class ObserveOnSink : IObserver<T>, IDisposable, IDrainTarget
     {
         /// <summary>The downstream observer.</summary>
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
index 2e67051b..c10ff22d 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
@@ -8,10 +8,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Bundled retry configuration for <see cref="RetryWithBackoffObservable{T}"/>: retry count, delay schedule,
-/// scheduler, and an optional error sink.
-/// </summary>
+/// <summary>Bundled retry configuration for <see cref="RetryWithBackoffObservable{T}"/>: retry count, delay schedule, scheduler, and an optional error sink.</summary>
 /// <param name="MaxRetries">Maximum number of retries.</param>
 /// <param name="InitialDelay">Delay before the first retry.</param>
 /// <param name="BackoffFactor">Multiplier applied to the delay per retry attempt.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
index 05d4b096..e7b05b55 100644
--- a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
@@ -10,12 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Runs a list of one-shot <see cref="IObservable{RxVoid}"/> observables sequentially,
-/// ignoring emitted values, and emits a single <see cref="RxVoid.Default"/> when all
-/// have completed. If the list is empty, emits <see cref="RxVoid.Default"/> immediately.
-/// Errors from any observable propagate to the downstream observer.
-/// </summary>
+/// <summary>Runs sources sequentially, ignores their values, and emits RxVoid on completion. Empty input completes immediately; source errors propagate.</summary>
 /// <param name="sources">The list of one-shot observables to run in order.</param>
 internal sealed class RunAllObservable(IReadOnlyList<IObservable<RxVoid>> sources) : IObservable<RxVoid>
 {
@@ -36,14 +31,10 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Stateful observer that walks the source list sequentially: the sink subscribes itself to each source, and its
-    /// own <see cref="IObserver{RxVoid}.OnCompleted"/> sets a per-iteration flag the surrounding loop reads to
-    /// decide whether to advance.
-    /// </summary>
+    /// <summary>Advances through sources as each subscription completes, handling synchronous completion without recursive subscription.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="sources">The source list to walk.</param>
-    private sealed class Sink(
+    internal sealed class Sink(
         IObserver<RxVoid> downstream,
         IReadOnlyList<IObservable<RxVoid>> sources) : IObserver<RxVoid>, IDisposable
     {
@@ -59,9 +50,7 @@ private sealed class Sink(
         /// <summary>Guards against re-entrant <see cref="RunNext"/> calls.</summary>
         private bool _looping;
 
-        /// <summary>Per-iteration latch (0 = pending, 1 = terminated), set by <see cref="OnCompleted"/> when a source
-        /// terminates synchronously during <c>Subscribe</c> and read by the surrounding loop in
-        /// <see cref="RunNext"/>.</summary>
+        /// <summary>Records synchronous source termination during subscription.</summary>
         private int _iterationTerminated;
 
         /// <inheritdoc/>
@@ -106,10 +95,7 @@ public void Dispose()
             Interlocked.Exchange(ref _currentSubscription, null)?.Dispose();
         }
 
-        /// <summary>
-        /// Subscribes to the next source, or emits RxVoid and completes if all are done.
-        /// Iteratively loops on synchronous completion to avoid recursive stack growth.
-        /// </summary>
+        /// <summary>Advances through synchronously completing sources without recursion, then completes when all sources are done.</summary>
         internal void RunNext()
         {
             _looping = true;
@@ -138,10 +124,8 @@ internal void RunNext()
         }
 
         /// <summary>Emits the terminal <see cref="RxVoid"/> and completes once all sources have run.</summary>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void CompleteRun()
+        internal void CompleteRun()
         {
-            // Race-only: a concurrent dispose can latch the done flag between the loop exit and this call.
             if (Interlocked.Exchange(ref _done, 1) != 0)
             {
                 return;
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
index 8d8832d7..48edde8c 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
@@ -10,16 +10,8 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Source-driven scheduled observable: for every upstream value, schedules a callback on the supplied
-/// <see cref="ISequencer"/> that applies an optional <see cref="Action{T}"/> side-effect and/or
-/// <see cref="Func{T,T}"/> transform before forwarding the value downstream.
-/// </summary>
+/// <summary>Schedules source values without forwarding errors or completion.</summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
-/// <remarks>
-/// Only <see cref="IObserver{T}.OnNext"/> is forwarded: source errors and completion never reach the downstream
-/// observer, so a subscriber sees no terminal notification.
-/// </remarks>
 internal sealed class ScheduledSourceObservable<T> : IObservable<T>
 {
     /// <summary>The upstream observable.</summary>
@@ -48,10 +40,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return _source.Subscribe(sink);
     }
 
-    /// <summary>
-    /// Carries the per-emission state by value into the scheduled callback so the scheduler lambda captures
-    /// nothing.
-    /// </summary>
+    /// <summary>Carries the per-emission state by value into the scheduled callback so the scheduler lambda captures nothing.</summary>
     /// <param name="Observer">The downstream observer.</param>
     /// <param name="Value">The value to emit.</param>
     /// <param name="Transform">The optional transform.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs b/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
index d5a61fa6..3c3e4e14 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduledValueObservable.cs
@@ -10,16 +10,8 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Single-value scheduled observable: on subscription, schedules a callback on the supplied
-/// <see cref="ISequencer"/> that applies an optional <see cref="Action{T}"/> side-effect and/or an optional
-/// <see cref="Func{T,T}"/> transform to the captured value and calls <see cref="IObserver{T}.OnNext"/> once.
-/// </summary>
+/// <summary>Schedules a value without a terminal notification; disposal ends the subscription.</summary>
 /// <typeparam name="T">The value type emitted to the downstream observer.</typeparam>
-/// <remarks>
-/// The sequence never completes on its own: no terminal notification is sent, so the subscriber ends it by
-/// disposing the subscription.
-/// </remarks>
 internal sealed class ScheduledValueObservable<T> : IObservable<T>
 {
     /// <summary>The value to emit.</summary>
diff --git a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
index 180f2b12..031020ca 100644
--- a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Runs the function once — inline when no scheduler is supplied, otherwise on the scheduler —
-/// emits the result, then completes.
-/// </summary>
+/// <summary>Runs the function once — inline when no scheduler is supplied, otherwise on the scheduler — emits the result, then completes.</summary>
 /// <typeparam name="TResult">Result type.</typeparam>
 /// <param name="function">Function to run.</param>
 /// <param name="scheduler">Optional scheduler; null runs inline.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
index fe782db6..4681e65b 100644
--- a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
@@ -34,10 +34,7 @@ internal static IObservable<DateTime> Get(TimeSpan timeSpan, ISequencer schedule
         return _timerList.GetOrAdd((timeSpan, scheduler), _create);
     }
 
-    /// <summary>
-    /// Connectable timer that fans each tick out to its observers: the tick path reads a swap-on-write observer
-    /// array lock-free, while subscribe and unsubscribe take the gate and publish a fresh array.
-    /// </summary>
+    /// <summary>Broadcasts ticks through immutable observer snapshots; subscription changes publish a new snapshot under the gate.</summary>
     /// <param name="timeSpan">The period.</param>
     /// <param name="scheduler">The scheduler.</param>
     private sealed class SharedTimer(TimeSpan timeSpan, ISequencer scheduler) : IObservable<DateTime>
@@ -48,10 +45,7 @@ private sealed class SharedTimer(TimeSpan timeSpan, ISequencer scheduler) : IObs
         /// <summary>The gate for subscribe/unsubscribe writes.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>
-        /// Snapshot of active observers, replaced rather than mutated on subscribe and unsubscribe under
-        /// <see cref="_gate"/> so the tick path can read it without the lock.
-        /// </summary>
+        /// <summary>Snapshot of active observers, replaced rather than mutated on subscribe and unsubscribe under <see cref="_gate"/> so the tick path can read it without the lock.</summary>
         private IObserver<DateTime>[] _observers = _emptyObservers;
 
         /// <summary>The active timer subscription, or <see langword="null"/> when no observers are attached.</summary>
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
index 6a4fcecf..17a3ee90 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
@@ -37,7 +37,7 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="downstream">The observer to forward elements to.</param>
     /// <param name="throttle">The throttle duration.</param>
     /// <param name="scheduler">The scheduler to use for timing.</param>
-    private sealed class ThrottleDistinctSink(
+    internal sealed class ThrottleDistinctSink(
         IObserver<T> downstream,
         TimeSpan throttle,
         ISequencer scheduler) : IObserver<T>, IDisposable
@@ -111,13 +111,11 @@ public void Dispose()
         }
 
         /// <summary>Emits the last received value when it differs from the last emitted value.</summary>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void Emit()
+        internal void Emit()
         {
             T? toEmit;
             lock (_gate)
             {
-                // Race-only: reachable when this scheduled callback overlaps Dispose or a terminal notification.
                 if (_state.Done || !_hasLastReceived)
                 {
                     return;
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
index c54836b6..f0642099 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleObservable.cs
@@ -10,13 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Classic throttle (debounce) operator. Emits a value only after
-/// <paramref name="dueTime"/> has elapsed without any new emission from the
-/// source. Each new upstream <c>OnNext</c> cancels the pending emission and
-/// schedules a new one. Provides the equivalent of Rx's
-/// <c>Observable.Throttle</c> without depending on System.Reactive.Linq.
-/// </summary>
+/// <summary>Emits the latest value after the configured quiet period.</summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="dueTime">The quiescence duration required before emission.</param>
@@ -42,7 +36,7 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="dueTime">The quiescence duration.</param>
     /// <param name="scheduler">The scheduler used to time emissions.</param>
-    private sealed class ThrottleSink(
+    internal sealed class ThrottleSink(
         IObserver<T> downstream,
         TimeSpan dueTime,
         ISequencer scheduler) : IObserver<T>, IDisposable
@@ -144,18 +138,13 @@ public void Dispose()
             _pending.Dispose();
         }
 
-        /// <summary>
-        /// Emits the buffered value when it is still current, meaning no newer <see cref="OnNext"/> arrived after
-        /// this emission was scheduled.
-        /// </summary>
+        /// <summary>Emits the buffered value when it is still current, meaning no newer <see cref="OnNext"/> arrived after this emission was scheduled.</summary>
         /// <param name="id">The emission id this callback was scheduled for.</param>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-        private void Emit(long id)
+        internal void Emit(long id)
         {
             T value;
             lock (_gate)
             {
-                // Race-only: reachable when this scheduled callback overlaps Dispose or a terminal notification.
                 if (_done || id != _emissionId || !_hasValue)
                 {
                     return;
diff --git a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
index 14755c3c..3f752c7e 100644
--- a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
@@ -46,10 +46,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
             });
     }
 
-    /// <summary>
-    /// Invokes the function against the resource, signals the produced value
-    /// followed by completion, then disposes the resource.
-    /// </summary>
+    /// <summary>Invokes the function against the resource, signals the produced value followed by completion, then disposes the resource.</summary>
     /// <param name="observer">The downstream observer.</param>
     /// <param name="resource">The resource to use and dispose.</param>
     /// <param name="function">The function invoked against the resource.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
index 214ce2d9..c22f6a14 100644
--- a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
@@ -36,10 +36,7 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Sink that orchestrates the iteration loop, scheduling the next iteration
-    /// after each emission and terminating when the predicate becomes false.
-    /// </summary>
+    /// <summary>Sink that orchestrates the iteration loop, scheduling the next iteration after each emission and terminating when the predicate becomes false.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="condition">The loop predicate.</param>
     /// <param name="action">The action invoked per iteration.</param>
diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.Retry.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.Retry.cs
index 3d11e9c5..1c06d613 100644
--- a/src/Primitives.Extensions.Shared/ReactiveExtensions.Retry.cs
+++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.Retry.cs
@@ -134,10 +134,7 @@ public IObservable<T> OnErrorRetry<TException>(Action<TException> onError, int r
                         onError(tex);
                     }));
 
-        /// <summary>
-        /// When caught exception, do onError action and repeat observable sequence after delay
-        /// time(work on delayScheduler) during within retryCount.
-        /// </summary>
+        /// <summary>When caught exception, do onError action and repeat observable sequence after delay time(work on delayScheduler) during within retryCount.</summary>
         /// <typeparam name="TException">The type of the exception.</typeparam>
         /// <param name="onError">The on error.</param>
         /// <param name="retryCount">The retry count.</param>
diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
index 33feaa0b..208caa36 100644
--- a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
@@ -712,11 +712,7 @@ public IObservable<TOut> WhereSelect<TOut>(Func<T, bool> predicate, Func<T, TOut
         public IObservable<T> CatchReturn(T fallback) =>
             new CatchReturnObservable<T>(source, fallback);
 
-        /// <summary>
-        /// Projects every source element to a stored constant, avoiding the closure
-        /// allocation of <c>.Select(_ =&gt; value)</c>. Common in fire-then-return-value
-        /// chains.
-        /// </summary>
+        /// <summary>Projects every source element to a stored constant, avoiding the closure allocation of <c>.Select(_ =&gt; value)</c>. Common in fire-then-return-value chains.</summary>
         /// <typeparam name="TResult">The result element type.</typeparam>
         /// <param name="constant">The constant value emitted for each source element.</param>
         /// <returns>An observable that emits <paramref name="constant"/> for each source element.</returns>
@@ -736,10 +732,7 @@ public IObservable<TResult> SelectConstant<TResult>(TResult constant) =>
         public IObservable<TOut> TrySelect<TOut>(Func<T, TOut?> selector) =>
             new TrySelectObservable<T, TOut>(source, selector);
 
-        /// <summary>
-        /// Chains two one-shot <c>SelectMany</c> projections into a single operator.
-        /// Replaces <c>.SelectMany(a).SelectMany(b)</c> (2 operator allocations) with 1.
-        /// </summary>
+        /// <summary>Chains two one-shot <c>SelectMany</c> projections into a single operator. Replaces <c>.SelectMany(a).SelectMany(b)</c> (2 operator allocations) with 1.</summary>
         /// <typeparam name="TMid">The intermediate element type.</typeparam>
         /// <typeparam name="TResult">The final result type.</typeparam>
         /// <param name="first">First projection: source → intermediate observable.</param>
diff --git a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
index 23490893..6fa5d1fc 100644
--- a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
+++ b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
@@ -23,6 +23,9 @@ public abstract class CoalescingDispatchScheduler : LocalScheduler
     /// <summary>Cached drain callback (this scheduler's <see cref="RunDrain"/>) marshalled by <see cref="Post"/>.</summary>
     private readonly Action _drain;
 
+    /// <summary>Schedules delays before work returns to the dispatcher.</summary>
+    private readonly IScheduler _delayScheduler;
+
     /// <summary>Approximate number of ready items; snapshots a drain batch.</summary>
     private int _readyCount;
 
@@ -30,7 +33,18 @@ public abstract class CoalescingDispatchScheduler : LocalScheduler
     private int _drainPosted;
 
     /// <summary>Initializes a new instance of the <see cref="CoalescingDispatchScheduler"/> class.</summary>
-    protected CoalescingDispatchScheduler() => _drain = RunDrain;
+    /// <param name="delayScheduler">Scheduler used for relative delays.</param>
+    internal CoalescingDispatchScheduler(IScheduler delayScheduler)
+    {
+        _drain = RunDrain;
+        _delayScheduler = delayScheduler;
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="CoalescingDispatchScheduler"/> class.</summary>
+    protected CoalescingDispatchScheduler()
+        : this(DefaultScheduler.Instance)
+    {
+    }
 
     /// <summary>Schedules an action to be executed as soon as possible on the dispatcher.</summary>
     /// <typeparam name="TState">The type of the state passed to the action.</typeparam>
@@ -76,16 +90,12 @@ public override IDisposable Schedule<TState>(
     /// <returns><see langword="true"/> when the dispatcher accepted the work.</returns>
     protected abstract bool Post(Action drain);
 
-    /// <summary>
-    /// Runs <paramref name="work"/> on the dispatcher after <paramref name="dueTime"/>. The default marshals the wait
-    /// onto the shared timer, then re-queues the work onto the dispatcher when it is due. Platforms with a native
-    /// UI-thread timer override this to run the work directly on the dispatcher thread.
-    /// </summary>
+    /// <summary>Schedules delayed work for dispatcher delivery; platforms may override with a native UI timer.</summary>
     /// <param name="work">Callback to invoke on the dispatcher thread when due.</param>
     /// <param name="dueTime">Relative time after which to invoke <paramref name="work"/>.</param>
     /// <returns>The disposable used to cancel the delayed dispatch.</returns>
     protected virtual IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime) =>
-        DefaultScheduler.Instance.Schedule(
+        _delayScheduler.Schedule(
             (Owner: this, work),
             dueTime,
             static (_, state) => state.Owner.Schedule(
diff --git a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
index be858aa8..0704be55 100644
--- a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
+++ b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
@@ -8,12 +8,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// Shared run/cancel core for scheduled, cancellable work items carrying closure-free state and the scheduler passed
-/// back to the action. It owns the atomic start-versus-cancel handshake so every dispatcher and event-loop scheduler
-/// implements it exactly once; derived types add only the cancellation resources specific to how the work was queued
-/// (for example a one-shot timer).
-/// </summary>
+/// <summary>Coordinates work execution and cancellation; derived items own scheduling resources.</summary>
 /// <typeparam name="TState">The scheduled state type.</typeparam>
 internal class DispatchWorkItemBase<TState>
 {
@@ -36,11 +31,6 @@ internal class DispatchWorkItemBase<TState>
     /// <param name="scheduler">The scheduler passed back to the scheduled action.</param>
     /// <param name="state">Scheduled state.</param>
     /// <param name="action">Scheduled action.</param>
-    /// <remarks>
-    /// Written out rather than made a primary constructor so it can stay <c>protected</c>: a primary
-    /// constructor on a concrete class is public, which would let anything construct the base directly
-    /// instead of going through a derived work item.
-    /// </remarks>
     protected DispatchWorkItemBase(
         IScheduler scheduler,
         TState state,
diff --git a/src/Primitives.Shared/Advanced/AsyncDeferSignal{T}.cs b/src/Primitives.Shared/Advanced/AsyncDeferSignal{T}.cs
index b2242045..f85abb3d 100644
--- a/src/Primitives.Shared/Advanced/AsyncDeferSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/AsyncDeferSignal{T}.cs
@@ -48,7 +48,7 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="observer">The downstream observer.</param>
     /// <param name="subscription">The subscription slot.</param>
     /// <returns>A task that completes when the source subscription has been assigned.</returns>
-    private static async Task RunAsyncFactory(
+    internal static async Task RunAsyncFactory(
         Func<CancellationToken, Task<IObservable<T>>> observableFactory,
         CreateWitness<T> observer,
         AsyncSubscriptionLifetime subscription)
diff --git a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
index a2a3e03c..cef1b153 100644
--- a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
@@ -92,13 +92,8 @@ internal void Release(IDisposable subscription)
         connection?.Dispose();
     }
 
-    /// <summary>Connects the source outside <see cref="_gate"/> and publishes or drops the connection.</summary>
+    /// <summary>Connects outside the subscription gate and releases the connection if every subscriber has disposed.</summary>
     /// <param name="subscription">The inner source subscription owned by the connecting observer.</param>
-    /// <remarks>
-    /// Connecting runs outside the lock so a synchronous source cannot drive user callbacks while the gate is
-    /// held, which lets a re-entrant or concurrent <see cref="Release"/> drain the subscriber count before the
-    /// connection is published.
-    /// </remarks>
     private void ConnectOutsideGate(IDisposable subscription)
     {
         var connection = ConnectOrUnwind(subscription);
diff --git a/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs b/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
index 0fc3c76d..1bf7ed94 100644
--- a/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSafeSignal{T}.cs
@@ -10,8 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Creates a signal from a subscribe delegate whose sink releases the subscription when a downstream
-/// <c>OnNext</c> throws.</summary>
+/// <summary>Creates a signal from a subscribe delegate whose sink releases the subscription when a downstream <c>OnNext</c> throws.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 internal sealed class CreateSafeSignal<T> : IRequireCurrentThread<T>
 {
diff --git a/src/Primitives.Shared/Advanced/EventHandlerScope.cs b/src/Primitives.Shared/Advanced/EventHandlerScope.cs
index 843db703..689fbb05 100644
--- a/src/Primitives.Shared/Advanced/EventHandlerScope.cs
+++ b/src/Primitives.Shared/Advanced/EventHandlerScope.cs
@@ -38,17 +38,13 @@ public static IDisposable Attach<TEventHandler>(
         return AttachScheduled(handler, addHandler, removeHandler, sequencer);
     }
 
-    /// <summary>Attaches and later detaches the handler on the sequencer instead of the calling thread.</summary>
+    /// <summary>Cancels any pending attachment before scheduling detachment.</summary>
     /// <typeparam name="TEventHandler">The delegate type used by the event.</typeparam>
     /// <param name="handler">The handler this subscription owns.</param>
     /// <param name="addHandler">The action that attaches the handler.</param>
     /// <param name="removeHandler">The action that detaches the handler.</param>
     /// <param name="sequencer">The sequencer that attaches and detaches the handler.</param>
     /// <returns>The disposable that detaches the handler.</returns>
-    /// <remarks>
-    /// Disposing cancels a still-pending attach before requesting the detach, so a subscription torn down
-    /// before the sequencer ran the attach cannot leave the handler on the event.
-    /// </remarks>
     private static IDisposable AttachScheduled<TEventHandler>(
         TEventHandler handler,
         Action<TEventHandler> addHandler,
diff --git a/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs b/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
index f96303f0..d42b7eee 100644
--- a/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/ExpireCoordinator{T}.cs
@@ -48,11 +48,7 @@ public sealed class ExpireCoordinator<T> : IObserver<T>, IDisposable
     /// <summary>Monotonic version that suppresses timeouts superseded by a newer value.</summary>
     private long _epoch;
 
-    /// <summary>
-    /// The instant on the sequencer's clock at which the current inactivity window closes, read and written under
-    /// <see cref="_gate"/>. It starts at <see cref="DateTimeOffset.MaxValue"/> so an unpublished window never
-    /// expires a value.
-    /// </summary>
+    /// <summary>Deadline guarded by the gate; MaxValue prevents expiration until the first window is armed.</summary>
     private DateTimeOffset _deadline = DateTimeOffset.MaxValue;
 
     /// <summary>Initializes a new instance of the <see cref="ExpireCoordinator{T}"/> class.</summary>
@@ -137,11 +133,7 @@ public void OnError(Exception error)
     }
 
     /// <inheritdoc/>
-    /// <remarks>
-    /// A value is on time only when it arrives before the inactivity window closes on the sequencer's clock, not
-    /// merely before the armed timer has run. A value that arrives past its deadline — which a saturated thread-pool
-    /// sequencer can allow — terminates the sequence with <see cref="TimeoutException"/> instead of being forwarded.
-    /// </remarks>
+    /// <remarks>Values arriving at or after the clock deadline fail with TimeoutException, even if the timer callback has not run.</remarks>
     public void OnNext(T value)
     {
         long epoch;
@@ -199,11 +191,8 @@ public ExpireCoordinator<T> Run()
         return this;
     }
 
-    /// <summary>Schedules a fresh inactivity timer for the given epoch and discards the in-flight one.</summary>
+    /// <summary>Schedules outside the gate and publishes the timer only if its window remains current.</summary>
     /// <param name="epoch">The version this timer must match to fire.</param>
-    /// <remarks>Scheduling happens outside the gate so a synchronous sequencer cannot re-enter <see cref="Lock"/>.
-    /// The publish is re-checked under the gate, so neither a terminal notification nor a newer value's window can be
-    /// overwritten by a superseded arm.</remarks>
     private void ArmTimer(long epoch)
     {
         var deadline = Deadline();
@@ -228,12 +217,8 @@ private void ArmTimer(long epoch)
         previous?.Dispose();
     }
 
-    /// <summary>Computes the closing instant of an inactivity window opened at the current time.</summary>
+    /// <summary>Captures a deadline for positive delays; zero delays remain queued immediate work.</summary>
     /// <returns>The deadline on the sequencer's clock, saturated instead of overflowing.</returns>
-    /// <remarks>
-    /// A due time that normalizes to zero is queued as immediate work, so it opens no clock window and a synchronous
-    /// value arriving before the queue drains wins; only a positive due time yields a real deadline.
-    /// </remarks>
     private DateTimeOffset Deadline()
     {
         var dueTime = Sequencer.Normalize(_dueTime);
diff --git a/src/Primitives.Shared/Advanced/ForkJoinWitness{TLeft,TRight,TResult}.cs b/src/Primitives.Shared/Advanced/ForkJoinWitness{TLeft,TRight,TResult}.cs
index a65028ea..b65c9af7 100644
--- a/src/Primitives.Shared/Advanced/ForkJoinWitness{TLeft,TRight,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/ForkJoinWitness{TLeft,TRight,TResult}.cs
@@ -131,8 +131,7 @@ private void OnError(Exception error)
         }
     }
 
-    /// <summary>Emits the result and completes once both sources are done.</summary>
-    /// <remarks>Must be called while holding <see cref="_gate"/> so the terminal notification stays serialized.</remarks>
+    /// <summary>Sends the terminal notification while the caller holds the gate.</summary>
     private void TryFinish()
     {
         if (!IsLeftDone || !IsRightDone)
diff --git a/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs b/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
index 0f283e61..fc2a6b3c 100644
--- a/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/GuardedWitness{T}.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Forwarding observer that releases its upstream cancel resource when the sequence terminates or a downstream
-/// <c>OnNext</c> throws, rethrowing the latter after release.
-/// </summary>
+/// <summary>Forwarding observer that releases its upstream cancel resource when the sequence terminates or a downstream <c>OnNext</c> throws, rethrowing the latter after release.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("GuardedWitness: Disposed = {_disposed}, Observer = {_observer}")]
 public sealed class GuardedWitness<T> : IObserver<T>, IDisposable
diff --git a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
index 4ebd7d17..a8b984f4 100644
--- a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
@@ -48,10 +48,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
             return EmptyDisposable.Instance;
         }
 
-        // The first value settles this operator, so the sink must own the subscription before any value arrives. A
-        // current-thread source drains the trampoline inside whichever call enters it first, so letting the source's
-        // own Subscribe enter it would deliver values before the sink holds the subscription, and an endless source
-        // would never stop. Entering the trampoline here leaves the source only able to queue its first tick.
+        // Acquire the subscription before the first value can terminate the source.
         if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
         {
             return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
index 2b8b016b..d2688174 100644
--- a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
@@ -84,9 +84,7 @@ public void OnSource(IObservable<T>? source)
             Active++;
         }
 
-        // A source is free to signal completion more than once. Latch per inner so a repeat cannot decrement
-        // the active count on behalf of a running sibling, which would complete the merge early and drop
-        // everything that sibling had left to produce.
+        // Latch completion per source so duplicate terminal notifications cannot decrement a sibling's count.
         var completed = 0;
         Subscriptions.Add(source.Subscribe(
             OnInnerNext,
diff --git a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
index 3ce907c8..786fd5b9 100644
--- a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Cold signal that mirrors the source and, when it produces any error, subscribes the fallback sequence in its
-/// place. The error is not forwarded downstream.
-/// </summary>
+/// <summary>Cold signal that mirrors the source and, when it produces any error, subscribes the fallback sequence in its place. The error is not forwarded downstream.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="fallback">The fallback observable subscribed to after the source errors.</param>
diff --git a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
index 5e70b6d2..7d7f808d 100644
--- a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
+++ b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
@@ -8,15 +8,10 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Subscription-time scheduling shared by advanced signals: a signal that observes the current-thread
-/// sequencer has to queue behind it while it is draining work, so emissions arrive in trampoline order.
-/// </summary>
+/// <summary>Preserves trampoline order when subscribing during a current-thread drain.</summary>
 internal static class SubscriptionScheduling
 {
-    /// <summary>
-    /// Subscribes inline when the current-thread sequencer is idle, otherwise queues the subscription on it.
-    /// </summary>
+    /// <summary>Subscribes inline when the current-thread sequencer is idle, otherwise queues the subscription on it.</summary>
     /// <typeparam name="TState">The type of the state passed to the subscribe callback.</typeparam>
     /// <param name="state">The state carried to <paramref name="subscribe"/>.</param>
     /// <param name="subscribe">Performs the subscription and returns it.</param>
diff --git a/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
index 27a9b1aa..5c799da8 100644
--- a/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/SwitchMapSignal{TSource,TResult}.cs
@@ -13,10 +13,6 @@ namespace ReactiveUI.Primitives.Advanced;
 /// <summary>Projects each source value to an inner observable and mirrors only the latest one.</summary>
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TResult">The element type of the projected inner observables.</typeparam>
-/// <remarks>
-/// The projection is fused into the switch, so it costs one object and one observer hop instead of the two of
-/// each, plus an intermediate sequence of observables, that a separate projection and switch cost.
-/// </remarks>
 [System.Diagnostics.DebuggerDisplay("SwitchMapSignal: Source = {_source}, SkipNullSources = {_skipNullSources}")]
 public sealed class SwitchMapSignal<TSource, TResult> : IObservable<TResult>
 {
@@ -41,8 +37,8 @@ public SwitchMapSignal(IObservable<TSource> source, Func<TSource, IObservable<TR
     /// <param name="source">The source whose values are projected to inner observables.</param>
     /// <param name="selector">Projects a source value to the inner observable to switch to.</param>
     /// <param name="skipNullSources">
-    /// Whether a null source value leaves the active inner subscription in place rather than switching. A caller
-    /// that projects null onto its own inner observable switches on it instead, which detaches the previous one.
+    /// Whether null source values retain the active subscription
+    /// without invoking the selector.
     /// </param>
     internal SwitchMapSignal(
         IObservable<TSource> source,
diff --git a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
index d4c5b23f..3c054045 100644
--- a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
@@ -80,10 +80,7 @@ private void OnSource(IObservable<T> source)
             error => OnError(current, error),
             () => OnCompleted(current));
 
-        // Subscribing can push a value downstream synchronously, and that handler is free to feed the outer
-        // source again, re-entering OnSource and installing a newer generation before this call returns. Only
-        // the current generation may occupy the slot: installing a superseded subscription would dispose the
-        // newer one and leave a sequence whose notifications are all filtered out by version.
+        // Reentrant subscription can install a newer generation; only the current generation may occupy the slot.
         var superseded = false;
         lock (_gate)
         {
diff --git a/src/Primitives.Shared/Advanced/TaskInstanceSignal{T}.cs b/src/Primitives.Shared/Advanced/TaskInstanceSignal{T}.cs
index c3f40877..2d7c3db5 100644
--- a/src/Primitives.Shared/Advanced/TaskInstanceSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/TaskInstanceSignal{T}.cs
@@ -40,7 +40,7 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="observer">The downstream observer.</param>
     /// <param name="subscription">The subscription lifetime.</param>
     /// <returns>A task representing the asynchronous observation.</returns>
-    private static async Task ObserveTaskAsync(
+    internal static async Task ObserveTaskAsync(
         Task<T> task,
         IObserver<T> observer,
         TaskInstanceSubscription subscription)
diff --git a/src/Primitives.Shared/Advanced/TimerSlot.cs b/src/Primitives.Shared/Advanced/TimerSlot.cs
index c0a1a04e..890f7659 100644
--- a/src/Primitives.Shared/Advanced/TimerSlot.cs
+++ b/src/Primitives.Shared/Advanced/TimerSlot.cs
@@ -17,11 +17,7 @@ public static class TimerSlot
     /// <param name="delay">The delay before the callback runs.</param>
     /// <param name="tick">The timer callback.</param>
     /// <exception cref="ArgumentNullException">An argument is <see langword="null"/>.</exception>
-    /// <remarks>
-    /// A sequencer may run <paramref name="tick"/> before its own <c>Schedule</c> returns, and that callback may
-    /// arm its successor. Reserving <paramref name="slot"/> first sends the late handle into a superseded
-    /// reservation, so the fired timer is disposed instead of the successor being cancelled.
-    /// </remarks>
+    /// <remarks>A callback that runs during scheduling can rearm the slot without its successor being canceled.</remarks>
     public static void Arm(SingleReplaceableDisposable slot, ISequencer sequencer, TimeSpan delay, Action tick)
     {
         ArgumentExceptionHelper.ThrowIfNull(slot);
diff --git a/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs b/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
index b7a8c76f..1b526797 100644
--- a/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
+++ b/src/Primitives.Shared/Concurrency/SequencerWorkItemDisposal.cs
@@ -11,13 +11,9 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>Disposal helpers shared by sequencer work items.</summary>
 internal static class SequencerWorkItemDisposal
 {
-    /// <summary>Publishes the action's disposable into the shared slot, disposing it when disposal won the race.</summary>
+    /// <summary>Publishes the disposable or releases it if disposal owns the slot.</summary>
     /// <param name="slot">The disposable slot shared with the work item's disposal.</param>
     /// <param name="disposable">The disposable returned by the scheduled action.</param>
-    /// <remarks>
-    /// Disposal swaps a non-null sentinel into the slot, so a non-null exchange result means disposal owns the
-    /// slot and this caller must release the disposable it produced.
-    /// </remarks>
     internal static void Publish(ref IDisposable? slot, IDisposable disposable)
     {
         if (Interlocked.CompareExchange(ref slot, disposable, null) is null)
diff --git a/src/Primitives.Shared/Core/SparkCompositeFormats.cs b/src/Primitives.Shared/Core/SparkCompositeFormats.cs
index bb1b5b6a..99f2f6df 100644
--- a/src/Primitives.Shared/Core/SparkCompositeFormats.cs
+++ b/src/Primitives.Shared/Core/SparkCompositeFormats.cs
@@ -10,11 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Core;
 namespace ReactiveUI.Primitives.Core;
 #endif
 
-/// <summary>Holds the parsed composite formats <see cref="Spark{T}"/> renders with.</summary>
-/// <remarks>
-/// A static field in <see cref="Spark{T}"/> is a distinct field per closed generic, so the formats live on a
-/// non-generic type to be parsed once for every <c>T</c>.
-/// </remarks>
+/// <summary>Shares parsed spark formats across all closed generic types.</summary>
 internal static class SparkCompositeFormats
 {
     /// <summary>The format an <see cref="SparkKind.OnNext"/> spark renders with.</summary>
diff --git a/src/Primitives.Shared/Core/Spark{T}.cs b/src/Primitives.Shared/Core/Spark{T}.cs
index 366358bc..72fc4bf5 100644
--- a/src/Primitives.Shared/Core/Spark{T}.cs
+++ b/src/Primitives.Shared/Core/Spark{T}.cs
@@ -12,10 +12,7 @@ namespace ReactiveUI.Primitives.Reactive.Core;
 namespace ReactiveUI.Primitives.Core;
 #endif
 
-/// <summary>
-/// Represents a spark to an observer. Being a value type, materializing a sequence allocates no
-/// per-notification heap object.
-/// </summary>
+/// <summary>Represents a spark to an observer. Being a value type, materializing a sequence allocates no per-notification heap object.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
 [Serializable]
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -56,10 +53,7 @@ private Spark(SparkKind kind, T value, Exception? exception)
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>
-    /// Determines whether both sparks carry the same observer message payload: the same <see cref="Kind"/> and,
-    /// for OnNext and OnError, the same value or exception.
-    /// </summary>
+    /// <summary>Determines whether both sparks carry the same observer message payload: the same <see cref="Kind"/> and, for OnNext and OnError, the same value or exception.</summary>
     /// <param name="other">The spark to compare with this one.</param>
     /// <returns>true if both sparks carry the same payload; otherwise, false.</returns>
     public bool Equals(Spark<T> other) => Kind == other.Kind && Kind switch
diff --git a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
index 61df4a34..f9a617d8 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
@@ -18,10 +18,7 @@ public static partial class LinqExtensions
     /// <param name="source">The source observable.</param>
     extension<TIn>(IObservable<TIn> source)
     {
-        /// <summary>
-        /// Projects each source value to an inner observable and mirrors only the latest one — a single fused
-        /// sink in place of <c>Select(selector).Switch()</c>.
-        /// </summary>
+        /// <summary>Projects each source value to an inner observable and mirrors only the latest one — a single fused sink in place of <c>Select(selector).Switch()</c>.</summary>
         /// <typeparam name="TOut">The element type of the projected inner observables.</typeparam>
         /// <param name="selector">Projects each source value to an inner observable.</param>
         /// <returns>An observable that mirrors the latest projected inner observable.</returns>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
index af954501..cadbaa0b 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
@@ -405,10 +405,7 @@ private sealed class CombineLatestCoordinator<TResult> : IDisposable
         /// <summary>The active source subscriptions.</summary>
         private readonly MultipleDisposable _subscriptions = [];
 
-        /// <summary>
-        /// One flag per source twice over: the first half records whether a source has produced a value, the
-        /// second whether it has completed.
-        /// </summary>
+        /// <summary>One flag per source twice over: the first half records whether a source has produced a value, the second whether it has completed.</summary>
         private bool[] _flags = [];
 
         /// <summary>The projection over this subscription's slots.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
index c1a27d67..c0bce856 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
@@ -13,9 +13,7 @@ namespace ReactiveUI.Primitives;
 /// <summary>Coordinator helpers for multi-source signal operators.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>
-    /// Range-specialized WithLatest (Latch): emits each left range value paired with the right range's final value.
-    /// </summary>
+    /// <summary>Range-specialized WithLatest (Latch): emits each left range value paired with the right range's final value.</summary>
     /// <typeparam name="TResult">The result value type.</typeparam>
     /// <param name="left">The left source range.</param>
     /// <param name="right">The right source range.</param>
@@ -481,10 +479,7 @@ private void OnRightCompleted()
             Drain();
         }
 
-        /// <summary>
-        /// Emits every pair the queues can form. The gate is held across the projection and the downstream
-        /// callbacks, so the left and right threads cannot interleave emissions.
-        /// </summary>
+        /// <summary>Projects and emits queued pairs under the gate, preserving emission order.</summary>
         private void Drain()
         {
             lock (_gate)
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
index 05594380..ea076748 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
@@ -16,113 +16,13 @@ namespace ReactiveUI.Primitives;
 /// </summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Dedicated signal for <c>Calm</c> (quiet-period debounce).</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="dueTime">The quiet period.</param>
-    /// <param name="scheduler">The sequencer used to schedule quiet-period timers.</param>
-    private sealed class CalmSignal<T>(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<T> _source = source;
-
-        /// <summary>The quiet period.</summary>
-        private readonly TimeSpan _dueTime = dueTime;
-
-        /// <summary>The sequencer used to schedule quiet-period timers.</summary>
-        private readonly ISequencer _scheduler = scheduler;
-
-        /// <inheritdoc/>
-        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            CalmCoordinator<T> coordinator = new(_source, _dueTime, _scheduler);
-            if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
-            {
-                return coordinator.Run(observer);
-            }
-
-            SingleDisposable subscription = new();
-            _ = Sequencer.CurrentThread.Schedule(
-                (subscription, coordinator, observer),
-                static (_, s) =>
-                {
-                    s.subscription.Create(s.coordinator.Run(s.observer));
-                    return EmptyDisposable.Instance;
-                });
-            return subscription;
-        }
-    }
-
-    /// <summary>Dedicated signal for <c>Shift</c> (delay each notification on a sequencer).</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    private sealed class ShiftSignal<T> : IRequireCurrentThread<T>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<T> _source;
-
-        /// <summary>The delay applied to each notification.</summary>
-        private readonly TimeSpan _dueTime;
-
-        /// <summary>The sequencer used to schedule delayed notifications.</summary>
-        private readonly ISequencer _scheduler;
-
-        /// <summary>Initializes a new instance of the <see cref="ShiftSignal{T}"/> class.</summary>
-        /// <param name="source">The source observable.</param>
-        /// <param name="dueTime">The delay applied to each notification.</param>
-        /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
-        internal ShiftSignal(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler)
-        {
-            _source = source;
-            _dueTime = Sequencer.Normalize(dueTime);
-            _scheduler = scheduler;
-        }
-
-        /// <inheritdoc/>
-        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
-            {
-                return RunCore(observer);
-            }
-
-            SingleDisposable subscription = new();
-            _ = Sequencer.CurrentThread.Schedule(
-                (Self: this, subscription, observer),
-                static (_, s) =>
-                {
-                    s.subscription.Create(s.Self.RunCore(s.observer));
-                    return EmptyDisposable.Instance;
-                });
-            return subscription;
-        }
-
-        /// <summary>Subscribes to the source and schedules each notification by the delay.</summary>
-        /// <param name="observer">The downstream observer.</param>
-        /// <returns>The disposable that cancels the source subscription and pending timers.</returns>
-        private ShiftCoordinator<T> RunCore(IObserver<T> observer)
-        {
-            ShiftCoordinator<T> coordinator = new(_source, _dueTime, _scheduler, observer);
-            return coordinator.Run();
-        }
-    }
-
     /// <summary>Coordinates delayed notification delivery with a single serialized timer.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <param name="dueTime">The normalized delay applied to each notification.</param>
     /// <param name="sequencer">The sequencer used to schedule delayed notifications.</param>
     /// <param name="observer">The downstream observer.</param>
-    private sealed class ShiftCoordinator<T>(IObservable<T> source, TimeSpan dueTime, ISequencer sequencer, IObserver<T> observer) : IDisposable
+    internal sealed class ShiftCoordinator<T>(IObservable<T> source, TimeSpan dueTime, ISequencer sequencer, IObserver<T> observer) : IDisposable
     {
         /// <summary>The source observable.</summary>
         private readonly IObservable<T> _source = source;
@@ -179,11 +79,22 @@ private enum NotificationKind
         /// <inheritdoc/>
         public void Dispose()
         {
-            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            if (!TryBeginDispose())
             {
                 return;
             }
 
+            ReleaseSubscriptions();
+        }
+
+        /// <summary>Claims disposal before waiting for an in-flight notification.</summary>
+        /// <returns>Whether this call owns resource cleanup.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal bool TryBeginDispose() => Interlocked.Exchange(ref _disposed, 1) == 0;
+
+        /// <summary>Releases resources after the active notification leaves the gate.</summary>
+        internal void ReleaseSubscriptions()
+        {
             lock (_gate)
             {
                 _timer.Dispose();
@@ -393,6 +304,106 @@ public static DelayedNotification Completed(DateTimeOffset dueAt) =>
         }
     }
 
+    /// <summary>Dedicated signal for <c>Calm</c> (quiet-period debounce).</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="dueTime">The quiet period.</param>
+    /// <param name="scheduler">The sequencer used to schedule quiet-period timers.</param>
+    private sealed class CalmSignal<T>(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<T> _source = source;
+
+        /// <summary>The quiet period.</summary>
+        private readonly TimeSpan _dueTime = dueTime;
+
+        /// <summary>The sequencer used to schedule quiet-period timers.</summary>
+        private readonly ISequencer _scheduler = scheduler;
+
+        /// <inheritdoc/>
+        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            CalmCoordinator<T> coordinator = new(_source, _dueTime, _scheduler);
+            if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
+            {
+                return coordinator.Run(observer);
+            }
+
+            SingleDisposable subscription = new();
+            _ = Sequencer.CurrentThread.Schedule(
+                (subscription, coordinator, observer),
+                static (_, s) =>
+                {
+                    s.subscription.Create(s.coordinator.Run(s.observer));
+                    return EmptyDisposable.Instance;
+                });
+            return subscription;
+        }
+    }
+
+    /// <summary>Dedicated signal for <c>Shift</c> (delay each notification on a sequencer).</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    private sealed class ShiftSignal<T> : IRequireCurrentThread<T>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<T> _source;
+
+        /// <summary>The delay applied to each notification.</summary>
+        private readonly TimeSpan _dueTime;
+
+        /// <summary>The sequencer used to schedule delayed notifications.</summary>
+        private readonly ISequencer _scheduler;
+
+        /// <summary>Initializes a new instance of the <see cref="ShiftSignal{T}"/> class.</summary>
+        /// <param name="source">The source observable.</param>
+        /// <param name="dueTime">The delay applied to each notification.</param>
+        /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
+        internal ShiftSignal(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler)
+        {
+            _source = source;
+            _dueTime = Sequencer.Normalize(dueTime);
+            _scheduler = scheduler;
+        }
+
+        /// <inheritdoc/>
+        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
+            {
+                return RunCore(observer);
+            }
+
+            SingleDisposable subscription = new();
+            _ = Sequencer.CurrentThread.Schedule(
+                (Self: this, subscription, observer),
+                static (_, s) =>
+                {
+                    s.subscription.Create(s.Self.RunCore(s.observer));
+                    return EmptyDisposable.Instance;
+                });
+            return subscription;
+        }
+
+        /// <summary>Subscribes to the source and schedules each notification by the delay.</summary>
+        /// <param name="observer">The downstream observer.</param>
+        /// <returns>The disposable that cancels the source subscription and pending timers.</returns>
+        private ShiftCoordinator<T> RunCore(IObserver<T> observer)
+        {
+            ShiftCoordinator<T> coordinator = new(_source, _dueTime, _scheduler, observer);
+            return coordinator.Run();
+        }
+    }
+
     /// <summary>Dedicated signal for absolute <c>Shift</c> overloads.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="source">The source observable.</param>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
index 8f5b7a35..bcd24388 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
@@ -36,9 +36,7 @@ public IDisposable Subscribe(IObserver<T> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // A current-thread source drains the trampoline inside whichever call enters it first. When that call
-            // is the source's own Subscribe, the sink does not hold the upstream subscription yet, so an endless
-            // source never learns the count was reached. Entering the trampoline here leaves Subscribe queueing only.
+            // Acquire the subscription before the trampoline delivers values that can terminate it.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -84,9 +82,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // Either arm can be a current-thread source, and whichever is subscribed first drains the trampoline
-            // inside that call, before the coordinator holds the subscription it needs in order to stop. Entering
-            // the trampoline here leaves both arms queueing only, so the coordinator owns both subscriptions first.
+            // Acquire both subscriptions before either trampoline starts delivering values.
             if ((!CurrentThreadRequirement.IsRequired(_source) && !CurrentThreadRequirement.IsRequired(_other))
                 || !CurrentThreadSequencer.IsScheduleRequired)
             {
@@ -458,9 +454,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // A current-thread source drains its trampoline inside its own Subscribe, so on an endless source the sink
-            // never receives the upstream subscription it would have to dispose. Entering the trampoline here leaves
-            // the source queueing only, so a failing predicate can stop it.
+            // Acquire the subscription before a predicate can stop the source.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
index 6457b889..d098d34f 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
@@ -11,29 +11,9 @@ namespace ReactiveUI.Primitives;
 /// <summary>The Switch operator: subscribes to the most recent inner sequence and drops the previous one.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>Dedicated signal for <c>SwitchTo</c> that hands each subscription to a coordinator.</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    private sealed class SwitchSignal<T> : IObservable<T>
-    {
-        /// <summary>The outer sequence of inner sources.</summary>
-        private readonly IObservable<IObservable<T>> _sources;
-
-        /// <summary>Initializes a new instance of the <see cref="SwitchSignal{T}"/> class.</summary>
-        /// <param name="sources">The outer sequence of inner sources.</param>
-        internal SwitchSignal(IObservable<IObservable<T>> sources) => _sources = sources;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            return new SwitchCoordinator<T>(observer).Run(_sources);
-        }
-    }
-
     /// <summary>Coordinates a switch operation.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
-    private sealed class SwitchCoordinator<T> : IDisposable
+    internal sealed class SwitchCoordinator<T> : IDisposable
     {
         /// <summary>The synchronization gate.</summary>
         private readonly Lock _gate = new();
@@ -63,6 +43,9 @@ private sealed class SwitchCoordinator<T> : IDisposable
         /// <param name="observer">The downstream observer.</param>
         internal SwitchCoordinator(IObserver<T> observer) => _observer = observer;
 
+        /// <summary>Gets the gate serializing switches and downstream notifications.</summary>
+        internal Lock Gate => _gate;
+
         /// <summary>Releases the active subscriptions.</summary>
         public void Dispose()
         {
@@ -197,4 +180,24 @@ private void TryComplete()
             _observer.OnCompleted();
         }
     }
+
+    /// <summary>Dedicated signal for <c>SwitchTo</c> that hands each subscription to a coordinator.</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    private sealed class SwitchSignal<T> : IObservable<T>
+    {
+        /// <summary>The outer sequence of inner sources.</summary>
+        private readonly IObservable<IObservable<T>> _sources;
+
+        /// <summary>Initializes a new instance of the <see cref="SwitchSignal{T}"/> class.</summary>
+        /// <param name="sources">The outer sequence of inner sources.</param>
+        internal SwitchSignal(IObservable<IObservable<T>> sources) => _sources = sources;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            return new SwitchCoordinator<T>(observer).Run(_sources);
+        }
+    }
 }
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
index 7d486880..77a9498a 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.MultiSource.cs
@@ -18,10 +18,7 @@ public static partial class LinqExtensions
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Combines the latest values from 3 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 3 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="TResult">The projected element type.</typeparam>
@@ -47,10 +44,7 @@ public IObservable<TResult> SyncLatest<T2, T3, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 4 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 4 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -81,10 +75,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 5 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 5 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -120,10 +111,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 6 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 6 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -164,10 +152,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 7 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 7 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -213,10 +198,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 8 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 8 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -271,10 +253,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 9 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 9 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
index c5ff8289..8b85dfce 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SyncLatest.WideArity.cs
@@ -18,10 +18,7 @@ public static partial class LinqExtensions
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Combines the latest values from 10 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 10 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -86,10 +83,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, TRes
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 11 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 11 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -159,10 +153,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 12 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 12 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -237,10 +228,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 13 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 13 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -320,10 +308,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 14 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 14 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -408,10 +393,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 15 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 15 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -501,10 +483,7 @@ public IObservable<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 16 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 16 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.cs b/src/Primitives.Shared/SignalOperatorMixins.cs
index eafa2030..fb5e66b2 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.cs
@@ -136,10 +136,7 @@ public IObservable<TResult> MapIndexed<TResult>(Func<T, int, TResult> selector)
             return new MapIndexedSignal<T, TResult>(source, selector);
         }
 
-        /// <summary>
-        /// Projects each element of an observable sequence into a new form by incorporating state that is passed to the
-        /// selector function.
-        /// </summary>
+        /// <summary>Projects each element of an observable sequence into a new form by incorporating state that is passed to the selector function.</summary>
         /// <typeparam name="TState">The type of the state used in the selector function.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
         /// <param name="state">The state to pass to the selector function.</param>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
index a7b60465..0b0e84f3 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
@@ -338,9 +338,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // The first value settles this operator, so it must be able to dispose the source the moment one arrives.
-            // A current-thread source drains its trampoline inside its own Subscribe, which would not return until the
-            // source ended — never, for an endless one — leaving the sink without the subscription it needs to stop it.
+            // Acquire the subscription before the first value can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -395,8 +393,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // The first matching value settles this operator, so it must own the source subscription before the source
-            // starts producing. See AnySignal for why a current-thread source livelocks without this bootstrap.
+            // Acquire the subscription before a match can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
index 0e786046..e386144f 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
@@ -38,9 +38,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // The first value the predicate rejects settles this operator, so it must own the source subscription
-            // before the source starts producing. A current-thread source drains its trampoline inside its own
-            // Subscribe, so on an endless source the sink would never be handed the subscription it needs to stop it.
+            // Acquire the subscription before a rejected value can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -129,8 +127,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // The value being sought settles this operator the moment it arrives, so it must own the source
-            // subscription before the source starts producing. See AllPredicateSignal for the livelock without this.
+            // Acquire the subscription before a match can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
index 39229e3e..26f721cf 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
@@ -228,9 +228,7 @@ private void OnOuterCompleted()
         /// <param name="value">The inner value.</param>
         private void OnInnerNext(TResult value)
         {
-            // Hot path: only one inner is active at a time (sequential concat semantics), so this forward is
-            // serialized without the gate. A volatile read of the disposed flag avoids a monitor acquire on
-            // every value; the lock releases elsewhere publish the write.
+            // One inner source runs at a time; the volatile disposal check needs no delivery gate.
             if (Volatile.Read(ref _disposed))
             {
                 return;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
index 085202b6..026c59f7 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
@@ -543,9 +543,7 @@ private void OnCompleted()
 
                 _done = true;
 
-                // Completion cuts the quiet window short rather than cancelling it, so a value the window was
-                // holding is delivered first. A value the timer delivered cleared _hasLatest under this same
-                // gate, so it cannot be emitted twice.
+                // Completion flushes the pending value; the timer clears the same flag under this gate.
                 if (_hasLatest)
                 {
                     _hasLatest = false;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
index 32bc2f72..4a9d399f 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
@@ -109,9 +109,7 @@ public void Dispose()
                 return;
             }
 
-            // Latch the terminal state as well as the resources: a source that ignores the disposal of its
-            // subscription can keep pushing, and its completion or error must not reach an unsubscribed observer.
-            // The gate is reentrant, so a terminal path may reach this while holding it.
+            // Latch termination to reject notifications from sources that ignore disposal.
             lock (_gate)
             {
                 _done = true;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
index 75860fea..e8633acc 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Tuples.cs
@@ -17,7 +17,6 @@ public static partial class LinqExtensions
     /// <summary>System.Reactive-named tuple-returning latest-value combination operators.</summary>
     /// <typeparam name="T">The element type of source 1.</typeparam>
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
-    /// <remarks>Lower overload priority keeps a call that passes an untyped null binding to the selector overload.</remarks>
     extension<T>(IObservable<T> source)
     {
         /// <summary>Combines latest values from 2 observable sources into tuple values.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
index f64774a8..4bb3c7f5 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.WideArity.cs
@@ -19,10 +19,7 @@ public static partial class LinqExtensions
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Combines the latest values from 10 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 10 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -73,10 +70,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source10,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 11 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 11 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -131,10 +125,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source11,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 12 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 12 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -193,10 +184,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source12,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 13 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 13 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -259,10 +247,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source13,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 14 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 14 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -329,10 +314,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source14,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 15 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 15 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -403,10 +385,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10, T
                 source15,
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 16 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 16 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
index 390af0f3..a68e7041 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.cs
@@ -18,10 +18,7 @@ public static partial class LinqExtensions
     /// <param name="source">Source observable 1 whose latest value is combined.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Combines the latest values from 3 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 3 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="TResult">The projected element type.</typeparam>
@@ -47,10 +44,7 @@ public IObservable<TResult> CombineLatest<T2, T3, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 4 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 4 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -81,10 +75,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 5 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 5 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -120,10 +111,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 6 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 6 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -164,10 +152,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 7 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 7 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -213,10 +198,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 8 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 8 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -271,10 +253,7 @@ public IObservable<TResult> CombineLatest<T2, T3, T4, T5, T6, T7, T8, TResult>(
                 selector);
         }
 
-        /// <summary>
-        /// Combines the latest values from 9 observable sources into a single sequence,
-        /// projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 9 observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.cs b/src/Primitives.Shared/SignalOperatorParityMixins.cs
index 3bacf622..a47bd918 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.cs
@@ -796,8 +796,7 @@ public IObservable<T> ToObservable()
         /// <exception cref="ArgumentNullException">The receiver task is <see langword="null"/>.</exception>
         public Task<T> ToTask() => task ?? throw new ArgumentNullException(nameof(task));
 
-        /// <summary>Returns a task that mirrors the supplied task but transitions to the canceled state when
-        /// <paramref name="cancellationToken"/> is canceled first.</summary>
+        /// <summary>Returns a task that mirrors the supplied task but transitions to the canceled state when <paramref name="cancellationToken"/> is canceled first.</summary>
         /// <param name="cancellationToken">The token used to cancel the returned task.</param>
         /// <returns>The supplied task, or a task that completes with the supplied task's outcome or cancels when <paramref name="cancellationToken"/> is canceled.</returns>
         /// <exception cref="ArgumentNullException">The receiver task is <see langword="null"/>.</exception>
@@ -837,8 +836,7 @@ private static async Task<T> AwaitWithCancellationAsync<T>(Task<T> task, Cancell
         }
         catch (OperationCanceledException)
         {
-            // The wait is abandoned while the underlying task can keep running, so observe any later fault
-            // to keep it from surfacing as an UnobservedTaskException on the finalizer thread.
+            // Observe faults from work that outlives cancellation of the wait.
             _ = task.ContinueWith(
                 static abandoned => _ = abandoned.Exception,
                 CancellationToken.None,
diff --git a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
index bc2c2f7f..b971523a 100644
--- a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
@@ -192,11 +192,7 @@ private bool Enqueue(T value)
         }
     }
 
-    /// <summary>Forwards queued values downstream while capacity is available.</summary>
-    /// <remarks>
-    /// Only one thread delivers downstream at a time: a caller that finds a drain in progress leaves its work to the
-    /// owner, and the owner re-checks for queued work under the gate before relinquishing ownership, so no wakeup is lost.
-    /// </remarks>
+    /// <summary>Drains queued notifications with one delivery owner, checking for pending work before releasing ownership.</summary>
     private void YieldUntilEmptyOrBlocked()
     {
         if (!TryBeginDrain())
@@ -252,8 +248,7 @@ private bool TryTakeNextDrainItem(out DrainItem item)
                 return true;
             }
 
-            // No work remains; release ownership atomically with the empty check so a
-            // producer that queues work after this point will be able to begin a fresh drain.
+            // Release ownership under the queue gate so subsequent producers can start a drain.
             _isDraining = false;
             return false;
         }
diff --git a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
index 06b85cd6..c051205e 100644
--- a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
+++ b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
@@ -137,6 +137,9 @@ public ReplaySignal(TimeSpan window)
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
     public bool IsDisposed { get; private set; }
 
+    /// <summary>Gets the gate shared by replay and live delivery.</summary>
+    internal Lock Gate => _observerLock;
+
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
@@ -214,10 +217,7 @@ public void OnError(Exception error)
 
     /// <summary>Buffers the value for replay and broadcasts it to the current observers.</summary>
     /// <param name="value">The value to emit.</param>
-    /// <remarks>
-    /// The append and the broadcast share the gate <see cref="Subscribe"/> holds while it attaches an observer and
-    /// replays the buffer, so a value reaches a new observer either through replay or live, never both or out of order.
-    /// </remarks>
+    /// <remarks>Concurrent subscription receives each value once, through replay or live delivery, in emission order.</remarks>
     public void OnNext(T value)
     {
         // Read the scheduler clock outside the lock; the window inputs are immutable.
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
index a15b63e8..200334d2 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs
@@ -32,9 +32,7 @@ public IObservable<TSource> Recover()
     /// <param name="source">Source sequence to recover or clean up.</param>
     extension<TSource>(IObservable<TSource> source)
     {
-        /// <summary>
-        /// Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.
-        /// </summary>
+        /// <summary>Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.</summary>
         /// <typeparam name="TException">The type of the exception to catch and handle. Needs to derive from <see cref="Exception"/>.</typeparam>
         /// <param name="handler">Exception handler function, producing another observable sequence.</param>
         /// <returns>
diff --git a/src/Primitives.Shared/Signals/Signal{Create}.cs b/src/Primitives.Shared/Signals/Signal{Create}.cs
index 61632298..182218f6 100644
--- a/src/Primitives.Shared/Signals/Signal{Create}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Create}.cs
@@ -76,10 +76,7 @@ public static IObservable<T> Create<T>(
         return new CreateSignal<T>(subscribe, isRequiredSubscribeOnCurrentThread);
     }
 
-    /// <summary>
-    /// Creates a signal that passes the state to the subscribe function for each observer, so the function can be
-    /// static instead of capturing a closure.
-    /// </summary>
+    /// <summary>Creates a signal that passes the state to the subscribe function for each observer, so the function can be static instead of capturing a closure.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <typeparam name="TState">The type of the captured state.</typeparam>
     /// <param name="state">The state passed to <paramref name="subscribe"/> on each subscription.</param>
@@ -95,10 +92,7 @@ public static IObservable<T> CreateWithState<T, TState>(
         return new CreateSignal<T, TState>(state, subscribe);
     }
 
-    /// <summary>
-    /// Creates a signal that passes the state to the subscribe function for each observer, so the function can be
-    /// static instead of capturing a closure.
-    /// </summary>
+    /// <summary>Creates a signal that passes the state to the subscribe function for each observer, so the function can be static instead of capturing a closure.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <typeparam name="TState">The type of the captured state.</typeparam>
     /// <param name="state">The state passed to <paramref name="subscribe"/> on each subscription.</param>
@@ -116,10 +110,7 @@ public static IObservable<T> CreateWithState<T, TState>(
         return new CreateSignal<T, TState>(state, subscribe, isRequiredSubscribeOnCurrentThread);
     }
 
-    /// <summary>
-    /// Creates a signal that runs the subscribe function for each observer and releases the subscription when a
-    /// downstream <c>OnNext</c> throws, which suits cold signals.
-    /// </summary>
+    /// <summary>Creates a signal that runs the subscribe function for each observer and releases the subscription when a downstream <c>OnNext</c> throws, which suits cold signals.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
     /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
@@ -131,10 +122,7 @@ public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subsc
         return new CreateSafeSignal<T>(subscribe);
     }
 
-    /// <summary>
-    /// Creates a signal that runs the subscribe function for each observer and releases the subscription when a
-    /// downstream <c>OnNext</c> throws, which suits cold signals.
-    /// </summary>
+    /// <summary>Creates a signal that runs the subscribe function for each observer and releases the subscription when a downstream <c>OnNext</c> throws, which suits cold signals.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
     /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
diff --git a/src/Primitives.Shared/Signals/Signal{FromTask}.cs b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
index 201b5645..161c63ec 100644
--- a/src/Primitives.Shared/Signals/Signal{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
@@ -74,6 +74,61 @@ public static ITaskSignal<TResult> FromTask<TResult>(
         CancellationTokenSource? cancellationTokenSource) =>
         CreateTaskSignal(actionAsync, scheduler, cancellationTokenSource);
 
+    /// <summary>Builds a disposer that cancels the source if it wins the terminal transition.</summary>
+    /// <param name="gate">The terminal-notification gate shared with the continuation.</param>
+    /// <param name="source">The cancellation source to cancel on disposal.</param>
+    /// <returns>The disposer.</returns>
+    internal static ActionDisposable CancelOnDispose(TaskStopGate gate, CancellationTokenSource source) =>
+        new(() =>
+        {
+            if (!gate.TryStop())
+            {
+                return;
+            }
+
+            Cancel(source);
+        });
+
+    /// <summary>Delivers task completion only if the subscription has not claimed disposal.</summary>
+    /// <typeparam name="TResult">The result type.</typeparam>
+    /// <param name="cancellableTask">The task raced against cancellation.</param>
+    /// <param name="observer">The observer receiving the notification.</param>
+    /// <param name="gate">The terminal-notification gate shared with the disposer.</param>
+    /// <param name="token">The token checked for cancellation.</param>
+    /// <returns>A task that completes once the notification is forwarded or suppressed.</returns>
+    internal static async Task ObserveTask<TResult>(
+        Task<(TResult Value, bool IsCanceled)> cancellableTask,
+        IObserver<TResult> observer,
+        TaskStopGate gate,
+        CancellationToken token)
+    {
+        try
+        {
+            var (result, isCanceled) = await cancellableTask.ConfigureAwait(false);
+            if (!gate.TryStop())
+            {
+                return;
+            }
+
+            if (!isCanceled && !token.IsCancellationRequested)
+            {
+                observer.OnNext(result);
+                observer.OnCompleted();
+            }
+            else
+            {
+                observer.OnError(new OperationCanceledException());
+            }
+        }
+        catch (Exception error)
+        {
+            if (gate.TryStop())
+            {
+                observer.OnError(error);
+            }
+        }
+    }
+
     /// <summary>Builds the task-backed signal, taking a direct-subscription form for the immediate sequencer.</summary>
     /// <typeparam name="TResult">The result type.</typeparam>
     /// <param name="execution">The function to execute.</param>
@@ -128,30 +183,12 @@ private static IDisposable SubscribeTask<TResult>(
         return CancelOnDispose(gate, source);
     }
 
-    /// <summary>Builds a disposer that cancels the source if it wins the terminal transition.</summary>
-    /// <param name="gate">The terminal-notification gate shared with the continuation.</param>
-    /// <param name="source">The cancellation source to cancel on disposal.</param>
-    /// <returns>The disposer.</returns>
-    private static ActionDisposable CancelOnDispose(TaskStopGate gate, CancellationTokenSource source) =>
-        new(() =>
-        {
-            if (!gate.TryStop())
-            {
-                return;
-            }
-
-            Cancel(source);
-        });
-
-    /// <summary>Emits the terminal notification synchronously when the task has finished.</summary>
+    /// <summary>Delivers synchronous completion before the subscription handle is returned.</summary>
     /// <typeparam name="TResult">The result type.</typeparam>
     /// <param name="task">The task to inspect.</param>
     /// <param name="observer">The observer receiving the notification.</param>
     /// <param name="token">The token checked for cancellation.</param>
     /// <returns><see langword="true"/> when a synchronous terminal notification was produced.</returns>
-    /// <remarks>
-    /// Runs before any disposer is handed out, so no dispose race is possible and the emission needs no gate.
-    /// </remarks>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
@@ -183,50 +220,6 @@ private static bool TryEmitSynchronously<TResult>(
         return true;
     }
 
-    /// <summary>Observes a pending task and forwards the terminal notification while honoring disposal.</summary>
-    /// <typeparam name="TResult">The result type.</typeparam>
-    /// <param name="cancellableTask">The task raced against cancellation.</param>
-    /// <param name="observer">The observer receiving the notification.</param>
-    /// <param name="gate">The terminal-notification gate shared with the disposer.</param>
-    /// <param name="token">The token checked for cancellation.</param>
-    /// <returns>A task that completes once the notification is forwarded or suppressed.</returns>
-    /// <remarks>
-    /// The notification is gated on <see cref="TaskStopGate.TryStop"/>, the transition the disposer wins on teardown,
-    /// so a subscription disposed while this continuation runs observes nothing.
-    /// </remarks>
-    private static async Task ObserveTask<TResult>(
-        Task<(TResult Value, bool IsCanceled)> cancellableTask,
-        IObserver<TResult> observer,
-        TaskStopGate gate,
-        CancellationToken token)
-    {
-        try
-        {
-            var (result, isCanceled) = await cancellableTask.ConfigureAwait(false);
-            if (!gate.TryStop())
-            {
-                return;
-            }
-
-            if (!isCanceled && !token.IsCancellationRequested)
-            {
-                observer.OnNext(result);
-                observer.OnCompleted();
-            }
-            else
-            {
-                observer.OnError(new OperationCanceledException());
-            }
-        }
-        catch (Exception error)
-        {
-            if (gate.TryStop())
-            {
-                observer.OnError(error);
-            }
-        }
-    }
-
     /// <summary>Cancels the source, tolerating a source another completion path disposed.</summary>
     /// <param name="source">The cancellation source to cancel.</param>
     private static void Cancel(CancellationTokenSource source)
@@ -241,6 +234,17 @@ private static void Cancel(CancellationTokenSource source)
         }
     }
 
+    /// <summary>Claims completion before notifying the observer, excluding disposed subscriptions.</summary>
+    internal sealed class TaskStopGate
+    {
+        /// <summary>Non-zero once the continuation has emitted or the subscription has been disposed.</summary>
+        private int _stopped;
+
+        /// <summary>Attempts to win the terminal transition.</summary>
+        /// <returns><see langword="true"/> when this caller won the stop race.</returns>
+        internal bool TryStop() => Interlocked.Exchange(ref _stopped, 1) == 0;
+    }
+
     /// <summary>Task signal that starts the task in <c>Subscribe</c> rather than through a nested observable pipeline.</summary>
     /// <typeparam name="TResult">The result type.</typeparam>
     private sealed class ImmediateTaskSignal<TResult> : ITaskSignal<TResult>
@@ -344,19 +348,4 @@ private void ThrowIfDisposed()
             throw new ObjectDisposedException(nameof(ImmediateTaskSignal<>));
         }
     }
-
-    /// <summary>Atomic gate that serializes the terminal notification against subscription disposal.</summary>
-    /// <remarks>
-    /// The task continuation and the disposer race on a single <see cref="Interlocked.Exchange(ref int, int)"/> and only
-    /// the winner proceeds, so no notification reaches a disposed subscription.
-    /// </remarks>
-    private sealed class TaskStopGate
-    {
-        /// <summary>Non-zero once the continuation has emitted or the subscription has been disposed.</summary>
-        private int _stopped;
-
-        /// <summary>Attempts to win the terminal transition.</summary>
-        /// <returns><see langword="true"/> when this caller won the stop race.</returns>
-        public bool TryStop() => Interlocked.Exchange(ref _stopped, 1) == 0;
-    }
 }
diff --git a/src/Primitives.Shared/Signals/TaskSignal{T}.cs b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
index 9e5d77f3..cfd1e872 100644
--- a/src/Primitives.Shared/Signals/TaskSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
@@ -65,15 +65,11 @@ public IDisposable Subscribe(IObserver<T> observer)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Dispose() => Dispose(true);
 
-    /// <summary>Creates a task-backed signal whose source the supplied factory builds.</summary>
+    /// <summary>Invokes the factory after the signal is fully initialized.</summary>
     /// <param name="observableFactory">Builds the source, receiving the signal it will belong to.</param>
     /// <param name="sequencer">The sequencer subscriptions are observed on.</param>
     /// <param name="cancellationTokenSource">The cancellation source to observe.</param>
     /// <returns>The created signal.</returns>
-    /// <remarks>
-    /// The factory receives the signal and may subscribe to, dispose, or store it the moment it is called, so
-    /// construction finishes before the factory runs rather than calling it from the constructor.
-    /// </remarks>
     internal static TaskSignal<T> Create(
         Func<ITaskSignal<T>, IObservable<T>> observableFactory,
         ISequencer? sequencer = null,
diff --git a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
index 9eedb81e..b43d4a94 100644
--- a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
@@ -10,11 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Signals;
 namespace ReactiveUI.Primitives.Signals;
 #endif
 
-/// <summary>
-/// Owns the task source, the source subscription and the cancellation registration for task-returning terminals.
-/// Callers wire their observer callbacks to <see cref="Resolve"/>/<see cref="Fail"/> and hand the subscription to
-/// <see cref="Attach"/>, which registers for cancellation only while the task is pending.
-/// </summary>
+/// <summary>Owns terminal task completion, the source subscription, and cancellation registration while pending.</summary>
 /// <typeparam name="T">The task result type.</typeparam>
 internal sealed class TaskTerminalCompletion<T>
 {
diff --git a/src/ReactiveUI.Disposables/Disposables/DisposableSlotHelper.cs b/src/ReactiveUI.Disposables/Disposables/DisposableSlotHelper.cs
index 7c176fe4..fcec9ec7 100644
--- a/src/ReactiveUI.Disposables/Disposables/DisposableSlotHelper.cs
+++ b/src/ReactiveUI.Disposables/Disposables/DisposableSlotHelper.cs
@@ -2,33 +2,15 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
-
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>
-/// Pure-plumbing helpers for the swap-disposable-slot pattern shared by
-/// <see cref="MutableDisposable"/> and <see cref="SwapDisposable"/>. Centralizes the
-/// pre-check / store / race-recheck flow so the call-site setters stay one-line delegations.
-/// All testable branches (already-disposed pre-check, steady-state assign, idempotent dispose)
-/// have direct RxVoid tests against this class. The single race-recheck step that fires only
-/// when <c>Dispose()</c> runs concurrently between the helper's <c>Volatile.Read</c> pre-check
-/// and the store is isolated in <see cref="DisposeIfRaced"/>, which is marked
-/// <see cref="ExcludeFromCodeCoverageAttribute"/>. That step is unreachable without a real
-/// concurrent thread, in the same spirit as the library's throw-helper methods.
-/// </summary>
+/// <summary>Assigns and disposes slots according to their holder's disposal state.</summary>
 internal static class DisposableSlotHelper
 {
     /// <summary>Sentinel value indicating the holder has been disposed.</summary>
     internal const int DisposedSentinel = 1;
 
-    /// <summary>
-    /// Reassigns an inner disposable slot WITHOUT disposing the previous value (mutable-assign
-    /// semantics, matching the <see cref="MutableDisposable"/> contract). If the holder is
-    /// already disposed, the incoming value is disposed immediately; if Dispose races between
-    /// the pre-check and the store, the just-stored value is disposed via
-    /// <see cref="DisposeIfRaced"/>.
-    /// </summary>
+    /// <summary>Replaces a slot without disposing its previous value; a disposed holder disposes the incoming value.</summary>
     /// <param name="slot">The reference to the current-inner field.</param>
     /// <param name="disposed">The reference to the disposed-flag field.</param>
     /// <param name="value">The incoming value (or <see langword="null"/>).</param>
@@ -47,12 +29,7 @@ internal static void AssignWithoutDisposingPrevious(
         DisposeIfRaced(ref slot, ref disposed);
     }
 
-    /// <summary>
-    /// Reassigns an inner disposable slot and disposes the previous value (swap semantics,
-    /// matching the <see cref="SwapDisposable"/> contract). If the holder is already disposed,
-    /// the incoming value is disposed immediately; if Dispose races between the swap and the
-    /// recheck, the just-stored value is disposed via <see cref="DisposeIfRaced"/>.
-    /// </summary>
+    /// <summary>Replaces a slot and disposes its previous value; a disposed holder also disposes the incoming value.</summary>
     /// <param name="slot">The reference to the current-inner field.</param>
     /// <param name="disposed">The reference to the disposed-flag field.</param>
     /// <param name="value">The incoming value (or <see langword="null"/>).</param>
@@ -72,12 +49,7 @@ internal static void SwapAndDisposePrevious(
         DisposeIfRaced(ref slot, ref disposed);
     }
 
-    /// <summary>
-    /// Performs the standard idempotent dispose step: latches the disposed flag and disposes
-    /// the current inner (if any). Returns <see langword="true"/> if this was the first call
-    /// and the caller should clean up; <see langword="false"/> if a prior dispose has already
-    /// done the work.
-    /// </summary>
+    /// <summary>Claims disposal and releases the inner value, returning true only for the first caller.</summary>
     /// <param name="slot">The reference to the current-inner field.</param>
     /// <param name="disposed">The reference to the disposed-flag field.</param>
     /// <returns>
@@ -95,16 +67,10 @@ internal static bool TryDispose(ref IDisposable? slot, ref int disposed)
         return true;
     }
 
-    /// <summary>
-    /// Race-only cleanup: if <c>Dispose()</c> ran concurrently between the setter's pre-check
-    /// and the slot store, swap the value out and dispose it to avoid leaking. The branch
-    /// only fires when a real concurrent thread cancels in the TOCTOU window, which cannot
-    /// be deterministically simulated in single-threaded RxVoid tests, hence the exclusion.
-    /// </summary>
+    /// <summary>Releases the stored value if disposal overlaps assignment.</summary>
     /// <param name="slot">The reference to the current-inner field.</param>
     /// <param name="disposed">The reference to the disposed-flag field.</param>
-    [ExcludeFromCodeCoverage]
-    private static void DisposeIfRaced(ref IDisposable? slot, ref int disposed)
+    internal static void DisposeIfRaced(ref IDisposable? slot, ref int disposed)
     {
         if (Volatile.Read(ref disposed) != DisposedSentinel)
         {
diff --git a/src/ReactiveUI.Disposables/Disposables/Scope.cs b/src/ReactiveUI.Disposables/Disposables/Scope.cs
index b6c917a9..2fb72c46 100644
--- a/src/ReactiveUI.Disposables/Disposables/Scope.cs
+++ b/src/ReactiveUI.Disposables/Disposables/Scope.cs
@@ -15,7 +15,7 @@ public static class Scope
     /// <summary>Creates a disposable object that invokes the specified action when disposed.</summary>
     /// <param name="dispose">Action to run during the first call to <see cref="IDisposable.Dispose"/>. The action is guaranteed to be run at most once.</param>
     /// <returns>The disposable object that runs the given action upon disposal.</returns>
-    /// <remarks>A <see langword="null"/> action returns <see cref="Empty"/> for backward compatibility with existing ReactiveUI.Primitives create pipelines.</remarks>
+    /// <remarks>A <see langword="null"/> action returns <see cref="Empty"/>.</remarks>
     public static IDisposable Create(Action dispose) =>
         dispose is null ? Empty : new ActionDisposable(dispose);
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
index 4e644a8e..43006eba 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
@@ -7,12 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Asynchronous mutual-exclusion primitive that serializes critical sections in the async pipeline.
-/// Each acquire hands back a <see cref="Lease"/> that releases the gate when disposed. Ownership is keyed
-/// on the managed thread id, so a nested acquire on the holding thread is granted immediately and reentry
-/// is recognised only while the caller stays on the thread that took the gate.
-/// </summary>
+/// <summary>Serializes asynchronous critical sections with disposable leases. Reentrant acquisition is allowed only on the managed thread that currently owns the gate.</summary>
 [System.Diagnostics.DebuggerDisplay("AsyncSerialGate: OwnerThreadId = {_ownerThreadId}, Waiters = {_waiters}, RecursionDepth = {_recursionDepth}")]
 public sealed class AsyncSerialGate : IDisposable
 {
@@ -47,23 +42,10 @@ public ValueTask<Lease> EnterAsync() =>
     /// <returns>A <see cref="ValueTask{Lease}"/> that completes when the gate has been acquired.</returns>
     /// <exception cref="OperationCanceledException">Thrown when the token is cancelled before the gate is
     /// acquired.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [DebuggerStepThrough]
-    public ValueTask<Lease> EnterAsync(CancellationToken cancellationToken)
-    {
-        var currentThreadId = Environment.CurrentManagedThreadId;
-
-        // Same-thread reentry: the calling thread owns the gate, so bumping depth needs no synchronization.
-        if (Volatile.Read(ref _ownerThreadId) == currentThreadId)
-        {
-            _recursionDepth++;
-            return new(new Lease(this));
-        }
-
-        // Fast uncontended acquire: pure CAS, no semaphore touch.
-        return Interlocked.CompareExchange(ref _ownerThreadId, currentThreadId, 0) == 0
-            ? new(new Lease(this))
-            : WaitForEntryAsync(cancellationToken);
-    }
+    public ValueTask<Lease> EnterAsync(CancellationToken cancellationToken) =>
+        EnterForThreadAsync(Environment.CurrentManagedThreadId, cancellationToken);
 
     /// <inheritdoc/>
     public void Dispose()
@@ -76,40 +58,40 @@ public void Dispose()
         _semaphore.Dispose();
     }
 
-    /// <summary>
-    /// Exits the gate. Decrements the recursion depth on a nested exit, or clears the owner
-    /// and signals one waiter (if any) on the outermost release.
-    /// </summary>
-    internal void Exit()
+    /// <summary>Acquires ownership for the supplied caller thread, allowing same-thread reentry.</summary>
+    /// <param name="currentThreadId">The calling thread identifier.</param>
+    /// <param name="cancellationToken">Cancellation observed while waiting.</param>
+    /// <returns>The acquired gate lease.</returns>
+    internal ValueTask<Lease> EnterForThreadAsync(int currentThreadId, CancellationToken cancellationToken)
     {
-        if (_recursionDepth > 0)
+        if (Volatile.Read(ref _ownerThreadId) == currentThreadId)
         {
-            _recursionDepth--;
-            return;
+            _recursionDepth++;
+            return new(new Lease(this));
         }
 
-        Volatile.Write(ref _ownerThreadId, 0);
-        WakeNextWaiter();
+        return Interlocked.CompareExchange(ref _ownerThreadId, currentThreadId, 0) == 0
+            ? new(new Lease(this))
+            : WaitForEntryAsync(cancellationToken);
     }
 
-    /// <summary>
-    /// Signals one parked waiter if any are present. A signal released after the last waiter has left
-    /// lands in the semaphore count and is consumed by the next waiter to arrive.
-    /// </summary>
-    private void WakeNextWaiter()
+    /// <summary>Exits the gate. Decrements the recursion depth on a nested exit, or clears the owner and signals one waiter (if any) on the outermost release.</summary>
+    internal void Exit()
     {
-        if (Volatile.Read(ref _waiters) == 0)
+        if (_recursionDepth > 0)
         {
+            _recursionDepth--;
             return;
         }
 
-        _ = _semaphore.Release();
+        Volatile.Write(ref _ownerThreadId, 0);
+        WakeNextWaiter();
     }
 
     /// <summary>Slow path: park as a waiter and retry the acquire CAS after each semaphore signal.</summary>
     /// <param name="cancellationToken">Cancellation token observed while waiting.</param>
     /// <returns>A <see cref="Lease"/> for the acquired gate.</returns>
-    private async ValueTask<Lease> WaitForEntryAsync(CancellationToken cancellationToken)
+    internal async ValueTask<Lease> WaitForEntryAsync(CancellationToken cancellationToken)
     {
         _ = Interlocked.Increment(ref _waiters);
         try
@@ -132,6 +114,17 @@ private async ValueTask<Lease> WaitForEntryAsync(CancellationToken cancellationT
         }
     }
 
+    /// <summary>Signals one parked waiter if any are present; a late signal is consumed by the next waiter.</summary>
+    private void WakeNextWaiter()
+    {
+        if (Volatile.Read(ref _waiters) == 0)
+        {
+            return;
+        }
+
+        _ = _semaphore.Release();
+    }
+
     /// <summary>Holds one acquisition of an <see cref="AsyncSerialGate"/> and releases it on disposal.</summary>
     [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
     public readonly record struct Lease : IDisposable
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
index cdba6c72..4e1a6b1f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
@@ -53,8 +53,7 @@ public FlatMapCoordinator(IObserverAsync<TResult> observer)
     /// <summary>Gets or sets a value indicating whether this coordinator has been disposed.</summary>
     private bool Disposed { get; set; }
 
-    /// <summary>Takes ownership of the outer subscription, disposing it immediately when this coordinator
-    /// has finished. Callable once per coordinator.</summary>
+    /// <summary>Takes ownership of the outer subscription, disposing it immediately when this coordinator has finished. Callable once per coordinator.</summary>
     /// <param name="observer">The outer subscription to own.</param>
     /// <returns>A task that completes once the subscription has been stored or disposed.</returns>
     /// <exception cref="InvalidOperationException">Thrown when an outer subscription is set twice.</exception>
@@ -117,8 +116,7 @@ public async ValueTask SubscribeInnerAsync(IObservableAsync<TResult> inner)
         }
     }
 
-    /// <summary>Forwards an inner value downstream, serialized against the other inner sequences so the observer
-    /// is never entered concurrently.</summary>
+    /// <summary>Forwards an inner value downstream, serialized against the other inner sequences so the observer is never entered concurrently.</summary>
     /// <param name="value">The value.</param>
     /// <returns>A task that completes once the observer has accepted the value.</returns>
     public async ValueTask RelayNextAsync(TResult value)
@@ -129,8 +127,7 @@ public async ValueTask RelayNextAsync(TResult value)
         }
     }
 
-    /// <summary>Forwards a non-terminal error downstream under the same serialization as values, leaving the
-    /// sequence running.</summary>
+    /// <summary>Forwards a non-terminal error downstream under the same serialization as values, leaving the sequence running.</summary>
     /// <param name="error">The error.</param>
     /// <returns>A task that completes once the observer has accepted the error.</returns>
     public async ValueTask RelayErrorAsync(Exception error)
@@ -141,8 +138,7 @@ public async ValueTask RelayErrorAsync(Exception error)
         }
     }
 
-    /// <summary>Records outer completion, finishing the sequence when the result is a failure or no inner
-    /// sequence is active, and otherwise waiting for the active inner sequences.</summary>
+    /// <summary>Records outer completion, finishing the sequence when the result is a failure or no inner sequence is active, and otherwise waiting for the active inner sequences.</summary>
     /// <param name="result">The completion result.</param>
     /// <returns>A task that completes once the sequence has finished, or immediately when it continues.</returns>
     public ValueTask CompleteOuterAsync(Result result)
@@ -157,8 +153,7 @@ public ValueTask CompleteOuterAsync(Result result)
         return shouldComplete ? FinishAsync(result) : default;
     }
 
-    /// <summary>Records one inner sequence finishing, completing the sequence when the result is a failure or
-    /// when the outer source has completed and no inner sequence remains.</summary>
+    /// <summary>Records one inner sequence finishing, completing the sequence when the result is a failure or when the outer source has completed and no inner sequence remains.</summary>
     /// <param name="result">The completion result.</param>
     /// <returns>A task that completes once the sequence has finished, or immediately when it continues.</returns>
     public ValueTask CompleteInnerAsync(Result result)
@@ -177,8 +172,7 @@ public ValueTask CompleteInnerAsync(Result result)
         return shouldComplete ? FinishAsync(result) : default;
     }
 
-    /// <summary>Completes the downstream observer and disposes every tracked subscription. Idempotent; a failure
-    /// handed in after teardown goes to the unhandled exception handler.</summary>
+    /// <summary>Completes the downstream observer and disposes every tracked subscription. Idempotent; a failure handed in after teardown goes to the unhandled exception handler.</summary>
     /// <param name="result">The result to forward, or <see langword="null"/> to tear down without completing
     /// the observer.</param>
     /// <returns>A task that completes once teardown has finished.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
index 79580141..7d7b45b5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IReentrantAsyncDisposable.cs
@@ -5,9 +5,7 @@
 namespace ReactiveUI.Primitives.Async.Advanced;
 
 /// <summary>An async-disposable that can be disposed from within its own in-flight notification.</summary>
-/// <remarks>A terminal sink disposes itself from inside the <c>OnNext</c>/<c>OnCompleted</c> call that produced
-/// its result, which <see cref="IAsyncDisposable.DisposeAsync"/> cannot serve: that path waits for in-flight calls
-/// to drain, and the notification awaiting the dispose is one of them. This entry point skips the self-join.</remarks>
+/// <remarks>Disposal from inside an observer callback must not wait for that same callback to finish.</remarks>
 public interface IReentrantAsyncDisposable
 {
     /// <summary>Disposes from within the object's own in-flight notification, skipping the in-flight-call wait.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
index 0dba9c7d..7be36594 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
@@ -2,17 +2,13 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks.Sources;
 using ReactiveUI.Primitives.Internal;
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Poolable <see cref="IValueTaskSource"/> backing <c>DelayAsync</c> for non-System
-/// <see cref="TimeProvider"/> instances, so a delay costs no per-call allocation.
-/// </summary>
+/// <summary>Poolable <see cref="IValueTaskSource"/> backing <c>DelayAsync</c> for non-System <see cref="TimeProvider"/> instances, so a delay costs no per-call allocation.</summary>
 /// <remarks>
 /// Whichever of the timer callback and the cancellation registration fires first claims completion
 /// through an <see cref="Interlocked.CompareExchange(ref int, int, int)"/> on a state flag; the
@@ -27,11 +23,7 @@ public sealed class PooledDelaySource : IValueTaskSource
     /// <summary>State value for <see cref="_completed"/> meaning "either timer or cancellation claimed completion".</summary>
     private const int StateClaimed = 1;
 
-    /// <summary>
-    /// Per-thread cached instance; one slot per thread suffices because the operators that consume
-    /// <c>DelayAsync</c> serialise their work behind a gate, so a thread holds at most one
-    /// in-flight delay per operator.
-    /// </summary>
+    /// <summary>One reusable delay source per thread; concurrent rentals allocate when this slot is empty.</summary>
     [ThreadStatic]
     private static PooledDelaySource? _threadCached;
 
@@ -135,7 +127,6 @@ public void GetResult(short token)
     }
 
     /// <summary>Completes the delay successfully when the timer's dueTime elapses, unless cancellation claimed it first.</summary>
-    [ExcludeFromCodeCoverage]
     private void OnTimerFired()
     {
         if (!ConcurrencyRaceHelpers.TryClaim(ref _completed, StateOpen, StateClaimed))
@@ -148,7 +139,6 @@ private void OnTimerFired()
 
     /// <summary>Faults the delay with <see cref="OperationCanceledException"/> when the caller's token fires, unless the timer claimed it first.</summary>
     /// <param name="cancellationToken">The cancellation token that fired.</param>
-    [ExcludeFromCodeCoverage]
     private void OnCancelled(CancellationToken cancellationToken)
     {
         if (!ConcurrencyRaceHelpers.TryClaim(ref _completed, StateOpen, StateClaimed))
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
index f6d753ca..5eacb0fe 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
@@ -55,11 +55,7 @@ internal ValueTask RelaySourceErrorAsync(Exception error, CancellationToken canc
         return Lifecycle.OnErrorResumeAsync(error);
     }
 
-    /// <summary>
-    /// Projects the latest-value slots through the selector and forwards the result downstream, doing
-    /// nothing until every source has produced a value. Called after a per-source OnNext has landed
-    /// under <see cref="ValuesLock"/>.
-    /// </summary>
+    /// <summary>Projects the latest values once every source has emitted. Called after updating a slot under ValuesLock.</summary>
     /// <returns>A ValueTask representing the asynchronous emit.</returns>
     internal abstract ValueTask EmitLatestAsync();
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestWitness{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestWitness{TSource,TResult}.cs
index 8f9d327b..18377710 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestWitness{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestWitness{TSource,TResult}.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Per-source observer used by arity-specific <c>SyncLatest</c> coordinators to record typed source values
-/// and forward source terminal notifications to the shared lifecycle.
-/// </summary>
+/// <summary>Per-source observer used by arity-specific <c>SyncLatest</c> coordinators to record typed source values and forward source terminal notifications to the shared lifecycle.</summary>
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TResult">The downstream element type.</typeparam>
 /// <param name="parent">The parent coordinator.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
index 2850efc3..4c9bfb5c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilSourceWitness.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// <see cref="WitnessAsync{T}"/> that forwards every source notification straight into a
-/// <see cref="TakeUntilLifecycle{T}"/>, which gates it on its way downstream.
-/// </summary>
+/// <summary><see cref="WitnessAsync{T}"/> that forwards every source notification straight into a <see cref="TakeUntilLifecycle{T}"/>, which gates it on its way downstream.</summary>
 /// <typeparam name="T">The downstream element type.</typeparam>
 /// <param name="lifecycle">The shared lifecycle owning the gate and forwarding logic.</param>
 public sealed class TakeUntilSourceWitness<T>(TakeUntilLifecycle<T> lifecycle) : WitnessAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
index bee366c6..1d93ba50 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// A subscription that runs a cancellable asynchronous job feeding a single observer, and joins that
-/// job on disposal.
-/// </summary>
+/// <summary>A subscription that runs a cancellable asynchronous job feeding a single observer, and joins that job on disposal.</summary>
 /// <typeparam name="T">The type of the elements observed by the subscription.</typeparam>
 /// <param name="observer">The observer that receives notifications for the subscription. Cannot be null.</param>
 /// <remarks>Disposal cancels the running job and waits for it to finish before releasing resources;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TimerSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TimerSignal.cs
index 8186290e..f0addbeb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TimerSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TimerSignal.cs
@@ -20,10 +20,10 @@ public TimerSignal(TimeSpan dueTime, TimeSpan? period, TimeProvider timeProvider
     }
 
     /// <summary>Gets the delay before the first tick.</summary>
-    private TimeSpan DueTime { get; }
+    internal TimeSpan DueTime { get; }
 
     /// <summary>Gets the optional delay between subsequent ticks.</summary>
-    private TimeSpan? Period { get; }
+    internal TimeSpan? Period { get; }
 
     /// <summary>Gets the time provider used for scheduling.</summary>
     private TimeProvider TimeProvider { get; }
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
index 10726809..56a27e57 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConcurrencyRaceHelpers.cs
@@ -4,16 +4,10 @@
 
 namespace ReactiveUI.Primitives.Internal;
 
-/// <summary>
-/// Pure race-claim helpers shared by the async layer: a first-caller-wins sentinel transition, and a cancel call that
-/// treats a concurrently disposed token source as a lost race rather than a failure.
-/// </summary>
+/// <summary>Atomic ownership claims and cancellation tolerant of prior disposal.</summary>
 internal static class ConcurrencyRaceHelpers
 {
-    /// <summary>
-    /// Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/> to
-    /// <paramref name="claimedSentinel"/>.
-    /// </summary>
+    /// <summary>Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/> to <paramref name="claimedSentinel"/>.</summary>
     /// <param name="state">The reference to the state field.</param>
     /// <param name="openSentinel">The sentinel value the state must currently hold.</param>
     /// <param name="claimedSentinel">The sentinel value the state transitions to on success.</param>
@@ -23,9 +17,7 @@ internal static class ConcurrencyRaceHelpers
     internal static bool TryClaim(ref int state, int openSentinel, int claimedSentinel) =>
         Interlocked.CompareExchange(ref state, claimedSentinel, openSentinel) == openSentinel;
 
-    /// <summary>
-    /// Cancels <paramref name="cts"/>, swallowing the <see cref="ObjectDisposedException"/> a racing dispose raises.
-    /// </summary>
+    /// <summary>Cancels <paramref name="cts"/>, swallowing the <see cref="ObjectDisposedException"/> a racing dispose raises.</summary>
     /// <param name="cts">The cancellation token source to cancel.</param>
     /// <returns>
     /// <see langword="true"/> when the cancellation completed; <see langword="false"/> when a concurrent caller had
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
index 5dde5678..95bfda91 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
@@ -8,10 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// The exception that is thrown when multiple concurrent calls are made to observer methods that do not support
-/// concurrent execution.
-/// </summary>
+/// <summary>The exception that is thrown when multiple concurrent calls are made to observer methods that do not support concurrent execution.</summary>
 /// <remarks><see cref="WitnessAsync{T}"/> serializes <c>OnNextAsync</c>, <c>OnErrorResumeAsync</c> and
 /// <c>OnCompletedAsync</c>; this exception reports one of those calls arriving while another is in flight. Await each
 /// call to completion before starting the next.</remarks>
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
index f2ff57d1..a719cb1f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
@@ -8,10 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// An asynchronous observable that multicasts a cold source through a signal, leaving the caller to decide when the
-/// source subscription is established.
-/// </summary>
+/// <summary>An asynchronous observable that multicasts a cold source through a signal, leaving the caller to decide when the source subscription is established.</summary>
 /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
 /// <remarks>Subscribing attaches the observer to the signal without touching the source, so observers that subscribe
 /// before <see cref="ConnectAsync"/> all share the one source subscription it creates.</remarks>
@@ -27,9 +24,7 @@ public ConnectableSignalAsync(IObservableAsync<T> source, ISignalAsync<T> signal
     /// <summary>Gets the mutable connection state owned by this wrapper.</summary>
     private ConnectableSignalAsyncState<T> State { get; }
 
-    /// <summary>
-    /// Subscribes the signal to the source, or returns the live connection when one exists.
-    /// </summary>
+    /// <summary>Subscribes the signal to the source, or returns the live connection when one exists.</summary>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous connection operation.</param>
     /// <returns>A handle whose disposal drops the source subscription, allowing a later call to reconnect.</returns>
     /// <exception cref="OperationCanceledException">This instance has been disposed, or
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
index bf6edcb5..885d4ee3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
@@ -22,8 +22,7 @@ internal static async ValueTask<IAsyncDisposable> ConnectAsync<T>(
         ConnectableSignalAsyncState<T> state,
         CancellationToken cancellationToken)
     {
-        // A disposed signal cancels this token, and the gate's uncontended fast path does not observe
-        // cancellation, so without this check a post-disposal connect would resubscribe the cold source.
+        // The gate's fast path does not check cancellation; reject disposed signals before entering.
         state.DisposedCancellationToken.ThrowIfCancellationRequested();
 
         CancellationTokenSource? linkedCts = null;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
index edc1db4e..7eb311f4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
@@ -52,10 +52,7 @@ internal sealed class DelegateAsyncDisposable(Func<ValueTask> disposeAsync) : IA
         public ValueTask DisposeAsync() => Interlocked.Exchange(ref _disposed, 1) == 1 ? default : disposeAsync();
     }
 
-    /// <summary>
-    /// An asynchronous disposable that invokes a delegate with a stored state when disposed, so the caller's data
-    /// travels in <typeparamref name="TState"/> instead of a closure.
-    /// </summary>
+    /// <summary>An asynchronous disposable that invokes a delegate with a stored state when disposed, so the caller's data travels in <typeparamref name="TState"/> instead of a closure.</summary>
     /// <typeparam name="TState">The type of the state passed to the dispose delegate.</typeparam>
     /// <param name="state">The state forwarded to the dispose delegate at dispose time.</param>
     /// <param name="disposeAsync">The delegate invoked to perform asynchronous disposal.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
index 602cc1fb..02b68d82 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Async.Disposables;
@@ -27,26 +26,9 @@ public static class DisposableAsyncSlot
     /// <param name="value">The new value to store, or <see langword="null"/> to clear the slot.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once the previous occupant (if any) has been disposed.</returns>
     [DebuggerStepThrough]
-    [ExcludeFromCodeCoverage]
-    public static ValueTask SwapAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value)
-    {
-        var current = Volatile.Read(ref slot);
-        while (true)
-        {
-            if (ReferenceEquals(current, DisposedSentinel))
-            {
-                return value?.DisposeAsync() ?? default;
-            }
-
-            var exchanged = Interlocked.CompareExchange(ref slot, value, current);
-            if (ReferenceEquals(exchanged, current))
-            {
-                return current?.DisposeAsync() ?? default;
-            }
-
-            current = exchanged;
-        }
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ValueTask SwapAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value) =>
+        SwapObservedAsync(ref slot, value, Volatile.Read(ref slot));
 
     /// <summary>Atomically fills an empty slot with <paramref name="value"/>. A closed slot disposes
     /// <paramref name="value"/> instead. Equivalent to
@@ -90,6 +72,30 @@ public static ValueTask DisposeAsync(ref IAsyncDisposable? slot)
     public static bool IsDisposed(IAsyncDisposable? slot) =>
         ReferenceEquals(slot, DisposedSentinel);
 
+    /// <summary>Retries a swap when the slot changed after the caller's observation.</summary>
+    /// <param name="slot">The slot to replace.</param>
+    /// <param name="value">The incoming disposable.</param>
+    /// <param name="current">The previously observed slot value.</param>
+    /// <returns>Disposal of the replaced value, or the incoming value when the slot is closed.</returns>
+    internal static ValueTask SwapObservedAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value, IAsyncDisposable? current)
+    {
+        while (true)
+        {
+            if (ReferenceEquals(current, DisposedSentinel))
+            {
+                return value?.DisposeAsync() ?? default;
+            }
+
+            var exchanged = Interlocked.CompareExchange(ref slot, value, current);
+            if (ReferenceEquals(exchanged, current))
+            {
+                return current?.DisposeAsync() ?? default;
+            }
+
+            current = exchanged;
+        }
+    }
+
     /// <summary>Creates the exception for a second assignment into a single-assignment slot.</summary>
     /// <returns>The invalid-operation exception to throw from the assignment path.</returns>
     internal static InvalidOperationException CreateAlreadyAssignedException() =>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
index dfe94093..ce047d27 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
@@ -27,8 +27,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>Factor the backing array's capacity is multiplied by when it overflows.</summary>
     private const int GrowthFactor = 2;
 
-    /// <summary>Divisor applied to the backing array's capacity when a sparse collection is compacted; safe because
-    /// compaction only runs below quarter occupancy.</summary>
+    /// <summary>Divisor applied to the backing array's capacity when a sparse collection is compacted; safe because compaction only runs below quarter occupancy.</summary>
     private const int CompactionShrinkDivisor = 2;
 
     /// <summary>The synchronization gate protecting all mutable state in this collection.</summary>
@@ -49,10 +48,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>Indicates whether the collection has been disposed.</summary>
     private bool _isDisposed;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class, allocating its backing array on
-    /// the first <see cref="AddAsync"/> call.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class, allocating its backing array on the first <see cref="AddAsync"/> call.</summary>
     public MultipleDisposableAsync()
     {
     }
@@ -67,10 +63,7 @@ public MultipleDisposableAsync(int capacity)
         _items = capacity == 0 ? null : new IAsyncDisposable?[capacity];
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class that contains the specified
-    /// disposables, sizing the backing array exactly.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class that contains the specified disposables, sizing the backing array exactly.</summary>
     /// <param name="disposables">An array of objects implementing <see cref="IAsyncDisposable"/>.</param>
     public MultipleDisposableAsync(params IAsyncDisposable[] disposables)
     {
@@ -145,9 +138,7 @@ public int Count
         }
     }
 
-    /// <summary>
-    /// Takes ownership of a disposable, disposing it on the spot when this collection has been disposed.
-    /// </summary>
+    /// <summary>Takes ownership of a disposable, disposing it on the spot when this collection has been disposed.</summary>
     /// <param name="item">The item whose lifetime this collection takes over. Cannot be null.</param>
     /// <returns>A completed task when the item was stored; otherwise the task disposing it.</returns>
     public ValueTask AddAsync(IAsyncDisposable item)
@@ -296,10 +287,7 @@ public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
         }
     }
 
-    /// <summary>
-    /// Asynchronously releases all resources used by the collection and disposes of each contained asynchronous
-    /// disposable object.
-    /// </summary>
+    /// <summary>Asynchronously releases all resources used by the collection and disposes of each contained asynchronous disposable object.</summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
     /// <remarks>Idempotent. Items are disposed one after another in insertion order.</remarks>
     public async ValueTask DisposeAsync()
@@ -396,8 +384,7 @@ private void CopyToCore(IAsyncDisposable[] array, int arrayIndex)
         }
     }
 
-    /// <summary>Ensures <see cref="_items"/> has at least one free slot at index <see cref="_length"/>.
-    /// Allocates the default-capacity array on first use; doubles on subsequent overflow.</summary>
+    /// <summary>Ensures <see cref="_items"/> has at least one free slot at index <see cref="_length"/>. Allocates the default-capacity array on first use; doubles on subsequent overflow.</summary>
     private void EnsureCapacityForOneMore()
     {
         if (_items is null)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
index 4297e435..2daec78b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
@@ -31,8 +31,7 @@ public sealed class SingleAssignmentDisposableAsync : IAsyncDisposable
         return DisposableAsyncSlot.IsDisposed(field) ? DisposableAsync.Empty : field;
     }
 
-    /// <summary>Assigns the resource this instance owns, disposing <paramref name="value"/> on the spot when this
-    /// instance has been disposed.</summary>
+    /// <summary>Assigns the resource this instance owns, disposing <paramref name="value"/> on the spot when this instance has been disposed.</summary>
     /// <param name="value">The <see cref="IAsyncDisposable"/> to take ownership of, or <see langword="null"/>.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once any disposal this call triggered has finished.</returns>
     /// <exception cref="InvalidOperationException">A resource has been assigned by an earlier call.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
index b23dcbb7..646260bc 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Disposables;
 
-/// <summary>
-/// Provides a thread-safe mechanism for managing a single asynchronously disposable resource that can be replaced or
-/// disposed of serially.
-/// </summary>
+/// <summary>Provides a thread-safe mechanism for managing a single asynchronously disposable resource that can be replaced or disposed of serially.</summary>
 /// <remarks>Exactly one resource is live at a time: each assignment disposes the one it displaces, and disposing this
 /// instance closes the slot so a further assignment disposes its argument. Safe to use from several threads.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleReplaceableDisposableAsync: Current = {_current}")]
@@ -18,10 +15,7 @@ public class SingleReplaceableDisposableAsync : IAsyncDisposable
     /// <summary>The tracked disposable, or the sentinel that marks the slot closed.</summary>
     private IAsyncDisposable? _current;
 
-    /// <summary>
-    /// Takes over from the tracked resource, disposing the one it displaces — or disposing <paramref name="value"/>
-    /// itself when this instance has been disposed.
-    /// </summary>
+    /// <summary>Takes over from the tracked resource, disposing the one it displaces — or disposing <paramref name="value"/> itself when this instance has been disposed.</summary>
     /// <param name="value">The new <see cref="IAsyncDisposable"/> instance to track. Can be <see langword="null"/> to clear the current
     /// resource.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once whichever resource this call gave up has been
@@ -32,7 +26,6 @@ public ValueTask SetDisposableAsync(IAsyncDisposable? value) =>
 
     /// <summary>Disposes the tracked resource and closes the slot.</summary>
     /// <returns>A <see cref="ValueTask"/> that completes once the tracked resource has been disposed.</returns>
-    /// <remarks>Idempotent.</remarks>
     public ValueTask DisposeAsync()
     {
         GC.SuppressFinalize(this);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
index 5e3c1a65..8b92f678 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/DisposalHelper.cs
@@ -2,13 +2,11 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Async.Helpers;
 
 /// <summary>Provides helper methods for idempotent disposal patterns using an integer flag.</summary>
-[ExcludeFromCodeCoverage]
 public static class DisposalHelper
 {
     /// <summary>Checks whether the disposed flag indicates disposal has occurred.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
index 01fab590..419e96b7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
@@ -10,7 +10,6 @@ namespace ReactiveUI.Primitives.Async.Helpers;
 /// Runs asynchronous work from a synchronous callback — a cancellation-token registration, a signal handler — where
 /// there is no caller to observe a task, reporting failures to <see cref="UnhandledExceptionHandler"/>.
 /// </summary>
-[ExcludeFromCodeCoverage]
 public static class FireAndForgetHelper
 {
     /// <summary>Executes an async action as fire-and-forget, swallowing all exceptions.</summary>
@@ -23,7 +22,14 @@ public static class FireAndForgetHelper
         "ReSharper",
         "AsyncVoidMethod",
         Justification = "This is a fire-and-forget helper.")]
-    public static async void Run(Func<ValueTask> action)
+    [ExcludeFromCodeCoverage]
+    public static async void Run(Func<ValueTask> action) =>
+        await RunAsync(action).ConfigureAwait(false);
+
+    /// <summary>Runs the action and reports failures to the unhandled exception handler.</summary>
+    /// <param name="action">The action to execute.</param>
+    /// <returns>The action and any exception reporting.</returns>
+    internal static async ValueTask RunAsync(Func<ValueTask> action)
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
index e8f50932..3a7728b5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/SubscriptionHelper.cs
@@ -4,14 +4,10 @@
 
 namespace ReactiveUI.Primitives.Async.Helpers;
 
-/// <summary>
-/// Provides a helper for safely subscribing an <see cref="IAsyncDisposable"/> subscription,
-/// ensuring the subscription is disposed if the subscribe action throws.
-/// </summary>
+/// <summary>Provides a helper for safely subscribing an <see cref="IAsyncDisposable"/> subscription, ensuring the subscription is disposed if the subscribe action throws.</summary>
 public static class SubscriptionHelper
 {
-    /// <summary>Runs <paramref name="subscribeAsync"/>, disposing <paramref name="subscription"/> and rethrowing if it
-    /// fails, so a half-built subscription is never handed back.</summary>
+    /// <summary>Runs <paramref name="subscribeAsync"/>, disposing <paramref name="subscription"/> and rethrowing if it fails, so a half-built subscription is never handed back.</summary>
     /// <param name="subscription">The subscription to manage.</param>
     /// <param name="subscribeAsync">The async action that wires up the subscription.</param>
     /// <returns>The subscription, once wiring succeeded.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
index 1bef1a1c..f2316798 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Defines an asynchronous observer that receives notifications about a sequence of values, completion, or errors, and
-/// supports asynchronous resource cleanup.
-/// </summary>
+/// <summary>Defines an asynchronous observer that receives notifications about a sequence of values, completion, or errors, and supports asynchronous resource cleanup.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
 /// <remarks>Every notification is awaitable and cancellable, so a producer that awaits them gets backpressure for
 /// free: the observer's handler has to finish before the next value is pushed.</remarks>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs b/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
index 7dc5b4b0..5dd42739 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Mixins/DisposableAsyncExtensions.cs
@@ -29,10 +29,7 @@ public IAsyncDisposable ToDisposableAsync()
         }
     }
 
-    /// <summary>
-    /// Presents a synchronous <see cref="IDisposable"/> as an <see cref="IAsyncDisposable"/>, calling
-    /// <see cref="IDisposable.Dispose"/> inline and completing synchronously.
-    /// </summary>
+    /// <summary>Presents a synchronous <see cref="IDisposable"/> as an <see cref="IAsyncDisposable"/>, calling <see cref="IDisposable.Dispose"/> inline and completing synchronously.</summary>
     /// <param name="disposable">The <see cref="IDisposable"/> instance to be wrapped for asynchronous disposal. Cannot be null.</param>
     internal sealed class DisposableToDisposableAsync(IDisposable disposable) : IAsyncDisposable
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
index 6979bd74..46361992 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
@@ -29,10 +29,7 @@ public IObserverAsync<T> AsObserverAsync()
             return new SignalAsyncWitness<T>(source);
         }
 
-        /// <summary>
-        /// Creates a new signal that applies a transformation to the values of the source signal using the specified
-        /// mapping function.
-        /// </summary>
+        /// <summary>Creates a new signal that applies a transformation to the values of the source signal using the specified mapping function.</summary>
         /// <param name="mapper">A function that takes an asynchronous observable of type T and returns a transformed asynchronous observable of
         /// type T. This function defines how the values are mapped.</param>
         /// <returns>A signal that publishes into <paramref name="source"/> but exposes the mapped sequence to its own
@@ -51,8 +48,8 @@ public ISignalAsync<T> MapValues(Func<IObservableAsync<T>, IObservableAsync<T>>
     /// <summary>A signal that applies a transformation to the observable values of the source signal.</summary>
     /// <typeparam name="T">The type of elements processed by the signal.</typeparam>
     /// <param name="original">The source signal.</param>
-    /// <param name="mapper">A function that takes an asynchronous observable of type T and returns a transformed asynchronous observable of
-    /// type T. This function defines how the values are mapped.</param>
+    /// <param name="mapper">Transforms the source's value sequence
+    /// once during construction.</param>
     internal sealed class MappedSignal<T>(
         ISignalAsync<T> original,
         Func<IObservableAsync<T>, IObservableAsync<T>> mapper) : ISignalAsync<T>
@@ -91,11 +88,7 @@ public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellat
     /// <param name="signal">The signal to forward notifications to.</param>
     internal sealed class SignalAsyncWitness<T>(ISignalAsync<T> signal) : WitnessAsync<T>
     {
-        /// <summary>
-        /// Forwards the value to the wrapped signal under <see cref="CancellationToken.None"/>, which every downstream
-        /// <see cref="WitnessAsync{T}"/> takes its no-link fast path on. Passing this observer's own dispose token
-        /// instead would buy nothing: disposal stops values from reaching this method at all.
-        /// </summary>
+        /// <summary>Forwards the value with an uncancelable token after the observer's disposal check.</summary>
         /// <param name="value">The value to be processed by the observer.</param>
         /// <param name="cancellationToken">The token captured by the base observer's TryEnter scope. Ignored on the forward.</param>
         /// <returns>A ValueTask that represents the asynchronous operation.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
index fe75b5d9..56ce4820 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides factory methods for creating asynchronous observables and background jobs that emit values to observers
-/// asynchronously.
-/// </summary>
+/// <summary>Provides factory methods for creating asynchronous observables and background jobs that emit values to observers asynchronously.</summary>
 /// <remarks>These are the entry points for turning an arbitrary asynchronous producer into a sequence: supply the
 /// subscribe logic yourself, or hand over a job to run per subscriber.</remarks>
 public static partial class SignalAsync
@@ -52,10 +49,7 @@ public static IObservableAsync<T> CreateAsBackgroundJob<T>(
         bool startSynchronously) =>
         new BackgroundJobSignal<T>(job, startSynchronously, null);
 
-    /// <summary>
-    /// Creates a new observable sequence that runs the specified asynchronous job as a background task using the
-    /// provided task scheduler.
-    /// </summary>
+    /// <summary>Creates a new observable sequence that runs the specified asynchronous job as a background task using the provided task scheduler.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
     /// a cancellation token to observe cancellation requests.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
index 15672725..b96d585a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Defer.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides factory methods for creating observable sequences that are generated by invoking a specified function each
-/// time a new observer subscribes.
-/// </summary>
+/// <summary>Provides factory methods for creating observable sequences that are generated by invoking a specified function each time a new observer subscribes.</summary>
 /// <remarks>Nothing runs at declaration: the factory is called once per subscriber, so each one gets a sequence built
 /// from the state that holds at its own subscribe time.</remarks>
 public static partial class SignalAsync
@@ -24,10 +21,7 @@ public static partial class SignalAsync
     public static IObservableAsync<T> Defer<T>(Func<CancellationToken, ValueTask<IObservableAsync<T>>> factory) =>
         new DeferAsyncSignalAsync<T>(factory);
 
-    /// <summary>
-    /// Returns an observable sequence that is created by invoking the specified factory function each time a new
-    /// observer subscribes.
-    /// </summary>
+    /// <summary>Returns an observable sequence that is created by invoking the specified factory function each time a new observer subscribes.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <param name="factory">A function that returns a new instance of an observable sequence to be subscribed to for each observer.</param>
     /// <returns>An observable sequence that calls <paramref name="factory"/> on each subscribe and subscribes to
@@ -36,8 +30,7 @@ public static IObservableAsync<T> Defer<T>(Func<CancellationToken, ValueTask<IOb
     public static IObservableAsync<T> Defer<T>(Func<IObservableAsync<T>> factory) =>
         new DeferSyncSignalAsync<T>(factory);
 
-    /// <summary>Backs <see cref="Defer{T}(Func{IObservableAsync{T}})"/>: each subscribe calls the factory and hands the
-    /// wrapped observer to the sequence it returns.</summary>
+    /// <summary>Backs <see cref="Defer{T}(Func{IObservableAsync{T}})"/>: each subscribe calls the factory and hands the wrapped observer to the sequence it returns.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="factory">The deferred factory invoked once per subscribe.</param>
     internal sealed class DeferSyncSignalAsync<T>(Func<IObservableAsync<T>> factory) : IObservableAsync<T>
@@ -50,9 +43,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             factory().SubscribeAsync(observer.Wrap(), cancellationToken);
     }
 
-    /// <summary>Backs the <see cref="ValueTask"/>-returning
-    /// <see cref="Defer{T}(Func{CancellationToken, ValueTask{IObservableAsync{T}}})"/>, awaiting the factory before it
-    /// can subscribe.</summary>
+    /// <summary>Backs the <see cref="ValueTask"/>-returning <see cref="Defer{T}(Func{CancellationToken, ValueTask{IObservableAsync{T}}})"/>, awaiting the factory before it can subscribe.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="factory">The deferred factory invoked once per subscribe.</param>
     internal sealed class DeferAsyncSignalAsync<T>(Func<CancellationToken, ValueTask<IObservableAsync<T>>> factory) : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
index 7b475e0f..b36b582c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
@@ -32,10 +32,7 @@ public static partial class SignalAsync
         Justification = "There are no parameters to infer from; the caller states the element type: SignalAsync.Empty<int>().")]
     public static IObservableAsync<T> Empty<T>() => EmptySignalAsync<T>.Instance;
 
-    /// <summary>
-    /// Signals successful completion on subscribe and hands back <see cref="DisposableAsync.Empty"/>, from a cached
-    /// instance per element type.
-    /// </summary>
+    /// <summary>Signals successful completion on subscribe and hands back <see cref="DisposableAsync.Empty"/>, from a cached instance per element type.</summary>
     /// <typeparam name="T">The element type of the empty sequence.</typeparam>
     internal sealed class EmptySignalAsync<T> : IObservableAsync<T>
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
index 448eda43..ee4627d0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
@@ -29,10 +29,7 @@ public static partial class SignalAsync
         Justification = "Return is the Rx-compatible alias for Emit and builds the same signal with no forwarding hop.")]
     public static IObservableAsync<T> Return<T>(T value) => new ReturnSignalAsync<T>(value);
 
-    /// <summary>
-    /// Holds the single value in a field and emits it from a <see cref="TaskSignalSubscription{T}"/> started per
-    /// subscriber, so the emit is deferred without a delegate to close over.
-    /// </summary>
+    /// <summary>Defers one value per subscriber without allocating a closure.</summary>
     /// <typeparam name="T">The element type emitted.</typeparam>
     /// <param name="value">The captured value emitted on each subscribe.</param>
     internal sealed class ReturnSignalAsync<T>(T value) : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
index ec2324dc..d8206c9c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides the clock-driven factory methods: a one-shot value after a delay, and periodic ticks.
-/// </summary>
+/// <summary>Provides the clock-driven factory methods: a one-shot value after a delay, and periodic ticks.</summary>
 public static partial class SignalAsync
 {
     /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then completes.</summary>
@@ -22,10 +20,7 @@ public static IObservableAsync<long> After(TimeSpan dueTime)
         return new TimerSignal(dueTime, null, TimeProvider.System);
     }
 
-    /// <summary>
-    /// Creates an observable sequence that produces a single value (0) after the specified delay,
-    /// then continues to produce sequential values at each specified period.
-    /// </summary>
+    /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then continues to produce sequential values at each specified period.</summary>
     /// <param name="dueTime">The initial delay before the first value is produced. Must be non-negative.</param>
     /// <param name="period">The interval between subsequent values after the initial delay. Must be positive.</param>
     /// <returns>An observable sequence that produces values starting after the initial delay and continuing
@@ -77,10 +72,7 @@ public static IObservableAsync<long> Timer(TimeSpan dueTime, TimeProvider? timeP
         return new TimerSignal(dueTime, null, timeProvider ?? TimeProvider.System);
     }
 
-    /// <summary>
-    /// Creates an observable sequence that produces a single value (0) after the specified delay,
-    /// then continues to produce sequential values at each specified period.
-    /// </summary>
+    /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then continues to produce sequential values at each specified period.</summary>
     /// <param name="dueTime">The initial delay before the first value is produced. Must be non-negative.</param>
     /// <param name="period">The interval between subsequent values after the initial delay. Must be positive.</param>
     /// <returns>An observable sequence that produces values starting after the initial delay and continuing
@@ -90,10 +82,7 @@ public static IObservableAsync<long> Timer(TimeSpan dueTime, TimeProvider? timeP
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<long> Timer(TimeSpan dueTime, TimeSpan period) => After(dueTime, period);
 
-    /// <summary>
-    /// Creates an observable sequence that produces a single value (0) after the specified delay,
-    /// then continues to produce sequential values at each specified period.
-    /// </summary>
+    /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then continues to produce sequential values at each specified period.</summary>
     /// <param name="dueTime">The initial delay before the first value is produced. Must be non-negative.</param>
     /// <param name="period">The interval between subsequent values after the initial delay. Must be positive.</param>
     /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
index 3017f5da..3f82bda5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides extension methods for converting tasks, asynchronous enumerables, and enumerable sequences into
-/// asynchronous observable sequences.
-/// </summary>
+/// <summary>Provides extension methods for converting tasks, asynchronous enumerables, and enumerable sequences into asynchronous observable sequences.</summary>
 /// <remarks>Every overload is spelled <c>ToAsyncSignal</c>, so the conversion reads the same whatever the source, and a
 /// sequence that is an <see cref="IObservableAsync{T}"/> passes straight through.</remarks>
 public static partial class SignalAsyncExtensions
@@ -36,10 +33,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The enumerable sequence to convert to an asynchronous observable. Cannot be null.</param>
     extension<T>(IEnumerable<T> source)
     {
-        /// <summary>
-        /// Converts the specified enumerable sequence to an asynchronous observable sequence, emitting each element in the
-        /// background.
-        /// </summary>
+        /// <summary>Converts the specified enumerable sequence to an asynchronous observable sequence, emitting each element in the background.</summary>
         /// <returns>An asynchronous observable sequence that emits each element from the source enumerable and completes when all
         /// elements have been emitted.</returns>
         /// <remarks>Enumeration runs on a background thread, once per subscriber, so a blocking or side-effecting
@@ -57,8 +51,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Null-checks and returns the source unchanged, so generic code can convert without knowing whether
-        /// it has a signal already.</summary>
+        /// <summary>Null-checks and returns the source unchanged, so generic code can convert without knowing whether it has a signal already.</summary>
         /// <returns>The same sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         [SuppressMessage(
@@ -74,10 +67,7 @@ public IObservableAsync<T> ToAsyncSignal() =>
     /// <param name="task">The task to convert to an asynchronous observable sequence. Cannot be null.</param>
     extension<T>(Task<T> task)
     {
-        /// <summary>
-        /// Converts a task representing a single asynchronous value into an observable sequence that emits the result when
-        /// the task completes.
-        /// </summary>
+        /// <summary>Converts a task representing a single asynchronous value into an observable sequence that emits the result when the task completes.</summary>
         /// <returns>An asynchronous observable sequence that emits the result of the task when it completes, followed by a
         /// completion notification.</returns>
         /// <remarks>A faulted or cancelled task terminates the sequence with that error. Since the task is a single
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
index f196f0d5..81174018 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
@@ -16,10 +16,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="sources">A collection of asynchronous observable sequences to be merged.</param>
     extension<T>(IEnumerable<IObservableAsync<T>> sources)
     {
-        /// <summary>
-        /// Combines multiple asynchronous observable sequences into a single observable sequence that emits items from all
-        /// source sequences as they arrive.
-        /// </summary>
+        /// <summary>Combines multiple asynchronous observable sequences into a single observable sequence that emits items from all source sequences as they arrive.</summary>
         /// <returns>An observable sequence that emits items from all input sequences as they are produced.</returns>
         /// <remarks>Emissions interleave as the sources produce them; the result completes once every source has
         /// completed, and an error from any source propagates and terminates it.</remarks>
@@ -27,10 +24,7 @@ public static partial class SignalAsyncExtensions
         public IObservableAsync<T> Blend() =>
             new BlendEnumerableSignal<T>(sources);
 
-        /// <summary>
-        /// Combines multiple asynchronous observable sequences into a single observable sequence that emits items from all
-        /// source sequences as they arrive.
-        /// </summary>
+        /// <summary>Combines multiple asynchronous observable sequences into a single observable sequence that emits items from all source sequences as they arrive.</summary>
         /// <returns>An observable sequence that emits items from all input sequences as they are produced.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Merge() =>
@@ -43,10 +37,7 @@ public IObservableAsync<T> Merge() =>
     /// Cannot be null.</param>
     extension<T>(IObservableAsync<IObservableAsync<T>> source)
     {
-        /// <summary>
-        /// Merges multiple asynchronous observable sequences into a single observable sequence that emits items from all
-        /// inner sequences as they arrive.
-        /// </summary>
+        /// <summary>Merges multiple asynchronous observable sequences into a single observable sequence that emits items from all inner sequences as they arrive.</summary>
         /// <returns>An asynchronous observable sequence that emits items from all inner observable sequences as they are produced.</returns>
         /// <remarks>Every inner sequence stays subscribed at once; the result completes only after the outer sequence
         /// and all inner sequences have completed, and an error from any of them propagates and terminates it.</remarks>
@@ -54,19 +45,13 @@ public IObservableAsync<T> Merge() =>
         public IObservableAsync<T> Blend() =>
             new BlendSignalSourcesSignal<T>(source);
 
-        /// <summary>
-        /// Merges multiple asynchronous observable sequences into a single observable sequence that emits items from all
-        /// inner sequences as they arrive.
-        /// </summary>
+        /// <summary>Merges multiple asynchronous observable sequences into a single observable sequence that emits items from all inner sequences as they arrive.</summary>
         /// <returns>An asynchronous observable sequence that emits items from all inner observable sequences as they are produced.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Merge() =>
             new BlendSignalSourcesSignal<T>(source);
 
-        /// <summary>
-        /// Merges the emissions of multiple asynchronous observable sequences into a single observable sequence, limiting
-        /// the number of concurrent subscriptions.
-        /// </summary>
+        /// <summary>Merges the emissions of multiple asynchronous observable sequences into a single observable sequence, limiting the number of concurrent subscriptions.</summary>
         /// <param name="maxConcurrent">The maximum number of inner observable sequences to subscribe to concurrently.</param>
         /// <returns>An observable sequence that emits the items from the merged inner observable sequences.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -230,16 +215,14 @@ internal void LinkExternalCancellation(CancellationToken external)
                 _disposeCts);
         }
 
-        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if the
-        /// subscription is alive.</summary>
+        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if the subscription is alive.</summary>
         /// <param name="value">The value to forward.</param>
         /// <returns>A task representing the asynchronous forward operation.</returns>
         internal ValueTask RelayNextIfActiveAsync(T value) => DisposalHelper.HasDisposed(_disposed)
             ? default
             : _observer.OnNextAsync(value, DisposedCancellationToken);
 
-        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if the
-        /// subscription is alive.</summary>
+        /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if the subscription is alive.</summary>
         /// <param name="exception">The error to forward.</param>
         /// <returns>A task representing the asynchronous forward operation.</returns>
         internal ValueTask RelayErrorIfActiveAsync(Exception exception) => DisposalHelper.HasDisposed(_disposed)
@@ -411,10 +394,7 @@ internal override async ValueTask SubscribeBranchAsync(IObservableAsync<T> inner
             }
             finally
             {
-                // On success the observer owns its semaphore slot and releases it on its own disposal
-                // (auto-dispose after OnCompletedAsync, or via parent FinishAsync). On failure we dispose
-                // the observer here so its idempotent CleanupBranchAsync returns the slot exactly once,
-                // regardless of whether the observer also gets disposed again through _innerDisposables.
+                // The observer releases its semaphore slot once; failed subscriptions also dispose it here.
                 if (!subscribed)
                 {
                     await innerObserver.DisposeAsync().ConfigureAwait(false);
@@ -430,10 +410,7 @@ internal override BlendBranchWitness CreateBranchObserver() =>
         /// <param name="parent">The parent bounded merge coordinator whose semaphore slot is released on disposal.</param>
         internal sealed class BlendBranchWitnessWithPermit(BoundedBlendCoordinator<T> parent) : BlendBranchWitness(parent)
         {
-            /// <summary>Guards the one-time release of this witness's semaphore slot.</summary>
-            /// <remarks><see cref="WitnessAsync{T}.DisposeAsync"/> can run several times for one witness, and a repeat
-            /// <see cref="SemaphoreSlim.Release()"/> would exceed the semaphore's count and throw
-            /// <see cref="SemaphoreFullException"/>, breaking the parent's completion chain.</remarks>
+            /// <summary>Releases the semaphore once for this witness.</summary>
             private int _released;
 
             /// <inheritdoc/>
@@ -519,8 +496,7 @@ public BlendSequenceCoordinator(IObserverAsync<T> observer, IEnumerable<IObserva
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask DisposeAsync() => FinishAsync(null);
 
-            /// <summary>Routes the exception of a completion result that arrives after disposal to the unhandled
-            /// exception handler.</summary>
+            /// <summary>Routes the exception of a completion result that arrives after disposal to the unhandled exception handler.</summary>
             /// <param name="result">The completion result, or null if disposing without signaling.</param>
             internal static void RoutePostDisposalException(Result? result)
             {
@@ -543,9 +519,7 @@ internal void BeginSubscribing() => FireAndForgetHelper.Run(async () =>
                 _reentrant.Value = true;
                 try
                 {
-                    // Sentinel: prevents premature completion while the loop is subscribing to sources.
-                    // Without this, a synchronously-completing source (e.g. Return) can decrement _active
-                    // to zero before the next source is subscribed, terminating the merge early.
+                    // Hold a sentinel while subscribing so synchronous sources cannot complete the merge early.
                     _ = Interlocked.Increment(ref _active);
 
                     foreach (var src in _sources)
@@ -627,8 +601,7 @@ internal async ValueTask RelayNextAsync(T value, CancellationToken token)
                 }
             }
 
-            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if
-            /// the subscription is alive.</summary>
+            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the value downstream if the subscription is alive.</summary>
             /// <param name="value">The value to forward.</param>
             /// <returns>A task representing the asynchronous forward operation.</returns>
             internal ValueTask RelayNextIfActiveAsync(T value) => DisposalHelper.HasDisposed(_disposed)
@@ -653,8 +626,7 @@ internal async ValueTask RelayErrorAsync(Exception ex, CancellationToken token)
                 }
             }
 
-            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if
-            /// the subscription is alive.</summary>
+            /// <summary>Re-checks the disposed flag inside the serialization gate and forwards the error downstream if the subscription is alive.</summary>
             /// <param name="ex">The error to forward.</param>
             /// <returns>A task representing the asynchronous forward operation.</returns>
             internal ValueTask RelayErrorIfActiveAsync(Exception ex) => DisposalHelper.HasDisposed(_disposed)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
index b09f9e00..82412d11 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="sources">A collection of asynchronous observable sequences to concatenate. Cannot be null.</param>
     extension<T>(IEnumerable<IObservableAsync<T>> sources)
     {
-        /// <summary>
-        /// Concatenates multiple asynchronous observable sequences into a single sequence that emits items from each source
-        /// in order.
-        /// </summary>
+        /// <summary>Concatenates multiple asynchronous observable sequences into a single sequence that emits items from each source in order.</summary>
         /// <returns>An asynchronous observable sequence that emits all items from each source sequence in the order they appear in
         /// the collection.</returns>
         /// <remarks>A source is subscribed only after the previous one completes, so at most one source is active at a
@@ -26,10 +23,7 @@ public static partial class SignalAsyncExtensions
         public IObservableAsync<T> Chain() =>
             new ChainEnumerableSignal<T>(sources);
 
-        /// <summary>
-        /// Concatenates multiple asynchronous observable sequences into a single sequence that emits items from each source
-        /// in order.
-        /// </summary>
+        /// <summary>Concatenates multiple asynchronous observable sequences into a single sequence that emits items from each source in order.</summary>
         /// <returns>An asynchronous observable sequence that emits all items from each source sequence in order.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Concat() =>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
index f18e70cd..e6bb0b31 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Represents an asynchronous observable sequence that concatenates multiple asynchronous observables, emitting their
-/// elements in order as each completes.
-/// </summary>
+/// <summary>Represents an asynchronous observable sequence that concatenates multiple asynchronous observables, emitting their elements in order as each completes.</summary>
 /// <typeparam name="T">The type of elements produced by the concatenated observable sequences.</typeparam>
 /// <param name="signals">A collection of asynchronous signals to be concatenated. Each signal is subscribed to sequentially; the next
 /// begins only after the previous completes.</param>
@@ -35,10 +32,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             subscription.SubscribeNextSignalAsync);
     }
 
-    /// <summary>
-    /// Manages sequential iteration through the enumerable of observables, subscribing to each
-    /// inner observable only after the previous one completes.
-    /// </summary>
+    /// <summary>Manages sequential iteration through the enumerable of observables, subscribing to each inner observable only after the previous one completes.</summary>
     internal sealed class ChainSequenceCoordinator : IAsyncDisposable
     {
         /// <summary>Enumerator that iterates through the collection of observable sequences to concatenate.</summary>
@@ -118,9 +112,7 @@ internal async ValueTask SubscribeNextSignalAsync()
         /// <returns>A task representing the asynchronous operation.</returns>
         internal ValueTask RelayInnerErrorAsync(Exception exception, CancellationToken cancellationToken)
         {
-            // The inner subscription is rooted in _disposedCancellationToken (see SubscribeNextSignalAsync), so
-            // disposing it cascades into the inner observer's own cancellation. Forwarding that token directly
-            // gives the same cancellation semantics as a linked CTS without allocating one per emission.
+            // The inner subscription shares this disposal token.
             _ = cancellationToken;
             return _observer.OnErrorResumeAsync(exception, _disposedCancellationToken);
         }
@@ -135,10 +127,7 @@ internal ValueTask RelayInnerValueAsync(T value, CancellationToken cancellationT
             return _observer.OnNextAsync(value, _disposedCancellationToken);
         }
 
-        /// <summary>
-        /// Disposes the inner subscription and enumerator, and optionally forwards a completion result
-        /// to the downstream observer. This method is idempotent.
-        /// </summary>
+        /// <summary>Disposes the inner subscription and enumerator, and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
index 292eeee3..cd5f496d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
@@ -8,10 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Async observable that concatenates inner observable sequences emitted by an outer observable,
-/// subscribing to each inner sequence only after the previous one completes.
-/// </summary>
+/// <summary>Async observable that concatenates inner observable sequences emitted by an outer observable, subscribing to each inner sequence only after the previous one completes.</summary>
 /// <typeparam name="T">The type of elements produced by the inner observable sequences.</typeparam>
 /// <param name="source">The outer observable sequence that emits inner observable sequences to concatenate.</param>
 public sealed class ChainSignalSourcesSignal<T>(IObservableAsync<IObservableAsync<T>> source) : IObservableAsync<T>
@@ -30,10 +27,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             () => subscription.SubscribeAsync(source, cancellationToken));
     }
 
-    /// <summary>
-    /// Manages the lifetime of the outer subscription and buffers inner observables,
-    /// subscribing to each one sequentially as the previous completes.
-    /// </summary>
+    /// <summary>Manages the lifetime of the outer subscription and buffers inner observables, subscribing to each one sequentially as the previous completes.</summary>
     internal sealed class ChainCoordinator : IAsyncDisposable
     {
         /// <summary>Concurrent queue that buffers inner observables waiting to be subscribed to.</summary>
@@ -100,10 +94,7 @@ internal async ValueTask SubscribeAsync(
             await _outerDisposable.SetDisposableAsync(outerSubscription).ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Handles a new inner observable from the outer sequence by buffering it and subscribing
-        /// if no inner sequence is currently active.
-        /// </summary>
+        /// <summary>Handles a new inner observable from the outer sequence by buffering it and subscribing if no inner sequence is currently active.</summary>
         /// <param name="inner">The inner observable to enqueue.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal ValueTask AcceptOuterValueAsync(IObservableAsync<T> inner)
@@ -121,10 +112,7 @@ internal ValueTask AcceptOuterValueAsync(IObservableAsync<T> inner)
             return !shouldSubscribe ? default : SubscribeCurrentInnerAsync(inner);
         }
 
-        /// <summary>
-        /// Handles the outer sequence completing, propagating completion downstream when the buffer is empty
-        /// or when the outer fails.
-        /// </summary>
+        /// <summary>Handles the outer sequence completing, propagating completion downstream when the buffer is empty or when the outer fails.</summary>
         /// <param name="result">The completion result from the outer sequence.</param>
         /// <returns>A task representing the asynchronous completion operation.</returns>
         internal ValueTask AcceptOuterCompletionAsync(Result result)
@@ -144,10 +132,7 @@ internal ValueTask AcceptOuterCompletionAsync(Result result)
             return shouldComplete ? FinishAsync(completeResult) : default;
         }
 
-        /// <summary>
-        /// Handles the current inner sequence completing, subscribing to the next buffered inner
-        /// sequence or completing the subscription if the outer has also completed.
-        /// </summary>
+        /// <summary>Handles the current inner sequence completing, subscribing to the next buffered inner sequence or completing the subscription if the outer has also completed.</summary>
         /// <param name="result">The completion result from the inner sequence.</param>
         /// <returns>A task representing the asynchronous completion operation.</returns>
         internal ValueTask AcceptInnerCompletionAsync(Result result)
@@ -192,10 +177,7 @@ await currentInner.SubscribeAsync(new ChainInnerWitness(this), _disposedCancella
             }
         }
 
-        /// <summary>
-        /// Disposes the inner and outer subscriptions and optionally forwards a completion result to
-        /// the downstream observer. This method is idempotent.
-        /// </summary>
+        /// <summary>Disposes the inner and outer subscriptions and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
@@ -237,9 +219,7 @@ protected override async ValueTask OnErrorResumeAsyncCore(
                 Exception error,
                 CancellationToken cancellationToken)
             {
-                // The outer subscription is rooted in _disposedCancellationToken, so disposing it cascades
-                // into this observer's cancellation. Forwarding the dispose token directly gives the same
-                // cancellation semantics as a linked CTS without allocating one per emission.
+                // The outer subscription shares this disposal token.
                 _ = cancellationToken;
                 var token = subscription._disposedCancellationToken;
                 using (await subscription._observerOnSomethingGate.EnterAsync(token).ConfigureAwait(false))
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
index a969cde6..80eec75d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/CompletionSignalDelegate.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Represents a method that subscribes to completion notifications and returns an asynchronous disposable used to
-/// unsubscribe.
-/// </summary>
+/// <summary>Represents a method that subscribes to completion notifications and returns an asynchronous disposable used to unsubscribe.</summary>
 /// <param name="notifyStop">An action to be invoked with a <see cref="Result"/> when the completion event occurs. This callback is called to
 /// notify the subscriber of the completion result.</param>
 /// <returns>An <see cref="IAsyncDisposable"/> that unsubscribes the notification when disposed asynchronously.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
index 64784606..6a46fa14 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Distinct.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns a sequence that contains only distinct elements from the source sequence, using the default equality
-        /// comparer for the element type.
-        /// </summary>
+        /// <summary>Returns a sequence that contains only distinct elements from the source sequence, using the default equality comparer for the element type.</summary>
         /// <returns>An observable sequence that contains distinct elements from the source sequence.</returns>
         /// <remarks>Only the first occurrence of each element reaches observers, in source order; the set of seen
         /// elements lives for the whole subscription.</remarks>
@@ -26,10 +23,7 @@ public IObservableAsync<T> Distinct()
             return new DistinctSignal<T>(source, EqualityComparer<T>.Default);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that contains only distinct elements from the source sequence, using the
-        /// specified equality comparer to determine uniqueness.
-        /// </summary>
+        /// <summary>Returns an observable sequence that contains only distinct elements from the source sequence, using the specified equality comparer to determine uniqueness.</summary>
         /// <param name="equalityComparer">An equality comparer to compare values for equality. If null, the default equality comparer for the type is
         /// used.</param>
         /// <returns>An observable sequence that emits each distinct element from the source sequence, in the order in which they
@@ -44,10 +38,7 @@ public IObservableAsync<T> Distinct(IEqualityComparer<T> equalityComparer)
             return new DistinctSignal<T>(source, equalityComparer);
         }
 
-        /// <summary>
-        /// Returns a sequence that contains distinct elements from the source sequence according to a specified key
-        /// selector function.
-        /// </summary>
+        /// <summary>Returns a sequence that contains distinct elements from the source sequence according to a specified key selector function.</summary>
         /// <typeparam name="TKey">The type of the key returned by the key selector function.</typeparam>
         /// <param name="keySelector">A function to extract the key for each element. Cannot be null.</param>
         /// <returns>An observable sequence that contains only the first occurrence of each distinct key as determined by the key
@@ -61,10 +52,7 @@ public IObservableAsync<T> DistinctBy<TKey>(Func<T, TKey> keySelector)
             return new DistinctBySignal<T, TKey>(source, keySelector, EqualityComparer<TKey>.Default);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that contains only distinct elements from the source sequence, comparing
-        /// values based on a specified key and equality comparer.
-        /// </summary>
+        /// <summary>Returns an observable sequence that contains only distinct elements from the source sequence, comparing values based on a specified key and equality comparer.</summary>
         /// <typeparam name="TKey">The type of the key used to determine the distinctness of elements.</typeparam>
         /// <param name="keySelector">A function to extract the key for each element. Cannot be null.</param>
         /// <param name="equalityComparer">An equality comparer to compare keys for equality. Cannot be null.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
index 177d980f..67adf464 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
@@ -30,10 +30,7 @@ public IObservableAsync<T> Expire(TimeSpan dueTime)
         }
     }
 
-    /// <summary>
-    /// Async observable that mirrors the source but completes with a <see cref="TimeoutException"/>
-    /// once an inter-element gap exceeds the configured interval.
-    /// </summary>
+    /// <summary>Async observable that mirrors the source but completes with a <see cref="TimeoutException"/> once an inter-element gap exceeds the configured interval.</summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence.</param>
     /// <param name="dueTime">The maximum allowed inter-element interval.</param>
@@ -54,10 +51,7 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return subscription;
         }
 
-        /// <summary>
-        /// Observer that resets a timer on each received element and signals a <see cref="TimeoutException"/>
-        /// if no element arrives within the configured interval.
-        /// </summary>
+        /// <summary>Observer that resets a timer on each received element and signals a <see cref="TimeoutException"/> if no element arrives within the configured interval.</summary>
         /// <param name="observer">The downstream observer to forward elements to.</param>
         /// <param name="dueTime">The maximum allowed inter-element interval.</param>
         /// <param name="timeProvider">The time provider used to schedule the deadline.</param>
@@ -90,13 +84,21 @@ internal void StartTimer(CancellationToken cancellationToken)
                 }
                 catch (Exception e)
                 {
-                    // A CreateTimer failure routes to the unhandled exception handler rather than tearing
-                    // down the subscription: with no timer the operator degrades to a pass-through that
-                    // forwards every emission and never signals a timeout.
+                    // Timer creation failure is reported; values continue without timeout enforcement.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
 
+            /// <summary>Rearms the deadline unless disposal has removed the timer.</summary>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void RearmTimer() =>
+                _timer?.Change(dueTime, System.Threading.Timeout.InfiniteTimeSpan);
+
+            /// <summary>Stops the deadline unless disposal has removed the timer.</summary>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void StopTimer() =>
+                _timer?.Change(System.Threading.Timeout.InfiniteTimeSpan, System.Threading.Timeout.InfiniteTimeSpan);
+
             /// <summary>Rearms the deadline timer and forwards the element to the downstream observer.</summary>
             /// <param name="value">The element to forward.</param>
             /// <param name="cancellationToken">A token to cancel the operation.</param>
@@ -184,27 +186,10 @@ private void OnTimerFired()
 
                 _ = FireTimeoutAsync(observer);
             }
-
-            /// <summary>Rearms the timeout deadline for the next emission; <c>_timer</c> is null only when the source
-            /// emits after <c>DisposeAsyncCore</c> has torn the timer down, a race no deterministic test can hit.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-            private void RearmTimer() =>
-                _timer?.Change(dueTime, System.Threading.Timeout.InfiniteTimeSpan);
-
-            /// <summary>Stops the timeout deadline on terminal forwarding; <c>_timer</c> is null only under the same
-            /// post-teardown race as <see cref="RearmTimer"/>.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-            private void StopTimer() =>
-                _timer?.Change(System.Threading.Timeout.InfiniteTimeSpan, System.Threading.Timeout.InfiniteTimeSpan);
         }
     }
 
-    /// <summary>
-    /// Async observable that mirrors the source but switches to a fallback observable
-    /// once an inter-element gap exceeds the configured interval.
-    /// </summary>
+    /// <summary>Async observable that mirrors the source but switches to a fallback observable once an inter-element gap exceeds the configured interval.</summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence.</param>
     /// <param name="dueTime">The maximum allowed inter-element interval.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
index 8e67ae98..81645b15 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/FirstOrDefaultAsync.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Asynchronously returns the first element that matches the specified predicate, or a default value if no such
-        /// element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the first element that matches the specified predicate, or a default value if no such element is found.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the first element for which this
         /// predicate returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element satisfies the predicate.</param>
@@ -29,10 +26,7 @@ public static partial class SignalAsyncExtensions
             T? defaultValue) =>
             source.FirstOrDefaultAsync(predicate, defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the first element that matches the specified predicate, or a default value if no such
-        /// element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the first element that matches the specified predicate, or a default value if no such element is found.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the first element for which this
         /// predicate returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element satisfies the predicate.</param>
@@ -66,10 +60,7 @@ public static partial class SignalAsyncExtensions
         public ValueTask<T?> FirstOrDefaultAsync(CancellationToken cancellationToken) =>
             source.FirstOrDefaultAsync(default, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously returns the first element of the sequence, or a specified default value if the sequence
-        /// contains no elements.
-        /// </summary>
+        /// <summary>Asynchronously returns the first element of the sequence, or a specified default value if the sequence contains no elements.</summary>
         /// <param name="defaultValue">The value to return if the sequence is empty.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element of the
         /// sequence, or <paramref name="defaultValue"/> if the sequence is empty.</returns>
@@ -77,10 +68,7 @@ public static partial class SignalAsyncExtensions
         public ValueTask<T?> FirstOrDefaultAsync(T? defaultValue) =>
             source.FirstOrDefaultAsync(defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the first element of the sequence, or a specified default value if the sequence
-        /// contains no elements.
-        /// </summary>
+        /// <summary>Asynchronously returns the first element of the sequence, or a specified default value if the sequence contains no elements.</summary>
         /// <param name="defaultValue">The value to return if the sequence is empty.</param>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the first element of the
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
index 338cacaa..58f2b100 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/FlatMap.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Projects each element of the observable sequence to an asynchronous observable sequence and
-        /// merges the resulting sequences into one observable sequence.
-        /// </summary>
+        /// <summary>Projects each element of the observable sequence to an asynchronous observable sequence and merges the resulting sequences into one observable sequence.</summary>
         /// <typeparam name="TResult">The type of the elements in the projected inner sequences.</typeparam>
         /// <param name="selector">A transform function to apply to each element; it returns an observable sequence
         /// for each element.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
index a445cb75..e6495cca 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides extension methods for asynchronous observable sequences, enabling functional operations such as scanning
-/// and accumulation over streamed data.
-/// </summary>
+/// <summary>Provides extension methods for asynchronous observable sequences, enabling functional operations such as scanning and accumulation over streamed data.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Fold/Scan (running accumulation) operators for an observable source sequence.</summary>
@@ -15,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence and returns each intermediate result
-        /// using the specified asynchronous accumulator.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence and returns each intermediate result using the specified asynchronous accumulator.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to be invoked on each element. Receives the current accumulator value,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
index a077a8a2..0b5a9dda 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/GroupBy.cs
@@ -36,10 +36,7 @@ public IObservableAsync<GroupedAsyncSignal<TKey, TValue>> GroupBy<TKey>(Func<TVa
                 static _ => AsyncSignalFactory.Create<TValue>());
         }
 
-        /// <summary>
-        /// Groups the elements of an asynchronous observable sequence according to a specified key selector function and
-        /// returns an observable sequence of grouped observables.
-        /// </summary>
+        /// <summary>Groups the elements of an asynchronous observable sequence according to a specified key selector function and returns an observable sequence of grouped observables.</summary>
         /// <typeparam name="TKey">The type of the key returned by the key selector function. Must be non-null.</typeparam>
         /// <param name="keySelector">A function to extract the key for each element in the source sequence.</param>
         /// <param name="groupSignalSelector">A function that provides a signal for each group, given its key. Used to control how elements are published
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
index 9f381fad..8c8a33c6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Creates a new observable sequence that contains only the elements from the source sequence that satisfy the
-        /// specified asynchronous predicate.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that contains only the elements from the source sequence that satisfy the specified asynchronous predicate.</summary>
         /// <param name="predicate">A function that evaluates each element and its associated cancellation token, returning a ValueTask that
         /// resolves to <see langword="true"/> to include the element in the resulting sequence; otherwise, <see
         /// langword="false"/>.</param>
@@ -29,10 +26,7 @@ public static partial class SignalAsyncExtensions
         public IObservableAsync<T> Keep(Func<T, CancellationToken, ValueTask<bool>> predicate) =>
             new KeepAsyncSignal<T>(source, predicate);
 
-        /// <summary>
-        /// Creates a new observable sequence that contains only the elements from the current sequence that satisfy the
-        /// specified predicate.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that contains only the elements from the current sequence that satisfy the specified predicate.</summary>
         /// <param name="predicate">A function to test each element for a condition. The element is included in the resulting sequence if the
         /// function returns <see langword="true"/>.</param>
         /// <returns>An observable sequence that contains elements from the current sequence that satisfy the specified
@@ -56,20 +50,14 @@ public IObservableAsync<T> KeepWith<TState>(
             return new KeepSyncSignal<T>(source, value => predicate(state, value));
         }
 
-        /// <summary>
-        /// Creates a new observable sequence that contains only the elements from the source sequence that satisfy the
-        /// specified asynchronous predicate.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that contains only the elements from the source sequence that satisfy the specified asynchronous predicate.</summary>
         /// <param name="predicate">A function that evaluates each element and cancellation token.</param>
         /// <returns>An observable sequence that emits only those elements for which the predicate returns <see langword="true"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Where(Func<T, CancellationToken, ValueTask<bool>> predicate) =>
             new KeepAsyncSignal<T>(source, predicate);
 
-        /// <summary>
-        /// Creates a new observable sequence that contains only the elements from the current sequence that satisfy the
-        /// specified predicate.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that contains only the elements from the current sequence that satisfy the specified predicate.</summary>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns>An observable sequence that contains elements from the current sequence that satisfy the predicate.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
index 3fdaa43f..d1c248b7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/KeepType.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Projects each element of the observable sequence to the specified reference type and filters out elements
-        /// that are not of that type.
-        /// </summary>
+        /// <summary>Projects each element of the observable sequence to the specified reference type and filters out elements that are not of that type.</summary>
         /// <typeparam name="TResult">The reference type to filter and project elements to. Must be a class.</typeparam>
         /// <returns>An observable sequence containing only the elements of type TResult from the original sequence.</returns>
         [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
index 5729144a..351fe1b3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/LastOrDefaultAsync.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Asynchronously returns the last element in the sequence that satisfies the specified predicate, or a default
-        /// value if no such element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the last element in the sequence that satisfies the specified predicate, or a default value if no such element is found.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the last element for which this
         /// predicate returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element in the sequence satisfies the predicate.</param>
@@ -29,10 +26,7 @@ public static partial class SignalAsyncExtensions
             T? defaultValue) =>
             source.LastOrDefaultAsync(predicate, defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the last element in the sequence that satisfies the specified predicate, or a default
-        /// value if no such element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the last element in the sequence that satisfies the specified predicate, or a default value if no such element is found.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the last element for which this
         /// predicate returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element in the sequence satisfies the predicate.</param>
@@ -66,10 +60,7 @@ public static partial class SignalAsyncExtensions
         public ValueTask<T?> LastOrDefaultAsync(CancellationToken cancellationToken) =>
             source.LastOrDefaultAsync(default, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously returns the last element of the sequence, or a specified default value if the sequence
-        /// contains no elements.
-        /// </summary>
+        /// <summary>Asynchronously returns the last element of the sequence, or a specified default value if the sequence contains no elements.</summary>
         /// <param name="defaultValue">The value to return if the sequence is empty.</param>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the last element of the
         /// sequence, or <paramref name="defaultValue"/> if the sequence is empty.</returns>
@@ -77,10 +68,7 @@ public static partial class SignalAsyncExtensions
         public ValueTask<T?> LastOrDefaultAsync(T? defaultValue) =>
             source.LastOrDefaultAsync(defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the last element of the sequence, or a specified default value if the sequence
-        /// contains no elements.
-        /// </summary>
+        /// <summary>Asynchronously returns the last element of the sequence, or a specified default value if the sequence contains no elements.</summary>
         /// <param name="defaultValue">The value to return if the sequence is empty.</param>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the last element of the
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
index db561212..23c10ef2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Lead.cs
@@ -14,19 +14,13 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns a new observable sequence that begins with the specified value, followed by the elements of the
-        /// current sequence.
-        /// </summary>
+        /// <summary>Returns a new observable sequence that begins with the specified value, followed by the elements of the current sequence.</summary>
         /// <param name="value">The value to prepend to the beginning of the sequence.</param>
         /// <returns>An observable sequence with the specified value prepended to the original sequence.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Lead(T value) => new LeadSignal<T>(source, [value]);
 
-        /// <summary>
-        /// Returns a new observable sequence that begins with the specified value, followed by the elements of the
-        /// current sequence.
-        /// </summary>
+        /// <summary>Returns a new observable sequence that begins with the specified value, followed by the elements of the current sequence.</summary>
         /// <param name="value">The value to prepend to the beginning of the sequence.</param>
         /// <returns>An observable sequence with the specified value prepended to the original sequence.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
index cf132ebd..f71f81a4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides a set of extension methods for creating and managing connectable asynchronous observables using various
-/// Signal types.
-/// </summary>
+/// <summary>Provides a set of extension methods for creating and managing connectable asynchronous observables using various Signal types.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Multicasting and publishing operators for an observable source sequence.</summary>
@@ -17,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Creates a connectable observable sequence that shares a single subscription to the underlying sequence using
-        /// the specified Signal.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that shares a single subscription to the underlying sequence using the specified Signal.</summary>
         /// <param name="signal">The signal that multicasts the source elements to multiple observers. Cannot be null.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence through the specified signal.</returns>
         /// <remarks>The source is not subscribed until Connect is called, so observers can subscribe first.</remarks>
@@ -37,10 +31,7 @@ public ConnectableSignalAsync<T> Multicast(ISignalAsync<T> signal) =>
         public ConnectableSignalAsync<T> Publish() =>
             new(source, new SerialSignalAsync<T>());
 
-        /// <summary>
-        /// Creates a connectable observable sequence that shares a single subscription to the underlying sequence,
-        /// using a Signal created with the specified options.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that shares a single subscription to the underlying sequence, using a Signal created with the specified options.</summary>
         /// <param name="options">The options that configure the multicasting signal. Cannot be null.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence using a Signal configured with the
         /// specified options.</returns>
@@ -72,10 +63,7 @@ public ConnectableSignalAsync<T> Publish(SignalCreationOptions options) =>
         public ConnectableSignalAsync<T> Publish(T initialValue) =>
             new(source, new SerialReplayLatestSignalAsync<T>(new(initialValue)));
 
-        /// <summary>
-        /// Creates a connectable observable sequence that shares a single subscription to the underlying sequence and
-        /// starts with the specified initial value.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that shares a single subscription to the underlying sequence and starts with the specified initial value.</summary>
         /// <param name="initialValue">The initial value to be emitted to subscribers before any items are emitted by the source sequence.</param>
         /// <param name="options">The options that configure the underlying behavior signal.</param>
         /// <returns>A connectable observable sequence that multicasts the source sequence and emits the specified initial value
@@ -100,10 +88,7 @@ public ConnectableSignalAsync<T> Publish(T initialValue, BehaviorSignalCreationO
                     "Unsupported behavior signal creation options.")
             });
 
-        /// <summary>
-        /// Creates a connectable observable sequence that shares a single subscription to the underlying source and
-        /// does not retain any state between subscriptions.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that shares a single subscription to the underlying source and does not retain any state between subscriptions.</summary>
         /// <returns>A connectable observable sequence that multicasts notifications from the source without retaining state
         /// between subscribers.</returns>
         /// <remarks>Each connection is independent of the ones around it, and no value is cached for late subscribers.</remarks>
@@ -129,10 +114,7 @@ public ConnectableSignalAsync<T> StatelessPublish(T initialValue) =>
         public ConnectableSignalAsync<T> ReplayLatestPublish() =>
             new(source, new SerialReplayLatestSignalAsync<T>(Optional<T>.Empty));
 
-        /// <summary>
-        /// Creates a connectable observable sequence that replays only the latest published value to new subscribers,
-        /// using the specified replay Signal creation options.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that replays only the latest published value to new subscribers, using the specified replay Signal creation options.</summary>
         /// <param name="options">The options that configure the replay signal.</param>
         /// <returns>A connectable observable sequence that replays the most recent value to each new subscriber after
         /// connection.</returns>
@@ -156,10 +138,7 @@ public ConnectableSignalAsync<T> ReplayLatestPublish(ReplayLatestSignalCreationO
                     "Unsupported replay-latest signal creation options.")
             });
 
-        /// <summary>
-        /// Creates a connectable observable sequence that replays only the latest item to new subscribers and publishes
-        /// items to all current subscribers.
-        /// </summary>
+        /// <summary>Creates a connectable observable sequence that replays only the latest item to new subscribers and publishes items to all current subscribers.</summary>
         /// <returns>A connectable observable sequence that replays the most recent item to new subscribers and multicasts
         /// notifications to all current subscribers.</returns>
         /// <remarks>Each connection replays only the most recent value published during that connection; nothing is
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
index 1c1dea53..9e7d4889 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
@@ -147,12 +147,11 @@ private async ValueTask AwaitAndForwardAsync(
         }
     }
 
-    /// <summary>Drops upstream duplicates, debounces each value, and suppresses duplicates again before forwarding.</summary>
+    /// <summary>Schedules the value without canceling superseded delays; only the current value is emitted.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="dueTime">The debounce window.</param>
     /// <param name="timeProvider">The time provider for the debounce timer.</param>
-    /// <remarks>A superseded delay is not cancelled: it runs to completion and its result is dropped by the id check.</remarks>
     internal sealed class ThrottleDistinctSignal<T>(
         IObservableAsync<T> source,
         TimeSpan dueTime,
@@ -232,15 +231,18 @@ internal bool TryClaimEmission(T value, long id)
                 }
             }
 
-            /// <inheritdoc/>
-            protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken)
+            /// <summary>Starts a delay for a distinct upstream value and supersedes the previous pending value.</summary>
+            /// <param name="value">The upstream value.</param>
+            /// <param name="cancellationToken">Cancellation for the delay.</param>
+            /// <returns>The pending emission, or a completed task for a duplicate value.</returns>
+            internal Task StartDelayAsync(T value, CancellationToken cancellationToken)
             {
                 long currentId;
                 lock (_gate)
                 {
                     if (_hasUpstream && Comparer.Equals(value, _lastUpstream))
                     {
-                        return default;
+                        return Task.CompletedTask;
                     }
 
                     _lastUpstream = value;
@@ -248,7 +250,13 @@ protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancella
                     currentId = ++_id;
                 }
 
-                _ = FireAfterDelayAsync(value, currentId, cancellationToken);
+                return FireAfterDelayAsync(value, currentId, cancellationToken);
+            }
+
+            /// <inheritdoc/>
+            protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken)
+            {
+                _ = StartDelayAsync(value, cancellationToken);
                 return default;
             }
 
@@ -426,14 +434,12 @@ private async ValueTask AwaitFullAsync(ValueTask actionTask, T value, Cancellati
         }
     }
 
-    /// <summary>Forwards a value at once when the condition holds, otherwise after the debounce window elapses.</summary>
+    /// <summary>Schedules the latest value, discarding superseded delay results.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="debounce">The debounce window applied to bypass-false values.</param>
     /// <param name="condition">When <see langword="true"/> the value bypasses the delay and is forwarded immediately.</param>
     /// <param name="timeProvider">The time provider for the debounce timer.</param>
-    /// <remarks>Each new upstream value supersedes a pending delay, which is not cancelled: it runs to completion and its
-    /// result is dropped by the id check.</remarks>
     internal sealed class DebounceUntilSignal<T>(
         IObservableAsync<T> source,
         TimeSpan debounce,
@@ -488,6 +494,21 @@ internal bool IsCurrentEmission(long id)
                 }
             }
 
+            /// <summary>Starts a delay that supersedes the previously pending value.</summary>
+            /// <param name="value">The pending value.</param>
+            /// <param name="cancellationToken">Cancellation for the delay.</param>
+            /// <returns>The delay and any downstream notification.</returns>
+            internal Task StartDelayAsync(T value, CancellationToken cancellationToken)
+            {
+                long currentId;
+                lock (_gate)
+                {
+                    currentId = ++_id;
+                }
+
+                return DelayAndEmitAsync(value, currentId, cancellationToken);
+            }
+
             /// <inheritdoc/>
             protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken)
             {
@@ -502,13 +523,7 @@ protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancella
                     return downstream.OnNextAsync(value, cancellationToken);
                 }
 
-                long currentId;
-                lock (_gate)
-                {
-                    currentId = ++_id;
-                }
-
-                _ = DelayAndEmitAsync(value, currentId, cancellationToken);
+                _ = StartDelayAsync(value, cancellationToken);
                 return default;
             }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
index e6db6101..dfcfe537 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Async.Disposables;
 
@@ -11,11 +10,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Provides the shared upstream coordinator backing the <c>Partition</c> parity helper.</summary>
 public static partial class SignalAsyncExtensions
 {
-    /// <summary>
-    /// Shares one upstream subscription between the two <c>Partition</c> branches, starting it when the first branch
-    /// subscribes and tearing it down when the last one disposes. Each emission dispatches to whichever branch observer
-    /// the predicate selects, or to nothing when that branch has no subscriber.
-    /// </summary>
+    /// <summary>Shares an upstream subscription between predicate-selected branches until the last subscriber disposes.</summary>
     /// <typeparam name="T">The element type partitioned across the two branches.</typeparam>
     internal sealed class PartitionCoordinator<T>
     {
@@ -126,8 +121,7 @@ internal bool TryAttachSourceSubscription(IAsyncDisposable subscription)
         /// <summary>Attaches the new upstream subscription, disposing it when both branches disposed during the subscribe.</summary>
         /// <param name="subscription">The freshly-created upstream subscription.</param>
         /// <returns>A task that completes once the subscription has been attached or disposed.</returns>
-        [ExcludeFromCodeCoverage]
-        private async ValueTask AttachOrDisposeStaleSubscriptionAsync(IAsyncDisposable subscription)
+        internal async ValueTask AttachOrDisposeStaleSubscriptionAsync(IAsyncDisposable subscription)
         {
             if (!TryAttachSourceSubscription(subscription))
             {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
index 3ca19c7c..ad0c0a3b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
@@ -226,10 +226,7 @@ public IObservableAsync<T> WaitUntil(Func<T, bool> predicate)
             return new PairwiseSignal<T>(source);
         }
 
-        /// <summary>
-        /// Partitions the source sequence into values that satisfy the predicate and values that do not.
-        /// The predicate is evaluated exactly once per element.
-        /// </summary>
+        /// <summary>Partitions the source sequence into values that satisfy the predicate and values that do not. The predicate is evaluated exactly once per element.</summary>
         /// <param name="predicate">The partition predicate.</param>
         /// <returns>A tuple of true and false partitions.</returns>
         public (IObservableAsync<T> True, IObservableAsync<T> False) Partition(Func<T, bool> predicate)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
index dcd5f9fe..29815e2d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs
-        /// in the source sequence.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs in the source sequence.</summary>
         /// <param name="handler">A function that receives the exception thrown by the source sequence and returns an alternative observable
         /// sequence to continue with.</param>
         /// <returns>An observable sequence that emits items from the source sequence, or from the handler-provided sequence if
@@ -42,10 +39,7 @@ public IObservableAsync<T> Resume(IObservableAsync<T> fallback)
             return new CatchSignal<T>(source, _ => fallback, null);
         }
 
-        /// <summary>
-        /// Continues the observable sequence with an alternative sequence provided by the specified handler when an
-        /// error occurs, and ignores the error after invoking the handler.
-        /// </summary>
+        /// <summary>Continues the observable sequence with an alternative sequence provided by the specified handler when an error occurs, and ignores the error after invoking the handler.</summary>
         /// <param name="handler">A function that receives the exception and returns an alternative observable sequence to resume with after
         /// an error occurs.</param>
         /// <returns>An observable sequence that resumes with the sequence returned by the handler when an error is encountered,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
index 3e5722b8..8cdfe496 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Applies an asynchronous accumulator function over the observable sequence, returning the
-        /// final accumulated value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an asynchronous accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
@@ -30,10 +27,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator) =>
             source.ReduceAsync(seed, accumulator);
 
-        /// <summary>
-        /// Applies an asynchronous accumulator function over the observable sequence, returning the
-        /// final accumulated value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an asynchronous accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
@@ -48,10 +42,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
             CancellationToken cancellationToken) =>
             source.ReduceAsync(seed, accumulator, cancellationToken);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence, returning the final accumulated
-        /// value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
@@ -64,10 +55,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
             Func<TAcc, T, TAcc> accumulator) =>
             source.ReduceAsync(seed, accumulator);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence, returning the final accumulated
-        /// value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
@@ -82,10 +70,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
             CancellationToken cancellationToken) =>
             source.ReduceAsync(seed, accumulator, cancellationToken);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence with a seed value, then applies
-        /// a result selector to the final accumulated value.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence with a seed value, then applies a result selector to the final accumulated value.</summary>
         /// <typeparam name="TAcc">The type of the intermediate accumulated value.</typeparam>
         /// <typeparam name="TResult">The type of the result value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
@@ -101,10 +86,7 @@ public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
             Func<TAcc, TResult> resultSelector) =>
             source.ReduceAsync(seed, accumulator, resultSelector);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence with a seed value, then applies
-        /// a result selector to the final accumulated value.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence with a seed value, then applies a result selector to the final accumulated value.</summary>
         /// <typeparam name="TAcc">The type of the intermediate accumulated value.</typeparam>
         /// <typeparam name="TResult">The type of the result value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
@@ -122,10 +104,7 @@ public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
             CancellationToken cancellationToken) =>
             source.ReduceAsync(seed, accumulator, resultSelector, cancellationToken);
 
-        /// <summary>
-        /// Applies an asynchronous accumulator function over the observable sequence, returning the
-        /// final accumulated value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an asynchronous accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
@@ -138,10 +117,7 @@ public ValueTask<TAcc> ReduceAsync<TAcc>(
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator) =>
             source.ReduceAsync(seed, accumulator, CancellationToken.None);
 
-        /// <summary>
-        /// Applies an asynchronous accumulator function over the observable sequence, returning the
-        /// final accumulated value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an asynchronous accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
@@ -163,10 +139,7 @@ public async ValueTask<TAcc> ReduceAsync<TAcc>(
             return await observer.AwaitResultAsync().ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence, returning the final accumulated
-        /// value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAccumulate">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
@@ -179,10 +152,7 @@ public ValueTask<TAccumulate> ReduceAsync<TAccumulate>(
             Func<TAccumulate, T, TAccumulate> accumulator) =>
             source.ReduceAsync(seed, accumulator, CancellationToken.None);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence, returning the final accumulated
-        /// value when the sequence completes.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence, returning the final accumulated value when the sequence completes.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
@@ -204,10 +174,7 @@ public async ValueTask<TAcc> ReduceAsync<TAcc>(
             return await observer.AwaitResultAsync().ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence with a seed value, then applies
-        /// a result selector to the final accumulated value.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence with a seed value, then applies a result selector to the final accumulated value.</summary>
         /// <typeparam name="TAcc">The type of the intermediate accumulated value.</typeparam>
         /// <typeparam name="TResult">The type of the result value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
@@ -223,10 +190,7 @@ public ValueTask<TResult> ReduceAsync<TAcc, TResult>(
             Func<TAcc, TResult> resultSelector) =>
             source.ReduceAsync(seed, accumulator, resultSelector, CancellationToken.None);
 
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence with a seed value, then applies
-        /// a result selector to the final accumulated value.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence with a seed value, then applies a result selector to the final accumulated value.</summary>
         /// <typeparam name="TAcc">The type of the intermediate accumulated value.</typeparam>
         /// <typeparam name="TResult">The type of the result value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
index 59ee2333..c1660ae7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
@@ -27,10 +27,7 @@ public IObservableAsync<T> RefCount() =>
             new RefCountSignal<T>(source);
     }
 
-    /// <summary>
-    /// Async observable that automatically connects to the underlying connectable source when the first
-    /// observer subscribes and disconnects when the last observer unsubscribes.
-    /// </summary>
+    /// <summary>Async observable that automatically connects to the underlying connectable source when the first observer subscribes and disconnects when the last observer unsubscribes.</summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The connectable observable to manage with reference counting.</param>
     internal sealed class RefCountSignal<T>(ConnectableSignalAsync<T> source) : IObservableAsync<T>, IDisposable
@@ -73,10 +70,7 @@ internal void Dispose(bool disposing)
             _connection?.DisposeAsync().AsTask().GetAwaiter().GetResult();
         }
 
-        /// <summary>
-        /// Subscribes the specified observer, incrementing the reference count and connecting to the source
-        /// if this is the first subscriber.
-        /// </summary>
+        /// <summary>Subscribes the specified observer, incrementing the reference count and connecting to the source if this is the first subscriber.</summary>
         /// <param name="observer">The observer to receive elements from the connectable source.</param>
         /// <param name="cancellationToken">A token to cancel the subscription.</param>
         /// <returns>An async disposable that decrements the reference count on disposal.</returns>
@@ -107,10 +101,7 @@ await connection
             }
         }
 
-        /// <summary>
-        /// Witness wrapper that forwards all notifications and decrements the parent's reference count on disposal,
-        /// disconnecting from the source when the count reaches zero.
-        /// </summary>
+        /// <summary>Witness wrapper that forwards all notifications and decrements the parent's reference count on disposal, disconnecting from the source when the count reaches zero.</summary>
         /// <param name="parent">The parent ref-count observable.</param>
         /// <param name="observer">The downstream witness to forward notifications to.</param>
         internal sealed class RefCountWitness(RefCountSignal<T> parent, IObserverAsync<T> observer) : WitnessAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
index 9a9bfa0b..62c90480 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Time-shifts the observable sequence by the specified time span. Each element notification
-        /// is delayed by the specified duration.
-        /// </summary>
+        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <returns>An observable sequence with element notifications time-shifted by the specified duration.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="delayInterval"/> is negative.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
index 5420d95b..673a7300 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Catch.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs
-        /// in the source sequence.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs in the source sequence.</summary>
         /// <param name="handler">A function that receives the exception thrown by the source sequence and returns an alternative observable
         /// sequence to continue with.</param>
         /// <returns>An observable sequence that emits items from the source sequence, or from the handler-provided sequence if
@@ -29,10 +26,7 @@ public IObservableAsync<T> Catch(Func<Exception, IObservableAsync<T>> handler)
             return new CatchSignal<T>(source, handler, null);
         }
 
-        /// <summary>
-        /// Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs
-        /// in the source sequence.
-        /// </summary>
+        /// <summary>Creates a new observable sequence that continues with a handler-provided sequence when an exception occurs in the source sequence.</summary>
         /// <param name="handler">A function that receives the exception thrown by the source sequence and returns an alternative observable
         /// sequence to continue with.</param>
         /// <param name="onErrorResume">An optional asynchronous callback invoked when an error occurs. If not specified, the observer's default
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.CombineLatest.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.CombineLatest.Rx.cs
index 9d577ed2..274164ed 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.CombineLatest.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.CombineLatest.Rx.cs
@@ -23,10 +23,7 @@ public IObservableAsync<IReadOnlyList<TSource>> CombineLatest()
             return new SyncLatestEnumerableSignal<TSource, IReadOnlyList<TSource>>(sources, static values => values);
         }
 
-        /// <summary>
-        /// Combines the latest value from each asynchronous observable sequence in the supplied collection and projects the
-        /// resulting snapshot into a result value.
-        /// </summary>
+        /// <summary>Combines the latest value from each asynchronous observable sequence in the supplied collection and projects the resulting snapshot into a result value.</summary>
         /// <typeparam name="TResult">The projected result type.</typeparam>
         /// <param name="resultSelector">A selector that projects the current snapshot of latest values into a result value.</param>
         /// <returns>An observable sequence that emits projected results whenever any source produces a new value, after all
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
index 307550e0..b29b3292 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Time-shifts the observable sequence by the specified time span. Each element notification
-        /// is delayed by the specified duration.
-        /// </summary>
+        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <returns>An observable sequence with element notifications time-shifted by the specified duration.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="delayInterval"/> is negative.</exception>
@@ -28,10 +25,7 @@ public IObservableAsync<T> Delay(TimeSpan delayInterval)
                 : new DelaySignal<T>(source, delayInterval, TimeProvider.System);
         }
 
-        /// <summary>
-        /// Time-shifts the observable sequence by the specified time span. Each element notification
-        /// is delayed by the specified duration.
-        /// </summary>
+        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
         /// is used.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
index b504de43..5060d051 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns an observable sequence that emits only distinct consecutive elements, suppressing duplicates that
-        /// are equal to the previous element.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits only distinct consecutive elements, suppressing duplicates that are equal to the previous element.</summary>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not equal to their
         /// immediate predecessor.</returns>
         public IObservableAsync<T> DistinctUntilChanged()
@@ -42,10 +39,7 @@ public IObservableAsync<T> DistinctUntilChanged(IEqualityComparer<T> equalityCom
             return new UniqueSignal<T>(source, equalityComparer);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
-        /// duplicates as determined by a key selector function.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits elements from the source sequence, suppressing consecutive duplicates as determined by a key selector function.</summary>
         /// <typeparam name="TKey">The type of the key that decides whether consecutive elements are duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
@@ -59,10 +53,7 @@ public IObservableAsync<T> DistinctUntilChangedBy<TKey>(Func<T, TKey> keySelecto
             return new UniqueBySignal<T, TKey>(source, keySelector, equalityComparer);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
-        /// duplicates as determined by a key selector and equality comparer.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits elements from the source sequence, suppressing consecutive duplicates as determined by a key selector and equality comparer.</summary>
         /// <typeparam name="TKey">The type of the key that decides whether consecutive elements are duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <param name="equalityComparer">The comparer that compares keys for equality.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
index e84c56b9..88f35d07 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Applies an accumulator function over the observable sequence and returns each intermediate result
-        /// using the specified asynchronous accumulator.
-        /// </summary>
+        /// <summary>Applies an accumulator function over the observable sequence and returns each intermediate result using the specified asynchronous accumulator.</summary>
         /// <typeparam name="TAcc">The type of the accumulated value.</typeparam>
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to be invoked on each element.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
index 72ffa99f..9b1fc010 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Projects each element of the observable sequence to an asynchronous observable sequence and
-        /// merges the resulting sequences into one observable sequence.
-        /// </summary>
+        /// <summary>Projects each element of the observable sequence to an asynchronous observable sequence and merges the resulting sequences into one observable sequence.</summary>
         /// <typeparam name="TResult">The type of the elements in the projected inner sequences.</typeparam>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the merged projection results.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
index ff682fdb..4eed6c62 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides extension methods for asynchronous observable sequences, enabling operations such as retrieving a single
-/// element that matches a specified condition.
-/// </summary>
+/// <summary>Provides extension methods for asynchronous observable sequences, enabling operations such as retrieving a single element that matches a specified condition.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Single-element operators for an observable source sequence.</summary>
@@ -17,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an
-        /// exception if more than one such element exists.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an exception if more than one such element exists.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element that matches
@@ -30,10 +24,7 @@ public static partial class SignalAsyncExtensions
         public ValueTask<T> SingleAsync(Func<T, bool> predicate) =>
             source.SingleAsync(predicate, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an
-        /// exception if more than one such element exists.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an exception if more than one such element exists.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
@@ -44,10 +35,7 @@ public ValueTask<T> SingleAsync(Func<T, bool> predicate) =>
         public ValueTask<T> SingleAsync(Func<T, bool> predicate, CancellationToken cancellationToken) =>
             SingleCoreAsync(source, predicate, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not
-        /// contain exactly one element.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not contain exactly one element.</summary>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
         /// <remarks>Both an empty sequence and a sequence of more than one element throw.</remarks>
@@ -55,10 +43,7 @@ public ValueTask<T> SingleAsync(Func<T, bool> predicate, CancellationToken cance
         public ValueTask<T> SingleAsync() =>
             source.SingleAsync(CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not
-        /// contain exactly one element.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not contain exactly one element.</summary>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
index d4366b6f..d6bf893a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
@@ -50,20 +50,14 @@ public static partial class SignalAsyncExtensions
             CancellationToken cancellationToken) =>
             SingleOrDefaultCoreAsync(source, predicate, defaultValue, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this
-        /// operation throws an exception if more than one element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this operation throws an exception if more than one element is found.</summary>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, or the default value of <typeparamref name="T"/> if the sequence is empty.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync() =>
             source.SingleOrDefaultAsync(default, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this
-        /// operation throws an exception if more than one element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this operation throws an exception if more than one element is found.</summary>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, or the default value of <typeparamref name="T"/> if the sequence is empty.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
index 506134ce..81f99d86 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Bypasses elements in the observable sequence as long as the specified asynchronous condition is true,
-        /// then emits all remaining elements.
-        /// </summary>
+        /// <summary>Bypasses elements in the observable sequence as long as the specified asynchronous condition is true, then emits all remaining elements.</summary>
         /// <param name="predicate">An asynchronous function to test each element for a condition. Receives the element
         /// and a cancellation token.</param>
         /// <returns>An observable sequence that skips elements while the predicate returns true and emits
@@ -29,10 +26,7 @@ public IObservableAsync<T> SkipWhile(Func<T, CancellationToken, ValueTask<bool>>
             return new SkipWhileAsyncSignal<T>(source, predicate);
         }
 
-        /// <summary>
-        /// Bypasses elements in the observable sequence as long as the specified condition is true,
-        /// then emits all remaining elements.
-        /// </summary>
+        /// <summary>Bypasses elements in the observable sequence as long as the specified condition is true, then emits all remaining elements.</summary>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns>An observable sequence that skips elements while the predicate returns true and emits
         /// all subsequent elements.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
index 4596fa62..b49f7a58 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Subscribes to the asynchronous data source and invokes the specified callbacks for each item, error, or
-        /// completion notification.
-        /// </summary>
+        /// <summary>Subscribes to the asynchronous data source and invokes the specified callbacks for each item, error, or completion notification.</summary>
         /// <param name="onNextAsync">A delegate that is invoked asynchronously for each item received from the data source. The delegate receives
         /// the item and a cancellation token.</param>
         /// <param name="onErrorResumeAsync">An optional delegate that is invoked asynchronously if an error occurs during data processing. The delegate
@@ -54,10 +51,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<Exception, CancellationToken, ValueTask>? onErrorResumeAsync) =>
             source.SubscribeAsync(onNextAsync, onErrorResumeAsync, null, CancellationToken.None);
 
-        /// <summary>
-        /// Subscribes to the asynchronous data source and invokes the specified callbacks for each item, error, or
-        /// completion notification.
-        /// </summary>
+        /// <summary>Subscribes to the asynchronous data source and invokes the specified callbacks for each item, error, or completion notification.</summary>
         /// <param name="onNextAsync">A delegate that is invoked asynchronously for each item received from the data source.</param>
         /// <param name="onErrorResumeAsync">An optional delegate that is invoked asynchronously if an error occurs during data processing.</param>
         /// <param name="onCompletedAsync">An optional delegate that is invoked asynchronously when the data source completes successfully.</param>
@@ -101,10 +95,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
         public ValueTask<IAsyncDisposable> SubscribeAsync(Action<T> onNext) =>
             source.SubscribeAsync(onNext, CancellationToken.None);
 
-        /// <summary>
-        /// Subscribes to the observable sequence asynchronously, invoking the specified callbacks for each element,
-        /// error, or completion notification.
-        /// </summary>
+        /// <summary>Subscribes to the observable sequence asynchronously, invoking the specified callbacks for each element, error, or completion notification.</summary>
         /// <param name="onNext">An action to invoke for each element in the sequence. Cannot be null.</param>
         /// <param name="onErrorResume">An optional action to invoke if an error occurs during the sequence. If null, errors are not handled by the
         /// subscriber.</param>
@@ -163,10 +154,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync() =>
         public ValueTask<IAsyncDisposable> SubscribeAsync(Func<T, CancellationToken, ValueTask> onNextAsync) =>
             source.SubscribeAsync(onNextAsync, CancellationToken.None);
 
-        /// <summary>
-        /// Subscribes asynchronously to receive notifications for each item in the sequence using the specified
-        /// asynchronous callback.
-        /// </summary>
+        /// <summary>Subscribes asynchronously to receive notifications for each item in the sequence using the specified asynchronous callback.</summary>
         /// <param name="onNextAsync">A function to invoke asynchronously for each item in the sequence. The function receives the item and a
         /// cancellation token, and returns a ValueTask that completes when processing is finished.</param>
         /// <param name="cancellationToken">The token that cancels the subscription.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
index d20c1afa..531b0ff4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchTo.cs
@@ -14,19 +14,13 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence of observable sequences.</param>
     extension<T>(IObservableAsync<IObservableAsync<T>> source)
     {
-        /// <summary>
-        /// Transforms an observable sequence of observable sequences into a single observable sequence that emits
-        /// values from the most recent inner observable sequence.
-        /// </summary>
+        /// <summary>Transforms an observable sequence of observable sequences into a single observable sequence that emits values from the most recent inner observable sequence.</summary>
         /// <returns>An observable sequence that emits items from the most recently emitted inner observable sequence. When a new
         /// inner sequence is emitted, the previous one is unsubscribed.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> SwitchTo() => new SwitchToSignal<T>(source);
 
-        /// <summary>
-        /// Transforms an observable sequence of observable sequences into a single observable sequence that emits
-        /// values from the most recent inner observable sequence.
-        /// </summary>
+        /// <summary>Transforms an observable sequence of observable sequences into a single observable sequence that emits values from the most recent inner observable sequence.</summary>
         /// <returns>An observable sequence that emits items from the most recently emitted inner observable sequence.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Switch() => new SwitchToSignal<T>(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
index 1e6ea198..817c72bd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Async observable that switches to the most recently emitted inner observable sequence,
-/// unsubscribing from the previous inner sequence each time a new one arrives.
-/// </summary>
+/// <summary>Async observable that switches to the most recently emitted inner observable sequence, unsubscribing from the previous inner sequence each time a new one arrives.</summary>
 /// <typeparam name="T">The type of elements produced by the inner observable sequences.</typeparam>
 /// <param name="source">The outer observable sequence that emits inner observable sequences.</param>
 public sealed class SwitchToSignal<T>(IObservableAsync<IObservableAsync<T>> source) : IObservableAsync<T>
@@ -30,10 +27,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             () => subscription.SubscribeAsync(source, cancellationToken));
     }
 
-    /// <summary>
-    /// Manages the lifetime of the outer subscription and the currently active inner subscription,
-    /// switching to new inner sequences as they arrive.
-    /// </summary>
+    /// <summary>Manages the lifetime of the outer subscription and the currently active inner subscription, switching to new inner sequences as they arrive.</summary>
     internal sealed class SwitchToCoordinator : IAsyncDisposable
     {
         /// <summary>The downstream observer to forward elements to.</summary>
@@ -91,10 +85,7 @@ internal async ValueTask SubscribeAsync(
             await _outerDisposable.SetDisposableAsync(outerSubscription).ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Handles a new inner observable from the outer sequence by disposing the previous inner subscription
-        /// and subscribing to the new one.
-        /// </summary>
+        /// <summary>Handles a new inner observable from the outer sequence by disposing the previous inner subscription and subscribing to the new one.</summary>
         /// <param name="inner">The new inner observable to switch to.</param>
         /// <returns>A task representing the asynchronous switch operation.</returns>
         internal ValueTask AcceptOuterValueAsync(IObservableAsync<T> inner)
@@ -109,10 +100,7 @@ internal ValueTask AcceptOuterValueAsync(IObservableAsync<T> inner)
             return SubscribeReplacementInnerAsync(inner, previousSubscription);
         }
 
-        /// <summary>
-        /// Handles the outer sequence completing, propagating completion downstream when no inner
-        /// sequence is active or when the outer fails.
-        /// </summary>
+        /// <summary>Handles the outer sequence completing, propagating completion downstream when no inner sequence is active or when the outer fails.</summary>
         /// <param name="result">The completion result from the outer sequence.</param>
         /// <returns>A task representing the asynchronous completion operation.</returns>
         internal ValueTask AcceptOuterCompletionAsync(Result result)
@@ -132,10 +120,7 @@ internal ValueTask AcceptOuterCompletionAsync(Result result)
             return shouldComplete ? FinishAsync(Result.Success) : default;
         }
 
-        /// <summary>
-        /// Handles the current inner sequence completing, propagating completion downstream
-        /// if the outer has also completed, or waiting for the next inner sequence otherwise.
-        /// </summary>
+        /// <summary>Handles the current inner sequence completing, propagating completion downstream if the outer has also completed, or waiting for the next inner sequence otherwise.</summary>
         /// <param name="result">The completion result from the inner sequence.</param>
         /// <returns>A task representing the asynchronous completion operation.</returns>
         internal ValueTask AcceptInnerCompletionAsync(Result result)
@@ -253,10 +238,7 @@ internal async ValueTask SubscribeReplacementInnerAsync(
             }
         }
 
-        /// <summary>
-        /// Disposes the current inner subscription, the outer subscription, and optionally forwards a
-        /// completion result to the downstream observer. This method is idempotent.
-        /// </summary>
+        /// <summary>Disposes the current inner subscription, the outer subscription, and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
index e9571374..16fd4031 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest10.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 10 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 10 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -60,10 +57,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 10 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 10 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
index 082d77a9..2d85db8a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest11.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 11 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 11 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -63,10 +60,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 11 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 11 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
index 43bfb58a..e179daf8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest12.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 12 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 12 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -66,10 +63,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11, src12),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 12 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 12 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
index 43be92df..ec10f526 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest13.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 13 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 13 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -69,10 +66,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11, src12, src13),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 13 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 13 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
index eca356c5..3bbde563 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest14.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 14 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 14 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -72,10 +69,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11, src12, src13, src14),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 14 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 14 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
index 2a52c9ff..98ddf7fe 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest15.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 15 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 15 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -90,10 +87,7 @@ public IObservableAsync<TResult> SyncLatest<
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11, src12, src13, src14, src15),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 15 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 15 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
index 37bef000..64ae8659 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest16.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 16 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 16 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -94,10 +91,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, T10,
                     src16),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 16 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 16 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest3.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest3.cs
index 0ab27988..8fdc8a30 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest3.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest3.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 3 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 3 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="TResult">The projected element type.</typeparam>
@@ -34,10 +31,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, TResult>(
                 new(src1, src2, src3),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 3 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 3 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="TResult">The projected element type.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest4.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest4.cs
index f4688e57..eb2f170d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest4.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest4.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 4 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 4 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -37,10 +34,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, TResult>(
                 new(src1, src2, src3, src4),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 4 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 4 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest5.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest5.cs
index 76c13da5..b41a2165 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest5.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest5.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 5 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 5 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -40,10 +37,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, TResult>(
                 new(src1, src2, src3, src4, src5),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 5 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 5 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest6.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest6.cs
index 09359d2c..9554ef42 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest6.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest6.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 6 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 6 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -43,10 +40,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, TResult>(
                 new(src1, src2, src3, src4, src5, src6),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 6 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 6 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest7.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest7.cs
index 90835fc6..c9ff4d3f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest7.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest7.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 7 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 7 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -46,10 +43,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, TResult>(
                 new(src1, src2, src3, src4, src5, src6, src7),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 7 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 7 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
index aac19c3b..ed04162c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest8.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 8 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 8 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -54,10 +51,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, TResult>
                 new(src1, src2, src3, src4, src5, src6, src7, src8),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 8 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 8 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
index c2c38f5c..9a5c9a4d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest9.cs
@@ -15,10 +15,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="src1">Source observable 1 whose latest value is combined.</param>
     extension<T1>(IObservableAsync<T1> src1)
     {
-        /// <summary>
-        /// Combines the latest values from 9 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 9 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
@@ -57,10 +54,7 @@ public IObservableAsync<TResult> SyncLatest<T2, T3, T4, T5, T6, T7, T8, T9, TRes
                 new(src1, src2, src3, src4, src5, src6, src7, src8, src9),
                 selector);
 
-        /// <summary>
-        /// Combines the latest values from 9 asynchronous observable sources into a single
-        /// sequence, projecting them through <paramref name="selector"/> whenever any source emits.
-        /// </summary>
+        /// <summary>Combines the latest values from 9 asynchronous observable sources into a single sequence, projecting them through <paramref name="selector"/> whenever any source emits.</summary>
         /// <typeparam name="T2">The element type of source 2.</typeparam>
         /// <typeparam name="T3">The element type of source 3.</typeparam>
         /// <typeparam name="T4">The element type of source 4.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
index 21df8a1d..3457e33c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
@@ -16,11 +16,7 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence that emits a snapshot of the latest values whenever any source produces a new value,
         /// after all sources have produced at least one value.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="sources"/> is <see langword="null"/>.</exception>
-        /// <remarks>Each emitted <see cref="IReadOnlyList{T}"/> is a reference to one buffer owned by the subscription,
-        /// not a fresh allocation. An observer must consume the snapshot inside its <c>OnNextAsync</c> handler: the buffer
-        /// is overwritten under the operator's gate before each emit, so a retained reference surfaces the next emission's
-        /// values. For a stable copy, use the projecting <c>CombineLatest</c> overload or
-        /// <c>.Select(static s =&gt; s.ToArray())</c>.</remarks>
+        /// <remarks>Snapshots share a subscription-owned buffer. Consume them inside OnNextAsync or copy them before retaining them; subsequent emissions overwrite the buffer.</remarks>
         public IObservableAsync<IReadOnlyList<TSource>> SyncLatest()
         {
             ArgumentExceptionHelper.ThrowIfNull(sources);
@@ -29,10 +25,7 @@ public IObservableAsync<IReadOnlyList<TSource>> SyncLatest()
             return new SyncLatestEnumerableSignal<TSource, IReadOnlyList<TSource>>(sources, static s => s);
         }
 
-        /// <summary>
-        /// Combines the latest value from each asynchronous observable sequence in the supplied collection and projects the
-        /// resulting snapshot into a result value.
-        /// </summary>
+        /// <summary>Combines the latest value from each asynchronous observable sequence in the supplied collection and projects the resulting snapshot into a result value.</summary>
         /// <typeparam name="TResult">The projected result type.</typeparam>
         /// <param name="resultSelector">A selector that projects the current snapshot of latest values into a result value.</param>
         /// <returns>An observable sequence that emits projected results whenever any source produces a new value, after all
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
index b7437840..3c26f71e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
@@ -18,10 +18,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns an observable sequence that emits items from the source sequence until the specified other
-        /// observable emits an item or completes.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits items from the source sequence until the specified other observable emits an item or completes.</summary>
         /// <typeparam name="TOther">The type of the elements in the other observable sequence that triggers termination of the source sequence.</typeparam>
         /// <param name="other">The observable sequence whose first emission or completion will cause the returned sequence to stop emitting
         /// items from the source.</param>
@@ -36,10 +33,7 @@ public IObservableAsync<T> TakeUntil<TOther>(IObservableAsync<TOther> other)
             return new TakeUntilAsyncSignal<T, TOther>(source, other, TakeUntilOptions.Default);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits items from the source sequence until the specified other
-        /// observable emits an item or completes.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits items from the source sequence until the specified other observable emits an item or completes.</summary>
         /// <typeparam name="TOther">The type of the elements in the other observable sequence that triggers termination of the source sequence.</typeparam>
         /// <param name="other">The observable sequence whose first emission or completion will cause the returned sequence to stop emitting
         /// items from the source.</param>
@@ -162,10 +156,7 @@ public IObservableAsync<T> TakeUntil(
                 : new TaskStopSignal<T>(source, task, options ?? TakeUntilOptions.Default);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits items from the source sequence until the specified cancellation
-        /// token is canceled.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits items from the source sequence until the specified cancellation token is canceled.</summary>
         /// <param name="cancellationToken">A cancellation token that, when canceled, will terminate the resulting observable sequence.</param>
         /// <returns>An observable sequence that completes when the provided cancellation token is canceled or when the source
         /// sequence completes.</returns>
@@ -204,10 +195,7 @@ public IObservableAsync<T> TakeUntil(Func<T, bool> predicate, CancellationToken
                 : new PredicateStopSignal<T>(source, predicate);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits elements from the source sequence until the specified asynchronous
-        /// predicate returns true for an element.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits elements from the source sequence until the specified asynchronous predicate returns true for an element.</summary>
         /// <param name="asyncPredicate">A function that evaluates each element and its associated cancellation token asynchronously. The sequence
         /// stops emitting elements when this function returns true.</param>
         /// <returns>An observable sequence that contains the elements from the source sequence up to, but not including, the
@@ -491,15 +479,12 @@ internal async ValueTask SubscribeSourcesAsync(CancellationToken cancellationTok
             internal void LinkExternalCancellation(CancellationToken external) =>
                 _lifecycle.LinkExternalCancellation(external);
 
-            /// <summary>Hands the stop delegate the callback that ends the sequence.</summary>
-            /// <remarks>Completion runs on the thread that invokes the callback, so a synchronous <c>notify</c> ends the
-            /// sequence before it returns whenever the downstream observer completes synchronously.</remarks>
+            /// <summary>Completes on the notifying thread when downstream completion is synchronous.</summary>
             internal void AwaitStopThenComplete()
             {
                 Volatile.Write(ref _stopRegistration, _parent._stopSignal(Stop));
 
-                // A delegate is free to notify before it returns, in which case Stop ran without a
-                // registration to release. Release it here so the stop source is never left attached.
+                // Release registrations returned after a synchronous stop notification.
                 if (Volatile.Read(ref _stopSignalled) != 1)
                 {
                     return;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
index 52af3b00..293507ef 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Tap.cs
@@ -45,10 +45,7 @@ public IObservableAsync<T> Tap(
             Action onCompleted) =>
             new TapSyncSignal<T>(source, onNext, onError, _ => onCompleted());
 
-        /// <summary>
-        /// Invokes the specified asynchronous actions for each element, error, or completion notification in the
-        /// observable sequence without modifying the sequence.
-        /// </summary>
+        /// <summary>Invokes the specified asynchronous actions for each element, error, or completion notification in the observable sequence without modifying the sequence.</summary>
         /// <param name="onNext">An asynchronous callback to invoke for each element in the sequence.</param>
         /// <param name="onErrorResume">An optional asynchronous callback to invoke if an error occurs in the sequence.</param>
         /// <param name="onCompleted">An optional asynchronous callback to invoke when the sequence completes.</param>
@@ -67,10 +64,7 @@ onNext is null && onErrorResume is null && onCompleted is null
         public IObservableAsync<T> Do(Func<T, CancellationToken, ValueTask>? onNext) =>
             onNext is null ? source : new TapAsyncSignal<T>(source, onNext, null, null);
 
-        /// <summary>
-        /// Invokes the specified actions in response to notifications from the observable sequence without modifying
-        /// the sequence itself.
-        /// </summary>
+        /// <summary>Invokes the specified actions in response to notifications from the observable sequence without modifying the sequence itself.</summary>
         /// <param name="onNext">An action to invoke for each element in the sequence as it is emitted.</param>
         /// <param name="onErrorResume">An action to invoke if an error occurs in the sequence.</param>
         /// <param name="onCompleted">An action to invoke when the sequence completes, receiving the final result.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
index b0002459..86576174 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
@@ -5,10 +5,7 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Throttle (debounce) extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Throttle ignores elements from the source sequence that are followed by another element
-/// within a specified time span. Only values that are not followed by another value within the due time
-/// are forwarded to observers. This is commonly used to suppress rapid bursts of events such as keystrokes
-/// or mouse movements.</remarks>
+/// <remarks>Only the latest value is emitted after the quiet period; each source value restarts that period.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Throttle (debounce) operators for an observable source sequence.</summary>
@@ -16,10 +13,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Ignores elements from the source sequence that are followed by another element within
-        /// the specified time span. Only the last element in each burst is forwarded.
-        /// </summary>
+        /// <summary>Ignores elements from the source sequence that are followed by another element within the specified time span. Only the last element in each burst is forwarded.</summary>
         /// <param name="dueTime">The time span that must elapse after the last element before it is forwarded.
         /// Must be non-negative.</param>
         /// <returns>An observable sequence containing only those elements that are not followed by another
@@ -32,10 +26,7 @@ public IObservableAsync<T> Throttle(TimeSpan dueTime)
             return new ThrottleSignal<T>(source, dueTime, TimeProvider.System);
         }
 
-        /// <summary>
-        /// Ignores elements from the source sequence that are followed by another element within
-        /// the specified time span. Only the last element in each burst is forwarded.
-        /// </summary>
+        /// <summary>Ignores elements from the source sequence that are followed by another element within the specified time span. Only the last element in each burst is forwarded.</summary>
         /// <param name="dueTime">The time span that must elapse after the last element before it is forwarded.
         /// Must be non-negative.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
@@ -55,17 +46,10 @@ public IObservableAsync<T> Throttle(TimeSpan dueTime, TimeProvider? timeProvider
     /// <param name="delay">The duration to delay.</param>
     extension(TimeSpan delay)
     {
-        /// <summary>Asynchronously delays for the specified duration using the provided time provider.</summary>
+        /// <summary>Creates a cancellable delay using the supplied time provider.</summary>
         /// <param name="timeProvider">The time provider to use for the delay.</param>
         /// <param name="cancellationToken">A token to cancel the delay.</param>
         /// <returns>A <see cref="ValueTask"/> that completes after the specified delay.</returns>
-        /// <remarks>
-        /// For <see cref="TimeProvider.System"/> the result is a wrapper around
-        /// <see cref="Task.Delay(TimeSpan, CancellationToken)"/>; for custom providers the call rents a
-        /// pooled <see cref="PooledDelaySource"/> so the per-call <see cref="TaskCompletionSource{TResult}"/>
-        /// + <see cref="Task{TResult}"/> + <see cref="CancellationTokenRegistration"/> allocation chain
-        /// from the legacy implementation collapses to zero on the steady path.
-        /// </remarks>
         internal ValueTask DelayAsync(
             TimeProvider timeProvider,
             CancellationToken cancellationToken) =>
@@ -74,10 +58,7 @@ internal ValueTask DelayAsync(
                 : PooledDelaySource.Rent().BeginAsync(delay, timeProvider, cancellationToken);
     }
 
-    /// <summary>
-    /// Async observable that debounces the source sequence, only forwarding elements that are not
-    /// followed by another element within the specified due time.
-    /// </summary>
+    /// <summary>Async observable that debounces the source sequence, only forwarding elements that are not followed by another element within the specified due time.</summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence to throttle.</param>
     /// <param name="dueTime">The quiet period that must elapse before an element is forwarded.</param>
@@ -96,10 +77,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
             return source.SubscribeAsync(throttleObserver, cancellationToken);
         }
 
-        /// <summary>
-        /// Observer that implements throttle/debounce logic by starting a timer on each element
-        /// and only forwarding the element if no newer element supersedes it before the timer fires.
-        /// </summary>
+        /// <summary>Delays each value and forwards it only if no newer value supersedes it.</summary>
         /// <param name="observer">The downstream observer to forward debounced elements to.</param>
         /// <param name="dueTime">The quiet period that must elapse before an element is forwarded.</param>
         /// <param name="timeProvider">The time provider used for scheduling the debounce timer.</param>
@@ -111,6 +89,21 @@ internal sealed class ThrottleWitness(IObserverAsync<T> observer, TimeSpan dueTi
             /// <summary>A monotonically increasing identifier used to detect whether a newer element has superseded the current timer.</summary>
             private long _id;
 
+            /// <summary>Starts a debounce delay with a fresh identifier.</summary>
+            /// <param name="value">The value to forward if it remains current.</param>
+            /// <param name="cancellationToken">Cancellation for the delay.</param>
+            /// <returns>The delay and notification operation.</returns>
+            internal Task StartDelayAsync(T value, CancellationToken cancellationToken)
+            {
+                long currentId;
+                lock (_gate)
+                {
+                    currentId = ++_id;
+                }
+
+                return FireAfterDelayAsync(value, currentId, cancellationToken);
+            }
+
             /// <summary>Waits for the debounce delay and then forwards the value if it has not been superseded.</summary>
             /// <param name="value">The value to forward after the delay.</param>
             /// <param name="id">The identifier of this timer; if superseded by a newer id, the value is discarded.</param>
@@ -140,26 +133,13 @@ internal async Task FireAfterDelayAsync(T value, long id, CancellationToken canc
                 }
             }
 
-            /// <summary>
-            /// Starts a new debounce timer for the received element, identifying it by a fresh id.
-            /// Supersession is detected post-delay via the id check rather than via a per-emission
-            /// linked CTS — eliminating the <c>Linked1CancellationTokenSource</c> allocation that
-            /// dominated the operator's GC profile. A superseded delay still runs to completion
-            /// (waiting the full <c>dueTime</c>) but its result is discarded, which trades a small
-            /// amount of transient state-machine retention for zero per-emission allocation.
-            /// </summary>
+            /// <summary>Schedules the value's delay and discards completion if a newer value supersedes it.</summary>
             /// <param name="value">The element to potentially forward after the debounce period.</param>
             /// <param name="cancellationToken">A token to cancel the operation.</param>
             /// <returns>A completed task; the actual forwarding happens asynchronously after the delay.</returns>
             protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken)
             {
-                long currentId;
-                lock (_gate)
-                {
-                    currentId = ++_id;
-                }
-
-                _ = FireAfterDelayAsync(value, currentId, cancellationToken);
+                _ = StartDelayAsync(value, cancellationToken);
                 return default;
             }
 
@@ -190,10 +170,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result)
                 return observer.OnCompletedAsync(result);
             }
 
-            /// <summary>
-            /// Marks any in-flight delay as superseded during disposal. The dispose token threaded
-            /// through <see cref="DelayAsync"/> by the base observer also unblocks the awaits.
-            /// </summary>
+            /// <summary>Marks any in-flight delay as superseded during disposal. The dispose token threaded through <see cref="DelayAsync"/> by the base observer also unblocks the awaits.</summary>
             /// <returns>A completed task.</returns>
             protected override ValueTask DisposeAsyncCore()
             {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
index d5df1d39..25bee995 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
@@ -16,10 +16,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The asynchronous observable to convert into an asynchronous enumerable.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Converts the specified asynchronous observable sequence to an asynchronous enumerable sequence, enabling
-        /// consumption using asynchronous iteration.
-        /// </summary>
+        /// <summary>Converts the specified asynchronous observable sequence to an asynchronous enumerable sequence, enabling consumption using asynchronous iteration.</summary>
         /// <param name="channelFactory">A factory function that produces a channel to buffer elements, controlling
         /// the buffering and backpressure behavior between the asynchronous observable and the asynchronous enumerable.</param>
         /// <returns>An asynchronous enumerable sequence that yields elements from the asynchronous observable. The
@@ -36,10 +33,7 @@ public IAsyncEnumerable<T> ToAsyncEnumerable(
             Func<Channel<T>> channelFactory) =>
             source.ToAsyncEnumerable(channelFactory, null);
 
-        /// <summary>
-        /// Converts the specified observable sequence to an asynchronous enumerable sequence, enabling consumption using
-        /// asynchronous iteration.
-        /// </summary>
+        /// <summary>Converts the specified observable sequence to an asynchronous enumerable sequence, enabling consumption using asynchronous iteration.</summary>
         /// <param name="channelFactory">A factory function that creates a new channel used to buffer items between the observable and the asynchronous
         /// enumerable. The channel controls the buffering and backpressure behavior.</param>
         /// <param name="onErrorResume">An optional asynchronous callback invoked when an error occurs in the observable sequence. If provided, this
@@ -48,10 +42,7 @@ public IAsyncEnumerable<T> ToAsyncEnumerable(
         /// <returns>An asynchronous enumerable sequence that yields the elements produced by the observable sequence. The
         /// enumeration completes when the observable completes or an unhandled error occurs.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="source"/> or <paramref name="channelFactory"/> is null.</exception>
-        /// <remarks>The returned asynchronous enumerable reflects the items and completion behavior of the source
-        /// observable. The buffering and concurrency characteristics depend on the channel created by <paramref
-        /// name="channelFactory"/>. If <paramref name="onErrorResume"/> is provided, it can be used to suppress or handle
-        /// errors from the observable; otherwise, errors are propagated to the enumerator.</remarks>
+        /// <remarks>The channel factory controls buffering. The optional error callback handles source errors; without it, errors propagate to the enumerator.</remarks>
         public IAsyncEnumerable<T> ToAsyncEnumerable(
             Func<Channel<T>> channelFactory,
             Func<Exception, CancellationToken, ValueTask>? onErrorResume)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
index fb7f8918..13b96143 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
@@ -7,10 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for asynchronously converting an observable sequence to a dictionary.</summary>
-/// <remarks>The methods in this class enable the transformation of an asynchronous observable sequence into a
-/// dictionary, using user-supplied key and element selector functions. These operations are performed asynchronously
-/// and support cancellation via a CancellationToken. All methods throw an exception if duplicate keys are encountered
-/// in the source sequence, consistent with the behavior of Dictionary{TKey, TValue}.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous dictionary-materialization operators for an observable source sequence.</summary>
@@ -35,10 +31,7 @@ public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(
             where TKey : notnull =>
             ToDictionaryCore(source, keySelector, DictionaryIdentity<T>.Instance, comparer, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously creates a dictionary from the elements of the sequence, using the specified key selector
-        /// function and the default equality comparer for the key type.
-        /// </summary>
+        /// <summary>Asynchronously creates a dictionary from the elements of the sequence, using the specified key selector function and the default equality comparer for the key type.</summary>
         /// <typeparam name="TKey">The type of the keys in the resulting dictionary. Must be non-nullable.</typeparam>
         /// <param name="keySelector">A function to extract a key from each element in the sequence. Cannot be null.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary mapping keys to
@@ -49,10 +42,7 @@ public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(Func<T, TKey> keyS
             where TKey : notnull =>
             source.ToDictionaryAsync(keySelector, null, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously creates a dictionary from the elements of the sequence using the specified key and element
-        /// selector functions.
-        /// </summary>
+        /// <summary>Asynchronously creates a dictionary from the elements of the sequence using the specified key and element selector functions.</summary>
         /// <typeparam name="TKey">The type of the keys in the resulting dictionary. Must be non-nullable.</typeparam>
         /// <typeparam name="TValue">The type of the values in the resulting dictionary.</typeparam>
         /// <param name="keySelector">A function to extract a key from each element in the sequence.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToListAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToListAsync.cs
index b883f87c..89e4c23b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToListAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToListAsync.cs
@@ -7,9 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for working with asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods that extend the functionality of asynchronous
-/// observables, enabling operations such as materializing the sequence into a list asynchronously. These methods are
-/// intended to simplify common tasks when consuming asynchronous observable streams.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Asynchronous list-materialization operators for an observable source sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
index dcc71d0d..ed06637c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
@@ -4,13 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides extension methods for working with asynchronous observable sequences, enabling operations such as
-/// suppressing consecutive duplicate elements.
-/// </summary>
-/// <remarks>The methods in this class allow developers to filter out consecutive duplicates in observable
-/// sequences, either by value or by a specified key. These operations are useful for scenarios where only changes or
-/// distinct consecutive values are of interest, such as event streams or state change notifications.</remarks>
+/// <summary>Provides extension methods for working with asynchronous observable sequences, enabling operations such as suppressing consecutive duplicate elements.</summary>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Consecutive-distinctness operators for an observable source sequence.</summary>
@@ -18,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Returns an observable sequence that emits only distinct consecutive elements, suppressing duplicates that
-        /// are equal to the previous element.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits only distinct consecutive elements, suppressing duplicates that are equal to the previous element.</summary>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not equal to their
         /// immediate predecessor.</returns>
         /// <remarks>Elements are compared using the default equality comparer for the type <typeparamref
@@ -53,10 +44,7 @@ public IObservableAsync<T> Unique(IEqualityComparer<T> equalityComparer)
             return new UniqueSignal<T>(source, equalityComparer);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
-        /// duplicates as determined by a key selector function.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits elements from the source sequence, suppressing consecutive duplicates as determined by a key selector function.</summary>
         /// <typeparam name="TKey">The type of the key used to determine whether consecutive elements are considered duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
@@ -72,10 +60,7 @@ public IObservableAsync<T> UniqueBy<TKey>(Func<T, TKey> keySelector)
             return new UniqueBySignal<T, TKey>(source, keySelector, EqualityComparer<TKey>.Default);
         }
 
-        /// <summary>
-        /// Returns an observable sequence that emits elements from the source sequence, suppressing consecutive
-        /// duplicates as determined by a key selector and equality comparer.
-        /// </summary>
+        /// <summary>Returns an observable sequence that emits elements from the source sequence, suppressing consecutive duplicates as determined by a key selector and equality comparer.</summary>
         /// <typeparam name="TKey">The type of the key used to determine whether consecutive elements are considered duplicates.</typeparam>
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <param name="equalityComparer">An equality comparer used to compare keys for equality.</param>
@@ -97,10 +82,7 @@ public IObservableAsync<T> UniqueBy<TKey>(
         }
     }
 
-    /// <summary>
-    /// Single-observer-layer <c>DistinctUntilChanged</c>. Replaces the previous \c Create + async-lambda + closure
-    /// pattern; per-subscription state lives in observer fields.
-    /// </summary>
+    /// <summary>Single-observer-layer <c>DistinctUntilChanged</c>. Replaces the previous \c Create + async-lambda + closure pattern; per-subscription state lives in observer fields.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="comparer">The equality comparer used to detect duplicates.</param>
@@ -161,10 +143,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result) =>
         }
     }
 
-    /// <summary>
-    /// Single-observer-layer <c>DistinctUntilChangedBy</c>; key is extracted once per emission and compared
-    /// against the most-recently-forwarded key.
-    /// </summary>
+    /// <summary>Single-observer-layer <c>DistinctUntilChangedBy</c>; key is extracted once per emission and compared against the most-recently-forwarded key.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <typeparam name="TKey">The key type.</typeparam>
     /// <param name="source">The upstream observable.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
index d61db55f..56e3b6ff 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
@@ -7,15 +7,9 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating and composing asynchronous observable sequences.</summary>
-/// <remarks>The SignalAsync class contains static methods for working with asynchronous observables, enabling
-/// resource management and composition patterns similar to those found in reactive programming. All members are
-/// thread-safe and intended for use in asynchronous and reactive scenarios.</remarks>
 public static partial class SignalAsync
 {
-    /// <summary>
-    /// Creates an observable sequence that manages the lifetime of an asynchronous resource, ensuring the resource is
-    /// disposed when the sequence terminates.
-    /// </summary>
+    /// <summary>Creates an observable sequence that manages the lifetime of an asynchronous resource, ensuring the resource is disposed when the sequence terminates.</summary>
     /// <typeparam name="TResource">The type of the asynchronous resource that implements <see cref="IAsyncDisposable"/>.</typeparam>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <param name="resourceFactory">A function that asynchronously creates the resource to be used by the observable sequence. The function receives
@@ -32,10 +26,7 @@ public static IObservableAsync<T> Use<TResource, T>(
         where TResource : IAsyncDisposable =>
         new UsingSignal<TResource, T>(resourceFactory, signalFactory);
 
-    /// <summary>
-    /// Creates an observable sequence that manages the lifetime of an asynchronous resource, ensuring the resource is
-    /// disposed when the sequence terminates.
-    /// </summary>
+    /// <summary>Creates an observable sequence that manages the lifetime of an asynchronous resource, ensuring the resource is disposed when the sequence terminates.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
     /// <typeparam name="TResource">The type of the asynchronous resource that implements <see cref="IAsyncDisposable"/>.</typeparam>
     /// <param name="resourceFactory">A function that asynchronously creates the resource to be used by the observable sequence.</param>
@@ -43,11 +34,7 @@ public static IObservableAsync<T> Use<TResource, T>(
     /// signal sequence that uses the resource.</param>
     /// <returns>An observable that uses the specified resource and ensures the resource is disposed
     /// asynchronously when the sequence completes or an error occurs.</returns>
-    /// <remarks>The resource is created for each subscription and is disposed asynchronously when the
-    /// observable sequence terminates, either by completion or error. If the observable factory throws an exception,
-    /// the resource is disposed before the exception is propagated. This method is useful for managing resources that
-    /// must be disposed when no longer needed, such as streams or database connections, in conjunction with
-    /// asynchronous observable sequences.</remarks>
+    /// <remarks>Each subscription owns its resource. Completion, error, or a throwing observable factory disposes that resource asynchronously.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net10.0/PublicAPI.txt
index 0eea0d9b..aefd152b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net10.0/PublicAPI.txt
@@ -878,6 +878,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1658,7 +1659,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1700,13 +1701,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net11.0/PublicAPI.txt
index 0eea0d9b..aefd152b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net11.0/PublicAPI.txt
@@ -878,6 +878,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1658,7 +1659,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1700,13 +1701,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net462/PublicAPI.txt
index e8e88287..2d1d11d2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net462/PublicAPI.txt
@@ -879,6 +879,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1659,7 +1660,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1701,13 +1702,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net472/PublicAPI.txt
index e8e88287..2d1d11d2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net472/PublicAPI.txt
@@ -879,6 +879,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1659,7 +1660,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1701,13 +1702,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net48/PublicAPI.txt
index e8e88287..2d1d11d2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net48/PublicAPI.txt
@@ -879,6 +879,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1659,7 +1660,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1701,13 +1702,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net481/PublicAPI.txt
index e8e88287..2d1d11d2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net481/PublicAPI.txt
@@ -879,6 +879,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1659,7 +1660,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1701,13 +1702,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net8.0/PublicAPI.txt
index 0eea0d9b..aefd152b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net8.0/PublicAPI.txt
@@ -878,6 +878,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1658,7 +1659,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1700,13 +1701,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net9.0/PublicAPI.txt
index 0eea0d9b..aefd152b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Core/PublicAPI/net9.0/PublicAPI.txt
@@ -878,6 +878,7 @@ namespace ReactiveUI.Primitives.Async.Advanced
         public void Dispose() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public System.Threading.Tasks.ValueTask<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease> EnterAsync(System.Threading.CancellationToken cancellationToken) { }
         [System.Diagnostics.DebuggerDisplay("Lease: Parent = {_parent}")]
         public readonly record struct Lease : System.IDisposable, System.IEquatable<ReactiveUI.Primitives.Async.Advanced.AsyncSerialGate.Lease>
@@ -1658,7 +1659,7 @@ namespace ReactiveUI.Primitives.Async.Disposables
         public static System.Threading.Tasks.ValueTask DisposeAsync(ref System.IAsyncDisposable? slot) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool IsDisposed(System.IAsyncDisposable? slot) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static System.Threading.Tasks.ValueTask SwapAsync(ref System.IAsyncDisposable? slot, System.IAsyncDisposable? value) { }
     }
     [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -1700,13 +1701,12 @@ namespace ReactiveUI.Primitives.Async.Disposables
 }
 namespace ReactiveUI.Primitives.Async.Helpers
 {
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class DisposalHelper
     {
     }
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     public static class FireAndForgetHelper
     {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static void Run(System.Func<System.Threading.Tasks.ValueTask> action) { }
     }
     public static class SubscriptionHelper
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
index ec236420..4188c29c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
@@ -8,11 +8,7 @@
 namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Provides helper methods for forwarding asynchronous observer notifications concurrently to multiple observers.</summary>
-/// <remarks>The methods in this class are intended for scenarios where multiple asynchronous observers need to be
-/// notified in parallel. All observer notifications are dispatched concurrently, and the returned ValueTask completes
-/// when all observer operations have finished. If the observers collection is empty, the methods complete immediately.
-/// Exceptions thrown by individual observers are aggregated into a single exception, consistent with Task.WhenAll
-/// behavior.</remarks>
+/// <remarks>All observers start concurrently; the returned task waits for every observer. Empty collections complete synchronously, and failures follow Task.WhenAll semantics.</remarks>
 public static class Concurrent
 {
     /// <summary>Forwards the specified value to all observers concurrently by invoking their OnNextAsync methods.</summary>
@@ -22,8 +18,7 @@ public static class Concurrent
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the forwarding operation.</param>
     /// <returns>A ValueTask that represents the asynchronous operation of forwarding the value to all observers. The task
     /// completes when all observers have processed the value.</returns>
-    /// <remarks>If the observers list is empty, the returned ValueTask is already completed. All OnNextAsync
-    /// calls are started concurrently; exceptions from observers are aggregated in the returned task.</remarks>
+    /// <remarks>Empty collections complete synchronously. Multiple observers follow Task.WhenAll failure semantics.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnNextConcurrently<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -62,19 +57,14 @@ public static ValueTask ForwardOnNextConcurrently<T>(
         return default;
     }
 
-    /// <summary>
-    /// Forwards an error notification to all specified asynchronous observers concurrently, allowing each observer to
-    /// handle the error and resume as appropriate.
-    /// </summary>
+    /// <summary>Forwards an error notification to all specified asynchronous observers concurrently, allowing each observer to handle the error and resume as appropriate.</summary>
     /// <typeparam name="T">The type of the elements observed by the observers.</typeparam>
     /// <param name="observers">A read-only list of asynchronous observers to which the error notification will be forwarded. Cannot be null.</param>
     /// <param name="error">The exception representing the error to forward to each observer. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the forwarding operation.</param>
     /// <returns>A ValueTask that represents the asynchronous operation of forwarding the error to all observers. The task
     /// completes when all observers have processed the error notification.</returns>
-    /// <remarks>If the list of observers is empty, the method returns a default ValueTask and no
-    /// notifications are sent. Each observer receives the error notification concurrently. If cancellation is requested
-    /// via the cancellation token, the operation may be canceled before completion.</remarks>
+    /// <remarks>Cancellation is forwarded to each observer; it does not prevent other observers from being called.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnErrorResumeConcurrently<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -113,19 +103,14 @@ public static ValueTask ForwardOnErrorResumeConcurrently<T>(
         return default;
     }
 
-    /// <summary>
-    /// Invokes the OnCompletedAsync method on each observer in the collection concurrently, forwarding the specified
-    /// result to all observers.
-    /// </summary>
+    /// <summary>Invokes the OnCompletedAsync method on each observer in the collection concurrently, forwarding the specified result to all observers.</summary>
     /// <typeparam name="T">The type of the elements observed by the observers.</typeparam>
     /// <param name="observers">A read-only list of observers to which the completion notification will be forwarded. Cannot be null.</param>
     /// <param name="result">The result to pass to each observer's OnCompletedAsync method.</param>
     /// <returns>A ValueTask that represents the asynchronous operation of notifying all observers. The task completes when all
     /// observers have finished processing the completion notification. If the observers list is empty, a default
     /// ValueTask is returned.</returns>
-    /// <remarks>All observers are notified concurrently. The returned ValueTask completes when all
-    /// OnCompletedAsync operations have finished. If any observer throws an exception, the returned task will complete
-    /// with an AggregateException containing all exceptions thrown.</remarks>
+    /// <remarks>Empty collections complete synchronously. Multiple observers follow Task.WhenAll failure semantics.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnCompletedConcurrently<T>(
         ImmutableArray<IObserverAsync<T>> observers,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
index 0a1e752f..a0ab9527 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -2,8 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
-
 namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Subscription handle that removes an observer from a replay signal when disposed.</summary>
@@ -25,7 +23,6 @@ public ValueTask DisposeAsync() =>
 
     /// <summary>Removes the observer from the replay signal under the serialization gate.</summary>
     /// <returns>A task that represents the asynchronous removal operation.</returns>
-    [ExcludeFromCodeCoverage]
     private async ValueTask RemoveObserverAsync()
     {
         if (state.IsDisposed)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
index f1e4f54c..af676fe6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
@@ -29,11 +29,7 @@ public ReplayLatestSignalAsyncState(Optional<T> initialValue)
     /// <summary>Gets the cancellation token source that is cancelled when this instance is disposed.</summary>
     internal CancellationTokenSource DisposedCts { get; } = new();
 
-    /// <summary>Gets the token cancelled when this instance is disposed. Captured while the source is still
-    /// alive because <see cref="Dispose"/> disposes that source, and reading
-    /// <see cref="CancellationTokenSource.Token"/> from a disposed source throws
-    /// <see cref="ObjectDisposedException"/>. Disposal always cancels before it disposes, so this token is
-    /// already cancelled by the time anyone can observe it post-disposal.</summary>
+    /// <summary>Gets the disposal token, which remains accessible after the source is disposed.</summary>
     internal CancellationToken DisposedCancellationToken { get; }
 
     /// <summary>Gets or sets the most recently published value, replayed to new subscribers upon subscription.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
index 9e894068..35870106 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
@@ -8,21 +8,10 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Shared serial-broadcast loops for the Serial* Signal family. The body of each Signal's
-/// <c>OnNextAsyncCore</c> / <c>OnErrorResumeAsyncCore</c> / <c>OnCompletedAsyncCore</c> is identical:
-/// iterate the observer snapshot and await each call in turn. Centralising the loops here keeps the
-/// hot-path single-observer fast-path inlined at the call site while removing the duplicated
-/// multi-observer body across four Signal classes. Methods are static so there is no virtual
-/// dispatch and no extra heap allocation per emission.
-/// </summary>
+/// <summary>Delivers notifications to each observer in a snapshot, awaiting them in order.</summary>
 internal static class SerialBroadcastHelpers
 {
-    /// <summary>
-    /// Single-observer fast path delegates directly to the observer's <c>OnNextAsync</c>; the
-    /// multi-observer case forwards to <see cref="BroadcastOnNextAsyncMulti{T}"/>, where the async
-    /// state machine is only used when an observer actually suspends.
-    /// </summary>
+    /// <summary>Forwards directly to a single observer or awaits multiple observers in order.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="observers">The current observer snapshot.</param>
     /// <param name="value">The value being broadcast.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
index 195d7460..1a6a1de9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -2,8 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
-
 namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Subscription handle that removes an observer from a stateless replay signal when disposed.</summary>
@@ -25,7 +23,6 @@ public ValueTask DisposeAsync() =>
 
     /// <summary>Removes the observer and restores the initial value when the last observer leaves.</summary>
     /// <returns>A task that represents the asynchronous removal operation.</returns>
-    [ExcludeFromCodeCoverage]
     private async ValueTask RemoveObserverAndResetAsync()
     {
         if (state.IsDisposed)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
index 9a0c3c1c..2d64e4d1 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
@@ -30,11 +30,7 @@ public StatelessReplayLatestSignalAsyncState(Optional<T> initialValue)
     /// <summary>Gets the cancellation token source that is cancelled when this instance is disposed.</summary>
     internal CancellationTokenSource DisposedCts { get; } = new();
 
-    /// <summary>Gets the token cancelled when this instance is disposed. Captured while the source is still
-    /// alive because <see cref="Dispose"/> disposes that source, and reading
-    /// <see cref="CancellationTokenSource.Token"/> from a disposed source throws
-    /// <see cref="ObjectDisposedException"/>. Disposal always cancels before it disposes, so this token is
-    /// already cancelled by the time anyone can observe it post-disposal.</summary>
+    /// <summary>Gets the disposal token, which remains accessible after the source is disposed.</summary>
     internal CancellationToken DisposedCancellationToken { get; }
 
     /// <summary>Gets the initial value to replay, if any.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
index a1254204..52e5f8c2 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
@@ -6,15 +6,10 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents an asynchronous Signal that replays only the latest value to new observers and supports concurrent
-/// notification of observers.
-/// </summary>
+/// <summary>Represents an asynchronous Signal that replays only the latest value to new observers and supports concurrent notification of observers.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">An optional initial value to be emitted to observers upon subscription if no other value has been published.</param>
-/// <remarks>This Signal notifies all observers concurrently, which can improve throughput in scenarios with
-/// multiple observers. The order in which observers receive notifications is not guaranteed. This type is thread-safe
-/// and suitable for use in asynchronous and concurrent environments.</remarks>
+/// <remarks>Observer notifications overlap; their completion order is unspecified.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentReplayLatestSignalAsync: LastValue = {_state.LastValue}, IsDisposed = {_state.IsDisposed}")]
 public sealed class ConcurrentReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
index 83a4f1c2..892b5425 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
@@ -8,9 +8,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Provides an asynchronous Signal that forwards notifications to observers concurrently.</summary>
 /// <typeparam name="T">The type of value observed and forwarded to observers.</typeparam>
-/// <remarks>Observers are notified in parallel for each event. This class is suitable for scenarios where high
-/// throughput and concurrent notification of multiple observers are required. Thread safety is ensured for observer
-/// notification operations. Cancellation tokens can be used to cancel ongoing notification tasks.</remarks>
+/// <remarks>Observer notifications overlap; their completion order is unspecified.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentSignalAsync: Observers = {_state.Observers.Length}, Result = {_state.Result}")]
 public sealed class ConcurrentSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
index 203f7690..d1a95f2f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
@@ -6,17 +6,11 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents an asynchronous Signal that replays the latest value to new observers and forwards notifications to all
-/// observers concurrently without maintaining internal state.
-/// </summary>
+/// <summary>Represents an asynchronous Signal that replays the latest value to new observers and forwards notifications to all observers concurrently without maintaining internal state.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">An optional initial value to be replayed to new observers. If not specified, no value is replayed until the first
 /// value is published.</param>
-/// <remarks>This Signal is designed for concurrent scenarios where notifications to observers should be
-/// delivered in parallel. It does not buffer or store a sequence of values, but only replays the most recent value (if
-/// any) to new subscribers. Thread safety is ensured for concurrent observer notifications. If a notification operation
-/// is canceled, not all observers may receive the notification.</remarks>
+/// <remarks>Replays the latest value to new subscribers and notifies observers concurrently. Cancellation can prevent some observers from receiving a notification.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentStatelessReplayLatestSignalAsync: Value = {_state.Value}, IsDisposed = {_state.IsDisposed}")]
 public sealed class ConcurrentStatelessReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
index 6e6cfa45..6a7042b7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
@@ -8,10 +8,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Represents a stateless asynchronous Signal that forwards notifications to observers concurrently.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-/// <remarks>This Signal distributes notifications to all subscribed observers in parallel, allowing for improved
-/// throughput in scenarios where observer processing can occur independently. Use this type when observer notification
-/// order is not important and concurrent delivery is desired. Thread safety is ensured for concurrent observer
-/// notifications.</remarks>
+/// <remarks>Observer notifications execute concurrently; their completion order is unspecified.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentStatelessSignalAsync: Observers = {_state.Observers.Length}")]
 public sealed class ConcurrentStatelessSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ISignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ISignalAsync.cs
index fe0d4288..4ed8c7ae 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ISignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ISignalAsync.cs
@@ -4,19 +4,10 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents an asynchronous Signal that allows observers to receive values, errors, or completion notifications
-/// asynchronously.
-/// </summary>
+/// <summary>Represents an asynchronous Signal that allows observers to receive values, errors, or completion notifications asynchronously.</summary>
 /// <typeparam name="T">The type of the values observed and published by the Signal.</typeparam>
-/// <remarks>An asynchronous Signal enables push-based notification of values, errors, or completion events to
-/// multiple observers. Observers can subscribe to the Signal's values stream and receive notifications as they are
-/// published. This interface is typically used in scenarios where asynchronous event propagation and coordination are
-/// required, such as reactive programming or event-driven architectures.</remarks>
 public interface ISignalAsync<T> : IObserverAsync<T>, IObservableAsync<T>
 {
     /// <summary>Gets an observable sequence that asynchronously provides the current values of the collection.</summary>
-    /// <remarks>The returned sequence emits updates whenever the underlying collection changes. Subscribers
-    /// receive notifications asynchronously as values are added, removed, or updated.</remarks>
     IObservableAsync<T> Values { get; }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
index f25eb90a..b178be7e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
@@ -9,8 +9,6 @@ namespace ReactiveUI.Primitives.Async.Signals;
 public sealed record BehaviorSignalCreationOptions
 {
     /// <summary>Gets the default configuration options for creating a new BehaviorSignal instance.</summary>
-    /// <remarks>Use this property to obtain a standard set of options when creating a BehaviorSignal, unless
-    /// custom behavior is required.</remarks>
     public static BehaviorSignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
     /// <summary>Gets the publishing option to use when processing the item.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
index 34f168cb..bf67718e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
@@ -4,25 +4,12 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Specifies the available options for publishing operations, indicating whether actions are performed serially or
-/// concurrently.
-/// </summary>
-/// <remarks>Use this enumeration to control the execution mode of publishing processes. Selecting 'Serial'
-/// ensures that operations are performed one after another, while 'Concurrent' allows multiple operations to be
-/// executed in parallel. The appropriate option depends on the requirements for performance and resource management in
-/// your application.</remarks>
+/// <summary>Specifies the available options for publishing operations, indicating whether actions are performed serially or concurrently.</summary>
 public enum PublishingOption
 {
-    /// <summary>Represents a serial communication interface for transmitting and receiving data over serial ports.</summary>
-    /// <remarks>Use this type to interact with devices that communicate via serial protocols, such as RS-232
-    /// or UART. Serial communication is commonly used for connecting to hardware peripherals, embedded systems, or
-    /// legacy equipment. Thread safety and supported features may vary depending on the implementation.</remarks>
+    /// <summary>Awaits each observer notification before invoking the next observer.</summary>
     Serial = 0,
 
-    /// <summary>Provides thread-safe operations for managing shared resources in concurrent programming scenarios.</summary>
-    /// <remarks>Use this type to coordinate access to data or resources that may be accessed by multiple
-    /// threads simultaneously. Thread safety is ensured for all public members, allowing safe usage in multi-threaded
-    /// environments without additional synchronization.</remarks>
+    /// <summary>Invokes observer notifications concurrently.</summary>
     Concurrent = 1,
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
index 62cc613c..b72f9410 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
@@ -4,20 +4,12 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents configuration options for creating a replay-latest Signal, controlling publishing behavior and state
-/// retention.
-/// </summary>
-/// <remarks>Use this type to specify how a replay-latest Signal should handle message publishing and whether it
-/// maintains state. The options provided affect how subscribers receive messages and whether the Signal retains the
-/// latest value. This type is immutable and can be used to configure Signal creation in a thread-safe
-/// manner.</remarks>
+/// <summary>Represents configuration options for creating a replay-latest Signal, controlling publishing behavior and state retention.</summary>
 [System.Diagnostics.DebuggerDisplay("ReplayLatestSignalCreationOptions: PublishingOption = {PublishingOption}, IsStateless = {IsStateless}")]
 public sealed record ReplayLatestSignalCreationOptions
 {
     /// <summary>Gets the default configuration options for creating a ReplayLatestSignal instance.</summary>
-    /// <remarks>The default options specify serial publishing and stateful behavior. Use this property to
-    /// obtain a baseline configuration that can be modified as needed.</remarks>
+    /// <remarks>Defaults to serial, stateful publishing.</remarks>
     public static ReplayLatestSignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
     /// <summary>Gets the publishing option to use when processing this item.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
index 2f70cf92..06023822 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
@@ -4,19 +4,12 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents the set of options used when creating a Signal, including publishing behavior and state management
-/// requirements.
-/// </summary>
-/// <remarks>Use this type to configure how a Signal is created, specifying whether it should be stateless and
-/// which publishing option to apply. The options provided affect the Signal's behavior and lifecycle. This record is
-/// immutable and can be used to ensure consistent Signal creation across different parts of an application.</remarks>
+/// <summary>Represents the set of options used when creating a Signal, including publishing behavior and state management requirements.</summary>
 [System.Diagnostics.DebuggerDisplay("SignalCreationOptions: PublishingOption = {PublishingOption}, IsStateless = {IsStateless}")]
 public sealed record SignalCreationOptions
 {
     /// <summary>Gets the default configuration for Signal creation options.</summary>
-    /// <remarks>The default options use serial publishing and are not stateless. Use this property as a
-    /// baseline when configuring new Signals if standard behavior is desired.</remarks>
+    /// <remarks>Defaults to serial, stateful publishing.</remarks>
     public static SignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
     /// <summary>Gets the publishing option to use when processing the item.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
index 1129e1c9..6ace90eb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
@@ -12,11 +12,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// </summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">An optional initial value to be emitted to new subscribers before any other values are published.</param>
-/// <remarks>This Signal is designed for scenarios where only the most recent value is relevant to subscribers.
-/// When a new observer subscribes, it immediately receives the latest value (if any) and then all subsequent
-/// notifications. All observer notifications are performed asynchronously and in a serial order, ensuring thread
-/// safety. This type is suitable for use cases where replaying only the latest value is desired, such as event streams
-/// or state broadcasts.</remarks>
+/// <remarks>New subscribers receive the latest value, if present. Each observer notification is awaited before invoking the next observer.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialReplayLatestSignalAsync: LastValue = {_state.LastValue}, IsDisposed = {_state.IsDisposed}")]
 public sealed class SerialReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
index bca7d516..bf1b0429 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
@@ -6,14 +6,9 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents an asynchronous Signal that notifies observers in a serial manner, ensuring each observer is notified
-/// one at a time.
-/// </summary>
+/// <summary>Represents an asynchronous Signal that notifies observers in a serial manner, ensuring each observer is notified one at a time.</summary>
 /// <typeparam name="T">The type of the elements processed and observed by the Signal.</typeparam>
-/// <remarks>SerialSignalAsync{T} is designed for scenarios where observers must be notified sequentially rather
-/// than concurrently. This can be useful when observer operations are not thread-safe or when order of notification is
-/// important. Notifications to observers are performed asynchronously and in sequence.</remarks>
+/// <remarks>Each observer notification finishes before the next observer is called.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialSignalAsync: Observers = {_state.Observers.Length}, Result = {_state.Result}")]
 public sealed class SerialSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
index aca8d563..91c2a6cc 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
@@ -6,17 +6,11 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents a serial, stateless asynchronous Signal that replays only the last value to new observers and supports
-/// asynchronous notification delivery.
-/// </summary>
+/// <summary>Represents a serial, stateless asynchronous Signal that replays only the last value to new observers and supports asynchronous notification delivery.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">An optional initial value to be replayed to new observers before any values are published. If not specified, no
 /// value is replayed until the first value is received.</param>
-/// <remarks>This Signal delivers notifications to observers one at a time in the order they are received. It
-/// does not maintain any state beyond the most recent value, and only the last value (if any) is replayed to new
-/// subscribers. All observer notifications are dispatched asynchronously and serially, ensuring that each observer
-/// receives notifications in the correct order.</remarks>
+/// <remarks>Replays the latest value, if present, and awaits each observer notification in order.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialStatelessReplayLatestSignalAsync: State = {_state}")]
 public sealed class SerialStatelessReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
index bbf71d98..6be57af8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
@@ -8,9 +8,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 
 /// <summary>Represents a stateless asynchronous Signal that notifies observers of events in a serial, sequential manner.</summary>
 /// <typeparam name="T">The type of the elements processed and observed by the Signal.</typeparam>
-/// <remarks>Observers are notified one at a time in the order they are registered. Each observer receives the
-/// event only after the previous observer has completed processing. This class is suitable for scenarios where event
-/// delivery order and sequential processing are required. Thread safety and ordering are managed internally.</remarks>
+/// <remarks>Observers are notified in registration order; each notification is awaited before the next begins.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialStatelessSignalAsync: Observers = {_state.Observers.Length}")]
 public sealed class SerialStatelessSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
index 79f0728e..735bf65f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
@@ -7,21 +7,12 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Provides factory methods for creating asynchronous Signal instances with configurable publishing and state
-/// retention behaviors.
-/// </summary>
-/// <remarks>The Signal class offers a variety of static methods to create Signals that support different
-/// publishing strategies (such as serial or concurrent) and state management options (stateful or stateless). These
-/// Signals can be used to broadcast values to multiple observers in asynchronous scenarios. Use the provided creation
-/// options to customize the Signal's behavior according to your application's requirements.</remarks>
+/// <summary>Provides factory methods for creating asynchronous Signal instances with configurable publishing and state retention behaviors.</summary>
 public static class Signal
 {
     /// <summary>Creates a new asynchronous Signal instance for the specified type.</summary>
     /// <typeparam name="T">The type of elements processed by the Signal.</typeparam>
     /// <returns>An <see cref="ISignalAsync{T}"/> that represents the newly created asynchronous Signal.</returns>
-    /// <remarks>The created Signal uses the default Signal creation options. Use the overload that accepts
-    /// <see cref="SignalCreationOptions"/> to customize Signal behavior.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
@@ -35,9 +26,6 @@ public static class Signal
     /// for publishing and statelessness.</param>
     /// <returns>An asynchronous Signal instance configured according to the specified options.</returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown if the specified combination of publishing and statelessness options is not supported.</exception>
-    /// <remarks>Use this method to create an ISignalAsync{T} with the desired concurrency and state
-    /// management characteristics. The returned Signal type depends on the values provided in the options
-    /// parameter.</remarks>
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
@@ -60,10 +48,7 @@ public static ISignalAsync<T> Create<T>(SignalCreationOptions? options) =>
     public static ISignalAsync<T> CreateBehavior<T>(T startValue) =>
         new SerialReplayLatestSignalAsync<T>(new(startValue));
 
-    /// <summary>
-    /// Creates a new asynchronous Signal that replays the latest value to new subscribers, using the specified initial
-    /// value and creation options.
-    /// </summary>
+    /// <summary>Creates a new asynchronous Signal that replays the latest value to new subscribers, using the specified initial value and creation options.</summary>
     /// <typeparam name="T">The type of the values published by the Signal.</typeparam>
     /// <param name="startValue">The initial value to be published by the Signal before any values are pushed.</param>
     /// <param name="options">The options that control the Signal's publishing behavior and state management.</param>
@@ -86,9 +71,7 @@ public static ISignalAsync<T> CreateBehavior<T>(T startValue, BehaviorSignalCrea
     /// <summary>Creates a new asynchronous Signal that replays only the most recent value to new subscribers.</summary>
     /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
     /// <returns>An asynchronous Signal that stores and replays the latest value to each new subscriber.</returns>
-    /// <remarks>The returned Signal will only retain the most recent value published. When a new subscriber
-    /// subscribes, it immediately receives the latest value, if any, followed by subsequent values. This is useful for
-    /// scenarios where only the most recent state is relevant to new observers.</remarks>
+    /// <remarks>New subscribers receive the latest published value, if present, followed by live values.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
@@ -97,10 +80,7 @@ public static ISignalAsync<T> CreateBehavior<T>(T startValue, BehaviorSignalCrea
     public static ISignalAsync<T> CreateReplayLatest<T>() =>
         new SerialReplayLatestSignalAsync<T>(Optional<T>.Empty);
 
-    /// <summary>
-    /// Creates a new asynchronous Signal that replays the latest value to new subscribers, with configuration options
-    /// for publishing behavior and statefulness.
-    /// </summary>
+    /// <summary>Creates a new asynchronous Signal that replays the latest value to new subscribers, with configuration options for publishing behavior and statefulness.</summary>
     /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
     /// <param name="options">The options that specify the publishing mode and whether the Signal maintains state. Cannot be null.</param>
     /// <returns>An asynchronous Signal that replays the latest value to new subscribers, configured according to the specified
diff --git a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
index 5ea985e0..83b816d1 100644
--- a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>
-/// Provides a mechanism for registering a global handler to process unhandled exceptions that occur during
-/// application execution.
-/// </summary>
+/// <summary>Provides a mechanism for registering a global handler to process unhandled exceptions that occur during application execution.</summary>
 /// <remarks>The process-wide default writes the exception to <see cref="System.Diagnostics.Trace"/>. Register a
 /// handler to log, clean up or notify instead. Cancellation is treated as normal flow and never reaches the
 /// handler.</remarks>
diff --git a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
index 3ae4e3f2..e2e0dfb1 100644
--- a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
@@ -9,8 +9,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>Base class for an asynchronous observer: handles the notification gate, cancellation linking and disposal
-/// so a derived sink only has to implement the three <c>Core</c> methods.</summary>
+/// <summary>Base class for an asynchronous observer: handles the notification gate, cancellation linking and disposal so a derived sink only has to implement the three <c>Core</c> methods.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
 /// <remarks>One notification runs at a time. A reentrant call from the thread that holds the gate is allowed, but an
 /// overlapping call from another thread is a contract violation: the notification is dropped and a
@@ -18,22 +17,16 @@ namespace ReactiveUI.Primitives.Async;
 [System.Diagnostics.DebuggerDisplay("WitnessAsync: Disposed = {_disposed}, CallState = {_callState}")]
 public abstract class WitnessAsync<T> : IObserverAsync<T>, IReentrantAsyncDisposable
 {
-    /// <summary>Signals disposal to in-flight operations; created on the first request for a dispose token, so a
-    /// terminal sink that never needs one does not pay for it.</summary>
+    /// <summary>Disposal source, allocated only when a disposal token is requested.</summary>
     private CancellationTokenSource? _disposeCts;
 
-    /// <summary>Disposal latch, set independently of <see cref="_disposeCts"/> so the lazy path can report
-    /// post-dispose state with no source in existence.</summary>
+    /// <summary>Disposal latch, set independently of <see cref="_disposeCts"/> so the lazy path can report post-dispose state with no source in existence.</summary>
     private int _disposed;
 
-    /// <summary>Set when disposal is requested from inside this observer's own notification, telling
-    /// <see cref="DisposeAsyncCore"/> to skip the in-flight-call wait that would self-join on the caller once its
-    /// continuation hops threads.</summary>
+    /// <summary>Prevents disposal inside a notification from waiting for that same notification.</summary>
     private int _disposeFromNotification;
 
-    /// <summary>Packed call state: the high 32 bits hold the managed thread ID inside
-    /// <c>OnNext/OnError/OnCompleted</c>, the low 32 bits the in-flight call depth, updated lock-free through
-    /// <see cref="Interlocked.CompareExchange(ref long, long, long)"/>.</summary>
+    /// <summary>Atomic call state: owner thread ID in the high 32 bits, active call depth in the low 32 bits.</summary>
     private long _callState;
 
     /// <summary>Completion source that is set when all in-flight calls finish after disposal has been requested.</summary>
@@ -54,11 +47,7 @@ protected WitnessAsync()
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="WitnessAsync{T}"/> class and links an external cancellation
-    /// token into its dispose chain. Equivalent to calling the parameterless constructor followed by
-    /// <see cref="LinkExternalCancellation(CancellationToken)"/>.
-    /// </summary>
+    /// <summary>Initializes a new instance of the WitnessAsync class linked to external cancellation.</summary>
     /// <param name="externalLink">The external token whose cancellation should trigger this observer's disposal.</param>
     protected WitnessAsync(CancellationToken externalLink) => LinkExternalCancellation(externalLink);
 
@@ -109,8 +98,7 @@ public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
         return OnNextAsyncSlow(core, scope);
     }
 
-    /// <summary>Routes a non-terminal error to <see cref="OnErrorResumeAsyncCore"/>, never propagating a failure back
-    /// to the producer.</summary>
+    /// <summary>Routes a non-terminal error to <see cref="OnErrorResumeAsyncCore"/>, never propagating a failure back to the producer.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
     /// <returns>A task that completes once the error has been handled.</returns>
@@ -121,8 +109,7 @@ public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellat
             return default;
         }
 
-        // RouteObserverErrorAsync is an async method, so a synchronous throw is captured into the returned
-        // ValueTask too and surfaces at the await in OnErrorResumeAsyncSlow; a try/catch here is dead code.
+        // Callback failures are captured in the returned ValueTask.
         var core = RouteObserverErrorAsync(error, scope.Token);
 
         if (core.IsCompletedSuccessfully)
@@ -199,23 +186,43 @@ ValueTask IReentrantAsyncDisposable.DisposeFromNotificationAsync()
     public ValueTask AssignSourceSubscriptionAsync(IAsyncDisposable? value) =>
         SingleAssignmentDisposableAsync.AssignDisposableAsync(ref _sourceSubscription, value);
 
-    /// <summary>
-    /// Makes an upstream observer's disposal dispose this observer too, so an operator chain tears down from the top
-    /// and its emissions need no linked cancellation source.
-    /// </summary>
+    /// <summary>Makes an upstream observer's disposal dispose this observer too, so an operator chain tears down from the top and its emissions need no linked cancellation source.</summary>
     /// <param name="upstream">The upstream observer's dispose token.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void LinkUpstreamCancellation(CancellationToken upstream) =>
         LinkExternalCancellation(upstream);
 
+    /// <summary>Captures the owner thread and active notification count atomically.</summary>
+    /// <returns>The packed notification state.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal long ReadCallState() => Volatile.Read(ref _callState);
+
     /// <summary>Attempts to enter a notification call, checking for disposal, cancellation, and concurrent access.</summary>
     /// <param name="cancellationToken">The caller-supplied cancellation token.</param>
     /// <param name="scope">When successful, a <see cref="LinkedTokenScope"/> providing the effective cancellation token.</param>
     /// <returns><see langword="true"/> if the call was entered successfully; otherwise, <see langword="false"/>.</returns>
     [DebuggerStepThrough]
-    internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out LinkedTokenScope scope)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out LinkedTokenScope scope) =>
+        TryEnterOnSomethingCall(Environment.CurrentManagedThreadId, cancellationToken, out scope);
+
+    /// <summary>Attempts to enter a notification for the supplied caller thread.</summary>
+    /// <param name="currentThreadId">The calling thread identifier.</param>
+    /// <param name="cancellationToken">Cancellation for the notification.</param>
+    /// <param name="scope">The notification's effective cancellation scope.</param>
+    /// <returns>Whether the caller acquired the notification gate.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal bool TryEnterOnSomethingCall(int currentThreadId, CancellationToken cancellationToken, out LinkedTokenScope scope) =>
+        TryEnterObservedCallState(currentThreadId, ReadCallState(), cancellationToken, out scope);
+
+    /// <summary>Retries notification entry when the captured call state has changed.</summary>
+    /// <param name="currentThreadId">The calling thread identifier.</param>
+    /// <param name="oldState">The captured notification state.</param>
+    /// <param name="cancellationToken">Cancellation for the notification.</param>
+    /// <param name="scope">The notification's effective cancellation scope.</param>
+    /// <returns>Whether entry succeeded.</returns>
+    internal bool TryEnterObservedCallState(int currentThreadId, long oldState, CancellationToken cancellationToken, out LinkedTokenScope scope)
     {
-        var currentThreadId = Environment.CurrentManagedThreadId;
         while (true)
         {
             if (Volatile.Read(ref _disposed) != 0 || cancellationToken.IsCancellationRequested)
@@ -224,13 +231,10 @@ internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out L
                 return false;
             }
 
-            var oldState = Volatile.Read(ref _callState);
             var oldCount = (int)oldState;
             var oldThreadId = (int)(oldState >> 32);
 
-            // Concurrent-call detection: if another thread is already in-flight, this is a contract
-            // violation. Reentrant calls from the same thread (a callback that re-enters the observer)
-            // are legal — only cross-thread overlap fires the exception.
+            // Same-thread reentrancy is allowed; overlapping calls from different threads violate the contract.
             if (oldCount > 0 && oldThreadId != currentThreadId)
             {
                 UnhandledExceptionHandler.ReportUnhandledException(new ConcurrentWitnessCallsException());
@@ -241,8 +245,10 @@ internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out L
             var newThreadId = oldCount == 0 ? currentThreadId : oldThreadId;
             var newState = ((long)newThreadId << 32) | (uint)(oldCount + 1);
 
-            if (Interlocked.CompareExchange(ref _callState, newState, oldState) != oldState)
+            var observedState = Interlocked.CompareExchange(ref _callState, newState, oldState);
+            if (observedState != oldState)
             {
+                oldState = observedState;
                 continue;
             }
 
@@ -255,11 +261,16 @@ internal bool TryEnterOnSomethingCall(CancellationToken cancellationToken, out L
     /// <returns><see langword="true"/> when the caller should proceed with disposal itself; <see langword="false"/>
     /// when a waiting <see cref="DisposeAsync"/> call was signalled instead.</returns>
     [DebuggerStepThrough]
-    internal bool ExitOnSomethingCall()
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal bool ExitOnSomethingCall() => ExitObservedCallState(ReadCallState());
+
+    /// <summary>Retries notification exit when the captured call state has changed.</summary>
+    /// <param name="oldState">The captured notification state.</param>
+    /// <returns>Whether the exiting caller owns disposal instead of an existing waiter.</returns>
+    internal bool ExitObservedCallState(long oldState)
     {
         while (true)
         {
-            var oldState = Volatile.Read(ref _callState);
             var oldCount = (int)oldState;
             var oldThreadId = (int)(oldState >> 32);
 
@@ -268,8 +279,10 @@ internal bool ExitOnSomethingCall()
             var newCount = oldCount - 1;
             var newState = ((long)(newCount == 0 ? 0 : oldThreadId) << 32) | (uint)newCount;
 
-            if (Interlocked.CompareExchange(ref _callState, newState, oldState) != oldState)
+            var observedState = Interlocked.CompareExchange(ref _callState, newState, oldState);
+            if (observedState != oldState)
             {
+                oldState = observedState;
                 continue;
             }
 
@@ -287,8 +300,47 @@ internal bool ExitOnSomethingCall()
         }
     }
 
-    /// <summary>Runs <see cref="OnErrorResumeAsyncCore"/>, sending anything it throws — and the original error when the
-    /// call is cancelled — to <see cref="UnhandledExceptionHandler"/>.</summary>
+    /// <summary>Publishes the completion waiter and accounts for a notification that exited before publication.</summary>
+    /// <returns>The task completed when the active call count reaches zero.</returns>
+    internal Task PublishCallCompletionWaiter()
+    {
+        TaskCompletionSource<object?> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        _ = Interlocked.Exchange(ref _allCallsCompletedTcs, tcs);
+        if ((int)Volatile.Read(ref _callState) == 0)
+        {
+            _ = tcs.TrySetResult(null);
+        }
+
+        return tcs.Task;
+    }
+
+    /// <summary>Publishes a disposal source, releasing a losing allocation and preserving prior disposal.</summary>
+    /// <returns>The published dispose source.</returns>
+    internal CancellationTokenSource MaterializeDisposeCts()
+    {
+        CancellationTokenSource fresh = new();
+        var prior = Interlocked.CompareExchange(ref _disposeCts, fresh, null);
+        if (prior is not null)
+        {
+            fresh.Dispose();
+            return prior;
+        }
+
+        if (Volatile.Read(ref _disposed) != 0)
+        {
+            fresh.Cancel();
+        }
+
+        return fresh;
+    }
+
+    /// <summary>Disposes when the exiting call owns disposal, or signals an existing waiter.</summary>
+    /// <returns>The disposal operation, or a completed task when a waiter owns disposal.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal ValueTask CompleteOrChainDispose() =>
+        ExitOnSomethingCall() ? DisposeAsync() : default;
+
+    /// <summary>Runs <see cref="OnErrorResumeAsyncCore"/>, sending anything it throws — and the original error when the call is cancelled — to <see cref="UnhandledExceptionHandler"/>.</summary>
     /// <param name="error">The exception that triggered error handling.</param>
     /// <param name="cancellationToken">A cancellation token for the operation.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
@@ -319,11 +371,7 @@ internal async ValueTask RouteObserverErrorAsync(Exception error, CancellationTo
     /// <returns>A task that completes when the result has been handled.</returns>
     protected abstract ValueTask OnCompletedAsyncCore(Result result);
 
-    /// <summary>
-    /// Links an external cancellation token into this observer's dispose chain: cancelling <paramref name="external"/>
-    /// disposes the observer and cancels the token handed to <c>OnNextAsyncCore</c> and
-    /// <c>OnErrorResumeAsyncCore</c>. An observer holds at most one link, and a second call replaces it.
-    /// </summary>
+    /// <summary>Replaces the external cancellation link that disposes this observer and cancels its notifications.</summary>
     /// <param name="external">The external token whose cancellation should trigger this observer's disposal.</param>
     [DebuggerStepThrough]
     protected void LinkExternalCancellation(CancellationToken external)
@@ -360,10 +408,8 @@ protected void LinkExternalCancellation(CancellationToken external)
         _externalLinkedToken = external;
     }
 
-    /// <summary>Performs the observer's asynchronous teardown.</summary>
+    /// <summary>Claims disposal, waits for active notifications, and releases subscriptions; overrides must call the base implementation.</summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>An override must call the base implementation: it claims disposal for the first caller, waits out a
-    /// notification in flight on another thread, and releases the cancellation link and source subscription.</remarks>
     [DebuggerStepThrough]
     protected virtual async ValueTask DisposeAsyncCore()
     {
@@ -380,22 +426,7 @@ protected virtual async ValueTask DisposeAsyncCore()
             && (int)(initialState >> 32) != Environment.CurrentManagedThreadId
             && Volatile.Read(ref _disposeFromNotification) == 0)
         {
-            TaskCompletionSource<object?> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            // Interlocked rather than a release store, so the re-read below cannot be reordered ahead of this
-            // publish. ExitOnSomethingCall decrements under a full-fence CAS and only then reads this field, so
-            // with the publish fenced, an Exit that reads a null source has made its decrement visible here and
-            // one of the two sides always signals. Unfenced, both can miss and the await below never completes.
-            _ = Interlocked.Exchange(ref _allCallsCompletedTcs, tcs);
-
-            // Exit may have dropped the count to zero before the publish became visible, so self-signal.
-            var stateAfter = Volatile.Read(ref _callState);
-            if ((int)stateAfter == 0)
-            {
-                _ = tcs.TrySetResult(null);
-            }
-
-            allOnSomethingCallsCompleted = tcs.Task;
+            allOnSomethingCallsCompleted = PublishCallCompletionWaiter();
         }
 
         // Only an existing source needs the cancellation broadcast; a later token request builds one pre-cancelled.
@@ -408,24 +439,19 @@ protected virtual async ValueTask DisposeAsyncCore()
         await CompleteDisposeAfterCancelAsync(allOnSomethingCallsCompleted).ConfigureAwait(false);
     }
 
-    /// <summary>Handles a non-terminal error; the sequence may deliver more values afterwards.</summary>
+    /// <summary>Handles non-terminal errors; callback failures reach the unhandled-exception handler.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous error handling operation.</param>
     /// <returns>A task that completes when the error has been handled.</returns>
-    /// <remarks>An exception thrown from an override is reported to <see cref="UnhandledExceptionHandler"/> instead of
-    /// reaching the producer.</remarks>
     protected abstract ValueTask OnErrorResumeAsyncCore(Exception error, CancellationToken cancellationToken);
 
-    /// <summary>Processes the next value in the asynchronous sequence.</summary>
+    /// <summary>Delivers the value, forwarding callback failures to error-resume handling and swallowing cancellation.</summary>
     /// <param name="value">The value to be processed.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
     /// <returns>A task that completes when the value has been handled.</returns>
-    /// <remarks>An exception thrown from an override is fed to <see cref="OnErrorResumeAsyncCore"/>, so the sequence
-    /// survives a failed value; a cancellation is swallowed.</remarks>
     protected abstract ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken);
 
-    /// <summary>Awaits any in-flight notifications, then releases the cancellation link, the dispose source and the
-    /// source subscription.</summary>
+    /// <summary>Awaits any in-flight notifications, then releases the cancellation link, the dispose source and the source subscription.</summary>
     /// <param name="allOnSomethingCallsCompleted">Optional gate awaited for in-flight On* calls.</param>
     /// <returns>A task representing the asynchronous teardown.</returns>
     private async ValueTask CompleteDisposeAfterCancelAsync(Task? allOnSomethingCallsCompleted)
@@ -452,13 +478,6 @@ private async ValueTask CompleteDisposeAfterCancelAsync(Task? allOnSomethingCall
         }
     }
 
-    /// <summary>Chains into <see cref="DisposeAsync"/> when this exiting call owns disposal, which happens only when a
-    /// concurrent <see cref="DisposeAsync"/> raised the in-flight gate while the notification was running.</summary>
-    /// <returns>The dispose task when this caller owns disposal; otherwise a completed task.</returns>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    private ValueTask CompleteOrChainDispose() =>
-        ExitOnSomethingCall() ? DisposeAsync() : default;
-
     /// <summary>Async continuation for <see cref="OnNextAsync"/> when the core <see cref="ValueTask"/> is incomplete.</summary>
     /// <param name="core">The pending core <see cref="ValueTask"/>.</param>
     /// <param name="scope">The linked-token scope to release on completion.</param>
@@ -546,9 +565,7 @@ private async ValueTask OnCompletedAsyncSlow(ValueTask core, LinkedTokenScope sc
         }
     }
 
-    /// <summary>Builds the <see cref="LinkedTokenScope"/> for one call, allocating a linked source only when the
-    /// caller's token is none of <see cref="CancellationToken.None"/>, this observer's own dispose token, or the token
-    /// linked through <see cref="LinkExternalCancellation"/> — each of which cancels the call anyway.</summary>
+    /// <summary>Links a distinct caller token with the observer's disposal token.</summary>
     /// <param name="cancellationToken">The caller-supplied cancellation token.</param>
     /// <returns>A scope whose <c>Token</c> drives the in-flight call's cancellation.</returns>
     private LinkedTokenScope BuildLinkedTokenScope(CancellationToken cancellationToken)
@@ -571,32 +588,7 @@ private LinkedTokenScope BuildLinkedTokenScope(CancellationToken cancellationTok
     private CancellationTokenSource GetOrCreateDisposeCts() =>
         Volatile.Read(ref _disposeCts) ?? MaterializeDisposeCts();
 
-    /// <summary>Creates and publishes the dispose source, discarding this instance when another thread wins the
-    /// publish, and cancelling it when the observer is disposed before any token was requested.</summary>
-    /// <returns>The published dispose source.</returns>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    private CancellationTokenSource MaterializeDisposeCts()
-    {
-        CancellationTokenSource fresh = new();
-        var prior = Interlocked.CompareExchange(ref _disposeCts, fresh, null);
-        if (prior is not null)
-        {
-            fresh.Dispose();
-            return prior;
-        }
-
-        if (Volatile.Read(ref _disposed) != 0)
-        {
-            fresh.Cancel();
-        }
-
-        return fresh;
-    }
-
-    /// <summary>
-    /// Pairs one notification call's effective cancellation token with the linked source backing it, if one was
-    /// needed, so disposing the scope releases that source.
-    /// </summary>
+    /// <summary>Pairs one notification call's effective cancellation token with the linked source backing it, if one was needed, so disposing the scope releases that source.</summary>
     /// <param name="Cts">The linked CTS to dispose, or <see langword="null"/> if no allocation was needed.</param>
     /// <param name="Token">The effective cancellation token for the notification call.</param>
     internal readonly record struct LinkedTokenScope(CancellationTokenSource? Cts, CancellationToken Token) : IDisposable
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/Concurrency/SequencerSchedulingExtensions.cs b/src/ReactiveUI.Primitives.Async.Reactive/Concurrency/SequencerSchedulingExtensions.cs
index 7b6ebda0..72e75689 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/Concurrency/SequencerSchedulingExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Reactive/Concurrency/SequencerSchedulingExtensions.cs
@@ -10,11 +10,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// Gives <see cref="IScheduler"/> the <c>ISequencer</c> scheduling shape the shared Extensions source expects,
-/// by forwarding to <see cref="System.Reactive.Concurrency.Scheduler"/>. Kept internal: it is the seam the leaf
-/// uses to invoke schedulers, not public surface.
-/// </summary>
+/// <summary>Adapts shared work-item scheduling calls to System.Reactive schedulers.</summary>
 internal static class SequencerSchedulingExtensions
 {
     /// <summary>Scheduling operators that give an <see cref="IScheduler"/> the shared-source sequencer shape.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net10.0/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net10.0/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net11.0/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net11.0/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net462/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net462/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net472/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net472/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net48/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net48/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net481/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net481/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net8.0/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net8.0/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net9.0/PublicAPI.txt
index 3266150e..439ae265 100644
--- a/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async.Reactive/PublicAPI/net9.0/PublicAPI.txt
@@ -12,7 +12,6 @@ namespace ReactiveUI.Primitives.Async.Reactive
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Reactive.Concurrency.IScheduler scheduler) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.Reactive.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.Reactive.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net10.0/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net10.0/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net11.0/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net11.0/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net462/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net462/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net472/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net472/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net48/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net48/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net481/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net481/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net8.0/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net8.0/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Async/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Async/PublicAPI/net9.0/PublicAPI.txt
index f18f2361..50e54ad0 100644
--- a/src/ReactiveUI.Primitives.Async/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Async/PublicAPI/net9.0/PublicAPI.txt
@@ -13,7 +13,6 @@ namespace ReactiveUI.Primitives.Async
         public static ReactiveUI.Primitives.Async.AsyncContext From(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.SynchronizationContext synchronizationContext) { }
         public static ReactiveUI.Primitives.Async.AsyncContext From(System.Threading.Tasks.TaskScheduler taskScheduler) { }
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         public static ReactiveUI.Primitives.Async.AsyncContext GetCurrent() { }
         [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
         public readonly record struct AsyncContextSwitcherAwaitable : System.IEquatable<ReactiveUI.Primitives.Async.AsyncContext.AsyncContextSwitcherAwaitable>, System.Runtime.CompilerServices.INotifyCompletion
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
index d5f0fa17..658b70e2 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
@@ -48,6 +48,7 @@ protected override bool Post(Action drain)
     }
 
     /// <inheritdoc/>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         DispatcherTimer timer = new(Priority, Dispatcher) { Interval = dueTime };
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net10.0/PublicAPI.txt
index 70d2fa05..f26b4280 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net10.0/PublicAPI.txt
@@ -10,6 +10,7 @@ public sealed class AvaloniaScheduler : ReactiveUI.Primitives.Reactive.Concurren
     public Avalonia.Threading.Dispatcher Dispatcher { get; }
     public Avalonia.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net11.0/PublicAPI.txt
index 70d2fa05..f26b4280 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net11.0/PublicAPI.txt
@@ -10,6 +10,7 @@ public sealed class AvaloniaScheduler : ReactiveUI.Primitives.Reactive.Concurren
     public Avalonia.Threading.Dispatcher Dispatcher { get; }
     public Avalonia.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net8.0/PublicAPI.txt
index 70d2fa05..f26b4280 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net8.0/PublicAPI.txt
@@ -10,6 +10,7 @@ public sealed class AvaloniaScheduler : ReactiveUI.Primitives.Reactive.Concurren
     public Avalonia.Threading.Dispatcher Dispatcher { get; }
     public Avalonia.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net9.0/PublicAPI.txt
index 70d2fa05..f26b4280 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/PublicAPI/net9.0/PublicAPI.txt
@@ -10,6 +10,7 @@ public sealed class AvaloniaScheduler : ReactiveUI.Primitives.Reactive.Concurren
     public Avalonia.Threading.Dispatcher Dispatcher { get; }
     public Avalonia.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
diff --git a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
index 63cfd3ca..3dd23c31 100644
--- a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
@@ -76,6 +76,7 @@ private bool Post(Action drain)
     /// <summary>Runs delayed work on a dispatcher timer bound to the selected dispatcher.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
     {
         DispatcherTimer timer =
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
index 679e0776..d614bd16 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
@@ -34,14 +34,8 @@ public IDisposable Subscribe(IObserver<T> observer)
         return subscription;
     }
 
-    /// <summary>Drives a single subscription's pump and coordinates single-owner enumerator disposal.</summary>
-    /// <remarks>
-    /// Enumerator disposal is single-owner through an interlocked claim: whichever of the pump's
-    /// <c>finally</c> and <see cref="Dispose"/> wins the claim disposes the enumerator exactly once. The
-    /// winner disposes without awaiting <see cref="IAsyncEnumerator{T}.MoveNextAsync"/>, so an enumerator
-    /// that ignores cancellation is torn down promptly rather than at its own pace.
-    /// </remarks>
-    private sealed class Subscription : IDisposable
+    /// <summary>Pumps values and disposes the enumerator once without waiting for a pending move.</summary>
+    internal sealed class Subscription : IDisposable
     {
         /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer;
@@ -65,7 +59,7 @@ private sealed class Subscription : IDisposable
         /// <param name="observer">The downstream observer.</param>
         /// <param name="values">The source async enumerable.</param>
         /// <param name="cancellationToken">The adapter cancellation token.</param>
-        public Subscription(IObserver<T> observer, IAsyncEnumerable<T> values, CancellationToken cancellationToken)
+        internal Subscription(IObserver<T> observer, IAsyncEnumerable<T> values, CancellationToken cancellationToken)
         {
             _observer = observer;
             _values = values;
@@ -74,9 +68,6 @@ public Subscription(IObserver<T> observer, IAsyncEnumerable<T> values, Cancellat
                 : new();
         }
 
-        /// <summary>Starts the asynchronous pump.</summary>
-        public void Start() => _ = PumpAsync();
-
         /// <inheritdoc/>
         public void Dispose()
         {
@@ -85,15 +76,7 @@ public void Dispose()
                 return;
             }
 
-            try
-            {
-                _cts.Cancel();
-            }
-            catch (ObjectDisposedException)
-            {
-                // The pump completed and disposed the cancellation source.
-            }
-
+            _cts.Cancel();
             if (TryClaimEnumerator(out var enumerator))
             {
                 FireAndForgetDispose(enumerator);
@@ -102,46 +85,12 @@ public void Dispose()
             _cts.Dispose();
         }
 
-        /// <summary>Disposes an enumerator without surfacing the resulting task to the caller.</summary>
-        /// <param name="enumerator">The enumerator to dispose.</param>
-        private static void FireAndForgetDispose(IAsyncEnumerator<T> enumerator)
-        {
-            // Disposal runs detached because IDisposable.Dispose cannot await it; the local method keeps
-            // the resulting task observed.
-            _ = ObserveAsync(enumerator);
-
-            static async Task ObserveAsync(IAsyncEnumerator<T> enumerator)
-            {
-                try
-                {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                }
-                catch (NotSupportedException)
-                {
-                    // Some enumerators only support disposal from the enumeration path.
-                }
-            }
-        }
-
-        /// <summary>Claims sole ownership of enumerator disposal for the calling path.</summary>
-        /// <param name="enumerator">The enumerator to dispose when the claim succeeds.</param>
-        /// <returns><see langword="true"/> when the caller won the claim and must dispose the enumerator.</returns>
-        private bool TryClaimEnumerator(out IAsyncEnumerator<T> enumerator)
-        {
-            var current = Volatile.Read(ref _enumerator);
-            if (current is not null && Interlocked.Exchange(ref _enumeratorDisposed, 1) == 0)
-            {
-                enumerator = current;
-                return true;
-            }
-
-            enumerator = null!;
-            return false;
-        }
+        /// <summary>Starts the asynchronous pump.</summary>
+        internal void Start() => _ = PumpAsync();
 
         /// <summary>Pumps the async enumerable into the observer.</summary>
         /// <returns>The asynchronous pump task.</returns>
-        private async Task PumpAsync()
+        internal async Task PumpAsync()
         {
             try
             {
@@ -149,8 +98,7 @@ private async Task PumpAsync()
                 Volatile.Write(ref _enumerator, enumerator);
                 while (!_cts.IsCancellationRequested && await enumerator.MoveNextAsync().ConfigureAwait(false))
                 {
-                    // Re-check after the await: disposal may have torn the subscription down while the
-                    // element was in flight, and a buffered value must not reach a stopped observer.
+                    // Cancellation during the move suppresses its buffered value.
                     if (_cts.IsCancellationRequested)
                     {
                         break;
@@ -182,6 +130,42 @@ private async Task PumpAsync()
                 Dispose();
             }
         }
+
+        /// <summary>Disposes an enumerator without surfacing the resulting task to the caller.</summary>
+        /// <param name="enumerator">The enumerator to dispose.</param>
+        private static void FireAndForgetDispose(IAsyncEnumerator<T> enumerator)
+        {
+            // IDisposable cannot await enumerator disposal.
+            _ = ObserveAsync(enumerator);
+
+            static async Task ObserveAsync(IAsyncEnumerator<T> enumerator)
+            {
+                try
+                {
+                    await enumerator.DisposeAsync().ConfigureAwait(false);
+                }
+                catch (NotSupportedException)
+                {
+                    // Some enumerators only support disposal from the enumeration path.
+                }
+            }
+        }
+
+        /// <summary>Claims sole ownership of enumerator disposal for the calling path.</summary>
+        /// <param name="enumerator">The enumerator to dispose when the claim succeeds.</param>
+        /// <returns><see langword="true"/> when the caller won the claim and must dispose the enumerator.</returns>
+        private bool TryClaimEnumerator(out IAsyncEnumerator<T> enumerator)
+        {
+            var current = Volatile.Read(ref _enumerator);
+            if (current is not null && Interlocked.Exchange(ref _enumeratorDisposed, 1) == 0)
+            {
+                enumerator = current;
+                return true;
+            }
+
+            enumerator = null!;
+            return false;
+        }
     }
 }
 #endif
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
index 8a0fd093..3d332734 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
@@ -64,8 +64,7 @@ public void OnNext(T value)
             return;
         }
 
-        // Reset to the skip *before* the hand-off: the observer may throw, and the sink must never be left
-        // holding an index into a buffer it has released, because the next value would index into null.
+        // Reset the index before a throwing observer can release the buffer.
         _buffer = null;
         _index = 0 - _skip;
 
@@ -120,8 +119,7 @@ public void OnCompleted()
     /// <inheritdoc/>
     public void Dispose()
     {
-        // Latching here makes the sink terminal on every teardown path, including disposal from Emit when
-        // the downstream observer throws, so a source that ignores disposal cannot push another value in.
+        // Reject further values on every teardown path, including observer failure.
         Volatile.Write(ref _done, 1);
         SinkSubscription.Dispose(ref _subscription);
     }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
index 8c80ae1c..da82edf3 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateThrowSignal{T}.cs
@@ -37,9 +37,9 @@ public IDisposable Subscribe(IObserver<T> observer)
     }
 
     /// <summary>Invokes <paramref name="onError"/> with the stored error before returning.</summary>
-    /// <param name="onNext">Never invoked.</param>
+    /// <param name="onNext">The unused value callback.</param>
     /// <param name="onError">Invoked with the stored error.</param>
-    /// <param name="onCompleted">Never invoked.</param>
+    /// <param name="onCompleted">The unused completion callback.</param>
     /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
index bacd6d05..5e8a721d 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmutableEmptySignal{T}.cs
@@ -37,8 +37,8 @@ public IDisposable Subscribe(IObserver<T> observer)
     }
 
     /// <summary>Invokes <paramref name="onCompleted"/> before returning.</summary>
-    /// <param name="onNext">Never invoked.</param>
-    /// <param name="onError">Never invoked.</param>
+    /// <param name="onNext">The unused value callback.</param>
+    /// <param name="onError">The unused error callback.</param>
     /// <param name="onCompleted">Invoked before this method returns.</param>
     /// <returns>An empty disposable; the signal has finished by the time this returns.</returns>
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
index 05968d3d..424c7a90 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
@@ -40,6 +40,9 @@ public SynchronizeWitness(IObserver<T> observer, Lock gate)
         _gate = gate;
     }
 
+    /// <summary>Gets the gate serializing downstream notifications.</summary>
+    internal Lock Gate => _gate;
+
     /// <inheritdoc/>
     public void OnNext(T value)
     {
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
index df70de30..743a54c6 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
@@ -125,10 +125,7 @@ public ScheduledItem(
     public static bool operator >=(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) >= 0;
 
-    /// <summary>
-    /// Cancels this scheduled work item: work that has not started does not run, and a disposable returned by work
-    /// that has begun is disposed as soon as it is available.
-    /// </summary>
+    /// <summary>Cancels this scheduled work item: work that has not started does not run, and a disposable returned by work that has begun is disposed as soon as it is available.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Cancel() => Dispose();
 
diff --git a/src/ReactiveUI.Primitives.Core/Core/CoreCompositeFormats.cs b/src/ReactiveUI.Primitives.Core/Core/CoreCompositeFormats.cs
index c72f515d..d775e8ef 100644
--- a/src/ReactiveUI.Primitives.Core/Core/CoreCompositeFormats.cs
+++ b/src/ReactiveUI.Primitives.Core/Core/CoreCompositeFormats.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Core;
 
-/// <summary>Holds the parsed composite formats the core value types render with.</summary>
-/// <remarks>
-/// The formats sit on a non-generic type on purpose. A static field inside <see cref="Moment{T}"/> is
-/// a field of each closed generic, so the format would be parsed once per <c>T</c>; one shared instance
-/// serves every one of them.
-/// </remarks>
+/// <summary>Shares parsed value formats across all closed generic types.</summary>
 internal static class CoreCompositeFormats
 {
     /// <summary>The format <see cref="Moment{T}"/> renders with.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
index 0ed3ec1e..6b545449 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
@@ -14,8 +14,7 @@ namespace ReactiveUI.Primitives.Signals;
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class AsyncSignal<T> : IAwaitSignal<T>
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Serializes observer changes and terminal-state transitions.</summary>
     private readonly Lock _observerLock = new();
 
     /// <summary>Stores state for the signal implementation.</summary>
@@ -239,13 +238,7 @@ public void Dispose()
     /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
     public T GetResult()
     {
-        if (!IsCompleted)
-        {
-            ManualResetEvent completionEvent = new(false);
-            SubscribeCompletion(() => completionEvent.Set(), false);
-            _ = completionEvent.WaitOne();
-        }
-
+        WaitIfPending(WaitForCompletion);
         _lastError.Rethrow();
 
         if (!_hasValue)
@@ -268,7 +261,30 @@ public void RemoveObserver(IObserver<T> observer)
         }
     }
 
-    /// <summary>Executes the ThrowIfDisposed operation.</summary>
+    /// <summary>Invokes the wait operation only while completion is pending.</summary>
+    /// <param name="wait">The operation that waits for this signal to complete.</param>
+    internal void WaitIfPending(Action<AsyncSignal<T>> wait)
+    {
+        if (IsCompleted)
+        {
+            return;
+        }
+
+        wait(this);
+    }
+
+    /// <summary>Blocks the calling thread until the signal completes.</summary>
+    /// <param name="signal">The signal supplying the completion notification.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void WaitForCompletion(AsyncSignal<T> signal)
+    {
+        // Registration precedes waiting so completion cannot be missed.
+        using ManualResetEvent completionEvent = new(false);
+        signal.SubscribeCompletion(() => completionEvent.Set(), false);
+        _ = completionEvent.WaitOne();
+    }
+
+    /// <summary>Rejects operations after the signal has been disposed.</summary>
     /// <exception cref="ObjectDisposedException">This instance has already been disposed.</exception>
     private void ThrowIfDisposed()
     {
@@ -280,7 +296,7 @@ private void ThrowIfDisposed()
         throw new ObjectDisposedException(string.Empty);
     }
 
-    /// <summary>Executes the SubscribeCompletion operation.</summary>
+    /// <summary>Registers a callback for either terminal notification.</summary>
     /// <param name="continuation">The continuation value.</param>
     /// <param name="originalContext">The originalContext value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
index 6f9703e1..4cd4a90c 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
@@ -30,11 +30,11 @@ public AwaitWitness(Action callback, bool originalContext)
         _callback = callback;
     }
 
-    /// <summary>Executes the OnCompleted operation.</summary>
+    /// <summary>Resumes the awaiting continuation on completion.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnCompleted() => InvokeOnOriginalContext();
 
-    /// <summary>Executes the OnError operation.</summary>
+    /// <summary>Resumes the awaiting continuation when the source fails.</summary>
     /// <param name="error">The error value.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
@@ -46,13 +46,13 @@ public AwaitWitness(Action callback, bool originalContext)
             + "other; having one call the other would misrepresent an error as a completion.")]
     public void OnError(Exception error) => InvokeOnOriginalContext();
 
-    /// <summary>Executes the OnNext operation.</summary>
+    /// <summary>Ignores values; only terminal notifications resume the continuation.</summary>
     /// <param name="value">The value.</param>
     public void OnNext(T value)
     {
     }
 
-    /// <summary>Executes the InvokeOnOriginalContext operation.</summary>
+    /// <summary>Posts the continuation to its captured context, or invokes it directly when none was captured.</summary>
     private void InvokeOnOriginalContext()
     {
         if (_context is not null)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
index 918ecdfd..0df1f8c7 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// Mutable state and mechanics backing the latest-value (behavior) signals. A single signal instance owns one
-/// of these inline (no separate heap object) and forwards its public surface here, so the latest-value logic
-/// lives in one place without inheritance or composition between the signal types.
-/// </summary>
+/// <summary>Stores the latest value, subscribers, and terminal state of a behavior signal.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.CodeAnalysis.SuppressMessage(
     "Performance",
@@ -86,12 +82,7 @@ internal readonly bool TryGetValue(out T? value)
         }
     }
 
-    /// <summary>Notifies all observers about the end of the sequence.</summary>
-    /// <remarks>
-    /// The broadcast runs under <see cref="_gate"/> so it serializes against <see cref="Subscribe"/>: a new
-    /// subscriber is either added before this completes (and is broadcast to here) or after (and replays the
-    /// terminal state itself), never seeing an out-of-order or duplicated notification.
-    /// </remarks>
+    /// <summary>Publishes completion under the subscription gate, preventing duplicate or out-of-order terminal notifications.</summary>
     internal void OnCompleted()
     {
         lock (_gate)
@@ -129,13 +120,8 @@ internal void OnError(Exception error)
         }
     }
 
-    /// <summary>Notifies all observers about the arrival of the specified value.</summary>
+    /// <summary>Updates and broadcasts the latest value under the subscription gate, preserving initial-value ordering.</summary>
     /// <param name="value">The value to send to all observers.</param>
-    /// <remarks>
-    /// The latest-value update and the broadcast happen together under <see cref="_gate"/>, so they are atomic
-    /// with respect to <see cref="Subscribe"/>; a new subscriber never observes a live value before the initial
-    /// value it was promised, and never observes the same value twice.
-    /// </remarks>
     internal void OnNext(T value)
     {
         lock (_gate)
@@ -165,10 +151,7 @@ internal IDisposable Subscribe(IWitnessRemovable<T> owner, IObserver<T> observer
             ThrowIfDisposed();
             if (!_isStopped)
             {
-                // Add and deliver the initial value under the same gate that serializes live broadcast, so
-                // the new observer is either added before a concurrent OnNext (and sees the initial value
-                // first, then the live value) or after it (and the live value becomes its initial value).
-                // It can never observe a newer live value ahead of, or in addition to, its initial value.
+                // Serialize initial delivery with live broadcast to preserve order and prevent duplicates.
                 _broadcaster.Add(observer);
                 var subscription = new BehaviorWitnessHandler<T>(owner, observer);
                 observer.OnNext(_lastValue!);
diff --git a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
index c9373518..ba80e2d5 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
@@ -20,15 +20,7 @@ public sealed class BehaviorSignal<T> : ISignal<T>, IWitnessRemovable<T>
 
     /// <summary>Gets the current value or throws an exception.</summary>
     /// <value>The initial value passed to the constructor until <see cref="OnNext"/> is called; after which, the last value passed to <see cref="OnNext"/>.</value>
-    /// <remarks>
-    /// <para><see cref="Value"/> is frozen after <see cref="OnCompleted"/> is called.</para>
-    /// <para>After <see cref="OnError"/> is called, <see cref="Value"/> always throws the specified exception.</para>
-    /// <para>An exception is always thrown after <see cref="Dispose()"/> is called.</para>
-    /// <alert type="caller">
-    /// Reading <see cref="Value"/> is a thread-safe operation, though there's a potential race condition when <see cref="OnNext"/> or <see cref="OnError"/> are being invoked concurrently.
-    /// In some cases, it may be necessary for a caller to use external synchronization to avoid race conditions.
-    /// </alert>
-    /// </remarks>
+    /// <remarks>Completion freezes the value. Failure makes value reads throw the terminal exception, and disposal makes them throw ObjectDisposedException.</remarks>
     public T Value => _state.GetValue();
 
     /// <summary>Gets a value indicating whether this instance has observers.</summary>
@@ -50,14 +42,7 @@ public sealed class BehaviorSignal<T> : ISignal<T>, IWitnessRemovable<T>
     /// <summary>Tries to get the current value or throws an exception.</summary>
     /// <param name="value">The initial value passed to the constructor until <see cref="OnNext"/> is called; after which, the last value passed to <see cref="OnNext"/>.</param>
     /// <returns>true if a value is available; false if the subject was disposed.</returns>
-    /// <remarks>
-    /// <para>The value returned from <see cref="TryGetValue"/> is frozen after <see cref="OnCompleted"/> is called.</para>
-    /// <para>After <see cref="OnError"/> is called, <see cref="TryGetValue"/> always throws the specified exception.</para>
-    /// <alert type="caller">
-    /// Calling <see cref="TryGetValue"/> is a thread-safe operation, though there's a potential race condition when <see cref="OnNext"/> or <see cref="OnError"/> are being invoked concurrently.
-    /// In some cases, it may be necessary for a caller to use external synchronization to avoid race conditions.
-    /// </alert>
-    /// </remarks>
+    /// <remarks>Completion freezes the value; failure makes reads throw the terminal exception. Each read is synchronized, but a separate read and state check are not atomic.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool TryGetValue(out T? value) => _state.TryGetValue(out value);
 
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
index 264ad079..62f76e23 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
@@ -37,10 +37,7 @@ public struct Broadcaster<T> : IEquatable<Broadcaster<T>>
     /// <returns><see langword="true"/> when the broadcasters reference different observer sets; otherwise, <see langword="false"/>.</returns>
     public static bool operator !=(Broadcaster<T> left, Broadcaster<T> right) => !left.Equals(right);
 
-    /// <summary>
-    /// Adds an observer to the broadcaster. The update is a lock-free compare-and-swap, so the
-    /// broadcaster is self-contained and does not rely on an external lock for correctness.
-    /// </summary>
+    /// <summary>Adds an observer to the broadcaster. The update is a lock-free compare-and-swap, so the broadcaster is self-contained and does not rely on an external lock for correctness.</summary>
     /// <param name="observer">Observer to add.</param>
     public void Add(IObserver<T> observer)
     {
@@ -173,16 +170,7 @@ public override readonly bool Equals(object? obj) =>
         obj is Broadcaster<T> other && Equals(other);
 
     /// <inheritdoc/>
-    /// <remarks>
-    /// The hash is taken over the observers the broadcaster is holding, not over the object it happens to
-    /// hold them in. That keeps it agreeing with <see cref="Equals(Broadcaster{T})"/> — two broadcasters
-    /// sharing a set share its observers — while saying something about the value rather than about which
-    /// array the copy-on-write path last allocated. No observers hashes to zero.
-    /// <para>
-    /// It moves as observers come and go, which is inherent: equality here is the observer set, and the
-    /// set is what changes. A broadcaster is compared, never filed in a hash table.
-    /// </para>
-    /// </remarks>
+    /// <remarks>The hash reflects the current observers and changes with subscriptions. Do not use a mutable broadcaster as a hash key.</remarks>
     [SuppressMessage(
         "Maintainability",
         "SST1482:GetHashCode reads mutable state",
diff --git a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
index 772cff90..25412439 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
@@ -91,55 +91,11 @@ public CommandSignal(Func<TResult> execute, IObservable<bool>? canRun)
     public bool CanRun => Volatile.Read(ref _canRun);
 
     /// <summary>Gets the lazily allocated fault stream.</summary>
-    private Signal<Exception> FaultsSignal
-    {
-        get
-        {
-            var signal = Volatile.Read(ref _faults);
-            if (signal is not null)
-            {
-                return signal;
-            }
-
-            signal = new();
-            var current = Interlocked.CompareExchange(ref _faults, signal, null);
-            if (current is null)
-            {
-                return signal;
-            }
-
-            signal.Dispose();
-            return current;
-        }
-    }
+    private Signal<Exception> FaultsSignal => Volatile.Read(ref _faults) ?? InstallFaultsSignal(new());
 
     /// <summary>Gets the lazily allocated running state stream.</summary>
-    private StateSignal<bool> IsRunningSignal
-    {
-        get
-        {
-            var signal = Volatile.Read(ref _isRunningState);
-            if (signal is not null)
-            {
-                return signal;
-            }
-
-            signal = new(Volatile.Read(ref _isRunning));
-            var current = Interlocked.CompareExchange(ref _isRunningState, signal, null);
-            if (current is null)
-            {
-                // The snapshot above may already be stale: a SetRunning call can run between it and
-                // the install. Reconcile under the running gate so the just-installed stream cannot
-                // latch a stale value, and so a concurrent SetRunning cannot lose its update to a
-                // late seed write here.
-                ReconcileRunningState();
-                return signal;
-            }
-
-            signal.Dispose();
-            return current;
-        }
-    }
+    private StateSignal<bool> IsRunningSignal =>
+        Volatile.Read(ref _isRunningState) ?? InstallRunningState(new(Volatile.Read(ref _isRunning)));
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -170,7 +126,7 @@ public CommandExecution<TResult> ExecuteAsync(CancellationToken cancellationToke
         }
     }
 
-    /// <summary>Executes the Dispose operation.</summary>
+    /// <summary>Detaches the execution gate and releases result, fault, and running-state subscriptions.</summary>
     public void Dispose()
     {
         if (Interlocked.Exchange(ref _disposed, 1) != 0)
@@ -196,6 +152,79 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return new ResultSubscription(this, observer);
     }
 
+    /// <summary>Attempts to append an observer to an unchanged snapshot.</summary>
+    /// <param name="storage">The published observer snapshot.</param>
+    /// <param name="current">The snapshot used to prepare the update.</param>
+    /// <param name="observer">The observer to append.</param>
+    /// <returns>Whether the update was published.</returns>
+    internal static bool TryAddResult(ref object? storage, object? current, IObserver<TResult> observer)
+    {
+        object next;
+        if (current is IObserver<TResult>[] many)
+        {
+            var copy = new IObserver<TResult>[many.Length + 1];
+            Array.Copy(many, copy, many.Length);
+            copy[many.Length] = observer;
+            next = copy;
+        }
+        else if (current is IObserver<TResult> single)
+        {
+            next = new[] { single, observer };
+        }
+        else
+        {
+            return Interlocked.CompareExchange(ref storage, observer, null) is null;
+        }
+
+        return ReferenceEquals(Interlocked.CompareExchange(ref storage, next, current), current);
+    }
+
+    /// <summary>Attempts to remove an observer from an unchanged snapshot.</summary>
+    /// <param name="storage">The published observer snapshot.</param>
+    /// <param name="current">The snapshot used to prepare the update.</param>
+    /// <param name="observer">The observer to remove.</param>
+    /// <returns>Whether no retry is required.</returns>
+    internal static bool TryRemoveResult(ref object? storage, object? current, IObserver<TResult> observer)
+    {
+        if (!TryGetRemoveResultNext(current, observer, out var next))
+        {
+            return true;
+        }
+
+        return ReferenceEquals(Interlocked.CompareExchange(ref storage, next, current), current);
+    }
+
+    /// <summary>Installs a fault stream or releases a candidate that lost installation.</summary>
+    /// <param name="signal">The newly allocated candidate.</param>
+    /// <returns>The installed stream.</returns>
+    internal Signal<Exception> InstallFaultsSignal(Signal<Exception> signal)
+    {
+        var current = Interlocked.CompareExchange(ref _faults, signal, null);
+        if (current is null)
+        {
+            return signal;
+        }
+
+        signal.Dispose();
+        return current;
+    }
+
+    /// <summary>Installs a running stream and reconciles its snapshot with the current execution state.</summary>
+    /// <param name="signal">The newly allocated candidate.</param>
+    /// <returns>The installed stream.</returns>
+    internal StateSignal<bool> InstallRunningState(StateSignal<bool> signal)
+    {
+        var current = Interlocked.CompareExchange(ref _isRunningState, signal, null);
+        if (current is null)
+        {
+            ReconcileRunningState();
+            return signal;
+        }
+
+        signal.Dispose();
+        return current;
+    }
+
     /// <summary>Gets the observer snapshot that should replace the current snapshot.</summary>
     /// <param name="current">Current observer snapshot.</param>
     /// <param name="observer">Observer to remove.</param>
@@ -312,10 +341,7 @@ private void BeginExecution()
     /// <param name="value">The running state.</param>
     private void SetRunning(bool value)
     {
-        // Set the flag and notify the stream through the same gated path the getter uses. Holding
-        // the gate across the flag write and the notification keeps the flag and the stream value
-        // observed together, so the lazy install and a concurrent transition cannot lose each
-        // other's update.
+        // Publish the flag and stream value under the installation gate.
         lock (_runningGate)
         {
             _isRunning = value;
@@ -370,7 +396,7 @@ private void PublishResult(TResult result)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void PublishFault(Exception error) => Volatile.Read(ref _faults)?.OnNext(error);
 
-    /// <summary>Executes the ThrowIfDisposed operation.</summary>
+    /// <summary>Rejects command operations after disposal.</summary>
     /// <exception cref="ObjectDisposedException">The command has been disposed.</exception>
     private void ThrowIfDisposed()
     {
@@ -384,33 +410,13 @@ private void ThrowIfDisposed()
 
     /// <summary>Adds a result subscriber.</summary>
     /// <param name="observer">Observer to add.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void AddResult(IObserver<TResult> observer)
     {
+        // Retry only when another thread replaced the observed snapshot.
         while (true)
         {
-            var current = Volatile.Read(ref _resultObservers);
-            object next;
-            if (current is IObserver<TResult>[] many)
-            {
-                var copy = new IObserver<TResult>[many.Length + 1];
-                Array.Copy(many, copy, many.Length);
-                copy[many.Length] = observer;
-                next = copy;
-            }
-            else if (current is IObserver<TResult> single)
-            {
-                next = new[] { single, observer };
-            }
-            else if (Interlocked.CompareExchange(ref _resultObservers, observer, null) is null)
-            {
-                return;
-            }
-            else
-            {
-                continue;
-            }
-
-            if (ReferenceEquals(Interlocked.CompareExchange(ref _resultObservers, next, current), current))
+            if (TryAddResult(ref _resultObservers, Volatile.Read(ref _resultObservers), observer))
             {
                 return;
             }
@@ -423,17 +429,13 @@ private void AddResult(IObserver<TResult> observer)
 
     /// <summary>Removes a result subscriber.</summary>
     /// <param name="observer">Observer to remove.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void RemoveResult(IObserver<TResult> observer)
     {
+        // Retry only when another thread replaced the observed snapshot.
         while (true)
         {
-            var current = Volatile.Read(ref _resultObservers);
-            if (!TryGetRemoveResultNext(current, observer, out var next))
-            {
-                return;
-            }
-
-            if (ReferenceEquals(Interlocked.CompareExchange(ref _resultObservers, next, current), current))
+            if (TryRemoveResult(ref _resultObservers, Volatile.Read(ref _resultObservers), observer))
             {
                 return;
             }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
index 4a79fb7a..5beab2a7 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
@@ -19,12 +19,12 @@ public sealed class KeepSignal<T>(IObservable<T> source, Func<T, bool> predicate
     /// <summary>Stores state for the signal implementation.</summary>
     private readonly Func<T, bool> _predicate = predicate;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
+    /// <summary>Preserves the source's current-thread subscription requirement.</summary>
     /// <returns>The result.</returns>
     public bool IsRequiredSubscribeOnCurrentThread() =>
         _source is IRequireCurrentThread<T> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread();
 
-    /// <summary>Executes the Subscribe operation.</summary>
+    /// <summary>Subscribes an observer to source values accepted by the predicate.</summary>
     /// <param name="observer">The observer value.</param>
     /// <returns>The result.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
@@ -48,7 +48,7 @@ private sealed class KeepWitness(IObserver<T> observer, Func<T, bool> predicate)
         /// <summary>Stores state for the signal implementation.</summary>
         private int _stopped;
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Forwards completion only while the sink is active.</summary>
         public void OnCompleted()
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
@@ -59,7 +59,7 @@ public void OnCompleted()
             _observer.OnCompleted();
         }
 
-        /// <summary>Executes the OnError operation.</summary>
+        /// <summary>Stops the sink and forwards its first error.</summary>
         /// <param name="error">The error value.</param>
         public void OnError(Exception error)
         {
@@ -71,7 +71,7 @@ public void OnError(Exception error)
             _observer.OnError(error);
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
+        /// <summary>Filters active values and turns predicate failures into terminal errors.</summary>
         /// <param name="value">The value.</param>
         public void OnNext(T value)
         {
diff --git a/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs b/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
index 356c5258..795ebb02 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// Filters source values using a caller-supplied state value, without allocating a per-value closure: the state is
-/// stored on the sink and passed to the predicate for each element.
-/// </summary>
+/// <summary>Filters source values using a caller-supplied state value, without allocating a per-value closure: the state is stored on the sink and passed to the predicate for each element.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <typeparam name="TState">The state type passed to the predicate.</typeparam>
 /// <param name="source">The source sequence.</param>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
index 56dcd610..35e72aff 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
@@ -20,12 +20,12 @@ public sealed class MapSignal<TSource, TResult>(IObservable<TSource> source, Fun
     /// <summary>Stores state for the signal implementation.</summary>
     private readonly Func<TSource, TResult> _selector = selector;
 
-    /// <summary>Executes the IsRequiredSubscribeOnCurrentThread operation.</summary>
+    /// <summary>Preserves the source's current-thread subscription requirement.</summary>
     /// <returns>The result.</returns>
     public bool IsRequiredSubscribeOnCurrentThread() =>
         _source is IRequireCurrentThread<TSource> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread();
 
-    /// <summary>Executes the Subscribe operation.</summary>
+    /// <summary>Subscribes an observer to the selected source values.</summary>
     /// <param name="observer">The observer value.</param>
     /// <returns>The result.</returns>
     public IDisposable Subscribe(IObserver<TResult> observer)
@@ -49,7 +49,7 @@ private sealed class MapWitness(IObserver<TResult> observer, Func<TSource, TResu
         /// <summary>Stores state for the signal implementation; non-zero once the sink has terminated.</summary>
         private int _stopped;
 
-        /// <summary>Executes the OnCompleted operation.</summary>
+        /// <summary>Forwards completion only while the sink is active.</summary>
         public void OnCompleted()
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
@@ -60,7 +60,7 @@ public void OnCompleted()
             _observer.OnCompleted();
         }
 
-        /// <summary>Executes the OnError operation.</summary>
+        /// <summary>Stops the sink and forwards its first error.</summary>
         /// <param name="error">The error value.</param>
         public void OnError(Exception error)
         {
@@ -72,7 +72,7 @@ public void OnError(Exception error)
             _observer.OnError(error);
         }
 
-        /// <summary>Executes the OnNext operation.</summary>
+        /// <summary>Projects active values and turns selector failures into terminal errors.</summary>
         /// <param name="value">The value.</param>
         public void OnNext(TSource value)
         {
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs b/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
index cc8c05dd..9cc1c700 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
@@ -11,8 +11,7 @@ namespace ReactiveUI.Primitives.Signals;
 [System.Diagnostics.DebuggerDisplay("ObserverHandler: Subject = {_subject}, Observer = {_observer}")]
 public sealed class ObserverHandler<T>(AsyncSignal<T> subject, IObserver<T> observer) : IDisposable
 {
-    /// <summary>Executes the new operation.</summary>
-    /// <returns>The result.</returns>
+    /// <summary>Serializes detachment from the signal.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>Stores state for the signal implementation.</summary>
@@ -22,7 +21,7 @@ public sealed class ObserverHandler<T>(AsyncSignal<T> subject, IObserver<T> obse
     /// <summary>Stores state for the signal implementation.</summary>
     private IObserver<T>? _observer = observer;
 
-    /// <summary>Executes the Dispose operation.</summary>
+    /// <summary>Detaches the observer once and releases references to both endpoints.</summary>
     public void Dispose()
     {
         lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
index ba74bbfa..a9063ac3 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
@@ -61,10 +61,7 @@ public TResult Value
     /// <summary>Gets the stream of current and subsequent values.</summary>
     public IObservable<TResult> Changed => this;
 
-    /// <summary>
-    /// Creates a projected read-only state and subscribes it to the source after construction, so the
-    /// instance is never exposed to the source while partially constructed.
-    /// </summary>
+    /// <summary>Creates a projected read-only state and subscribes it to the source after construction, so the instance is never exposed to the source while partially constructed.</summary>
     /// <param name="source">The source state signal.</param>
     /// <param name="selector">The projection applied to each source value.</param>
     /// <returns>The fully-initialized projected read-only state.</returns>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
index 72628e48..8fa1fd3b 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
@@ -45,7 +45,7 @@ public ReadOnlyState(IObservable<T> source, T initialValue)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) => _inner.Subscribe(observer);
 
-    /// <summary>Executes the Dispose operation.</summary>
+    /// <summary>Stops mirroring the source and disposes the cached state.</summary>
     public void Dispose()
     {
         _subscription.Dispose();
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
index 4edde548..b6dffb44 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
@@ -25,23 +25,13 @@ public class Signal<T> : ISignal<T>
     /// <summary>Published in place of the observers once the signal has been disposed.</summary>
     private static readonly object DisposedMarker = new();
 
-    /// <summary>
-    /// Guards observer-set and terminal-state mutations. Dispatch does not take it: subscribe, remove, and
-    /// the terminal transitions each publish one new value to <see cref="_observers"/>, and they mutate
-    /// reusable array slots in place rather than copying, so subscribe/unsubscribe churn does not allocate a
-    /// new array per change.
-    /// </summary>
+    /// <summary>Serializes observer-set and terminal-state mutations; dispatch reads the published target without this gate.</summary>
     private readonly Lock _observerLock = new();
 
     /// <summary>Stores state for the signal implementation.</summary>
     private Exception? _exception;
 
-    /// <summary>
-    /// The dispatch target, and the only field <see cref="OnNext"/> reads: <see langword="null"/> while
-    /// nobody is subscribed, the subscription itself for exactly one subscriber, the slot array for more, or
-    /// one of the terminal markers. Every shape change publishes a single new value here, so a dispatch sees
-    /// either the whole change or none of it. That is what lets the emit path run without taking the gate.
-    /// </summary>
+    /// <summary>Atomically published dispatch target: empty, one subscription, a slot array, or a terminal marker.</summary>
     private object? _observers;
 
     /// <summary>The reusable slot array backing the multi-subscriber shape, kept across an empty period.</summary>
@@ -137,11 +127,7 @@ public void OnError(Exception error)
 
     /// <summary>Called when [next].</summary>
     /// <param name="value">The value.</param>
-    /// <remarks>
-    /// One volatile read of <see cref="_observers"/> decides the whole dispatch, so emitting never takes the
-    /// observer gate. A terminal transition or a disposal publishes a marker to that same field, which is how
-    /// a stopped signal stays silent and a disposed one still throws without a lock on the emit path.
-    /// </remarks>
+    /// <remarks>Emission reads the published observer state without locking. Terminal signals ignore subsequent values; disposed signals throw.</remarks>
     public void OnNext(T value)
     {
         var observers = Volatile.Read(ref _observers);
@@ -207,7 +193,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Executes the SubscribeAction operation.</summary>
+    /// <summary>Registers a value callback, or rethrows the stored error if the signal has already failed.</summary>
     /// <param name="onNext">The onNext value.</param>
     /// <returns>The result.</returns>
     public IDisposable SubscribeAction(Action<T> onNext)
@@ -263,8 +249,7 @@ protected virtual void Dispose(bool disposing)
         {
             _exception = null;
 
-            // Set before the marker is published: the marker goes out with a release write, so a dispatch
-            // that acquires it is guaranteed to see the disposed flag its trailing check reads.
+            // The release write publishes the disposed flag with the terminal marker.
             _isDisposed = true;
             observers = ClearObserversLocked(DisposedMarker);
         }
@@ -274,13 +259,9 @@ protected virtual void Dispose(bool disposing)
 
     /// <summary>Creates the exception every use-after-disposal path throws.</summary>
     /// <returns>The exception to throw.</returns>
-    /// <remarks>
-    /// Returned rather than thrown so each caller ends in <c>throw</c>. The guard-clause shape the analyzers
-    /// require would otherwise leave every one of those methods with an epilogue nothing can reach.
-    /// </remarks>
     private static ObjectDisposedException Disposed() => new(string.Empty);
 
-    /// <summary>Executes the Completed operation.</summary>
+    /// <summary>Forwards completion to each subscription in the captured observer snapshot.</summary>
     /// <param name="observers">The observer shape captured while the signal was still running.</param>
     private static void Completed(object? observers)
     {
@@ -301,7 +282,7 @@ private static void Completed(object? observers)
         }
     }
 
-    /// <summary>Executes the Error operation.</summary>
+    /// <summary>Forwards an error to each subscription in the captured observer snapshot.</summary>
     /// <param name="observers">The observer shape captured while the signal was still running.</param>
     /// <param name="exception">The exception value.</param>
     private static void Error(object? observers, Exception exception)
@@ -323,7 +304,7 @@ private static void Error(object? observers, Exception exception)
         }
     }
 
-    /// <summary>Executes the HasActionSubscribers operation.</summary>
+    /// <summary>Checks whether the captured snapshot contains any value-only callback subscriptions.</summary>
     /// <param name="observers">The observer shape captured while the signal was still running.</param>
     /// <returns>The result.</returns>
     private static bool HasActionSubscribers(object? observers)
@@ -349,7 +330,7 @@ private static bool HasActionSubscribers(object? observers)
         return false;
     }
 
-    /// <summary>Executes the DisposeSubscriptions operation.</summary>
+    /// <summary>Detaches each subscription in the captured observer snapshot.</summary>
     /// <param name="observers">The observer shape captured before disposal.</param>
     private static void DisposeSubscriptions(object? observers)
     {
@@ -370,7 +351,7 @@ private static void DisposeSubscriptions(object? observers)
         }
     }
 
-    /// <summary>Executes the DispatchSubscriptions operation.</summary>
+    /// <summary>Forwards a value to each occupied subscription slot.</summary>
     /// <param name="subscriptions">The subscription snapshot, which the observer field only ever holds non-null.</param>
     /// <param name="value">The value.</param>
     private static void DispatchSubscriptions(SignalSubscription?[] subscriptions, T value)
@@ -401,7 +382,7 @@ private void DispatchToSlots(SignalSubscription?[] subscriptions, T value)
         throw Disposed();
     }
 
-    /// <summary>Executes the ThrowIfDisposed operation.</summary>
+    /// <summary>Rejects operations after the signal has been disposed.</summary>
     private void ThrowIfDisposed()
     {
         if (!IsDisposed)
@@ -484,7 +465,7 @@ private void AddSubscriptionLocked(SignalSubscription subscription)
         return observers;
     }
 
-    /// <summary>Executes the Remove operation.</summary>
+    /// <summary>Removes a subscription while holding the observer lock.</summary>
     /// <param name="subscription">The subscription value.</param>
     private void Remove(SignalSubscription subscription)
     {
@@ -504,14 +485,9 @@ private void Remove(SignalSubscription subscription)
         }
     }
 
-    /// <summary>Removes an array-backed subscription, keeping the array for the next subscriber.</summary>
+    /// <summary>Removes a subscription from its owning slot array.</summary>
     /// <param name="slots">The active slot array.</param>
     /// <param name="subscription">The subscription value.</param>
-    /// <remarks>
-    /// A subscription disposes itself once and only ever sits in the array it was added to, so the search
-    /// always finds it. The index guard is what keeps that assumption from corrupting the slot array if it
-    /// ever stops holding.
-    /// </remarks>
     private void RemoveFromSlotsLocked(SignalSubscription?[] slots, SignalSubscription subscription)
     {
         var index = Array.IndexOf(slots, subscription);
@@ -577,8 +553,6 @@ public SignalSubscription(Signal<T> subject, Action<T> onNext)
         /// <param name="value">The value.</param>
         public void OnNext(T value)
         {
-            // Branch on a null check of the typed fields rather than an `is Action<T>` test plus cast: this runs
-            // once per observer per value on the multicast dispatch hot path, where that overhead is measurable.
             var observer = _observer;
             if (observer is not null)
             {
@@ -598,7 +572,7 @@ public void OnNext(T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted() => _observer?.OnCompleted();
 
-        /// <summary>Executes the Dispose operation.</summary>
+        /// <summary>Detaches this subscription once.</summary>
         public void Dispose()
         {
             var subject = Interlocked.Exchange(ref _subject, null);
diff --git a/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs b/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
index 6a1f3786..77456a7c 100644
--- a/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
+++ b/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
@@ -38,10 +38,7 @@ public void Rethrow()
     /// <param name="source">Signals sequence to subscribe to.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Subscribes to the Signals sequence without specifying any handlers.
-        /// This method can be used to evaluate the Signals sequence for its side-effects only.
-        /// </summary>
+        /// <summary>Subscribes to the Signals sequence without specifying any handlers. This method can be used to evaluate the Signals sequence for its side-effects only.</summary>
         /// <returns><see cref="IDisposable"/> object used to unsubscribe from the Signals sequence.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <c>null</c>.</exception>
         public IDisposable Subscribe()
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
index dd3a3bce..eb6c9e1c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
@@ -68,8 +68,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return subscription;
     }
 
-    /// <summary>Clears the lazy enumerator. Caller must hold <see cref="_gate"/> on the production
-    /// paths; exposed to internal tests that exercise the idempotent-second-call branch.</summary>
+    /// <summary>Clears the lazy enumerator. Caller must hold <see cref="_gate"/> on the production paths; exposed to internal tests that exercise the idempotent-second-call branch.</summary>
     internal void ClearRator()
     {
         _rator?.Dispose();
@@ -92,7 +91,7 @@ internal void PullNextTask(IObserver<T> observer) =>
         "PSH1315:A blocking wait on an awaitable that may not be done",
         Justification =
             "Task is guaranteed complete at this call site (IsFaulted/IsCanceled were both false above); reading .Result drives the synchronous IObserver<T> contract without blocking.")]
-    private void ProcessTaskCompletion(Subscription subscription, Task<T> completed)
+    internal void ProcessTaskCompletion(Subscription subscription, Task<T> completed)
     {
         lock (_gate)
         {
@@ -152,9 +151,7 @@ private void PullNextTask(Subscription subscription)
 
             _outstanding++;
 
-            // The continuation passes the Subscription as state — already a reference type, so
-            // no per-task ValueTuple boxing is needed. The static lambda preserves zero closure
-            // capture.
+            // The subscription carries continuation state without boxing or closure capture.
             _rator.Current?.ContinueWith(
                 static (ant, state) =>
                 {
@@ -168,9 +165,7 @@ private void PullNextTask(Subscription subscription)
         }
     }
 
-    /// <summary>Per-subscription handle: holds the observer reference and a disposal latch.
-    /// Replaces the previous <c>ActionDisposable(() =&gt; Disposed = true)</c> pattern with a
-    /// dedicated class — no closure object per subscribe.</summary>
+    /// <summary>Holds the observer and prevents notification delivery after disposal.</summary>
     /// <param name="limiter">The owning limiter.</param>
     /// <param name="observer">The downstream observer.</param>
     internal sealed class Subscription(ConcurrencyLimiter<T> limiter, IObserver<T> observer) : IDisposable
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
index 42b258ac..2782b64e 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
@@ -100,10 +100,7 @@ protected virtual async void Dispose(bool disposing)
     private static void SignalPhaseSync(object? state) =>
         ((Continuation)state!)._phaseSync.SignalAndWait(CancellationToken.None);
 
-    /// <summary>Schedules <see cref="SignalPhaseSync"/> on the default task scheduler. Hoisted
-    /// out of the <see cref="Lock{T}"/> and <see cref="UnLock"/> call sites because cobertura
-    /// tags the multi-argument <c>Task.Factory.StartNew(...)</c> call as a branch line — the
-    /// per-call overload-resolution metadata is collapsed here so it counts once.</summary>
+    /// <summary>Schedules an action on the default task scheduler.</summary>
     /// <returns>The task representing the scheduled signal work.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private Task ScheduleSignalPhase() =>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs b/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
index 8ca39789..849d22c4 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
@@ -7,15 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Thread-safe subject that holds the most-recently-emitted value, replays it to new subscribers,
-/// and broadcasts subsequent emissions. Per-emission hot path:
-/// <list type="bullet">
-///   <item>Lock taken only to read the current observer state and update the cached value.</item>
-///   <item>Single-observer state lives in a dedicated field — no array allocated for the common case.</item>
-///   <item>Multi-observer state uses a copy-on-write <c>IObserver{T}[]</c> snapshot iterated outside the lock.</item>
-/// </list>
-/// </summary>
+/// <summary>Stores the latest value, replays it to new subscribers, and broadcasts updates outside the state lock.</summary>
 /// <typeparam name="T">The element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("CurrentValueSubject: Value = {_value}, Completed = {_completed}, Disposed = {_disposed}")]
 public sealed class CurrentValueSubject<T> : IObservable<T>, IObserver<T>, IDisposable
@@ -256,11 +248,7 @@ private void Unsubscribe(IObserver<T> observer)
                 return;
             }
 
-            // Subscription.Dispose's Interlocked guard means a given observer reaches Unsubscribe
-            // at most once, and Subscribe ensures that observer is present in _observers before
-            // returning. OnError / OnCompleted / Dispose nullify _observers atomically, which the
-            // is-null check above already short-circuits — so when we get here, IndexOf finds the
-            // observer by construction.
+            // A subscription removes its registered observer at most once.
             var index = Array.IndexOf(existing, observer);
 
             if (existing.Length == 2)
@@ -286,10 +274,7 @@ private void Unsubscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Per-subscription handle that detaches the observer on dispose. Idempotency is
-    /// enforced via <see cref="Interlocked.Exchange{T}(ref T, T)"/> on <see cref="_observer"/> —
-    /// the second dispose sees <see langword="null"/> and returns. Eliminates the previous
-    /// dedicated <c>_disposed</c> int and shaves a field off every subscription.</summary>
+    /// <summary>Atomically clears its observer reference to detach exactly once.</summary>
     /// <param name="parent">The owning subject.</param>
     /// <param name="observer">The observer to detach.</param>
     private sealed class Subscription(CurrentValueSubject<T> parent, IObserver<T> observer) : IDisposable
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
index 161c4021..876b034d 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
@@ -4,14 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Internal;
 
-/// <summary>
-/// Pure helpers for the two recurring race-claim primitives in the async layer:
-/// the "first caller wins" <see cref="Interlocked.CompareExchange(ref int, int, int)"/>
-/// transition used by <c>PooledDelaySource</c>, and the "tolerate already-disposed CTS"
-/// <c>CancellationTokenSource.CancelAsync</c> wrapper used by <c>ObserverAsync</c>'s
-/// dispose path. Both are pure functions over their inputs and are directly RxVoid-tested
-/// against this class.
-/// </summary>
+/// <summary>Claims one-time transitions and tolerates cancellation of disposed token sources.</summary>
 internal static class ConcurrencyRaceHelpers
 {
     /// <summary>
@@ -29,13 +22,7 @@ internal static class ConcurrencyRaceHelpers
     internal static bool TryClaim(ref int state, int openSentinel, int claimedSentinel) =>
         Interlocked.CompareExchange(ref state, claimedSentinel, openSentinel) == openSentinel;
 
-    /// <summary>
-    /// Calls <c>CancellationTokenSource.CancelAsync</c> on <paramref name="cts"/>,
-    /// tolerating the <see cref="ObjectDisposedException"/> that another concurrent dispose
-    /// may have already raced ahead with. Returns <see langword="true"/> if the cancellation
-    /// went through; <see langword="false"/> if another caller had already cancelled-and-
-    /// disposed the source.
-    /// </summary>
+    /// <summary>Cancels the source asynchronously, tolerating concurrent disposal.</summary>
     /// <param name="cts">The cancellation token source to cancel.</param>
     /// <returns>
     /// <see langword="true"/> if the cancellation completed; <see langword="false"/> if the
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
index a7514283..f82aca30 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
@@ -7,21 +7,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Internal;
 
-/// <summary>
-/// Shared subscription loop for sync operators that fan an indexed callback set across an N-source
-/// list (e.g. <c>BooleanReduceObservable</c>, <c>MinMaxObservable</c>). Each call site previously
-/// hand-rolled the same loop — index-capture, <see cref="ObservableSubscribeExtensions.SubscribeCallbacks{T}"/>
-/// triple, <see cref="DisposableBag"/> aggregate — so centralising it here keeps the per-emission
-/// closure shape consistent and the duplication off Sonar's CPD radar.
-/// </summary>
+/// <summary>Subscribes indexed callbacks to each source and aggregates the subscription handles.</summary>
 internal static class IndexedSubscribeHelper
 {
-    /// <summary>
-    /// Subscribes the supplied callbacks to every source in <paramref name="sources"/>, threading
-    /// each source's positional index through to the <paramref name="onNext"/> and
-    /// <paramref name="onCompleted"/> hooks. The returned disposable disposes every per-source
-    /// subscription on dispose.
-    /// </summary>
+    /// <summary>Subscribes callbacks carrying each source's index and returns a handle that disposes all subscriptions.</summary>
     /// <typeparam name="T">The element type of the source observables.</typeparam>
     /// <param name="sources">The source observables, indexed 0..N-1.</param>
     /// <param name="onNext">Per-source OnNext hook: <c>(index, value)</c>.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
index 72c5ad82..921ca609 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
@@ -14,12 +14,7 @@ internal static class ObservableSubscribeExtensions
     /// <param name="source">The source observable.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>
-        /// Subscribes using delegate callbacks for OnNext / OnError / OnCompleted. Unique name to
-        /// avoid the System.Reactive <c>Subscribe(onNext, onError, onCompleted)</c> ambiguity; the
-        /// delegates are wrapped by the core <see cref="SubscribeExtensions"/> sink rather than a
-        /// duplicated observer.
-        /// </summary>
+        /// <summary>Subscribes delegate callbacks through the core sink; the distinct name avoids ambiguity with System.Reactive extensions.</summary>
         /// <param name="onNext">Per-value callback.</param>
         /// <param name="onError">Error callback.</param>
         /// <param name="onCompleted">Completion callback.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
index 3b84df37..bb3123fc 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
@@ -4,12 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Internal;
 
-/// <summary>
-/// Shared synchronous reduce-sink state used by <c>BooleanReduceObservable</c> (AllTrue / AllFalse)
-/// and <c>MinMaxObservable</c> (Max / Min). Each per-operator sink composes one instance (has-a, not
-/// is-a) and adds only its operator-specific OnNext reduce step; the boilerplate gate, value cache,
-/// completion bookkeeping, OnError, and OnCompleted bodies all live here in one place.
-/// </summary>
+/// <summary>Stores synchronized reduction state and coordinates terminal notifications.</summary>
 /// <typeparam name="TIn">The source element type (must be a struct so <c>TIn?</c> doubles as the
 /// "value seen yet?" Optional).</typeparam>
 /// <typeparam name="TOut">The downstream element type the operator emits after reducing.</typeparam>
@@ -95,10 +90,7 @@ internal void HandleError(Exception error)
         }
     }
 
-    /// <summary>
-    /// Records completion of the source at <paramref name="index"/>. The combined sequence terminates
-    /// once every source has completed OR a source completes without ever having emitted a value.
-    /// </summary>
+    /// <summary>Records source completion, terminating when all sources complete or one completes without a value.</summary>
     /// <param name="index">The 0-based source index that just completed.</param>
     internal void HandleCompleted(int index)
     {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
index 2b1a05b2..eb36b262 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
@@ -88,11 +88,7 @@ private static IReadOnlyList<IObservable<bool>> MaterializeSources(IEnumerable<I
         return trimmed;
     }
 
-    /// <summary>
-    /// Sink that holds the latest value per source and reduces them against <paramref name="target"/>.
-    /// Composes <see cref="ReduceSinkState{TIn, TOut}"/> for the shared gate / value cache / OnError /
-    /// OnCompleted plumbing so this class carries only the per-operator reduce step.
-    /// </summary>
+    /// <summary>Compares each source's latest value with the target using shared value and terminal state.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="count">The number of sources.</param>
     /// <param name="target">The value every source must hold for emit to be <c>true</c>.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
index 8bf50b12..137c4edb 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Catches the configured exception type, emits a fallback built from the exception, and completes.
-/// Other exception types propagate downstream.
-/// </summary>
+/// <summary>Catches the configured exception type, emits a fallback built from the exception, and completes. Other exception types propagate downstream.</summary>
 /// <typeparam name="T">Element type.</typeparam>
 /// <typeparam name="TException">Exception type to catch.</typeparam>
 /// <param name="source">Upstream source.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
index 1e996a4c..93d4ba87 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
@@ -22,11 +22,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DoOnDisposeSubscription(source.Subscribe(observer), disposeAction);
     }
 
-    /// <summary>
-    /// Per-subscribe disposal handle that forwards <see cref="IDisposable.Dispose"/> to the source
-    /// subscription and then to the caller-supplied action. Dedicated class instead of the
-    /// previous <c>ActionDisposable(() =&gt; …)</c> form so no closure is allocated per subscribe.
-    /// </summary>
+    /// <summary>Disposes the upstream subscription, then invokes the action exactly once.</summary>
     /// <param name="subscription">The upstream subscription disposed before the action fires.</param>
     /// <param name="disposeAction">The action executed once after the upstream is disposed.</param>
     private sealed class DoOnDisposeSubscription(IDisposable subscription, Action disposeAction) : IDisposable
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
index ea38cf77..8f18f0ee 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
@@ -1,22 +1,16 @@
 // Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
 // ReactiveUI Association Incorporated 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;
 using ReactiveUI.Primitives.Disposables;
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Operator that drops source elements while an asynchronous action is in progress.
-/// Replaces the closure-based implementation in ReactiveExtensions.DropIfBusy.
-/// </summary>
-/// <typeparam name="T">The element type.</typeparam>
-/// <param name="source">The source observable.</param>
-/// <param name="asyncAction">The asynchronous action to execute for each forwarded element.</param>
-public sealed class DropIfBusyObservable<T>(
-    IObservable<T> source,
-    Func<T, ValueTask> asyncAction) : IObservable<T>
+/// <summary>Operator that drops source elements while an asynchronous action is in progress. Replaces the closure-based implementation in ReactiveExtensions.DropIfBusy.</summary>
+/// <typeparam name = "T">The element type.</typeparam>
+/// <param name = "source">The source observable.</param>
+/// <param name = "asyncAction">The asynchronous action to execute for each forwarded element.</param>
+public sealed class DropIfBusyObservable<T>(IObservable<T> source, Func<T, ValueTask> asyncAction) : IObservable<T>
 {
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<T> observer)
@@ -29,12 +23,10 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DisposableBag(sub, sink);
     }
 
-    /// <summary>Sink that manages the busy state and executes the async action.</summary>
-    /// <param name="downstream">The downstream observer.</param>
-    /// <param name="asyncAction">The async action to run.</param>
-    private sealed class DropIfBusySink(
-        IObserver<T> downstream,
-        Func<T, ValueTask> asyncAction) : IObserver<T>, IDisposable
+    /// <summary>Processes source values and owns the subscription state.</summary>
+    /// <param name = "downstream">The downstream observer.</param>
+    /// <param name = "asyncAction">The asynchronous operation.</param>
+    internal sealed class DropIfBusySink(IObserver<T> downstream, Func<T, ValueTask> asyncAction) : IObserver<T>, IDisposable
     {
         /// <summary>0 = idle, 1 = busy.</summary>
         private int _isBusy;
@@ -43,21 +35,8 @@ private sealed class DropIfBusySink(
         private int _done;
 
         /// <inheritdoc/>
-        public void OnNext(T value)
-        {
-            if (Volatile.Read(ref _done) != 0)
-            {
-                return;
-            }
-
-            // If we can transition from 0 to 1, we handle this value.
-            if (Interlocked.CompareExchange(ref _isBusy, 1, 0) != 0)
-            {
-                return;
-            }
-
-            _ = ProcessAsync(value);
-        }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public void OnNext(T value) => _ = OnNextAsync(value);
 
         /// <inheritdoc/>
         public void OnError(Exception error)
@@ -81,8 +60,24 @@ public void OnCompleted()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose() => Volatile.Write(ref _done, 1);
 
+        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <param name = "value">The source value.</param>
+        /// <returns>The processing task, or a completed task when no work starts.</returns>
+        internal Task OnNextAsync(T value)
+        {
+            if (Volatile.Read(ref _done) != 0)
+            {
+                return Task.CompletedTask;
+            }
+
+            // If we can transition from 0 to 1, we handle this value.
+            return Interlocked.CompareExchange(ref _isBusy, 1, 0) != 0
+                ? Task.CompletedTask
+                : ProcessAsync(value);
+        }
+
         /// <summary>Executes the async action and manages the busy state transition.</summary>
-        /// <param name="value">The value to process.</param>
+        /// <param name = "value">The value to process.</param>
         /// <returns>A task representing the async operation.</returns>
         private async Task ProcessAsync(T value)
         {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
index 827ed604..c6af7913 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Operator that filters string elements using a <see cref="Regex"/>. Replaces the closure-based implementation in ReactiveExtensions.Filter.</summary>
+/// <summary>Filters strings using a regular expression and forwards matching errors to the observer.</summary>
 /// <param name="source">The source observable emitting strings.</param>
 /// <param name="regex">The regex to use for filtering.</param>
 public sealed class FilterRegexObservable(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
index fc5ea674..eaac15fc 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
@@ -8,12 +8,8 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Walks a list of candidate keys sequentially, projects each into a one-shot
-/// <see cref="IObservable{TRaw}"/>, transforms the raw value into
-/// <typeparamref name="TResult"/>, and emits the first transformed value that
-/// satisfies a predicate. Errors from individual projections are swallowed (the
-/// candidate is skipped and the next one is tried). If no candidate matches,
-/// completes with a single emission of <paramref name="fallback"/>.
+/// Projects candidates sequentially and emits the first transformed value satisfying the predicate.
+/// Projection errors skip the candidate. If none matches, emits the fallback value and completes.
 /// </summary>
 /// <typeparam name="TKey">The type of candidate keys.</typeparam>
 /// <typeparam name="TRaw">The element type emitted by the projected observable.</typeparam>
@@ -23,13 +19,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="transform">Synchronous transform applied to each raw value to produce the result.</param>
 /// <param name="predicate">Returns <see langword="true"/> when a transformed value is a match.</param>
 /// <param name="fallback">Value emitted when no candidate matches.</param>
-/// <remarks>
-/// <c>Subscribe</c> attempts a synchronous fast-path first: each candidate's
-/// projection is subscribed and, if it completes inline, the transform + predicate
-/// run on the calling thread with zero additional allocations. Only when a
-/// projection completes asynchronously does the method allocate an
-/// <see cref="AsyncSink"/> to track state across callbacks.
-/// </remarks>
+/// <remarks>Synchronous projections run on the caller's thread. Asynchronous projections retain their state until callbacks complete.</remarks>
 public sealed class FirstMatchFromCandidatesObservable<TKey, TRaw, TResult>(
     IReadOnlyList<TKey> candidates,
     Func<TKey, IObservable<TRaw>> project,
@@ -61,10 +51,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
     /// <returns>The subscription disposable.</returns>
     internal IDisposable TrySyncLoop(IObserver<TResult> observer)
     {
-        // Reuse the SyncProbe across subscribes on the current thread — it carries no
-        // per-call state once Reset, so per-cycle allocation drops to zero on the fast path.
-        // Race-free because the field is [ThreadStatic]; only one TrySyncLoop call can be
-        // active per thread.
+        // The thread-local probe is reset between subscriptions.
         var probe = SyncProbe.RentForCurrentThread();
 
         for (var i = 0; i < candidates.Count; i++)
@@ -125,8 +112,7 @@ internal IDisposable TrySyncLoop(IObserver<TResult> observer)
     [System.Diagnostics.DebuggerDisplay("SyncProbe: Completed = {Completed}, HasValue = {HasValue}, Value = {Value}")]
     public sealed class SyncProbe : IObserver<TRaw>
     {
-        /// <summary>Per-thread cached instance; rented on entry to <c>TrySyncLoop</c> and returned
-        /// on exit. Eliminates the per-subscribe allocation on the fast path.</summary>
+        /// <summary>Per-thread cached instance; rented on entry to <c>TrySyncLoop</c> and returned on exit. Eliminates the per-subscribe allocation on the fast path.</summary>
         [ThreadStatic]
         private static SyncProbe? _cached;
 
@@ -188,10 +174,7 @@ internal void Reset()
         }
     }
 
-    /// <summary>
-    /// Heap-allocated observer used when a projection does not complete synchronously.
-    /// Walks the remaining candidates via async callbacks.
-    /// </summary>
+    /// <summary>Heap-allocated observer used when a projection does not complete synchronously. Walks the remaining candidates via async callbacks.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="candidates">The candidate list.</param>
     /// <param name="project">The projection delegate.</param>
@@ -346,12 +329,7 @@ internal void TryNext()
             downstream.OnCompleted();
         }
 
-        /// <summary>
-        /// Forwarding <see cref="IObserver{TRaw}"/> that records whether a terminal notification
-        /// (<c>OnError</c> / <c>OnCompleted</c>) arrived synchronously during the <c>Subscribe</c>
-        /// call. Replaces the prior <c>_syncCompleted</c> field on <see cref="AsyncSink"/> so the
-        /// flag is per-iteration state rather than instance state.
-        /// </summary>
+        /// <summary>Forwards notifications and records synchronous termination for one candidate subscription.</summary>
         /// <param name="inner">The wrapped sink that receives forwarded notifications.</param>
         private sealed class CompletionFlagWitness(IObserver<TRaw> inner) : IObserver<TRaw>
         {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
index 0bdd4c0a..d5570e6c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
@@ -102,9 +102,7 @@ public void Dispose()
 
             lock (_parent._gate)
             {
-                // Invariant: a Subscription whose Interlocked.Exchange just transitioned _disposed
-                // from 0 to 1 was created by Subscribe under the same lock, which sets _sink
-                // before returning — so _sink is non-null here by construction.
+                // Subscribe assigns the sink under this lock before returning the handle.
                 _parent._sink!.Remove(_observer, _side);
                 _parent._subscriptionCount--;
                 if (_parent._subscriptionCount == 0)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
index f278aeb4..7db5bebc 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
@@ -6,14 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Fused replacement for
-/// <c>Observable.FromEventPattern(...).Where(name match).Select(getter).StartWith(getter)</c>.
-/// Subscribes directly to <see cref="INotifyPropertyChanged.PropertyChanged"/>, holds the
-/// compiled getter once at construction (the original chain compiled it twice per
-/// subscription), and emits the current value on subscribe followed by the getter
-/// result for each matching property change — all through a single sink.
-/// </summary>
+/// <summary>Emits the current property value on subscription, then invokes the shared getter for matching property changes.</summary>
 /// <typeparam name="T">The owning type that raises <see cref="INotifyPropertyChanged.PropertyChanged"/>.</typeparam>
 /// <typeparam name="TProperty">The property element type.</typeparam>
 /// <param name="source">The owning instance.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
index c40010db..87381ba5 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
@@ -5,10 +5,8 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Emits a stored initial value to every new subscriber, then forwards subsequent emissions from the
-/// shared source. Each subscriber gets its own independent subscription to the source; the per-subscriber
-/// replay is the fixed <c>initialValue</c> supplied at construction (matching the legacy BehaviorSubject
-/// semantics — late subscribers do NOT see the latest value emitted to earlier subscribers).
+/// Emits the fixed initial value to each subscriber, then subscribes independently to the source.
+/// Late subscribers receive that initial value, not a cached source emission.
 /// </summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
index 12ac76be..ed6d5d89 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
@@ -1,21 +1,17 @@
 // Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
-
 using ReactiveUI.Primitives.Disposables;
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>Projects each element to an asynchronous operation with limited concurrency.</summary>
-/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
-/// <param name="source">The source observable.</param>
-/// <param name="selector">The asynchronous projection function.</param>
-/// <param name="maxConcurrency">The maximum number of concurrent operations.</param>
-public sealed class SelectAsyncConcurrentObservable<TSource, TResult>(
-    IObservable<TSource> source,
-    Func<TSource, Task<TResult>> selector,
-    int maxConcurrency) : IObservable<TResult>
+/// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name = "source">The source observable.</param>
+/// <param name = "selector">The asynchronous projection function.</param>
+/// <param name = "maxConcurrency">The maximum number of concurrent operations.</param>
+public sealed class SelectAsyncConcurrentObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector, int maxConcurrency) : IObservable<TResult>
 {
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<TResult> observer)
@@ -23,20 +19,16 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(source);
         InvalidOperationExceptionHelper.ThrowIfNull(selector);
         ArgumentExceptionHelper.ThrowIfNull(observer);
-
         SelectAsyncConcurrentSink sink = new(observer, selector, maxConcurrency);
         var sub = source.Subscribe(sink);
         return new DisposableBag(sub, sink);
     }
 
-    /// <summary>Sink that manages concurrent async projection.</summary>
-    /// <param name="downstream">The downstream observer.</param>
-    /// <param name="selector">The async selector.</param>
-    /// <param name="maxConcurrency">The maximum concurrency.</param>
-    private sealed class SelectAsyncConcurrentSink(
-        IObserver<TResult> downstream,
-        Func<TSource, Task<TResult>> selector,
-        int maxConcurrency) : IObserver<TSource>, IDisposable
+    /// <summary>Processes source values and owns the subscription state.</summary>
+    /// <param name = "downstream">The downstream observer.</param>
+    /// <param name = "selector">The asynchronous operation.</param>
+    /// <param name = "maxConcurrency">The maximum concurrency.</param>
+    internal sealed class SelectAsyncConcurrentSink(IObserver<TResult> downstream, Func<TSource, Task<TResult>> selector, int maxConcurrency) : IObserver<TSource>, IDisposable
     {
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
@@ -54,19 +46,8 @@ private sealed class SelectAsyncConcurrentSink(
         private bool _disposed;
 
         /// <inheritdoc/>
-        public void OnNext(TSource value)
-        {
-            lock (_gate)
-            {
-                if (_done || _disposed)
-                {
-                    return;
-                }
-
-                _queue.Enqueue(value);
-                TryProcessNext();
-            }
-        }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public void OnNext(TSource value) => _ = OnNextAsync(value);
 
         /// <inheritdoc/>
         public void OnError(Exception error)
@@ -110,19 +91,43 @@ public void Dispose()
             }
         }
 
+        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <param name = "value">The source value.</param>
+        /// <returns>The processing task, or a completed task when no work starts.</returns>
+        internal Task OnNextAsync(TSource value)
+        {
+            Task processing;
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return Task.CompletedTask;
+                }
+
+                _queue.Enqueue(value);
+                processing = TryProcessNext();
+            }
+
+            return processing;
+        }
+
         /// <summary>Attempts to process the next value in the queue.</summary>
-        private void TryProcessNext()
+        /// <returns>The last operation started, or a completed task when the queue cannot advance.</returns>
+        private Task TryProcessNext()
         {
+            var processing = Task.CompletedTask;
             while (_running < maxConcurrency && _queue.Count > 0)
             {
                 var value = _queue.Dequeue();
                 _running++;
-                _ = ProcessAsync(value);
+                processing = ProcessAsync(value);
             }
+
+            return processing;
         }
 
         /// <summary>Processes the async operation.</summary>
-        /// <param name="value">The value to project.</param>
+        /// <param name = "value">The value to project.</param>
         /// <returns>A task representing the operation.</returns>
         private async Task ProcessAsync(TSource value)
         {
@@ -161,7 +166,7 @@ private async Task ProcessAsync(TSource value)
                         }
                         else
                         {
-                            TryProcessNext();
+                            _ = TryProcessNext();
                         }
                     }
                 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
index b49a7378..dbe6a704 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
@@ -1,19 +1,16 @@
 // Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
-
 using ReactiveUI.Primitives.Disposables;
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>Projects each element to an asynchronous operation, preserving order and handling sequential execution.</summary>
-/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
-/// <param name="source">The source observable.</param>
-/// <param name="selector">The asynchronous projection function.</param>
-public sealed class SelectAsyncSequentialObservable<TSource, TResult>(
-    IObservable<TSource> source,
-    Func<TSource, Task<TResult>> selector) : IObservable<TResult>
+/// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name = "source">The source observable.</param>
+/// <param name = "selector">The asynchronous projection function.</param>
+public sealed class SelectAsyncSequentialObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector) : IObservable<TResult>
 {
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<TResult> observer)
@@ -21,18 +18,15 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(source);
         InvalidOperationExceptionHelper.ThrowIfNull(selector);
         ArgumentExceptionHelper.ThrowIfNull(observer);
-
         SelectAsyncSequentialSink sink = new(observer, selector);
         var sub = source.Subscribe(sink);
         return new DisposableBag(sub, sink);
     }
 
-    /// <summary>Sink that manages sequential async projection.</summary>
-    /// <param name="downstream">The downstream observer.</param>
-    /// <param name="selector">The async selector.</param>
-    private sealed class SelectAsyncSequentialSink(
-        IObserver<TResult> downstream,
-        Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
+    /// <summary>Processes source values and owns the subscription state.</summary>
+    /// <param name = "downstream">The downstream observer.</param>
+    /// <param name = "selector">The asynchronous operation.</param>
+    internal sealed class SelectAsyncSequentialSink(IObserver<TResult> downstream, Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
     {
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
@@ -50,23 +44,8 @@ private sealed class SelectAsyncSequentialSink(
         private bool _disposed;
 
         /// <inheritdoc/>
-        public void OnNext(TSource value)
-        {
-            lock (_gate)
-            {
-                if (_done || _disposed)
-                {
-                    return;
-                }
-
-                _queue.Enqueue(value);
-                if (!_isProcessing)
-                {
-                    _isProcessing = true;
-                    _ = ProcessNextAsync();
-                }
-            }
-        }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public void OnNext(TSource value) => _ = OnNextAsync(value);
 
         /// <inheritdoc/>
         public void OnError(Exception error)
@@ -110,6 +89,30 @@ public void Dispose()
             }
         }
 
+        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <param name = "value">The source value.</param>
+        /// <returns>The processing task, or a completed task when no work starts.</returns>
+        internal Task OnNextAsync(TSource value)
+        {
+            var processing = Task.CompletedTask;
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return Task.CompletedTask;
+                }
+
+                _queue.Enqueue(value);
+                if (!_isProcessing)
+                {
+                    _isProcessing = true;
+                    processing = ProcessNextAsync();
+                }
+            }
+
+            return processing;
+        }
+
         /// <summary>Processes the next value in the queue.</summary>
         /// <returns>A task representing the operation.</returns>
         private async Task ProcessNextAsync()
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
index 78c56b55..13e4b11d 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
@@ -28,10 +28,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return source.Subscribe(new SelectConstantWitness(observer, constant));
     }
 
-    /// <summary>
-    /// Forwarding observer that replaces every <see cref="OnNext"/> value with
-    /// the stored constant. Error and completion signals pass through unchanged.
-    /// </summary>
+    /// <summary>Forwarding observer that replaces every <see cref="OnNext"/> value with the stored constant. Error and completion signals pass through unchanged.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="constant">The constant value to emit.</param>
     private sealed class SelectConstantWitness(IObserver<TResult> downstream, TResult constant) : IObserver<TSource>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
index 7385798a..3b43bb5c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
@@ -1,19 +1,16 @@
 // Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
-
 using ReactiveUI.Primitives.Disposables;
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>Projects each element to an asynchronous operation, but only the result of the latest operation is emitted.</summary>
-/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
-/// <param name="source">The source observable.</param>
-/// <param name="selector">The asynchronous projection function.</param>
-public sealed class SelectLatestAsyncObservable<TSource, TResult>(
-    IObservable<TSource> source,
-    Func<TSource, Task<TResult>> selector) : IObservable<TResult>
+/// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name = "source">The source observable.</param>
+/// <param name = "selector">The asynchronous projection function.</param>
+public sealed class SelectLatestAsyncObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector) : IObservable<TResult>
 {
     /// <inheritdoc/>
     public IDisposable Subscribe(IObserver<TResult> observer)
@@ -21,18 +18,15 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(source);
         InvalidOperationExceptionHelper.ThrowIfNull(selector);
         ArgumentExceptionHelper.ThrowIfNull(observer);
-
         SelectLatestAsyncSink sink = new(observer, selector);
         var sub = source.Subscribe(sink);
         return new DisposableBag(sub, sink);
     }
 
-    /// <summary>Sink that manages the latest async projection.</summary>
-    /// <param name="downstream">The downstream observer.</param>
-    /// <param name="selector">The async selector.</param>
-    private sealed class SelectLatestAsyncSink(
-        IObserver<TResult> downstream,
-        Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
+    /// <summary>Processes source values and owns the subscription state.</summary>
+    /// <param name = "downstream">The downstream observer.</param>
+    /// <param name = "selector">The asynchronous operation.</param>
+    internal sealed class SelectLatestAsyncSink(IObserver<TResult> downstream, Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
     {
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
@@ -53,25 +47,8 @@ private sealed class SelectLatestAsyncSink(
         private bool _disposed;
 
         /// <inheritdoc/>
-        public void OnNext(TSource value)
-        {
-            long id;
-            lock (_gate)
-            {
-                if (_sourceCompleted || _disposed)
-                {
-                    return;
-                }
-
-                id = ++_currentId;
-            }
-
-            var task = ProcessAsync(value, id);
-            lock (_gate)
-            {
-                _latestTask = task;
-            }
-        }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public void OnNext(TSource value) => _ = OnNextAsync(value);
 
         /// <inheritdoc/>
         public void OnError(Exception error)
@@ -110,10 +87,7 @@ public void OnCompleted()
                 return;
             }
 
-            _ = toAwait.ContinueWith(
-                static (_, s) => ((SelectLatestAsyncSink)s!).SignalCompleted(),
-                this,
-                TaskScheduler.Default);
+            _ = toAwait.ContinueWith(static (_, s) => ((SelectLatestAsyncSink)s!).SignalCompleted(), this, TaskScheduler.Default);
         }
 
         /// <inheritdoc/>
@@ -125,8 +99,33 @@ public void Dispose()
             }
         }
 
+        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <param name = "value">The source value.</param>
+        /// <returns>The processing task, or a completed task when no work starts.</returns>
+        internal Task OnNextAsync(TSource value)
+        {
+            long id;
+            lock (_gate)
+            {
+                if (_sourceCompleted || _disposed)
+                {
+                    return Task.CompletedTask;
+                }
+
+                id = ++_currentId;
+            }
+
+            var task = ProcessAsync(value, id);
+            lock (_gate)
+            {
+                _latestTask = task;
+            }
+
+            return task;
+        }
+
         /// <summary>Signals downstream completion exactly once after the latest projection has finished.</summary>
-        private void SignalCompleted()
+        internal void SignalCompleted()
         {
             lock (_gate)
             {
@@ -141,8 +140,8 @@ private void SignalCompleted()
         }
 
         /// <summary>Processes the async operation and checks for latest ID.</summary>
-        /// <param name="value">The value to project.</param>
-        /// <param name="id">The ID of this operation.</param>
+        /// <param name = "value">The value to project.</param>
+        /// <param name = "id">The ID of this operation.</param>
         /// <returns>A task representing the operation.</returns>
         private async Task ProcessAsync(TSource value, long id)
         {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
index 77e99137..98f0b109 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
@@ -6,13 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Fused <c>.SelectMany(first).SelectMany(second)</c> operator that chains two one-shot
-/// async projections in a single operator allocation. The source emits a value, it's
-/// projected through <paramref name="first"/> producing an intermediate observable, whose
-/// single emission is then projected through <paramref name="second"/> producing the
-/// final result. Errors at any stage propagate to the downstream observer.
-/// </summary>
+/// <summary>Chains two one-shot observable projections and forwards errors from either stage.</summary>
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TMid">The intermediate element type produced by the first projection.</typeparam>
 /// <typeparam name="TResult">The final element type produced by the second projection.</typeparam>
@@ -34,9 +28,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return source.Subscribe(new SourceWitness(observer, first, second));
     }
 
-    /// <summary>Receives the source value and subscribes to the first projection. Holds a single
-    /// reusable <see cref="MidWitness"/> created at subscribe time — the mid observer captures
-    /// only <c>downstream</c> and <c>second</c>, so the same instance handles every source emission.</summary>
+    /// <summary>Subscribes the reusable intermediate observer to the first projection.</summary>
     private sealed class SourceWitness : IObserver<TSource>
     {
         /// <summary>The downstream observer that ultimately receives <typeparamref name="TResult"/> values.</summary>
@@ -84,8 +76,7 @@ public void OnNext(TSource value)
         public void OnCompleted() => _downstream.OnCompleted();
     }
 
-    /// <summary>Receives the intermediate value, applies <c>second</c>, and subscribes the resulting
-    /// observable directly to <c>downstream</c> — no separate final-stage observer needed.</summary>
+    /// <summary>Receives the intermediate value, applies <c>second</c>, and subscribes the resulting observable directly to <c>downstream</c> — no separate final-stage observer needed.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="second">Second projection delegate.</param>
     private sealed class MidWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
index 1338eefc..fa3186ce 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
@@ -7,22 +7,9 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Operator that randomly shuffles arrays emitted by the source.</summary>
+/// <summary>Shuffles arrays in place using non-cryptographic randomness.</summary>
 /// <typeparam name="T">The array element type.</typeparam>
 /// <param name="source">The source observable emitting arrays.</param>
-/// <remarks>
-/// <para>READ THIS BEFORE TOUCHING THE RANDOMNESS IN THIS FILE.</para>
-/// <para>This operator deliberately uses non-cryptographic random (System.Random / Random.Shared).
-/// This is intentional. We want random, and we want it fast.</para>
-/// <para>Any analyzer or scanner warning that flags this as a security risk — for example CA5394 "Do not
-/// use insecure randomness" or S2245 "Make sure that using this pseudorandom number generator is safe
-/// here" — is a big false positive. Do not "fix" it. Do not swap in RandomNumberGenerator.</para>
-/// <para>Why: this is a general-purpose shuffle for arbitrary observable data. It is not used for keys,
-/// tokens, passwords, nonces, lottery draws, or anything security-sensitive. Crypto RNG here is slow,
-/// slow, slow (a syscall for entropy on every draw) for zero real benefit. If you genuinely need
-/// crypto-grade randomness, compose RandomNumberGenerator yourself in your own code — that is the
-/// caller's job, not this hot-path operator's. Do not touch.</para>
-/// </remarks>
 public sealed class ShuffleObservable<T>(IObservable<T[]> source) : IObservable<T[]>
 {
     /// <inheritdoc/>
@@ -33,17 +20,13 @@ public IDisposable Subscribe(IObserver<T[]> observer)
         return source.Subscribe(new ShuffleWitness(observer));
     }
 
-    /// <summary>Observer that shuffles arrays in place.</summary>
+    /// <summary>Randomizes buffered values for non-security use.</summary>
     /// <param name="downstream">The downstream observer receiving shuffled arrays.</param>
-    /// <remarks>
-    /// INTENTIONAL non-crypto randomness. CA5394 here is a FALSE POSITIVE — see the banner at the top
-    /// of this file. This is a fast, general-purpose shuffle, NOT a security primitive. DO NOT TOUCH.
-    /// </remarks>
     [SuppressMessage(
         "Security",
         "CA5394:Do not use insecure randomness",
         Justification =
-            "Shuffle is non-cryptographic by design; Random is faster and crypto RNG buys nothing here. FALSE POSITIVE.")]
+            "Array shuffling does not require cryptographic randomness.")]
     private sealed class ShuffleWitness(IObserver<T[]> downstream) : IObserver<T[]>
     {
 #if !NET8_0_OR_GREATER
@@ -63,7 +46,6 @@ public void OnNext(T[] value)
             }
 
 #if NET8_0_OR_GREATER
-            // Random.Shared.Shuffle: fast, thread-safe, NON-CRYPTO BY DESIGN. WE WANT THIS. DO NOT TOUCH.
             Random.Shared.Shuffle(value);
 #else
             ShuffleInPlace(value);
@@ -85,8 +67,7 @@ public void OnNext(T[] value)
         /// <param name="array">The array to shuffle in place.</param>
         private static void ShuffleInPlace(T[] array)
         {
-            // Plain System.Random on purpose. NON-CRYPTO IS INTENTIONAL — fast path, not a security
-            // primitive. Any "insecure randomness" warning here is a FALSE POSITIVE. DO NOT TOUCH.
+            // This shuffle requires no cryptographic randomness.
             var random = _threadRandom;
             if (random is null)
             {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
index 13a42849..c71ffcfa 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
@@ -6,13 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Filtering operator that drops leading <see langword="null"/> values, then forwards every value
-/// (including subsequent <see langword="null"/>s) once the latch has opened. Replaces the previous
-/// <c>source.SkipWhile(x =&gt; x == null)</c> composition that delegated to System.Reactive's
-/// <c>SkipWhile</c>, eliminating the per-subscription closure allocation and the extra observer
-/// layer the chain introduced.
-/// </summary>
+/// <summary>Drops leading null values, then forwards every value, including subsequent nulls.</summary>
 /// <typeparam name="T">The element type of the source observable; must be a reference type so the
 /// null check is meaningful.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
index 26ec9eba..afaa9203 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
@@ -65,26 +65,35 @@ public void Dispose()
         }
     }
 
-    /// <summary>Called when a new value is emitted by the source.</summary>
-    /// <param name="value">The value emitted by the source.</param>
-    private void OnNext(T value)
+    /// <summary>Queues a source value and returns the operation started by it.</summary>
+    /// <param name="value">The source value.</param>
+    /// <returns>The processing task, or a completed task if no work starts.</returns>
+    internal Task OnNextAsync(T value)
     {
+        var processing = Task.CompletedTask;
         lock (_gate)
         {
             if (_done || _disposed)
             {
-                return;
+                return Task.CompletedTask;
             }
 
             _queue.Enqueue(value);
             if (!_isProcessing)
             {
                 _isProcessing = true;
-                _ = ProcessNextAsync();
+                processing = ProcessNextAsync();
             }
         }
+
+        return processing;
     }
 
+    /// <summary>Queues a source value.</summary>
+    /// <param name="value">The source value.</param>
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private void OnNext(T value) => _ = OnNextAsync(value);
+
     /// <summary>Called when an error occurs in the source.</summary>
     /// <param name="error">The error that occurred.</param>
     private void OnError(Exception error)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
index 80a3cabe..c26fdc65 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
@@ -24,7 +24,7 @@ public IDisposable Subscribe(IObserver<(T Value, IDisposable Sync)> observer)
 
     /// <summary>The sink for the <see cref="SynchronizeAsyncObservable{T}"/>.</summary>
     /// <param name="downstream">The downstream observer.</param>
-    private sealed class SynchronizeAsyncSink(IObserver<(T Value, IDisposable Sync)> downstream) : IObserver<T>, IDisposable
+    internal sealed class SynchronizeAsyncSink(IObserver<(T Value, IDisposable Sync)> downstream) : IObserver<T>, IDisposable
     {
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
@@ -47,8 +47,6 @@ public void OnNext(T value)
                 }
             }
 
-            // Implementation note: The original used 'new Continuation().Lock(item, observer)'.
-            // This is complex and stateful, so we maintain that logic in a way that respects sequentiality.
             _ = ProcessAsync(value);
         }
 
@@ -91,12 +89,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>
-        /// Processes the value. Pushes <c>(value, signal)</c> downstream and waits for the consumer
-        /// to dispose the signal. The fast path (consumer disposes synchronously inside <c>OnNext</c>)
-        /// returns a completed task without allocating a state machine or <see cref="TaskCompletionSource"/>;
-        /// the slow path (consumer defers disposal) lazily promotes the signal to a TCS-backed gate.
-        /// </summary>
+        /// <summary>Delivers the value and waits for the consumer to dispose its acknowledgement signal.</summary>
         /// <param name="value">The value to process.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         private Task ProcessAsync(T value)
@@ -106,13 +99,8 @@ private Task ProcessAsync(T value)
             return signal.WaitForDisposeAsync();
         }
 
-        /// <summary>
-        /// Per-emission gate: the downstream receives this handle as <c>Sync</c>. The producer
-        /// calls <see cref="WaitForDisposeAsync"/> after pushing the value; synchronous disposal
-        /// short-circuits to <see cref="Task.CompletedTask"/> with no TCS allocation. Late
-        /// (asynchronous) disposal lazily allocates a single <see cref="TaskCompletionSource"/>.
-        /// </summary>
-        private sealed class SyncSignal : IDisposable
+        /// <summary>Releases one emission when the consumer disposes it, allocating completion state only for an asynchronous wait.</summary>
+        internal sealed class SyncSignal : IDisposable
         {
             /// <summary>The lazily-created completion source; only allocated on the slow path.</summary>
             private TaskCompletionSource<bool>? _tcs;
@@ -120,11 +108,20 @@ private sealed class SyncSignal : IDisposable
             /// <summary>Latches to <c>1</c> on the first dispose so signalling is idempotent.</summary>
             private int _disposed;
 
-            /// <summary>Returns the task the producer should await before completing the emission.
-            /// The producer calls this exactly once per signal, so the TCS is published with a plain
-            /// volatile write rather than a compare-exchange.</summary>
+            /// <inheritdoc/>
+            public void Dispose()
+            {
+                if (Interlocked.Exchange(ref _disposed, 1) != 0)
+                {
+                    return;
+                }
+
+                Volatile.Read(ref _tcs)?.TrySetResult(true);
+            }
+
+            /// <summary>Returns the disposal task; the producer must call this exactly once per emission.</summary>
             /// <returns>A completed task if the consumer already disposed; otherwise the lazily-allocated TCS task.</returns>
-            public Task WaitForDisposeAsync()
+            internal Task WaitForDisposeAsync()
             {
                 if (Volatile.Read(ref _disposed) == 1)
                 {
@@ -137,24 +134,9 @@ public Task WaitForDisposeAsync()
                 return tcs.Task;
             }
 
-            /// <inheritdoc/>
-            public void Dispose()
-            {
-                if (Interlocked.Exchange(ref _disposed, 1) != 0)
-                {
-                    return;
-                }
-
-                Volatile.Read(ref _tcs)?.TrySetResult(true);
-            }
-
-            /// <summary>Self-completes the just-published TCS if a dispose raced ahead of the publish and could
-            /// not see it, so the producer's await never hangs.</summary>
+            /// <summary>Completes the acknowledgement task when disposal overlaps its publication.</summary>
             /// <param name="tcs">The completion source published for this signal.</param>
-            /// <remarks>The set-result is only taken when a concurrent dispose latches between the publish and
-            /// this re-check; isolated here and excluded from coverage as race-only.</remarks>
-            [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-            private void CompleteIfDisposedRaced(TaskCompletionSource<bool> tcs)
+            internal void CompleteIfDisposedRaced(TaskCompletionSource<bool> tcs)
             {
                 if (Volatile.Read(ref _disposed) != 1)
                 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
index 0fb39716..01201e07 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Takes elements from the source sequence until a predicate returns true for an element.
-/// The element that satisfies the predicate is included in the sequence.
-/// </summary>
+/// <summary>Takes elements from the source sequence until a predicate returns true for an element. The element that satisfies the predicate is included in the sequence.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="predicate">The predicate to determine when to stop taking elements.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
index 6ed804ab..e6c368f1 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
@@ -6,13 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Shared lock + timer + done-flag triple used by the synchronous timer-driven operator sinks
-/// (Debounce-Until, Detect-Stale, Throttle-Distinct, Buffer-Until-Idle, etc.). Each of those sinks
-/// previously hand-rolled three identical OnError / OnCompleted / Dispose method bodies on top of
-/// the same fields; this helper centralises the bodies so the per-sink class only carries the
-/// operator-specific OnNext logic. Sinks compose one instance and forward to it — no base class.
-/// </summary>
+/// <summary>Stores timer ownership, disposal state, and terminal notification state.</summary>
 /// <typeparam name="T">The element type the downstream observer receives.</typeparam>
 /// <param name="downstream">The downstream observer terminal callbacks fan out to.</param>
 [System.Diagnostics.CodeAnalysis.SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
index 79c5db64..54d95eb6 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
@@ -22,14 +22,9 @@ internal static class ActivationExtensionsEmitter
     /// <summary>The indentation the generated overloads' bodies and constraints sit at.</summary>
     private const int BodyIndent = MethodIndent + SourceFileWriter.IndentWidth;
 
-    /// <summary>Emits every generated activation overload into one partial-class file.</summary>
+    /// <summary>Emits concrete activation overloads that take precedence over the generic placeholder.</summary>
     /// <param name="models">The overloads to emit, in request order.</param>
     /// <returns>The generated source.</returns>
-    /// <remarks>
-    /// The overloads join the same partial class as the placeholder they displace, so a call site binds to the
-    /// concrete overload without the consumer importing anything: a non-generic candidate beats the generic
-    /// placeholder outright.
-    /// </remarks>
     internal static string Emit(ImmutableArray<ActivationModel> models)
     {
         var builder = new PooledStringBuilder(ScaffoldCapacity + (models.Length * OverloadCapacity));
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
index fa50f9e4..fd68afb6 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationSource.cs
@@ -4,14 +4,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
-/// <summary>The API a consumer writes against, emitted into every compilation.</summary>
-/// <remarks>
-/// This is what makes the generator opt-in without a package-level runtime dependency: the placeholder
-/// <c>Events&lt;T&gt;</c> gives a call site something to bind to while it is being typed, and the generated overload
-/// for the receiver's own type displaces it once the type resolves. The attribute has to exist here too because a
-/// static host has no receiver to hang a call off, and nothing here is annotated, so this is the one generated file
-/// that carries no <c>#nullable</c> directive.
-/// </remarks>
+/// <summary>Declares the generic activation placeholder and static-host attribute.</summary>
 internal static class ActivationSource
 {
     /// <summary>The source text added to every compilation.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
index 056298b1..f995af85 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
@@ -7,13 +7,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
-/// <summary>Builds the wrapper class and generated file names, from the identity of the host they belong to.</summary>
-/// <remarks>
-/// Sanitizing punctuation out of a fully qualified name maps distinct hosts onto the same identifier -
-/// <c>Samples.A_B.C</c> and <c>Samples.A.B_C</c> both flatten to <c>Samples_A_B_C</c> - so a hash of the unflattened
-/// identity is appended to keep them apart, while the readable half keeps a generated file recognisable in a build
-/// log.
-/// </remarks>
+/// <summary>Builds readable identifiers with an identity hash to distinguish flattened names.</summary>
 internal static class GeneratedNames
 {
     /// <summary>The prefix of a generated wrapper class name.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
index d5e9ceb3..7e25fc67 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.CodeGeneration;
 
-/// <summary>A fluent builder for generated source, backed by thread-local pooled character buffers.</summary>
-/// <remarks>
-/// The free list is thread-local rather than a shared pool: source-output callbacks run concurrently, fragment
-/// builders nest inside file builders, and nothing here outlives the call that rented it. Returning a buffer is what
-/// buys the reuse; forgetting to costs reuse, never correctness.
-/// </remarks>
+/// <summary>Builds source text using buffers rented from a thread-local pool.</summary>
 internal sealed class PooledStringBuilder
 {
     /// <summary>The smallest buffer worth renting, sized to hold a typical fragment without growing.</summary>
@@ -85,13 +80,9 @@ internal PooledStringBuilder Append(char value)
         return this;
     }
 
-    /// <summary>Appends the invariant decimal rendering of a non-negative integer.</summary>
+    /// <summary>Appends an integer directly to the buffer without an intermediate string.</summary>
     /// <param name="value">The value to append; the only callers pass a name length, so it is never negative.</param>
     /// <returns>This builder, for chaining.</returns>
-    /// <remarks>
-    /// Formats digits straight into the buffer; these appends sit in the per-event loop that builds the mangled
-    /// static property names, where <c>ToString</c> would allocate a string per name segment.
-    /// </remarks>
     internal PooledStringBuilder Append(int value)
     {
         EnsureCapacity(_position + MaxIntegerDigits);
@@ -153,14 +144,10 @@ internal PooledStringBuilder AppendIndent(int spaces)
         return this;
     }
 
-    /// <summary>Appends a block of newline-separated lines, indenting each non-empty one.</summary>
+    /// <summary>Appends indented text, leaving empty lines free of whitespace.</summary>
     /// <param name="value">The block to append, which may be empty.</param>
     /// <param name="spaces">The indentation width applied to every non-empty line.</param>
     /// <returns>This builder, for chaining.</returns>
-    /// <remarks>
-    /// Blank lines are left bare rather than filled with spaces, so an indented block never carries trailing
-    /// whitespace into the generated file.
-    /// </remarks>
     internal PooledStringBuilder AppendIndentedLines(string value, int spaces)
     {
         var start = 0;
@@ -187,8 +174,7 @@ internal PooledStringBuilder AppendIndentedLines(string value, int spaces)
         return this;
     }
 
-    /// <summary>Hands the buffer back to the thread's free list.</summary>
-    /// <remarks>The builder must not be appended to afterwards.</remarks>
+    /// <summary>Returns the buffer to the pool, ending this builder's lifetime.</summary>
     internal void Return()
     {
         var toReturn = _buffer;
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
index 58448aef..c613ae05 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
@@ -51,15 +51,11 @@ internal static void AppendFooter(PooledStringBuilder builder, string namespaceN
         _ = builder.AppendLine("}");
     }
 
-    /// <summary>Appends the observable property that wraps one event.</summary>
+    /// <summary>Emits a local event handler with the delegate's return type.</summary>
     /// <param name="builder">The destination builder.</param>
     /// <param name="model">The event to wrap.</param>
     /// <param name="provider">The observable implementation to write against.</param>
     /// <param name="indent">The indentation the property sits at.</param>
-    /// <remarks>
-    /// The handler is emitted as a local function rather than a lambda so a delegate returning <c>Task</c> or
-    /// <c>ValueTask</c> can satisfy its own signature.
-    /// </remarks>
     internal static void AppendEventProperty(
         PooledStringBuilder builder,
         EventModel model,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
index db30e7cc..8e3a1822 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/StaticEventsEmitter.cs
@@ -15,14 +15,10 @@ internal static class StaticEventsEmitter
     /// <summary>The room to reserve per generated observable property.</summary>
     private const int PropertyCapacity = 512;
 
-    /// <summary>Emits the static observable properties for one namespace.</summary>
+    /// <summary>Emits static event properties in a partial class within each requested namespace.</summary>
     /// <param name="model">The namespace and its static events.</param>
     /// <param name="provider">The observable implementation to write against.</param>
     /// <returns>The generated source.</returns>
-    /// <remarks>
-    /// A static event has no instance to hang an extension method off, so it is reached through a class named the
-    /// same in every namespace, left partial so a consumer can add to it.
-    /// </remarks>
     internal static string Emit(StaticNamespaceModel model, ObservableProvider provider)
     {
         var events = model.Events.AsArray();
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
index 59211884..bbc69cf5 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
@@ -12,13 +12,7 @@
 namespace ReactiveUI.Primitives.ObservableEvents;
 
 /// <summary>Generates observable wrappers for the event-bearing types a consumer asks for.</summary>
-/// <remarks>
-/// Generation is requested either by an <c>Events()</c> call, whose receiver names the host, or by an assembly
-/// attribute naming a static host; both converge on the same extraction and the same emitters. Everything leaving a
-/// semantic transform is a model of strings that compares by value, and every output is keyed on the smallest model
-/// that decides it - one wrapper per host, one file per namespace of static events, one file of activation
-/// overloads - so an edit to one host's events re-emits that host's file alone.
-/// </remarks>
+/// <remarks>Requests come from Events() calls or static-host attributes. Output is cached per host, namespace, and activation signature.</remarks>
 [Generator(LanguageNames.CSharp)]
 public sealed class EventGenerator : IIncrementalGenerator
 {
@@ -27,8 +21,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         RegisterActivationOutput(in context);
 
-        // Which observable library is referenced decides every type name in the generated source but nothing about
-        // which events exist, so resolving it separately keeps extraction from re-running when references move.
+        // Resolve provider names independently so reference changes do not invalidate event extraction.
         var provider = context.CompilationProvider
             .Select(static (compilation, _) => ProviderResolver.Resolve(compilation))
             .WithTrackingName(GeneratorStepNames.Provider);
@@ -57,14 +50,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         RegisterStaticOutputs(in context, staticTargets, provider);
     }
 
-    /// <summary>Registers the activation API a consumer writes against.</summary>
+    /// <summary>Registers activation source without modifying the semantic input compilation.</summary>
     /// <param name="context">The generator initialization context.</param>
-    /// <remarks>
-    /// An ordinary source output rather than post-initialization output: post-initialization source is added to the
-    /// compilation the pipeline then runs against, making that compilation new on every run and discarding every
-    /// semantic result cached against the one it replaces. One inert post-initialization file costs that, so this
-    /// generator registers none.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void RegisterActivationOutput(in IncrementalGeneratorInitializationContext context) =>
         context.RegisterSourceOutput(
@@ -96,14 +83,10 @@ private static void RegisterInstanceOutputs(
             static (output, data) => EmitActivationOverloads(in output, data.Left, data.Right));
     }
 
-    /// <summary>Registers the per-namespace static wrapper files and their request diagnostics.</summary>
+    /// <summary>Registers per-request diagnostics and per-namespace static event output.</summary>
     /// <param name="context">The generator initialization context.</param>
     /// <param name="targets">The distinct requested static hosts.</param>
     /// <param name="provider">The resolved observable implementation.</param>
-    /// <remarks>
-    /// Diagnostics hang off the individual requests while source hangs off the namespace groups, because a request
-    /// that produced no events still has something to say about itself but contributes nothing to a file.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void RegisterStaticOutputs(
         in IncrementalGeneratorInitializationContext context,
@@ -199,14 +182,10 @@ private static void EmitStaticNamespace(
         output.AddSource(model.HintName, StaticEventsEmitter.Emit(model, provider));
     }
 
-    /// <summary>Reports that nothing can be generated for a request because no provider is referenced.</summary>
+    /// <summary>Reports a missing provider, or the extraction diagnostics when a provider is available.</summary>
     /// <param name="output">The source-production context.</param>
     /// <param name="displayName">The requested host's readable name.</param>
     /// <param name="location">Where the request was written.</param>
-    /// <remarks>
-    /// Reported instead of, not alongside, whatever else extraction found: without a provider nothing would compile
-    /// anyway, and the one actionable thing to say is which package to reference.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void ReportMissingProvider(
         in SourceProductionContext output,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
index d2f22bd4..ecc2c5d8 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/GeneratorStepNames.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents;
 
-/// <summary>The names the pipeline's steps are tracked under.</summary>
-/// <remarks>
-/// A driver told to track steps reports, per run, whether each named step recomputed and whether its value changed,
-/// which is how a test asserts that the models compare by value and the caching holds.
-/// </remarks>
+/// <summary>Names the pipeline steps reported by incremental tracking.</summary>
 internal static class GeneratorStepNames
 {
     /// <summary>The step that resolves which observable implementation is referenced.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventExtractor.cs
index 12ed97ec..b571b99f 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventExtractor.cs
@@ -17,16 +17,11 @@ internal static class EventExtractor
     /// <summary>The parameter count of the conventional sender-and-arguments event delegate.</summary>
     private const int SenderAndArgsParameterCount = 2;
 
-    /// <summary>Collects the events a host can expose, recording a diagnostic for each one it cannot.</summary>
+    /// <summary>Extracts inherited events, preferring the most derived declaration for duplicate names.</summary>
     /// <param name="request">Everything about the host and where it was requested from.</param>
     /// <param name="diagnostics">The destination for anything found wrong.</param>
     /// <param name="cancellationToken">A token that cancels the walk.</param>
     /// <returns>The supported events, in declaration order from the host down to its last base type.</returns>
-    /// <remarks>
-    /// Walking the base chain by hand rather than asking for all members at once is what lets a derived host expose
-    /// an event it inherits. A name already seen is skipped so an event redeclared in a derived type wins over the
-    /// one it hides, which is the member a consumer's own code would bind to.
-    /// </remarks>
     internal static EquatableArray<EventModel> Collect(
         in EventRequest request,
         List<DiagnosticInfo> diagnostics,
@@ -67,15 +62,10 @@ internal static EquatableArray<EventModel> Collect(
         return events.Count == 0 ? EquatableArray<EventModel>.Empty : new([.. events]);
     }
 
-    /// <summary>Builds the mangled property name a static event gets on its namespace's shared class.</summary>
+    /// <summary>Builds an unambiguous static property name from length-prefixed host segments.</summary>
     /// <param name="host">The requested static host.</param>
     /// <param name="eventName">The event name.</param>
     /// <returns>The generated property name.</returns>
-    /// <remarks>
-    /// Every namespace's static events share one class, so the host's name has to be part of the property name.
-    /// Concatenating names would let distinct hosts collide - <c>A.BC</c> and <c>AB.C</c> both flattening to
-    /// <c>ABC</c> - so each segment is length-prefixed, which no pair of different segmentations can produce.
-    /// </remarks>
     private static string StaticPropertyName(INamedTypeSymbol host, string eventName)
     {
         var containers = new Stack<INamedTypeSymbol>();
@@ -118,14 +108,10 @@ private static EventModel CreateModel(IEventSymbol eventSymbol, in EventRequest
             SymbolHelpers.EscapeXml(eventSymbol.Name));
     }
 
-    /// <summary>Builds the expression the generated handler is added to and removed from.</summary>
+    /// <summary>Qualifies event access with its declaring type to resolve hidden inherited members.</summary>
     /// <param name="eventSymbol">The event to subscribe to.</param>
     /// <param name="request">The host request the event was reached through.</param>
     /// <returns>The subscription target expression.</returns>
-    /// <remarks>
-    /// An instance target is cast to the type that declares the event rather than to the requested host, so an
-    /// event the host inherits and hides with a member of the same name still binds to the one being wrapped.
-    /// </remarks>
     private static string BuildEventAccess(IEventSymbol eventSymbol, in EventRequest request)
     {
         var builder = new PooledStringBuilder();
@@ -143,15 +129,10 @@ private static string BuildEventAccess(IEventSymbol eventSymbol, in EventRequest
         return builder.Append('.').Append(SymbolHelpers.EscapeIdentifier(eventSymbol.Name)).ToStringAndReturn();
     }
 
-    /// <summary>Selects the observable payload type and the value handed to the observer.</summary>
+    /// <summary>Selects event payloads: arguments for sender/args delegates, otherwise all parameters.</summary>
     /// <param name="invokeMethod">The delegate's invocation method.</param>
     /// <param name="request">The host request the event was reached through.</param>
     /// <returns>The payload type and value, both empty for a parameterless delegate.</returns>
-    /// <remarks>
-    /// The two-parameter sender/args shape is the one nearly every .NET event has, and its sender is the object the
-    /// consumer already holds, so only the args are surfaced. Anything else is passed through whole: a single
-    /// parameter as itself, several as a tuple.
-    /// </remarks>
     private static (string PayloadType, string PayloadValue) SelectPayload(
         IMethodSymbol invokeMethod,
         in EventRequest request)
@@ -177,14 +158,10 @@ private static (string PayloadType, string PayloadValue) SelectPayload(
                 $"({JoinParameterNames(invokeMethod)})");
     }
 
-    /// <summary>Renders the generated handler's parameter list.</summary>
+    /// <summary>Builds handler parameters with the delegate's nullability annotations.</summary>
     /// <param name="invokeMethod">The delegate's invocation method.</param>
     /// <param name="request">The host request the event was reached through.</param>
     /// <returns>The comma-separated parameter declarations.</returns>
-    /// <remarks>
-    /// The declared types carry whatever annotations the delegate declared, because a handler is only assignable to
-    /// a delegate whose parameter nullability it matches.
-    /// </remarks>
     private static string JoinParameterDeclarations(IMethodSymbol invokeMethod, in EventRequest request)
     {
         var builder = new PooledStringBuilder();
@@ -240,15 +217,10 @@ private static string SelectHandlerReturnValue(IMethodSymbol invokeMethod, WellK
         return returnsTask ? Constants.CompletedTask : Constants.DefaultValueTask;
     }
 
-    /// <summary>Determines why an event cannot be exposed as an observable.</summary>
+    /// <summary>Returns why an event cannot be captured or exposed to an observer.</summary>
     /// <param name="eventSymbol">The event to validate.</param>
     /// <param name="wellKnownTypes">The task types resolved from the consumer compilation.</param>
     /// <returns>The reason, or <see langword="null"/> when the event is supported.</returns>
-    /// <remarks>
-    /// The generated handler hands its parameters to an observer, which outlives the callback, so anything that
-    /// cannot leave the stack or be captured has to be refused here rather than emitted and left to fail the
-    /// consumer's build.
-    /// </remarks>
     private static string? SelectUnsupportedReason(IEventSymbol eventSymbol, WellKnownTypes wellKnownTypes)
     {
         if (eventSymbol.Type is not INamedTypeSymbol { DelegateInvokeMethod: { } invokeMethod })
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventRequest.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventRequest.cs
index 9669426f..164d3288 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventRequest.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/EventRequest.cs
@@ -7,17 +7,13 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 
-/// <summary>One host to extract events from, with everything the extraction needs to render them.</summary>
+/// <summary>Groups compiler symbols used only within an event extraction transform.</summary>
 /// <param name="Host">The type whose events are being wrapped.</param>
 /// <param name="IsStatic">Whether static rather than instance events are wanted.</param>
 /// <param name="TypeParameterNames">The generated type-parameter names, or null for a non-generic host.</param>
 /// <param name="SupportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
 /// <param name="Location">Where the request was written, for diagnostics.</param>
 /// <param name="WellKnownTypes">The task types resolved from the consumer compilation.</param>
-/// <remarks>
-/// This carries symbols and so never leaves the semantic transform that created it; what comes back out is a model
-/// of strings. Bundling the arguments keeps the extraction methods from growing a parameter list each.
-/// </remarks>
 internal readonly record struct EventRequest(
     INamedTypeSymbol Host,
     bool IsStatic,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
index 99ec4e9f..a3affeae 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
@@ -12,14 +12,10 @@ namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 /// <summary>Turns an <c>Events()</c> call site into the model of the wrapper it asks for.</summary>
 internal static class InstanceTargetExtractor
 {
-    /// <summary>Cheaply rejects syntax that cannot be an activation call.</summary>
+    /// <summary>Identifies candidate activation calls by syntax alone.</summary>
     /// <param name="node">The node under consideration.</param>
     /// <param name="cancellationToken">A token that cancels the check.</param>
     /// <returns><see langword="true"/> when the node is a parameterless <c>Events()</c> member invocation.</returns>
-    /// <remarks>
-    /// This runs on every node of every edited file, so it only looks at shape and spelling. Deciding whether the
-    /// call is really ours needs the semantic model, and is left to the transform that runs on the survivors.
-    /// </remarks>
     internal static bool IsActivationInvocation(SyntaxNode node, CancellationToken cancellationToken)
     {
         _ = cancellationToken;
@@ -31,16 +27,10 @@ internal static bool IsActivationInvocation(SyntaxNode node, CancellationToken c
         && memberAccess.Name.Identifier.ValueText == Constants.EventMethodName;
     }
 
-    /// <summary>Resolves an activation call into the host it wraps.</summary>
+    /// <summary>Extracts the receiver type from an unresolved activation call.</summary>
     /// <param name="context">The semantic context for the candidate call.</param>
     /// <param name="cancellationToken">A token that cancels the resolution.</param>
     /// <returns>The requested host, or <see langword="null"/> for an unrelated call.</returns>
-    /// <remarks>
-    /// The activation placeholder this call will eventually bind to is this generator's own output, and output is
-    /// not visible to the pipeline that produced it - so during a run the call resolves to nothing. That absence is
-    /// the signal: a call that <em>does</em> resolve belongs to somebody else and is left alone, and a call that
-    /// does not is ours to answer. What the request needs is the receiver's type, which binds on its own.
-    /// </remarks>
     internal static InstanceTargetModel? Extract(GeneratorSyntaxContext context, CancellationToken cancellationToken)
     {
         var invocation = (InvocationExpressionSyntax)context.Node;
@@ -62,17 +52,13 @@ internal static bool IsActivationInvocation(SyntaxNode node, CancellationToken c
             : null;
     }
 
-    /// <summary>Builds the model for one requested host.</summary>
+    /// <summary>Extracts a host's original generic definition for a shared wrapper.</summary>
     /// <param name="host">The host to wrap, reduced to its original definition.</param>
     /// <param name="location">The call site, for diagnostics.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
     /// <param name="wellKnownTypes">The task types resolved from the consumer compilation.</param>
     /// <param name="cancellationToken">A token that cancels the walk.</param>
     /// <returns>The host model.</returns>
-    /// <remarks>
-    /// A generic host is reduced to its original definition so that <c>Foo&lt;int&gt;</c> and
-    /// <c>Foo&lt;string&gt;</c> share one wrapper, generic in the same parameters the host is.
-    /// </remarks>
     private static InstanceTargetModel Create(
         INamedTypeSymbol host,
         LocationInfo? location,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/LanguageSupport.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/LanguageSupport.cs
index dbd47acb..da2b3be1 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/LanguageSupport.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/LanguageSupport.cs
@@ -10,19 +10,9 @@ namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 /// <summary>What the consumer's language version lets the generated source say.</summary>
 internal static class LanguageSupport
 {
-    /// <summary>Determines whether the consumer's language can express a nullable reference type.</summary>
+    /// <summary>Determines whether the C# language version supports nullable annotations and directives.</summary>
     /// <param name="tree">A syntax tree from the consumer, which carries the language version it was parsed at.</param>
     /// <returns><see langword="true"/> when annotations and the nullable directive may be emitted.</returns>
-    /// <remarks>
-    /// Everything about the generated file's nullability follows from this one answer: whether it opens with
-    /// <c>#nullable enable</c>, and whether the handler signatures carry the annotations that make them match the
-    /// delegates they are assigned to. Emitting either against an older language version is a compile error in the
-    /// consumer's build, so both are decided together and from the same place.
-    /// </remarks>
-    /// <remarks>
-    /// The cast is safe by registration: the generator is declared for C# only, so every tree it is ever handed
-    /// was parsed with C# options.
-    /// </remarks>
     internal static bool SupportsNullableAnnotations(SyntaxTree tree) =>
         ((CSharpParseOptions)tree.Options).LanguageVersion >= LanguageVersion.CSharp8;
 }
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/ProviderResolver.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/ProviderResolver.cs
index 3c5c4387..e091b4c4 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/ProviderResolver.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/ProviderResolver.cs
@@ -10,15 +10,9 @@ namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 /// <summary>Chooses which observable implementation the generated code is written against.</summary>
 internal static class ProviderResolver
 {
-    /// <summary>Selects the best provider visible to a consumer.</summary>
+    /// <summary>Selects a fully referenced provider, preferring Primitives over System.Reactive.</summary>
     /// <param name="compilation">The consumer compilation.</param>
     /// <returns>The selected provider, or <see cref="ObservableProvider.None"/> when none is referenced.</returns>
-    /// <remarks>
-    /// Lean wins over reactive when both are referenced, because a consumer that has the lean package on hand is
-    /// asking for the allocation-free payload; falling back to <c>Unit</c> there would be a silent downgrade. Each
-    /// candidate is confirmed by every type its generated code names, so a partial reference set moves on to the
-    /// next candidate instead of emitting source that will not compile.
-    /// </remarks>
     internal static ObservableProvider Resolve(Compilation compilation)
     {
         if (HasTypes(
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
index c944f178..37bca49c 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
@@ -9,13 +9,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 
-/// <summary>Turns each <c>GenerateStaticEventObservables</c> application into the model of the host it names.</summary>
-/// <remarks>
-/// Matched on how the attribute is written rather than on the symbol it binds to. The attribute is declared by this
-/// generator's own output, and output is not visible to the pipeline that produced it, so there is no symbol to
-/// match against while the pipeline runs. What the request actually needs - the host type - comes from the
-/// <c>typeof</c> argument, which binds on its own.
-/// </remarks>
+/// <summary>Matches activation attributes by syntax because their declarations are generated output.</summary>
 internal static class StaticTargetExtractor
 {
     /// <summary>Cheaply rejects syntax that cannot be a static generation request.</summary>
@@ -31,15 +25,10 @@ internal static bool IsStaticRequestAttribute(SyntaxNode node, CancellationToken
             && IsRequestAttributeName(attribute.Name);
     }
 
-    /// <summary>Resolves one static request into the host it names.</summary>
+    /// <summary>Extracts static-host requests, ignoring missing or invalid type arguments.</summary>
     /// <param name="context">The semantic context for the candidate attribute.</param>
     /// <param name="cancellationToken">A token that cancels the resolution.</param>
     /// <returns>The requested host, or <see langword="null"/> when the attribute names nothing usable.</returns>
-    /// <remarks>
-    /// An attribute that names nothing usable - written without an argument, or with one that is not a type - is
-    /// skipped rather than diagnosed: the consumer is already being told about it by the compiler, and a half-typed
-    /// attribute should not add a second complaint on every keystroke.
-    /// </remarks>
     internal static StaticTargetModel? Extract(GeneratorSyntaxContext context, CancellationToken cancellationToken)
     {
         var attribute = (AttributeSyntax)context.Node;
@@ -77,17 +66,13 @@ private static bool IsRequestAttributeName(NameSyntax name)
         _ => string.Empty,
     };
 
-    /// <summary>Builds the model for one requested static host.</summary>
+    /// <summary>Rejects generic static hosts whose type arguments cannot be inferred.</summary>
     /// <param name="host">The host to expose, reduced to its original definition.</param>
     /// <param name="location">The attribute application, for diagnostics.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
     /// <param name="wellKnownTypes">The task types resolved from the consumer compilation.</param>
     /// <param name="cancellationToken">A token that cancels the walk.</param>
     /// <returns>The host model.</returns>
-    /// <remarks>
-    /// A generic host is refused outright: its static events belong to each closed construction rather than to the
-    /// open type, and the generated class has no receiver to infer type arguments from.
-    /// </remarks>
     private static StaticTargetModel Create(
         INamedTypeSymbol host,
         LocationInfo? location,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
index fb116e7d..2b5ca5d2 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
@@ -21,26 +21,16 @@ internal static class SymbolHelpers
     /// <summary>Renders a type without nullable annotations, for a consumer whose language predates them.</summary>
     private static readonly SymbolDisplayFormat ObliviousFormat = SymbolDisplayFormat.FullyQualifiedFormat;
 
-    /// <summary>Renders a type with its nullable annotations.</summary>
-    /// <remarks>
-    /// The generated handler has to match the delegate it is assigned to exactly. A delegate declared with an
-    /// annotated parameter - <c>EventHandler</c> and its sender being the one nearly every event goes through -
-    /// does not match a handler that declares the same parameter unannotated, and the consumer's build says so.
-    /// </remarks>
+    /// <summary>Formats a type with the nullability required by its delegate signature.</summary>
     private static readonly SymbolDisplayFormat AnnotatedFormat =
         SymbolDisplayFormat.FullyQualifiedFormat.AddMiscellaneousOptions(
             SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
 
-    /// <summary>Renders a type as a fully qualified reference, substituting renamed type parameters.</summary>
+    /// <summary>Substitutes type parameter names by symbol, preserving other display parts.</summary>
     /// <param name="symbol">The type to render.</param>
     /// <param name="typeParameterNames">The generated type-parameter names, or null when none were renamed.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
     /// <returns>The fully qualified type reference.</returns>
-    /// <remarks>
-    /// Walking display parts rather than the finished string is what makes the substitution safe: a part carrying a
-    /// type parameter is identified by its symbol, so a parameter named <c>T</c> is replaced while a type whose name
-    /// merely contains <c>T</c> is left alone.
-    /// </remarks>
     internal static string Display(
         ITypeSymbol symbol,
         IReadOnlyDictionary<ITypeParameterSymbol, string>? typeParameterNames,
@@ -68,13 +58,9 @@ internal static string Display(
         return builder.ToStringAndReturn();
     }
 
-    /// <summary>Collects the type parameters a wrapper has to redeclare, outermost container first.</summary>
+    /// <summary>Collects the host's type parameters, including those inherited from containing types.</summary>
     /// <param name="type">The host type.</param>
     /// <returns>The complete ordered type-parameter list.</returns>
-    /// <remarks>
-    /// A wrapper for a nested generic sits at namespace level, so it has to redeclare every parameter its host
-    /// inherits from its containing types as well as its own.
-    /// </remarks>
     internal static List<ITypeParameterSymbol> CollectTypeParameters(INamedTypeSymbol type)
     {
         var containers = new Stack<INamedTypeSymbol>();
@@ -92,14 +78,9 @@ internal static List<ITypeParameterSymbol> CollectTypeParameters(INamedTypeSymbo
         return result;
     }
 
-    /// <summary>Assigns each type parameter a name that is unique across the flattened list.</summary>
+    /// <summary>Assigns distinct names to type parameters from nested generic scopes.</summary>
     /// <param name="typeParameters">The ordered type parameters.</param>
     /// <returns>The symbol-to-generated-name mapping.</returns>
-    /// <remarks>
-    /// Flattening a nested generic can collide two parameters that were distinct in their own scopes -
-    /// <c>Outer&lt;T&gt;.Inner&lt;T&gt;</c> being the usual shape - so the second one is suffixed rather than
-    /// silently shadowing the first.
-    /// </remarks>
     internal static Dictionary<ITypeParameterSymbol, string> CreateTypeParameterNames(
         List<ITypeParameterSymbol> typeParameters)
     {
@@ -149,15 +130,11 @@ internal static string BuildTypeParameterList(
         return builder.Append('>').ToStringAndReturn();
     }
 
-    /// <summary>Renders the generic constraint clauses, one per line and without indentation.</summary>
+    /// <summary>Formats constraint clauses without indentation.</summary>
     /// <param name="typeParameters">The ordered type parameters.</param>
     /// <param name="typeParameterNames">The generated type-parameter names.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
     /// <returns>The constraint clauses, or an empty string when nothing is constrained.</returns>
-    /// <remarks>
-    /// Left unindented because the same clauses are emitted at two different depths - once on the wrapper class and
-    /// once on the activation overload - and the emitter is what knows which.
-    /// </remarks>
     internal static string BuildConstraints(
         List<ITypeParameterSymbol> typeParameters,
         IReadOnlyDictionary<ITypeParameterSymbol, string> typeParameterNames,
@@ -215,15 +192,11 @@ internal static string EscapeXml(string value)
         return builder.ToStringAndReturn();
     }
 
-    /// <summary>Appends one type parameter's comma-separated constraints.</summary>
+    /// <summary>Appends the single applicable primary constraint before other constraints.</summary>
     /// <param name="builder">The destination builder.</param>
     /// <param name="parameter">The constrained type parameter.</param>
     /// <param name="typeParameterNames">The generated type-parameter names.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
-    /// <remarks>
-    /// The primary constraint has to come first and only one of the four forms may appear, which is why they are
-    /// tested in order rather than accumulated.
-    /// </remarks>
     private static void AppendConstraintClause(
         PooledStringBuilder builder,
         ITypeParameterSymbol parameter,
@@ -268,8 +241,7 @@ private static string SelectPrimaryConstraint(ITypeParameterSymbol parameter, bo
 
         if (parameter.HasReferenceTypeConstraint)
         {
-            // A referenced assembly can declare `class?` whatever the consumer's language version is, so the
-            // annotation has to be dropped rather than repeated when the consumer could not have written it.
+            // Omit referenced nullable constraints when the consumer's language cannot express them.
             return supportsNullableAnnotations
                 && parameter.ReferenceTypeConstraintNullableAnnotation == NullableAnnotation.Annotated
                 ? "class?"
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
index 261521a9..6b8a3ed4 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
@@ -8,12 +8,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 
-/// <summary>Reconciles the requests found across a compilation into the set of files to generate.</summary>
-/// <remarks>
-/// Requests arrive one per call site or attribute, but generated files are keyed on the host or the namespace, so
-/// this is where the two are brought back into line. Both passes keep the order the requests were found in, so the
-/// generated output does not shuffle when an unrelated file is edited.
-/// </remarks>
+/// <summary>Deduplicates requests by output identity, preserving discovery order.</summary>
 internal static class TargetCollections
 {
     /// <summary>The largest request count that cannot contain a duplicate.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/WellKnownTypes.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/WellKnownTypes.cs
index 78b07aae..3bd157b4 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/WellKnownTypes.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/WellKnownTypes.cs
@@ -6,13 +6,9 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Helpers;
 
-/// <summary>The framework types an event delegate is allowed to return, resolved once per extraction.</summary>
+/// <summary>Caches framework symbols used during event extraction.</summary>
 /// <param name="Task">The resolved task type, or null when the consumer cannot see it.</param>
 /// <param name="ValueTask">The resolved value task type, or null when the consumer cannot see it.</param>
-/// <remarks>
-/// Resolved up front rather than per event, because an async event host declares many events and each one would
-/// otherwise repeat the same two metadata lookups.
-/// </remarks>
 internal readonly record struct WellKnownTypes(INamedTypeSymbol? Task, INamedTypeSymbol? ValueTask)
 {
     /// <summary>Resolves the types from a consumer compilation.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/ActivationModel.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/ActivationModel.cs
index 37cd41e1..e16025bc 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/ActivationModel.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/ActivationModel.cs
@@ -4,17 +4,13 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>One strongly typed <c>Events()</c> overload, which replaces the placeholder for a given host.</summary>
+/// <summary>Stores the signature that determines an activation overload.</summary>
 /// <param name="TypeReference">The fully qualified host reference the overload accepts.</param>
 /// <param name="WrapperReference">The fully qualified wrapper reference the overload returns.</param>
 /// <param name="TypeParameterList">The overload's type parameter list, or empty for a non-generic host.</param>
 /// <param name="Constraints">One <c>where</c> clause per line without indentation, or empty when unconstrained.</param>
 /// <param name="DocumentationName">The host reference, escaped for the generated documentation comment.</param>
 /// <param name="SupportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
-/// <remarks>
-/// Kept apart from <see cref="InstanceTargetModel"/> so the one file carrying every overload only re-emits when an
-/// overload signature actually moves, rather than whenever any wrapper's events change.
-/// </remarks>
 internal sealed record ActivationModel(
     string TypeReference,
     string WrapperReference,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/DiagnosticInfo.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/DiagnosticInfo.cs
index ef1f2ba0..faf1983f 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/DiagnosticInfo.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/DiagnosticInfo.cs
@@ -6,16 +6,11 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>A diagnostic held as values, so it can ride along in a model until it is reported.</summary>
+/// <summary>Stores diagnostic content and coordinates without retaining compiler objects.</summary>
 /// <param name="Descriptor">The descriptor to report.</param>
 /// <param name="Location">Where to point, or <see langword="null"/> when the request has no source location.</param>
 /// <param name="FirstArgument">The first message argument.</param>
 /// <param name="SecondArgument">The second message argument, when the descriptor takes one.</param>
-/// <remarks>
-/// A <see cref="Diagnostic"/> carries a <see cref="Microsoft.CodeAnalysis.Location"/> and therefore a syntax tree,
-/// which the pipeline can neither compare nor safely cache. Extraction records what to say and where; the source
-/// output turns it back into a diagnostic.
-/// </remarks>
 internal sealed record DiagnosticInfo(
     DiagnosticDescriptor Descriptor,
     LocationInfo? Location,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/EquatableArray.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/EquatableArray.cs
index 1f662292..4429af6d 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/EquatableArray.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/EquatableArray.cs
@@ -6,15 +6,8 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>An array that compares by value, so it can sit inside an incremental-pipeline model.</summary>
+/// <summary>An immutable array with element-wise equality and a cached hash.</summary>
 /// <typeparam name="T">The element type, which must itself compare by value.</typeparam>
-/// <remarks>
-/// The pipeline decides whether to re-run a downstream step by asking whether the model it produced equals the one
-/// from the previous run. An array compares by reference, so a model carrying a bare array is never equal to its
-/// predecessor and every step below it re-runs on every keystroke. Wrapping the array here is what makes the
-/// per-target caching real. A readonly struct so the value sits inline in its owning record rather than adding a
-/// heap object per collection.
-/// </remarks>
 internal readonly struct EquatableArray<T> : IEquatable<EquatableArray<T>>
     where T : notnull, IEquatable<T>
 {
@@ -59,11 +52,7 @@ internal EquatableArray(T[] values)
     public static bool operator !=(EquatableArray<T> left, EquatableArray<T> right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    /// <remarks>
-    /// A defaulted instance and one wrapping a zero-length array are the same value here. Treating them as
-    /// different would make an extraction that happened to build an empty array compare unequal to one that
-    /// returned <see cref="Empty"/>, and silently cost the caching this type exists for.
-    /// </remarks>
+    /// <summary>Compares elements in order, treating default and empty arrays as equal.</summary>
     public bool Equals(EquatableArray<T> other)
     {
         var values = _values;
@@ -101,13 +90,9 @@ public bool Equals(EquatableArray<T> other)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal T[] AsArray() => _values ?? [];
 
-    /// <summary>Computes the deterministic hash of the elements.</summary>
+    /// <summary>Hashes elements in order, returning zero for an empty array.</summary>
     /// <param name="values">The elements to hash.</param>
     /// <returns>The combined hash.</returns>
-    /// <remarks>
-    /// Empty hashes to zero, which is what a default-constructed instance keeps in its field without calling
-    /// here - so the two forms of empty that <see cref="Equals(EquatableArray{T})"/> calls equal hash alike.
-    /// </remarks>
     private static int ComputeHashCode(T[] values)
     {
         if (values.Length == 0)
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
index 52c03a98..8a99328a 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>One event, reduced to the exact fragments its generated observable property is assembled from.</summary>
+/// <summary>Stores event emission data without compiler objects; parameterless payloads remain provider-independent.</summary>
 /// <param name="PropertyName">The generated property name, already escaped.</param>
 /// <param name="EventAccess">The subscription target and event name, already escaped.</param>
 /// <param name="PayloadType">The observable payload type, or empty when the delegate takes no parameters.</param>
@@ -14,12 +14,6 @@ namespace ReactiveUI.Primitives.ObservableEvents.Models;
 /// <param name="HandlerReturnValue">The handler's return expression, or empty when it returns void.</param>
 /// <param name="IsStatic">Whether the generated property is static.</param>
 /// <param name="DocumentationName">The event name, escaped for the generated documentation comment.</param>
-/// <remarks>
-/// Everything the emitter needs is a string by this point: no symbol, syntax node, or compilation survives into the
-/// pipeline. A parameterless delegate leaves the payload fields empty rather than naming a void type, because which
-/// void type applies is the one thing that depends on the provider - keeping it out here is what lets a model stay
-/// cached when only the consumer's references change.
-/// </remarks>
 internal sealed record EventModel(
     string PropertyName,
     string EventAccess,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/InstanceTargetModel.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/InstanceTargetModel.cs
index 662534d9..28f6a178 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/InstanceTargetModel.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/InstanceTargetModel.cs
@@ -35,12 +35,8 @@ internal sealed record InstanceTargetModel(
     EquatableArray<DiagnosticInfo> Diagnostics,
     LocationInfo? Location)
 {
-    /// <summary>Creates the activation overload this host's wrapper is reached through.</summary>
+    /// <summary>Gets the activation signature independently of the host's event list.</summary>
     /// <returns>The overload model.</returns>
-    /// <remarks>
-    /// Projected out rather than stored, so the one file carrying every overload compares equal - and stays
-    /// uncompiled - when a host's events change but its signature does not.
-    /// </remarks>
     internal ActivationModel ToActivation() =>
         new(
             TypeReference,
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/LocationInfo.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/LocationInfo.cs
index 8fa140fb..145b2acc 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/LocationInfo.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/LocationInfo.cs
@@ -8,15 +8,10 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>Where a diagnostic points, reduced to values the incremental pipeline can compare.</summary>
+/// <summary>Stores diagnostic coordinates without retaining syntax trees.</summary>
 /// <param name="FilePath">The source file the request was written in.</param>
 /// <param name="TextSpan">The span within that file.</param>
 /// <param name="LineSpan">The line and character span within that file.</param>
-/// <remarks>
-/// A <see cref="Location"/> holds onto its syntax tree, which would pin a whole compilation in the pipeline's cache
-/// and never compare equal between runs. Keeping the three values it is built from lets the location survive in a
-/// model and be rebuilt at the point a diagnostic is actually reported.
-/// </remarks>
 internal sealed record LocationInfo(string FilePath, TextSpan TextSpan, LinePositionSpan LineSpan)
 {
     /// <summary>Reduces a Roslyn location to its comparable values.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/ObservableProvider.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/ObservableProvider.cs
index 8ff07a0f..26d3224b 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/ObservableProvider.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/ObservableProvider.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>The observable implementation the generated code is written against.</summary>
-/// <remarks>
-/// Resolved once from the consumer's references and flowed into emission as a value, so that the far more expensive
-/// event extraction does not have to re-run when only the reference set moves.
-/// </remarks>
+/// <summary>Stores the selected observable provider independently of event extraction.</summary>
 internal enum ObservableProvider
 {
     /// <summary>No supported observable factory is visible; nothing can be generated.</summary>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/StaticNamespaceModel.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/StaticNamespaceModel.cs
index f9ccd3e8..b370ed1a 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/StaticNamespaceModel.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/StaticNamespaceModel.cs
@@ -4,15 +4,11 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
-/// <summary>Every static event requested in one namespace, which share a single generated <c>RxEvents</c> class.</summary>
+/// <summary>Groups deduplicated static event hosts by namespace.</summary>
 /// <param name="HintName">The generated file name for this namespace.</param>
 /// <param name="Namespace">The namespace to emit into, or empty for the global namespace.</param>
 /// <param name="SupportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
 /// <param name="Events">The static events to expose, in request order.</param>
-/// <remarks>
-/// Grouping happens after deduplication so that adding a request in one namespace leaves every other namespace's
-/// file byte-identical, and therefore uncached only where it actually changed.
-/// </remarks>
 internal sealed record StaticNamespaceModel(
     string HintName,
     string Namespace,
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/SequencerSchedulingExtensions.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/SequencerSchedulingExtensions.cs
index af93b947..67a4f06e 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/SequencerSchedulingExtensions.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/SequencerSchedulingExtensions.cs
@@ -10,11 +10,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// Gives <see cref="IScheduler"/> the <c>ISequencer</c> scheduling shape the shared Primitives source expects,
-/// by forwarding to <see cref="System.Reactive.Concurrency.Scheduler"/>. Kept internal: it is the seam the leaf
-/// uses to invoke schedulers, not public surface.
-/// </summary>
+/// <summary>Adapts IScheduler to the scheduling operations used by shared Primitives source.</summary>
 internal static class SequencerSchedulingExtensions
 {
     /// <summary>Scheduling operators that give an <see cref="IScheduler"/> the shared-source sequencer shape.</summary>
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
index f528e8cb..61a49691 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
@@ -3,19 +3,13 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using System.Reactive.Concurrency;
-using Timer = System.Threading.Timer;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>
-/// Task-pool replacement for single-threaded event-loop runtimes such as browser WebAssembly: it never starts
-/// threads, never blocks, and does not support long-running scheduling. Immediate work is batched one drain per
-/// event-loop turn through a zero-due timer (a <c>setTimeout(0)</c> macrotask on WebAssembly, so the browser can
-/// render between batches); delayed and periodic work use one-shot/periodic timers, which the WebAssembly runtime
-/// backs with the JS event loop. Successor to the retired <c>Reactive.Wasm</c> package's scheduler, whose runtime
-/// reflection no longer exists on modern .NET.
+/// Schedules work on a single-threaded event loop without blocking or starting threads. Immediate work runs in
+/// batches between event-loop turns; delayed and periodic work use timers. Long-running scheduling is unsupported.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
 public sealed class WasmScheduler : LocalScheduler, ISchedulerPeriodic, IDisposable
@@ -36,38 +30,36 @@ public sealed class WasmScheduler : LocalScheduler, ISchedulerPeriodic, IDisposa
     private readonly ConcurrentQueue<IReadyWorkItem> _ready = new();
 
     /// <summary>One-shot timer used to yield a drain to the event loop.</summary>
-    private readonly Timer _drainTimer;
+    private readonly ITimer _drainTimer;
+
+    /// <summary>Creates the timers that dispatch scheduled work.</summary>
+    private readonly TimeProvider _timeProvider;
 
     /// <summary>Approximate number of ready items; snapshots a drain batch.</summary>
     private int _readyCount;
 
-    /// <summary>
-    /// Single-flight drain state: <c>0</c> idle, <c>1</c> a drain is running, <c>2</c> a drain is running and more
-    /// work arrived while it ran. Keeping at most one drain in flight preserves the single-threaded, FIFO,
-    /// one-drain-per-event-loop-turn semantics the type promises even though the backing timer may fire callbacks
-    /// on more than one thread-pool thread.
-    /// </summary>
+    /// <summary>Drain state: zero idle, one active, two active with another pass requested.</summary>
     private int _drainState;
 
     /// <summary>Non-zero once <see cref="Dispose"/> has released the drain timer and the ready queue.</summary>
     private int _isDisposed;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="WasmScheduler"/> class. Callers use <see cref="Default"/>; this is
-    /// internal so a test can own an isolated scheduler it may dispose without shutting the shared singleton down for
-    /// every other test.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="WasmScheduler"/> class.</summary>
+    /// <param name="timeProvider">Timer provider; null selects the system provider.</param>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Correctness",
         "SST2403:Do not let 'this' escape from a constructor",
         Justification =
             "The drain timer is created disarmed, so nothing can call back into it until Schedule arms it after construction.")]
-    internal WasmScheduler() =>
-        _drainTimer = new(
+    internal WasmScheduler(TimeProvider? timeProvider = null)
+    {
+        _timeProvider = timeProvider ?? TimeProvider.System;
+        _drainTimer = _timeProvider.CreateTimer(
             static state => ((WasmScheduler)state!).RunDrain(),
             this,
             Timeout.InfiniteTimeSpan,
             Timeout.InfiniteTimeSpan);
+    }
 
     /// <summary>A queued work item awaiting an event-loop drain or a one-shot timer. Disposing it cancels it.</summary>
     internal interface IReadyWorkItem : IDisposable
@@ -125,7 +117,7 @@ public override IDisposable Schedule<TState>(
 
         // The timer roots itself while armed through the callback's target (the work item), which stores the
         // timer; the item's Dispose cancels and releases it.
-        item.AttachTimer(new Timer(static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
+        item.AttachTimer(_timeProvider.CreateTimer(static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
         return item;
     }
 
@@ -153,14 +145,12 @@ public IDisposable SchedulePeriodic<TState>(TState state, TimeSpan period, Func<
             period = OneMillisecond;
         }
 
-        return PeriodicWorkItem<TState>.Start(state, period, action);
+        return PeriodicWorkItem<TState>.Start(state, period, action, _timeProvider);
     }
 
     /// <summary>
-    /// Releases the drain timer this scheduler owns and cancels the ready work still queued behind it. Scheduling
-    /// through a disposed scheduler throws <see cref="ObjectDisposedException"/> rather than queueing work no drain
-    /// will ever reach. Work an in-flight drain has already dequeued runs to completion, and a delayed item that
-    /// already owns its one-shot timer keeps it — the caller cancels those through the disposable it was handed.
+    /// Releases the drain timer and cancels queued work. Subsequent scheduling throws ObjectDisposedException.
+    /// Running work completes; callers retain responsibility for cancelling delayed work through its returned handle.
     /// </summary>
     public void Dispose()
     {
@@ -173,20 +163,14 @@ public void Dispose()
         ReleaseReady();
     }
 
-    /// <summary>
-    /// Enqueues immediate work and coalesces a single drain post. Internal rather than private so a test can drive the
-    /// enqueue that was already past <see cref="Schedule{TState}(TState, Func{IScheduler, TState, IDisposable})"/>'s
-    /// disposed check when disposal drained the ready queue, and prove the item is released rather than stranded.
-    /// </summary>
+    /// <summary>Enqueues work and requests a drain, releasing the item if disposal overlaps.</summary>
     /// <param name="item">Work item to execute on the next event-loop turn.</param>
     internal void Enqueue(IReadyWorkItem item)
     {
         QueueReady(item);
         PostDrain();
 
-        // A disposal that raced the enqueue above may have drained the queue before this item joined it. Re-check
-        // the flag the disposal published first, so the loser of that race releases the item instead of leaving it
-        // queued behind a timer that can no longer fire.
+        // Release work enqueued after disposal drained the queue.
         if (!IsDisposed)
         {
             return;
@@ -195,10 +179,7 @@ internal void Enqueue(IReadyWorkItem item)
         ReleaseReady();
     }
 
-    /// <summary>
-    /// Adds a work item to the ready queue without arming a drain. Internal rather than private so a test can order an
-    /// enqueue, a disposal and a drain as explicit steps instead of racing them across threads.
-    /// </summary>
+    /// <summary>Adds ready work without requesting a drain.</summary>
     /// <param name="item">Work item to add to the ready queue.</param>
     internal void QueueReady(IReadyWorkItem item)
     {
@@ -206,10 +187,7 @@ internal void QueueReady(IReadyWorkItem item)
         _ = Interlocked.Increment(ref _readyCount);
     }
 
-    /// <summary>
-    /// Runs one batch: every item the ready count promised, stopping early if a concurrent drain took one first.
-    /// Internal rather than private so a test can run a drain pass at the point in a sequence it chooses.
-    /// </summary>
+    /// <summary>Runs the ready items in one batch.</summary>
     internal void RunReadyBatch()
     {
         for (var remaining = Volatile.Read(ref _readyCount);
@@ -221,10 +199,31 @@ internal void RunReadyBatch()
         }
     }
 
-    /// <summary>
-    /// Cancels and drops every ready item. The items are the handles their callers hold, so disposing them releases
-    /// the caller's work instead of stranding it in a queue nothing will ever drain again.
-    /// </summary>
+    /// <summary>Claims a drain or requests another pass if the observed state is still current.</summary>
+    /// <param name="observedState">The drain state observed before attempting the transition.</param>
+    /// <returns>True when no further claim attempt is needed; false when the observed state changed.</returns>
+    internal bool TryPostDrain(int observedState)
+    {
+        if (Volatile.Read(ref _readyCount) == 0)
+        {
+            return true;
+        }
+
+        if (observedState != DrainIdle)
+        {
+            return Interlocked.CompareExchange(ref _drainState, DrainRunningPending, observedState) == observedState;
+        }
+
+        if (Interlocked.CompareExchange(ref _drainState, DrainRunning, DrainIdle) != DrainIdle)
+        {
+            return false;
+        }
+
+        ArmDrain();
+        return true;
+    }
+
+    /// <summary>Cancels and removes every queued work item.</summary>
     private void ReleaseReady()
     {
         while (_ready.TryDequeue(out var item))
@@ -234,49 +233,22 @@ private void ReleaseReady()
         }
     }
 
-    /// <summary>
-    /// Arms a single drain if none is in flight, otherwise flags the running drain to loop again.
-    /// <para>
-    /// The whole body is the claim protocol: it spins only while a compare-exchange
-    /// loses to a concurrent claim, and exits early only when a concurrent drain empties the queue between the
-    /// caller's enqueue and this read. Neither path is reachable without a second thread interleaving, so the
-    /// shell carries the coverage exclusion; the work it schedules lives in ArmDrain, which is covered.
-    /// </para>
-    /// </summary>
-    [ExcludeFromCodeCoverage]
+    /// <summary>Retries drain claims after competing state updates.</summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void PostDrain()
     {
-        while (Volatile.Read(ref _readyCount) != 0)
+        int state;
+        do
         {
-            var state = Volatile.Read(ref _drainState);
-            if (state != DrainIdle)
-            {
-                // A drain is already running; flag that more work arrived so it drains again.
-                if (Interlocked.CompareExchange(ref _drainState, DrainRunningPending, state) == state)
-                {
-                    return;
-                }
-
-                continue;
-            }
-
-            // Become the sole drainer, then yield a batch to the event loop.
-            if (Interlocked.CompareExchange(ref _drainState, DrainRunning, DrainIdle) != DrainIdle)
-            {
-                continue;
-            }
-
-            ArmDrain();
-            return;
+            state = Volatile.Read(ref _drainState);
         }
+        while (!TryPostDrain(state));
     }
 
     /// <summary>Yields the claimed drain batch to the event loop, or hands the latch back when disposal beat it.</summary>
     private void ArmDrain()
     {
-        // Arming a released timer is a silent no-op, so a claim made while the scheduler was being disposed would
-        // leave the latch set on a drain that can never run. Hand the latch back instead: with scheduling closed and
-        // the ready queue released, there is nothing left for that drain to do anyway.
+        // Release the drain claim when disposal prevents arming the timer.
         if (IsDisposed)
         {
             Volatile.Write(ref _drainState, DrainIdle);
@@ -286,15 +258,7 @@ private void ArmDrain()
         _ = _drainTimer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
     }
 
-    /// <summary>
-    /// Runs event-loop batches for the single in-flight drain until no more work is queued.
-    /// <para>
-    /// This is a thin batching shell around <see cref="RunReadyBatch"/>. It repeats a pass only when a concurrent
-    /// <see cref="PostDrain"/> flagged more work mid-pass, which needs a second thread to interleave, so the shell
-    /// carries the coverage exclusion and the per-item work lives in the method it calls.
-    /// </para>
-    /// </summary>
-    [ExcludeFromCodeCoverage]
+    /// <summary>Drains queued batches until no further pass is requested.</summary>
     private void RunDrain()
     {
         do
@@ -316,20 +280,11 @@ private void RunDrain()
         PostDrain();
     }
 
-    /// <summary>
-    /// A cancellable scheduled work item carrying closure-free state and the scheduler passed back to the action;
-    /// also the target that roots a delayed one-shot timer. The run/cancel handshake lives in the shared
-    /// <see cref="DispatchWorkItemBase{TState}"/>; this item only adds the optional one-shot timer a delayed schedule
-    /// attaches.
-    /// </summary>
+    /// <summary>Owns scheduled work and its optional one-shot timer.</summary>
     /// <typeparam name="TState">The scheduled state type.</typeparam>
     internal sealed class StatefulWorkItem<TState> : DispatchWorkItemBase<TState>, IReadyWorkItem
     {
-        /// <summary>
-        /// Release handle for the one-shot timer driving a delayed item; <see langword="null"/> for immediate work.
-        /// Typed as the cancellation the item actually performs rather than the timer itself, so a test can hand it a
-        /// recording handle and observe the release directly.
-        /// </summary>
+        /// <summary>The delayed item's timer release handle, or null for immediate work.</summary>
         private IDisposable? _timer;
 
         /// <summary>Initializes a new instance of the <see cref="StatefulWorkItem{TState}"/> class.</summary>
@@ -344,8 +299,7 @@ public StatefulWorkItem(WasmScheduler scheduler, TState state, Func<IScheduler,
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Claim cancellation first so a racing AttachTimer observes the disposed state and releases the timer it
-            // just stored, then reclaim any timer this item already owns and the disposable the action returned.
+            // Publish cancellation before reclaiming timers so a concurrent attachment releases its handle.
             if (!TryClaimDispose())
             {
                 return;
@@ -379,11 +333,8 @@ internal sealed class PeriodicWorkItem<TState> : IDisposable
         /// <summary>Scheduled action.</summary>
         private readonly Func<TState, TState> _action;
 
-        /// <summary>
-        /// Periodic timer; rooted through the tick callback's target while armed. Attached by <see cref="Start"/>
-        /// once the item is fully constructed, so it is never <see langword="null"/> for an item a caller can see.
-        /// </summary>
-        private Timer? _timer;
+        /// <summary>Periodic timer, attached after construction and rooted by its callback while armed.</summary>
+        private ITimer? _timer;
 
         /// <summary>State threaded through the periodic action.</summary>
         private TState _state;
@@ -412,27 +363,27 @@ public void Dispose()
 
                 _isDisposed = true;
 
-                // Start is the only construction path and always assigns the timer before returning, and a second
-                // Dispose exits at the flag above, so the timer is always present on the one pass that reaches here.
+                // Start assigns the timer before returning; only the first Dispose reaches this point.
                 _timer!.Dispose();
                 _timer = null;
                 _state = default!;
             }
         }
 
-        /// <summary>
-        /// Creates a periodic item and arms its timer. Arming it here rather than in the constructor is what keeps
-        /// the tick callback from ever seeing a half-built item: the timer is created disarmed, attached, and only
-        /// then started, so the first tick runs against an item whose fields are all published.
-        /// </summary>
+        /// <summary>Publishes the periodic item and its timer before enabling ticks.</summary>
         /// <param name="state">Initial state.</param>
         /// <param name="period">Tick period.</param>
         /// <param name="action">Scheduled action.</param>
+        /// <param name="timeProvider">Timer provider.</param>
         /// <returns>The armed periodic work item, which cancels the ticks when disposed.</returns>
-        internal static PeriodicWorkItem<TState> Start(TState state, TimeSpan period, Func<TState, TState> action)
+        internal static PeriodicWorkItem<TState> Start(
+            TState state,
+            TimeSpan period,
+            Func<TState, TState> action,
+            TimeProvider timeProvider)
         {
             PeriodicWorkItem<TState> item = new(state, action);
-            Timer timer = new(
+            var timer = timeProvider.CreateTimer(
                 static s => ((PeriodicWorkItem<TState>)s!).Tick(),
                 item,
                 Timeout.InfiniteTimeSpan,
@@ -443,10 +394,7 @@ internal static PeriodicWorkItem<TState> Start(TState state, TimeSpan period, Fu
             return item;
         }
 
-        /// <summary>
-        /// Runs one periodic tick. Internal rather than private so a test can drive the tick a timer callback already
-        /// in flight would deliver after <see cref="Dispose"/> won the race, and prove the action does not run.
-        /// </summary>
+        /// <summary>Runs one periodic tick unless the work item is disposed.</summary>
         internal void Tick()
         {
             lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs b/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
index 467c2919..02ce2775 100644
--- a/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
@@ -11,19 +11,7 @@ namespace ReactiveUI.Primitives.Reactive.Disposables;
 /// <see cref="CompositeDisposable"/>, so an activation-scoped container flows into APIs written against
 /// System.Reactive - <c>DisposeWith</c> above all - without the caller converting it by hand.
 /// </summary>
-/// <remarks>
-/// <para>
-/// The conversion is identity-stable: every conversion of the same container yields the same
-/// <see cref="CompositeDisposable"/>, and the container owns that composite, so anything registered through it
-/// is disposed when the container is. Registering after the container is disposed disposes the registration
-/// immediately, matching <see cref="MultipleDisposable.Add"/>.
-/// </para>
-/// <para>
-/// Registrations made through the composite are not visible to the container's own
-/// <see cref="ICollection{T}"/> members: the composite occupies a single slot, so <c>Count</c> counts it once
-/// and <c>Contains</c>/<c>Remove</c> do not see through it.
-/// </para>
-/// </remarks>
+/// <remarks>Conversions reuse a composite owned by the container. Composite registrations occupy one container slot and are not individually visible through Count, Contains, or Remove.</remarks>
 [System.Diagnostics.DebuggerDisplay("ContainerDisposable: Count = {Count}, IsDisposed = {IsDisposed}")]
 public sealed class ContainerDisposable : MultipleDisposable
 {
@@ -79,9 +67,7 @@ public CompositeDisposable ToCompositeDisposable()
     {
         lock (_gate)
         {
-            // A disposed composite is still the right answer once the container itself is disposed - it is the
-            // sink that disposes late arrivals. After Clear() or Remove() the container lives on, so a composite
-            // it disposed has to be replaced rather than handed out again.
+            // Disposed containers reject late additions; live containers replace composites removed by Clear or Remove.
             var existing = _composite;
             if (existing is not null && (!existing.IsDisposed || IsDisposed))
             {
@@ -91,9 +77,7 @@ public CompositeDisposable ToCompositeDisposable()
             var created = new CompositeDisposable();
             _composite = created;
 
-            // Registering the composite with the container is what ties the two lifetimes together. On an
-            // already-disposed container this disposes the composite instead, which is what a caller adding to
-            // a disposed container should get.
+            // Register the composite so its lifetime follows the container.
             Add(created);
             return created;
         }
@@ -104,9 +88,7 @@ protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
 
-        // The composite occupies a slot in the container, so the base disposed it just now - or Clear()/Remove()
-        // did on the way out. Disposing it here is idempotent and states the ownership outright. Nothing in this
-        // hierarchy has a finalizer and the class is sealed, so this only ever runs on the deterministic path.
+        // The container owns the composite; repeated disposal is harmless.
         _composite?.Dispose();
     }
 }
diff --git a/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs b/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
index b9e73a39..56783db4 100644
--- a/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
@@ -19,13 +19,7 @@ public static partial class LinqExtensions
         /// <param name="disposables">The container.</param>
         /// <returns>The original disposable.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="disposables"/> is <see langword="null"/>.</exception>
-        /// <remarks>
-        /// A <see cref="ContainerDisposable"/> converts to a System.Reactive <c>CompositeDisposable</c>, so
-        /// without this overload a call site that imports both this namespace and System.Reactive's fluent
-        /// disposal helpers has two equally-good candidates - the inherited
-        /// <c>DisposeWith(MultipleDisposable)</c> and System.Reactive's <c>DisposeWith(CompositeDisposable)</c>
-        /// - and is ambiguous. Taking the container exactly makes this an identity match, which wins outright.
-        /// </remarks>
+        /// <remarks>This exact container overload resolves DisposeWith calls when System.Reactive's composite overload is also in scope.</remarks>
         public T DisposeWith(ContainerDisposable disposables)
         {
             ArgumentExceptionHelper.ThrowIfNull(disposables);
diff --git a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
index bc20bcf3..de0d9f10 100644
--- a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
@@ -17,10 +17,7 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency;
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class HandlerSequencer : CoalescingDispatchScheduler
 {
-    /// <summary>
-    /// Cached runnable wrapping the drain. The drain callback is invariant for the lifetime of the sequencer,
-    /// so the JNI runnable bridge is built once and reused for every posted batch rather than per post.
-    /// </summary>
+    /// <summary>JNI drain callback reused across posted batches.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
diff --git a/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
index 9ba8aed4..eff3ce0a 100644
--- a/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
@@ -21,10 +21,7 @@ public sealed class NSRunloopSequencer : CoalescingDispatchScheduler
     /// <summary>Nanoseconds per millisecond, used to convert a managed delay into a <see cref="DispatchTime"/> offset.</summary>
     private const long NanosecondsPerMillisecond = 1_000_000;
 
-    /// <summary>
-    /// Cached dispatch block wrapping the drain. The drain callback is invariant for the lifetime of the
-    /// sequencer, so the block is created once and re-enqueued for every posted batch rather than per post.
-    /// </summary>
+    /// <summary>Native drain callback reused across posted batches.</summary>
     private DispatchBlock? _drainBlock;
 
     /// <summary>Initializes a new instance of the <see cref="NSRunloopSequencer"/> class.</summary>
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
index b0a31c20..58638557 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
@@ -58,6 +58,7 @@ protected override bool Post(Action drain)
     }
 
     /// <inheritdoc/>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         var timer = DispatcherQueue.CreateTimer();
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net10.0-windows10.0.19041.0/PublicAPI.txt b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net10.0-windows10.0.19041.0/PublicAPI.txt
index cdd92cd7..0e98b297 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net10.0-windows10.0.19041.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net10.0-windows10.0.19041.0/PublicAPI.txt
@@ -21,6 +21,7 @@ public sealed class DispatcherQueueSequencer : ReactiveUI.Primitives.Reactive.Co
     public Microsoft.UI.Dispatching.DispatcherQueue DispatcherQueue { get; }
     public Microsoft.UI.Dispatching.DispatcherQueuePriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 public static class DispatcherQueueSequencerExtensions
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net11.0-windows10.0.19041.0/PublicAPI.txt b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net11.0-windows10.0.19041.0/PublicAPI.txt
index cdd92cd7..0e98b297 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net11.0-windows10.0.19041.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net11.0-windows10.0.19041.0/PublicAPI.txt
@@ -21,6 +21,7 @@ public sealed class DispatcherQueueSequencer : ReactiveUI.Primitives.Reactive.Co
     public Microsoft.UI.Dispatching.DispatcherQueue DispatcherQueue { get; }
     public Microsoft.UI.Dispatching.DispatcherQueuePriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 public static class DispatcherQueueSequencerExtensions
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net8.0-windows10.0.19041.0/PublicAPI.txt b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net8.0-windows10.0.19041.0/PublicAPI.txt
index cdd92cd7..0e98b297 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net8.0-windows10.0.19041.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net8.0-windows10.0.19041.0/PublicAPI.txt
@@ -21,6 +21,7 @@ public sealed class DispatcherQueueSequencer : ReactiveUI.Primitives.Reactive.Co
     public Microsoft.UI.Dispatching.DispatcherQueue DispatcherQueue { get; }
     public Microsoft.UI.Dispatching.DispatcherQueuePriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 public static class DispatcherQueueSequencerExtensions
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net9.0-windows10.0.19041.0/PublicAPI.txt b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net9.0-windows10.0.19041.0/PublicAPI.txt
index cdd92cd7..0e98b297 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net9.0-windows10.0.19041.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/PublicAPI/net9.0-windows10.0.19041.0/PublicAPI.txt
@@ -21,6 +21,7 @@ public sealed class DispatcherQueueSequencer : ReactiveUI.Primitives.Reactive.Co
     public Microsoft.UI.Dispatching.DispatcherQueue DispatcherQueue { get; }
     public Microsoft.UI.Dispatching.DispatcherQueuePriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
 public static class DispatcherQueueSequencerExtensions
diff --git a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
index e355b457..eae31d1f 100644
--- a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
@@ -57,7 +57,7 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
-    private string DebuggerDisplay => ToString() ?? string.Empty;
+    internal string DebuggerDisplay => ToString() ?? string.Empty;
 
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -85,6 +85,7 @@ private bool Post(Action drain)
     /// <summary>Runs delayed work on a dispatcher queue timer so it executes directly on the dispatcher thread.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
     {
         var timer = DispatcherQueue.CreateTimer();
diff --git a/src/ReactiveUI.Primitives.WinUI/Properties/AssemblyInfo.cs b/src/ReactiveUI.Primitives.WinUI/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..f20e0b73
--- /dev/null
+++ b/src/ReactiveUI.Primitives.WinUI/Properties/AssemblyInfo.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+
+[assembly: InternalsVisibleTo("ReactiveUI.Primitives.WinUI.Tests")]
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
index dca228a7..3c262918 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
@@ -44,6 +44,7 @@ protected override bool Post(Action drain)
     }
 
     /// <inheritdoc/>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         DispatcherTimer timer = new(Priority, Dispatcher) { Interval = dueTime };
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net10.0-windows/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net10.0-windows/PublicAPI.txt
index 2402cbe7..bd7a95e0 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net10.0-windows/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net10.0-windows/PublicAPI.txt
@@ -21,5 +21,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net11.0-windows/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net11.0-windows/PublicAPI.txt
index 2402cbe7..bd7a95e0 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net11.0-windows/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net11.0-windows/PublicAPI.txt
@@ -21,5 +21,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net462/PublicAPI.txt
index cad7393f..d8bf2565 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net462/PublicAPI.txt
@@ -20,5 +20,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net472/PublicAPI.txt
index cad7393f..d8bf2565 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net472/PublicAPI.txt
@@ -20,5 +20,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net48/PublicAPI.txt
index cad7393f..d8bf2565 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net48/PublicAPI.txt
@@ -20,5 +20,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net481/PublicAPI.txt
index cad7393f..d8bf2565 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net481/PublicAPI.txt
@@ -20,5 +20,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net8.0-windows/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net8.0-windows/PublicAPI.txt
index 2402cbe7..bd7a95e0 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net8.0-windows/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net8.0-windows/PublicAPI.txt
@@ -21,5 +21,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net9.0-windows/PublicAPI.txt b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net9.0-windows/PublicAPI.txt
index 2402cbe7..bd7a95e0 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net9.0-windows/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/PublicAPI/net9.0-windows/PublicAPI.txt
@@ -21,5 +21,6 @@ public sealed class DispatcherSequencer : ReactiveUI.Primitives.Reactive.Concurr
     public System.Windows.Threading.Dispatcher Dispatcher { get; }
     public System.Windows.Threading.DispatcherPriority Priority { get; }
     protected override bool Post(System.Action drain) { }
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     protected override System.IDisposable ScheduleOnDispatcher(System.Action work, System.TimeSpan dueTime) { }
 }
diff --git a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
index d03c06f8..9047b599 100644
--- a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
@@ -49,7 +49,7 @@ public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
-    private string DebuggerDisplay => ToString() ?? string.Empty;
+    internal string DebuggerDisplay => ToString() ?? string.Empty;
 
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -71,6 +71,7 @@ private bool Post(Action drain)
     /// <summary>Runs delayed work on a dispatcher timer so it executes directly on the dispatcher thread.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
     {
         DispatcherTimer timer =
diff --git a/src/ReactiveUI.Primitives.Wpf/Properties/AssemblyInfo.cs b/src/ReactiveUI.Primitives.Wpf/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..f9cae6c8
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Wpf/Properties/AssemblyInfo.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+
+[assembly: InternalsVisibleTo("ReactiveUI.Primitives.Wpf.Tests")]
diff --git a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
index 1493e25b..2fb26692 100644
--- a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
+++ b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
@@ -37,6 +37,9 @@ public record struct DispatchSequencerState
     /// <summary>Optional platform delayed-scheduling override; <see langword="null"/> uses the shared thread-pool timer.</summary>
     private readonly Action<IWorkItem, long>? _scheduleDelayed;
 
+    /// <summary>Schedules delayed work when the platform provides no override.</summary>
+    private readonly ISequencer _sharedTimer;
+
     /// <summary>Approximate number of ready items; snapshots a drain batch.</summary>
     private int _readyCount;
 
@@ -62,12 +65,29 @@ public DispatchSequencerState(
         Func<Action, bool> post,
         Action drain,
         Action<IWorkItem, long>? scheduleDelayed)
+        : this(owner, post, drain, scheduleDelayed, ThreadPoolSequencer.Instance)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="DispatchSequencerState"/> struct.</summary>
+    /// <param name="owner">The owning sequencer.</param>
+    /// <param name="post">Posts the cached drain.</param>
+    /// <param name="drain">The cached drain callback.</param>
+    /// <param name="scheduleDelayed">The optional platform delay override.</param>
+    /// <param name="sharedTimer">Schedules work without a platform delay override.</param>
+    internal DispatchSequencerState(
+        ISequencer owner,
+        Func<Action, bool> post,
+        Action drain,
+        Action<IWorkItem, long>? scheduleDelayed,
+        ISequencer sharedTimer)
     {
         _ready = new();
         _owner = owner;
         _post = post;
         _drain = drain;
         _scheduleDelayed = scheduleDelayed;
+        _sharedTimer = sharedTimer;
     }
 
     /// <summary>Gets the sequencer's notion of current time.</summary>
@@ -188,11 +208,7 @@ public void RunDrain()
         }
     }
 
-    /// <summary>Cancels and drops every ready work item, disposing each so its caller's handle is released.</summary>
-    /// <remarks>
-    /// Only <see cref="WasmSequencer"/> calls this: it owns the timer that is its dispatcher, so disposal leaves
-    /// nothing able to drain the queue, whereas the platform dispatchers outlive the sequencer and keep draining.
-    /// </remarks>
+    /// <summary>Releases queued items when the sequencer owns its dispatcher lifetime.</summary>
     internal void ReleaseQueued()
     {
         while (_ready.TryDequeue(out var item))
@@ -205,21 +221,17 @@ internal void ReleaseQueued()
         }
     }
 
-    // Only the live shared thread-pool timer coming due reaches this path, so coverage excludes it.
     /// <summary>Parks delayed work on the shared thread-pool timer, which marshals it back to the dispatcher when due.</summary>
     /// <param name="item">Work item to execute once due.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [ExcludeFromCodeCoverage]
     private readonly void ScheduleOnSharedTimer(IWorkItem item, long dueTimestamp) =>
-        ThreadPoolSequencer.Instance.Schedule(new MarshalOnDueWorkItem(_owner, item), dueTimestamp);
+        _sharedTimer.Schedule(new MarshalOnDueWorkItem(_owner, item), dueTimestamp);
 
-    // Constructed and run only by the shared thread-pool timer path, so coverage excludes it too.
     /// <summary>Work item used by the shared timer path to marshal delayed work back to the dispatcher.</summary>
     /// <param name="owner">Owning dispatch sequencer.</param>
     /// <param name="item">Work item to marshal.</param>
-    [ExcludeFromCodeCoverage]
-    private sealed class MarshalOnDueWorkItem(ISequencer owner, IWorkItem item) : IWorkItem
+    internal sealed class MarshalOnDueWorkItem(ISequencer owner, IWorkItem item) : IWorkItem
     {
         /// <summary>Owning dispatch sequencer.</summary>
         private readonly ISequencer _owner = owner;
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index e5b8b8fa..a609bb3a 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -110,11 +110,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         {
             SetRunning(true);
 
-            var dueTime = Sequencer.TimeUntil(dueTimestamp);
-            if (dueTime > TimeSpan.Zero)
-            {
-                Thread.Sleep(dueTime);
-            }
+            WaitIfNeeded(Sequencer.TimeUntil(dueTimestamp), Wait);
 
             try
             {
@@ -173,6 +169,19 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         queue.Enqueue(si);
     }
 
+    /// <summary>Waits only when work remains in the future.</summary>
+    /// <param name="dueTime">The remaining delay.</param>
+    /// <param name="wait">The wait operation.</param>
+    internal static void WaitIfNeeded(TimeSpan dueTime, Action<TimeSpan> wait)
+    {
+        if (dueTime <= TimeSpan.Zero)
+        {
+            return;
+        }
+
+        wait(dueTime);
+    }
+
     /// <summary>Gets the queued recursive work for the current thread.</summary>
     /// <returns>The current thread queue, if one exists.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -186,12 +195,25 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     /// <param name="running">Value indicating whether work is running.</param>
     private static void SetRunning(bool running) => _running = running;
 
+    /// <summary>Blocks the scheduling thread until delayed work becomes due.</summary>
+    /// <param name="dueTime">The remaining delay.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Wait(TimeSpan dueTime) => Thread.Sleep(dueTime);
+
     /// <summary>Runs queued current-thread work.</summary>
-    private static class Trampoline
+    internal static class Trampoline
     {
         /// <summary>Runs all work currently in the queue.</summary>
         /// <param name="queue">Queue to drain.</param>
-        public static void Run(SequencerQueue<long> queue)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Run(SequencerQueue<long> queue) => Run(queue, static () => Sequencer.Timestamp, Wait);
+
+        /// <summary>Drains work using the supplied clock and wait operation.</summary>
+        /// <param name="queue">The pending work.</param>
+        /// <param name="timestamp">The monotonic clock.</param>
+        /// <param name="wait">The wait operation.</param>
+        internal static void Run(SequencerQueue<long> queue, Func<long> timestamp, Action<TimeSpan> wait)
         {
             while (queue.Count > 0)
             {
@@ -201,11 +223,7 @@ public static void Run(SequencerQueue<long> queue)
                     continue;
                 }
 
-                var wait = Sequencer.TimeUntil(item.DueTime);
-                if (wait > TimeSpan.Zero)
-                {
-                    Thread.Sleep(wait);
-                }
+                WaitIfNeeded(Sequencer.TimeUntil(item.DueTime, timestamp()), wait);
 
                 if (!item.IsDisposed)
                 {
@@ -216,7 +234,7 @@ public static void Run(SequencerQueue<long> queue)
     }
 
     /// <summary>Cancellable action work item.</summary>
-    private sealed class ActionWorkItem : IWorkItem, IsDisposed
+    internal sealed class ActionWorkItem : IWorkItem, IsDisposed
     {
         /// <summary>Action to execute.</summary>
         private readonly Action _action;
diff --git a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
index f17d94db..b02cc01e 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
@@ -68,10 +68,18 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
 
-        var dueTime = Sequencer.TimeUntil(dueTimestamp);
+        RunScheduled(item, Sequencer.TimeUntil(dueTimestamp), Wait);
+    }
+
+    /// <summary>Waits for a relative delay and executes work that remains active.</summary>
+    /// <param name="item">The scheduled work.</param>
+    /// <param name="dueTime">The remaining delay.</param>
+    /// <param name="wait">The blocking wait operation.</param>
+    internal static void RunScheduled(IWorkItem item, TimeSpan dueTime, Action<TimeSpan> wait)
+    {
         if (dueTime.Ticks > 0)
         {
-            Thread.Sleep(dueTime);
+            wait(dueTime);
         }
 
         if (Sequencer.IsCancelled(item))
@@ -81,4 +89,10 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         item.Execute();
     }
+
+    /// <summary>Blocks the scheduling thread for the remaining delay.</summary>
+    /// <param name="dueTime">The remaining delay.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private static void Wait(TimeSpan dueTime) => Thread.Sleep(dueTime);
 }
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
index b3a8c1f1..1e5f1e32 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
@@ -45,9 +45,16 @@ internal static long AddTimestamp(long timestamp, TimeSpan dueTime)
     /// <summary>Calculates the remaining wall time until a monotonic timestamp.</summary>
     /// <param name="dueTimestamp">Absolute monotonic timestamp.</param>
     /// <returns>The remaining time until <paramref name="dueTimestamp"/>.</returns>
-    internal static TimeSpan TimeUntil(long dueTimestamp)
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    internal static TimeSpan TimeUntil(long dueTimestamp) => TimeUntil(dueTimestamp, Timestamp);
+
+    /// <summary>Calculates a delay from an explicit monotonic clock reading.</summary>
+    /// <param name="dueTimestamp">The absolute due timestamp.</param>
+    /// <param name="timestamp">The current clock reading.</param>
+    /// <returns>The nonnegative remaining delay.</returns>
+    internal static TimeSpan TimeUntil(long dueTimestamp, long timestamp)
     {
-        var delta = dueTimestamp - Timestamp;
+        var delta = dueTimestamp - timestamp;
         return delta <= 0
             ? TimeSpan.Zero
             : TimeSpan.FromSeconds(delta / (double)System.Diagnostics.Stopwatch.Frequency);
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
index cc5161d5..b56f57ff 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
@@ -9,17 +9,31 @@ namespace ReactiveUI.Primitives.Concurrency;
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class SynchronizationContextSequencer : ISequencer
 {
+    /// <summary>Schedules delayed marshal callbacks.</summary>
+    private readonly ISequencer _delaySequencer;
+
     /// <summary>Initializes a new instance of the <see cref="SynchronizationContextSequencer"/> class.</summary>
     /// <param name="context">The synchronization context used to schedule work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="context"/> is <see langword="null"/>.</exception>
-    public SynchronizationContextSequencer(SynchronizationContext context) =>
+    public SynchronizationContextSequencer(SynchronizationContext context)
+        : this(context, ThreadPoolSequencer.Instance)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="SynchronizationContextSequencer"/> class.</summary>
+    /// <param name="context">The context receiving ready work.</param>
+    /// <param name="delaySequencer">The scheduler delivering delayed callbacks.</param>
+    /// <exception cref="ArgumentNullException">The synchronization context is null.</exception>
+    internal SynchronizationContextSequencer(SynchronizationContext context, ISequencer delaySequencer)
+    {
         Context = context ?? throw new ArgumentNullException(nameof(context));
+        _delaySequencer = delaySequencer;
+    }
 
     /// <summary>Gets a sequencer for the current synchronization context.</summary>
     /// <exception cref="InvalidOperationException">There is no current synchronization context.</exception>
     public static SynchronizationContextSequencer Current
     {
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         get => new(SynchronizationContext.Current
             ?? throw new InvalidOperationException("There is no current synchronization context."));
     }
@@ -57,7 +71,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
             return;
         }
 
-        ThreadPoolSequencer.Instance.Schedule(new DelayedPostWorkItem(this, item), dueTimestamp);
+        _delaySequencer.Schedule(new DelayedPostWorkItem(this, item), dueTimestamp);
     }
 
     /// <summary>Executes the work item unless it has been cancelled.</summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
index cd26e04d..49341509 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
 
 namespace ReactiveUI.Primitives.Concurrency;
 
@@ -15,11 +14,26 @@ public sealed class TaskPoolSequencer : ISequencer
     /// <summary>Task factory used to schedule asynchronous work.</summary>
     private readonly TaskFactory _taskFactory;
 
+    /// <summary>Schedules delayed dispatch callbacks.</summary>
+    private readonly ISequencer _delaySequencer;
+
     /// <summary>Initializes a new instance of the <see cref="TaskPoolSequencer"/> class.</summary>
     /// <param name="taskFactory">The task factory.</param>
     /// <exception cref="ArgumentNullException"><paramref name="taskFactory"/> is <see langword="null"/>.</exception>
-    public TaskPoolSequencer(TaskFactory taskFactory) =>
+    public TaskPoolSequencer(TaskFactory taskFactory)
+        : this(taskFactory, ThreadPoolSequencer.Instance)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="TaskPoolSequencer"/> class.</summary>
+    /// <param name="taskFactory">The factory dispatching ready work.</param>
+    /// <param name="delaySequencer">The scheduler delivering delayed callbacks.</param>
+    /// <exception cref="ArgumentNullException">The task factory is null.</exception>
+    internal TaskPoolSequencer(TaskFactory taskFactory, ISequencer delaySequencer)
+    {
         _taskFactory = taskFactory ?? throw new ArgumentNullException(nameof(taskFactory));
+        _delaySequencer = delaySequencer;
+    }
 
     /// <summary>Gets the shared sequencer backed by <see cref="Task.Factory"/>.</summary>
     public static TaskPoolSequencer Instance { get; } = new(Task.Factory);
@@ -70,7 +84,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
             return;
         }
 
-        ThreadPoolSequencer.Instance.Schedule(new DelayedDispatchWorkItem(this, item), dueTimestamp);
+        _delaySequencer.Schedule(new DelayedDispatchWorkItem(this, item), dueTimestamp);
     }
 
     /// <summary>Executes a work item and routes unhandled exceptions.</summary>
@@ -95,7 +109,7 @@ private void Execute(IWorkItem item)
                 return;
             }
 
-            ExceptionDispatchInfo.Capture(ex).Throw();
+            throw;
         }
     }
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index defeae76..f18b34f6 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -26,12 +26,18 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
     private readonly PriorityQueue<TimedWorkItem> _queue = new();
 
     /// <summary>Single timer owned by the sequencer for all delayed work.</summary>
-    private readonly Timer _timer;
+    private readonly Timer? _timer;
 
-    /// <summary>
-    /// Non-zero once <see cref="Dispose"/> has released the timer and the queue; written under <see cref="_gate"/> so
-    /// timer paths are ordered against disposal, and read unlocked on the immediate path, which ignores the timer.
-    /// </summary>
+    /// <summary>Reads the monotonic clock used by the delay queue.</summary>
+    private readonly Func<long> _timestamp;
+
+    /// <summary>Queues an immediate callback.</summary>
+    private readonly Action<WaitCallback, object> _queueImmediate;
+
+    /// <summary>Updates the delay timer.</summary>
+    private readonly Action<TimeSpan> _changeTimer;
+
+    /// <summary>Non-zero after disposal; writes hold the gate, and immediate scheduling reads without it.</summary>
     private int _isDisposed;
 
     /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class; callers use <see cref="Instance"/>.</summary>
@@ -40,18 +46,37 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
         "SST2403:Do not let 'this' escape from a constructor",
         Justification =
             "The timer is created disarmed, so nothing can call back into it until Schedule arms it after construction.")]
-    internal ThreadPoolSequencer() =>
+    internal ThreadPoolSequencer()
+    {
         _timer = new(
             static state => ((ThreadPoolSequencer)state!).RunDue(),
             this,
             Timeout.InfiniteTimeSpan,
             Timeout.InfiniteTimeSpan);
+        _timestamp = static () => Sequencer.Timestamp;
+        _queueImmediate = QueueOnThreadPool;
+        _changeTimer = ChangeTimer;
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class.</summary>
+    /// <param name="timestamp">Reads the monotonic clock.</param>
+    /// <param name="queueImmediate">Queues an immediate callback.</param>
+    /// <param name="changeTimer">Updates the delay timer.</param>
+    internal ThreadPoolSequencer(
+        Func<long> timestamp,
+        Action<WaitCallback, object> queueImmediate,
+        Action<TimeSpan> changeTimer)
+    {
+        _timestamp = timestamp;
+        _queueImmediate = queueImmediate;
+        _changeTimer = changeTimer;
+    }
 
     /// <summary>Gets the scheduler's notion of current time.</summary>
     public DateTimeOffset Now => Sequencer.Now;
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
-    public long Timestamp => Sequencer.Timestamp;
+    public long Timestamp => _timestamp();
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -70,7 +95,7 @@ public void Schedule(IWorkItem item)
         ArgumentExceptionHelper.ThrowIfNull(item);
         ObjectDisposedExceptionHelper.ThrowIf(IsDisposed, this);
 
-        _ = ThreadPool.UnsafeQueueUserWorkItem(ImmediateCallback, item);
+        _queueImmediate(ImmediateCallback, item);
     }
 
     /// <summary>Schedules a work item to be executed through the thread pool at a monotonic timestamp.</summary>
@@ -90,8 +115,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         lock (_gate)
         {
-            // Checked under the gate disposal takes, so an item that reaches the queue is one disposal will see and
-            // release; it can never land behind a released timer.
+            // Queue under the disposal gate so accepted items are released during teardown.
             ObjectDisposedExceptionHelper.ThrowIf(IsDisposed, this);
 
             _queue.Enqueue(new(item, dueTimestamp));
@@ -106,9 +130,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     /// </summary>
     public void Dispose()
     {
-        // Arming the timer takes this gate too, so it cannot be re-armed after the release below. Timer.Dispose does
-        // not wait for an in-flight callback, so a drain blocked on the gate observes the disposed flag rather than
-        // deadlocking here.
+        // The gate prevents rearming after disposal; timer disposal does not wait for callbacks.
         lock (_gate)
         {
             if (IsDisposed)
@@ -117,25 +139,13 @@ public void Dispose()
             }
 
             Volatile.Write(ref _isDisposed, 1);
-            _timer.Dispose();
+            _timer?.Dispose();
             ReleaseQueuedNoLock();
         }
     }
 
-    /// <summary>Executes the work item unless it has been cancelled.</summary>
-    /// <param name="item">Work item to execute.</param>
-    private static void ExecuteQueued(IWorkItem item)
-    {
-        if (Sequencer.IsCancelled(item))
-        {
-            return;
-        }
-
-        item.Execute();
-    }
-
     /// <summary>Runs due delayed work.</summary>
-    private void RunDue()
+    internal void RunDue()
     {
         while (true)
         {
@@ -153,6 +163,26 @@ private void RunDue()
         }
     }
 
+    /// <summary>Queues the runtime callback on the thread pool.</summary>
+    /// <param name="callback">The callback to queue.</param>
+    /// <param name="state">The callback state.</param>
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void QueueOnThreadPool(WaitCallback callback, object state) =>
+        ThreadPool.UnsafeQueueUserWorkItem(callback, state);
+
+    /// <summary>Executes the work item unless it has been cancelled.</summary>
+    /// <param name="item">Work item to execute.</param>
+    private static void ExecuteQueued(IWorkItem item)
+    {
+        if (Sequencer.IsCancelled(item))
+        {
+            return;
+        }
+
+        item.Execute();
+    }
+
     /// <summary>Attempts to dequeue the next due item.</summary>
     /// <param name="item">The dequeued item.</param>
     /// <returns><see langword="true"/> when an item was dequeued.</returns>
@@ -198,8 +228,7 @@ private void ArmTimerNoLock()
     {
         if (IsDisposed)
         {
-            // Disposal released the timer and the queue under this same gate, so a drain unwinding on the timer's
-            // callback thread lands here and must not re-arm a released timer.
+            // A callback unwinding after disposal must not rearm the timer.
             return;
         }
 
@@ -210,13 +239,19 @@ private void ArmTimerNoLock()
 
         if (_queue.Count == 0)
         {
-            _ = _timer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+            _changeTimer(Timeout.InfiniteTimeSpan);
             return;
         }
 
-        _ = _timer.Change(Sequencer.TimeUntil(_queue.Peek().DueTimestamp), Timeout.InfiniteTimeSpan);
+        _changeTimer(Sequencer.TimeUntil(_queue.Peek().DueTimestamp, Timestamp));
     }
 
+    /// <summary>Arms the runtime delay timer.</summary>
+    /// <param name="dueTime">The remaining delay.</param>
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ChangeTimer(TimeSpan dueTime) => _timer!.Change(dueTime, Timeout.InfiniteTimeSpan);
+
     /// <summary>Delayed thread-pool work item queued in the sequencer heap.</summary>
     internal readonly struct TimedWorkItem : IComparable<TimedWorkItem>, IEquatable<TimedWorkItem>
     {
@@ -252,10 +287,7 @@ public override int GetHashCode() =>
             unchecked((RuntimeHelpers.GetHashCode(Item) * 397) ^ DueTimestamp.GetHashCode());
     }
 
-    /// <summary>
-    /// Stateful work item carrying the scheduled state and the sequencer handed back to the action, with the
-    /// run/cancel handshake that lets a cancellation arriving mid-run still release whatever the action returned.
-    /// </summary>
+    /// <summary>Runs an action with its state and releases its result if canceled during execution.</summary>
     /// <typeparam name="TState">The scheduled state type.</typeparam>
     /// <param name="owner">The owning sequencer.</param>
     /// <param name="state">The scheduled state.</param>
@@ -312,6 +344,17 @@ public void Dispose()
         internal void Queue(TimeSpan dueTime) =>
             _owner.Schedule(this, Sequencer.AddTimestamp(_owner.Timestamp, dueTime));
 
+        /// <summary>Releases a published result if cancellation owns the work item.</summary>
+        internal void ReleaseCanceledResult()
+        {
+            if (!IsDisposed)
+            {
+                return;
+            }
+
+            Interlocked.Exchange(ref _disposable, EmptyDisposable.Instance)?.Dispose();
+        }
+
         /// <summary>Runs scheduled work.</summary>
         private void Run()
         {
@@ -328,12 +371,7 @@ private void Run()
                 return;
             }
 
-            if (!IsDisposed)
-            {
-                return;
-            }
-
-            disposable.Dispose();
+            ReleaseCanceledResult();
         }
     }
 }
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
index 19e850c9..f502c324 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
@@ -10,13 +10,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>Builds the exception messages the virtual-time sequencers throw.</summary>
-/// <remarks>
-/// The parsed format sits on a non-generic type on purpose. A static field inside
-/// <see cref="VirtualTimeState{TAbsolute, TRelative}"/> is a field of each closed generic, so the format would be
-/// parsed once per type-argument pair; one shared instance serves every one of them. Frameworks without
-/// <c>CompositeFormat</c> fall back to formatting the literal.
-/// </remarks>
+/// <summary>Shares virtual-time message formats across clock types.</summary>
 internal static class VirtualTimeMessages
 {
     /// <summary>Format of the message thrown when the clock is advanced while the scheduler is already running.</summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
index 0750f8b5..54220103 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Mutable state and mechanics backing the virtual-time sequencers. A single sequencer owns one of these inline
-/// and forwards its public surface here, so the virtual-time logic lives in one place without inheritance or
-/// composition between the sequencer types. Per-clock arithmetic is supplied as delegates rather than overrides.
-/// </summary>
+/// <summary>Stores virtual-time state with delegate-supplied clock arithmetic.</summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <typeparam name="TRelative">Relative time representation type.</typeparam>
 [System.Diagnostics.CodeAnalysis.SuppressMessage(
@@ -306,8 +302,7 @@ internal readonly IDisposable ScheduleAbsolute<TState>(
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
 
-        // Copy the reference-typed queue into a local so the self-removal closure synchronizes through that
-        // reference rather than capturing the enclosing struct's "this" (not permitted for struct members).
+        // Capture the queue reference; a struct member cannot capture this in a closure.
         var queue = _queue;
 
         ScheduledItem<TAbsolute> si = new(dueTime, _comparer, self =>
diff --git a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
index 26897a66..23a1f68d 100644
--- a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
@@ -9,39 +9,32 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>
-/// Task-pool replacement for single-threaded event-loop runtimes such as browser WebAssembly: it never starts
-/// threads and never blocks. Immediate work is batched one drain per event-loop turn through a zero-due timer
-/// (a <c>setTimeout(0)</c> macrotask on WebAssembly, so the browser can render between batches); delayed work
-/// uses the shared timer, which the WebAssembly runtime backs with the JS event loop.
+/// Schedules batches on a single-threaded event loop without blocking or starting threads.
+/// Delayed work uses the shared timer; immediate batches yield between event-loop turns.
 /// </summary>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class WasmSequencer : ISequencer, IDisposable
 {
-    /// <summary>
-    /// Guards the drain timer. Every arm of the timer goes through <see cref="Post"/>, which takes this gate, and
-    /// <see cref="Dispose"/> releases the timer while holding it — so the timer can never be armed after it is gone.
-    /// </summary>
+    /// <summary>Serializes timer arming and disposal.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>One-shot timer used to yield a drain to the event loop.</summary>
-    private readonly Timer _timer;
+    private readonly Timer? _timer;
+
+    /// <summary>Posts a drain to the event loop.</summary>
+    private readonly Func<Action, bool> _postDrain;
+
+    /// <summary>Schedules the delayed marshal callback.</summary>
+    private readonly Action<IWorkItem, long> _scheduleDelayed;
 
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
-    /// <summary>
-    /// Non-zero once <see cref="Dispose"/> has released the drain timer and the ready queue. Written under
-    /// <see cref="_gate"/> so every path that touches the timer is ordered against disposal, but read without it
-    /// on the scheduling paths, which re-check it after enqueueing rather than holding the gate across a queue.
-    /// </summary>
+    /// <summary>Non-zero after disposal releases the timer and queue; timer access is serialized by the gate.</summary>
     private int _isDisposed;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="WasmSequencer"/> class. Callers use <see cref="Default"/>; this is
-    /// internal so a test can own an isolated sequencer it may dispose without shutting the shared singleton down for
-    /// every other test.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Correctness",
         "SST2403:Do not let 'this' escape from a constructor",
@@ -54,6 +47,18 @@ internal WasmSequencer()
             this,
             Timeout.InfiniteTimeSpan,
             Timeout.InfiniteTimeSpan);
+        _postDrain = ArmDrainTimer;
+        _scheduleDelayed = ThreadPoolSequencer.Instance.Schedule;
+        _state = new(this, Post, RunDrain, ScheduleDelayed);
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class.</summary>
+    /// <param name="postDrain">Posts a drain to the event loop.</param>
+    /// <param name="scheduleDelayed">Schedules the delayed marshal callback.</param>
+    internal WasmSequencer(Func<Action, bool> postDrain, Action<IWorkItem, long> scheduleDelayed)
+    {
+        _postDrain = postDrain;
+        _scheduleDelayed = scheduleDelayed;
         _state = new(this, Post, RunDrain, ScheduleDelayed);
     }
 
@@ -94,16 +99,12 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     }
 
     /// <summary>
-    /// Releases the drain timer this sequencer owns and cancels the ready work still queued behind it. Scheduling
-    /// through a disposed sequencer throws <see cref="ObjectDisposedException"/> rather than queueing work no drain
-    /// will ever reach. Delayed work still parked on the shared timer is released when it comes due, because the
-    /// caller cancels it through the handle it was given rather than through this sequencer.
+    /// Releases the drain timer and cancels queued work. Further scheduling throws.
+    /// Delayed work on the shared timer is released when due unless its caller cancels it first.
     /// </summary>
     public void Dispose()
     {
-        // Under the gate: every arm of the timer takes it too, so the timer can never be re-armed after it is
-        // released here. Timer.Dispose does not wait for an in-flight callback, so a drain blocked on the gate
-        // inside Post cannot deadlock this — it simply observes the disposed flag once it gets in, and backs off.
+        // Timer arming and disposal share the gate; disposal does not wait for active callbacks.
         lock (_gate)
         {
             if (IsDisposed)
@@ -112,18 +113,13 @@ public void Dispose()
             }
 
             Volatile.Write(ref _isDisposed, 1);
-            _timer.Dispose();
+            _timer?.Dispose();
         }
 
         _state.ReleaseQueued();
     }
 
-    /// <summary>
-    /// Enqueues ready work onto the drain without the disposed guard, releasing it again when a disposal raced the
-    /// enqueue. Internal rather than private so a test can drive the enqueue that was already past
-    /// <see cref="Schedule(IWorkItem)"/>'s disposed check when the disposal drained the ready queue, and prove the
-    /// item is handed back rather than stranded.
-    /// </summary>
+    /// <summary>Queues ready work and releases it if disposal overlaps the enqueue.</summary>
     /// <param name="item">Work item to execute on the next event-loop turn.</param>
     internal void ScheduleReady(IWorkItem item)
     {
@@ -132,32 +128,30 @@ internal void ScheduleReady(IWorkItem item)
     }
 
     /// <summary>Arms the drain timer to fire on the next event-loop turn.</summary>
-    /// <param name="_">
-    /// Ignored. The parameter exists only because <see cref="DispatchSequencerState"/> posts through a
-    /// <see cref="Func{T, TResult}"/> of <see cref="Action"/>; the drain callback is already carried by the timer's state.
-    /// </param>
+    /// <param name="drain">The callback to post.</param>
     /// <returns><see langword="true"/> when the timer accepted the change.</returns>
-    private bool Post(Action _)
+    private bool Post(Action drain)
     {
         lock (_gate)
         {
-            // Arming a released timer is a silent no-op that would leave the drain latch set on a drain that can
-            // never run. Refusing the post instead lets the engine hand the latch straight back; with the ready
-            // queue released and scheduling closed, there is nothing left for that drain to do anyway.
-            return !IsDisposed && _timer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+            // Reject posts after disposal so the drain claim is released.
+            return !IsDisposed && _postDrain(drain);
         }
     }
 
-    /// <summary>
-    /// Marshals delayed work back onto this sequencer's drain once the shared timer says it is due. This replaces the
-    /// engine's default marshal step, which would call back through <see cref="Schedule(IWorkItem)"/> and throw
-    /// <see cref="ObjectDisposedException"/> on the timer's thread for an item that came due after disposal.
-    /// </summary>
+    /// <summary>Returns due work to the drain, releasing it if the sequencer is disposed.</summary>
     /// <param name="item">Work item to run once it is due.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp) =>
-        ThreadPoolSequencer.Instance.Schedule(new DelayedWorkItem(this, item), dueTimestamp);
+        _scheduleDelayed(new DelayedWorkItem(this, item), dueTimestamp);
+
+    /// <summary>Arms the runtime drain timer.</summary>
+    /// <param name="drain">The cached callback carried by the timer.</param>
+    /// <returns>Whether the timer accepted the callback.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool ArmDrainTimer(Action drain) => _timer!.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
 
     /// <summary>Forwards the cached drain callback to the engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -174,11 +168,7 @@ private void ReleaseQueuedIfDisposed()
         _state.ReleaseQueued();
     }
 
-    /// <summary>
-    /// Delayed work held by the shared timer until it comes due, then marshalled onto the owner's drain. A sequencer
-    /// disposed while this waits can no longer drain anything, so the item is released to its caller instead of being
-    /// pushed into a queue that will never move again.
-    /// </summary>
+    /// <summary>Requeues work when due, or releases it if the sequencer is disposed.</summary>
     /// <param name="owner">The sequencer whose drain runs the item.</param>
     /// <param name="item">The work item to marshal.</param>
     private sealed class DelayedWorkItem(WasmSequencer owner, IWorkItem item) : IWorkItem
diff --git a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
index 4a2bcb30..d3611a72 100644
--- a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
@@ -20,10 +20,7 @@ public sealed class HandlerSequencer : ISequencer
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
-    /// <summary>
-    /// Cached runnable wrapping the drain. The drain callback is invariant for the lifetime of the sequencer,
-    /// so the JNI runnable bridge is built once and reused for every posted batch rather than per post.
-    /// </summary>
+    /// <summary>JNI drain callback reused across posted batches.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
diff --git a/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs b/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
index 94037799..4a9b5ef1 100644
--- a/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
+++ b/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
@@ -23,10 +23,7 @@ public sealed class NSRunloopSequencer : ISequencer
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
-    /// <summary>
-    /// Cached dispatch block wrapping the drain. The drain callback is invariant for the lifetime of the
-    /// sequencer, so the block is created once and re-enqueued for every posted batch rather than per post.
-    /// </summary>
+    /// <summary>Native drain callback reused across posted batches.</summary>
     private DispatchBlock? _drainBlock;
 
     /// <summary>Initializes a new instance of the <see cref="NSRunloopSequencer"/> class.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AllocationProbe.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AllocationProbe.cs
index a30ef906..d6392f13 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AllocationProbe.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AllocationProbe.cs
@@ -10,13 +10,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Harness-free allocation probe (<c>--alloc</c>). Measures the exact bytes allocated per operation
-/// with <see cref="GC.GetAllocatedBytesForCurrentThread"/>, reusing a single observer so the
-/// reported figure is the operator's own allocation -- not the per-op test observer that
-/// BenchmarkDotNet's <c>Allocated</c> column folds in. Run with:
-/// <c>dotnet run -c Release --project ... -- --alloc</c>.
-/// </summary>
+/// <summary>Measures per-operation allocation with a shared observer for the <c>--alloc</c> command.</summary>
 internal static class AllocationProbe
 {
     /// <summary>Shared single-character payload reused by reference/type-coercion probes.</summary>
@@ -107,7 +101,7 @@ internal static void Run()
         ProbePassThroughTerminal(observer, sparkObserver, intervalObserver, listObserver, arrayObserver);
 
         Section("Coverage-gap operators / factories");
-        ProbeCoverageGap(observer, listObserver, stringObserver, failSource);
+        ProbeOperatorsAndFactories(observer, listObserver, stringObserver, failSource);
 
         // Calm / Shift / DelayStart need time advancement; their allocation is captured by the
         // OperatorTimeSchedulerBenchmarks BDN "Allocated" column instead of this synchronous probe.
@@ -212,12 +206,12 @@ private static void ProbePassThroughTerminal(
         Row("CollectArray (range)", () => Signal.Sequence(0, Count).CollectArray().Subscribe(arrayObserver).Dispose());
     }
 
-    /// <summary>Probes coverage-gap operator and factory allocation.</summary>
+    /// <summary>Measures operator and factory allocations per subscription.</summary>
     /// <param name="observer">The reused integer observer.</param>
     /// <param name="listObserver">The reused list observer.</param>
     /// <param name="stringObserver">The reused string observer.</param>
     /// <param name="failSource">The shared failing source.</param>
-    private static void ProbeCoverageGap(
+    private static void ProbeOperatorsAndFactories(
         IntSignalWitness observer,
         CountingSignalWitness<IList<int>> listObserver,
         CountingSignalWitness<string> stringObserver,
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ConnectableMulticastBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ConnectableMulticastBenchmarks.cs
index c1759fb3..1f071301 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ConnectableMulticastBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ConnectableMulticastBenchmarks.cs
@@ -11,10 +11,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks the general multicast primitive (a connectable backed by a caller-supplied hub),
-/// which underlies the Publish/Share family.
-/// </summary>
+/// <summary>Benchmarks the general multicast primitive (a connectable backed by a caller-supplied hub), which underlies the Publish/Share family.</summary>
 [MemoryDiagnoser]
 public class ConnectableMulticastBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryStateTimerBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryStateTimerBenchmarks.cs
index adb9d8a2..5abf8532 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryStateTimerBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryStateTimerBenchmarks.cs
@@ -15,11 +15,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks the previously-uncovered factories: the closure-free <c>CreateWithState</c> against
-/// closure-based <c>Create</c>, the <c>Iterate</c> generator, the <c>Every</c>/<c>After</c> timer
-/// factories under virtual time, and the <c>FromEventPattern</c> event bridge.
-/// </summary>
+/// <summary>Benchmarks stateful factories, generators, virtual timers, and event subscriptions.</summary>
 [MemoryDiagnoser]
 [System.Diagnostics.DebuggerDisplay("FactoryStateTimerBenchmarks: Limit = {_limit}")]
 public class FactoryStateTimerBenchmarks
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorCombineLatestBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorCombineLatestBenchmarks.cs
index 0cc853d6..5dfdb760 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorCombineLatestBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorCombineLatestBenchmarks.cs
@@ -9,12 +9,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks latest-value combination across the shapes that reach different coordinators: the pairwise
-/// coordinator holds both values in typed fields, while three or more sources share one coordinator that keeps
-/// latest values in an <c>object?[]</c>. The tuple and list overloads sit on top of those, so their cases show
-/// what the result shape itself costs on each path.
-/// </summary>
+/// <summary>Benchmarks latest-value combination across pair, tuple, and list result shapes.</summary>
 [MemoryDiagnoser]
 public class OperatorCombineLatestBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
index 861edf2d..52a64aa6 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
@@ -13,10 +13,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks for the pass-through and materialization operators converted to dedicated signals
-/// (Tap, IgnoreValues, Spark/Unspark materialize round-trip, SubscribeOn, Reattempt).
-/// </summary>
+/// <summary>Benchmarks for the pass-through and materialization operators converted to dedicated signals (Tap, IgnoreValues, Spark/Unspark materialize round-trip, SubscribeOn, Reattempt).</summary>
 [MemoryDiagnoser]
 public class OperatorPassThroughBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulVariantBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulVariantBenchmarks.cs
index c22b883c..3513c0fc 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulVariantBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulVariantBenchmarks.cs
@@ -9,12 +9,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks the state-passing operator variants (MapWith / KeepWith / TapWith) against the
-/// closure-capturing equivalents in System.Reactive and R3. The Primitives variants pass runtime
-/// state explicitly with a cached static delegate, so they allocate no per-subscription closure;
-/// the comparison frameworks must capture the same runtime value in a closure.
-/// </summary>
+/// <summary>Compares explicit-state operators with closure-based equivalents in System.Reactive and R3.</summary>
 [MemoryDiagnoser]
 [System.Diagnostics.DebuggerDisplay("OperatorStatefulVariantBenchmarks: Factor = {_factor}, Threshold = {_threshold}")]
 public class OperatorStatefulVariantBenchmarks
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTakeBufferRecoverBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTakeBufferRecoverBenchmarks.cs
index 907a4e1d..31ed4acf 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTakeBufferRecoverBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTakeBufferRecoverBenchmarks.cs
@@ -10,10 +10,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks for the common, previously-uncovered operators: prefix truncation (Take), batching
-/// (Buffer / Chunk), and the error-handling path (Recover / Resume vs Catch).
-/// </summary>
+/// <summary>Benchmarks prefix truncation, batching, and error recovery across observable libraries.</summary>
 [MemoryDiagnoser]
 public class OperatorTakeBufferRecoverBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
index 1bb811b2..e123f901 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
@@ -235,9 +235,7 @@ private static IObservable<int> ThrowInt(ExtensionsLibrary library) =>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static IObservable<RxVoid> ThrowPrimitiveUnit() => Signal.Fail<RxVoid>(Boom);
 
-    /// <summary>
-    /// Creates the generated even-digit regex.
-    /// </summary>
+    /// <summary>Creates the generated even-digit regex.</summary>
     /// <returns>The generated regex instance.</returns>
     [GeneratedRegex("^[02468]$")]
     private static partial Regex EvenRegex();
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeBenchmarkRunner.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeBenchmarkRunner.cs
index d3284d5b..df1433b9 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeBenchmarkRunner.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeBenchmarkRunner.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Runs every benchmark scenario once and writes each result as a <c>key=value</c> row, so the
-/// libraries can be compared for parity by <see cref="SmokeParityValidator"/>. Row order is
-/// significant: the validator groups consecutive rows that share a scenario name.
-/// </summary>
+/// <summary>Runs each scenario once and writes consecutive key=value rows for parity comparison.</summary>
 internal static class SmokeBenchmarkRunner
 {
     /// <summary>Runs the deterministic smoke benchmark scenarios and writes their results to the console.</summary>
@@ -19,7 +15,7 @@ internal static async Task RunAsync()
         await RunOperatorSmokeAsync();
         RunSubjectSmoke();
         RunAsyncBridgeSmoke();
-        await RunExpansionSmokeBenchmarksAsync();
+        await RunOperatorAndFactorySmokeBenchmarksAsync();
         RunCoreRuntimeSmokeBenchmarks();
     }
 
@@ -130,9 +126,9 @@ private static void RunAsyncBridgeSmoke()
         Console.WriteLine($"R3CompletedTaskBridge={taskBridge.R3CompletedTaskBridge()}");
     }
 
-    /// <summary>Runs the expansion-coverage smoke benchmark scenarios and writes their results to the console.</summary>
-    /// <returns>A task that completes when all expansion smoke benchmarks have run.</returns>
-    private static async Task RunExpansionSmokeBenchmarksAsync()
+    /// <summary>Runs operator and factory smoke benchmarks and prints their results.</summary>
+    /// <returns>The asynchronous benchmark run.</returns>
+    private static async Task RunOperatorAndFactorySmokeBenchmarksAsync()
     {
         await RunFactoryAdapterExpansionSmokeAsync();
         RunTimeSchedulerSmoke();
@@ -269,10 +265,7 @@ private static async Task RunTerminalCollectionSmokeAsync()
         Console.WriteLine($"R3AllContains={await terminalCollections.R3AllContains()}");
     }
 
-    /// <summary>
-    /// Writes the synchronous array-collection smoke results from a non-async method so the
-    /// synchronous CollectArray benchmarks are measured without awaiting their async overloads.
-    /// </summary>
+    /// <summary>Writes the synchronous array-collection smoke results from a non-async method so the synchronous CollectArray benchmarks are measured without awaiting their async overloads.</summary>
     /// <param name="terminalCollections">The terminal-collection benchmarks instance.</param>
     private static void WriteSynchronousCollectArrayResults(TerminalCollectionBenchmarks terminalCollections)
     {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeParityValidator.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeParityValidator.cs
index c253ad07..1286e947 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeParityValidator.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SmokeParityValidator.cs
@@ -7,12 +7,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Validates the <c>key=value</c> rows written by <see cref="SmokeBenchmarkRunner"/>. Consecutive
-/// rows that normalize to the same scenario form a group, and every library in a group must produce
-/// the same value — except for the scheduling differences documented below, which are pinned to
-/// their known values so a change in behaviour is caught rather than silently accepted.
-/// </summary>
+/// <summary>Validates consecutive scenario groups against cross-library results and explicit scheduling expectations.</summary>
 internal static class SmokeParityValidator
 {
     /// <summary>The expected Primitives value for the documented SwitchRanges scheduling difference.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TerminalAsyncVariantBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TerminalAsyncVariantBenchmarks.cs
index 9fa39900..ac6f1f35 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TerminalAsyncVariantBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TerminalAsyncVariantBenchmarks.cs
@@ -9,10 +9,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks the async terminal variants (CollectListAsync, FirstOrDefaultAsync,
-/// LastOrDefaultAsync) against their System.Reactive and R3 task-returning equivalents.
-/// </summary>
+/// <summary>Benchmarks the async terminal variants (CollectListAsync, FirstOrDefaultAsync, LastOrDefaultAsync) against their System.Reactive and R3 task-returning equivalents.</summary>
 [MemoryDiagnoser]
 public class TerminalAsyncVariantBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TimerSlotBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TimerSlotBenchmarks.cs
index 8e519bbc..1cf86334 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TimerSlotBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/TimerSlotBenchmarks.cs
@@ -11,12 +11,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>
-/// Benchmarks the timer slot every repeating operator arms once per window. The burst cases elsewhere schedule
-/// a single timer for the whole run and so never show what re-arming costs; these advance the clock between
-/// values, which closes each window and forces a fresh arm, which is the rate that matters for a debounce over
-/// a slow-moving source or for a periodic tick.
-/// </summary>
+/// <summary>Measures timer rearming by advancing virtual time through one window per value.</summary>
 [MemoryDiagnoser]
 public class TimerSlotBenchmarks
 {
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/CorpusSize.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/CorpusSize.cs
index 202e8012..452df936 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/CorpusSize.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/CorpusSize.cs
@@ -5,7 +5,6 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 
 /// <summary>How much event-bearing source the benchmarks put in front of the generator.</summary>
-/// <remarks>Public because BenchmarkDotNet reads it off a public benchmark parameter.</remarks>
 public enum CorpusSize
 {
     /// <summary>One wrapped host, the shape a small view model has.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventCorpus.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventCorpus.cs
index 4dcd64fa..25452270 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventCorpus.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventCorpus.cs
@@ -7,19 +7,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 
-/// <summary>Builds the consumer source the generator is measured against.</summary>
-/// <remarks>
-/// <para>
-/// Every host carries one of each delegate shape the generator handles - the conventional sender and arguments
-/// pair, a parameterless action, a single payload, a multi-parameter delegate that becomes a tuple, and a
-/// task-returning handler - because the per-event work differs between them and a corpus of only the easy shape
-/// would flatter the emitter.
-/// </para>
-/// <para>
-/// One host per file, as real code is laid out. That is what makes the incremental cases mean what they claim:
-/// editing one host has to be editing one file, or the measurement is of re-parsing the whole corpus instead.
-/// </para>
-/// </remarks>
+/// <summary>Builds one event host per file, with every supported delegate shape.</summary>
 internal static class EventCorpus
 {
     /// <summary>The file name of the shared declarations every host file depends on.</summary>
@@ -84,13 +72,9 @@ public static class StaticHost
         return files;
     }
 
-    /// <summary>Builds one host's file with an extra event on it.</summary>
+    /// <summary>Changes one host's events while preserving its activation signature.</summary>
     /// <param name="index">The host index.</param>
     /// <returns>The file text.</returns>
-    /// <remarks>
-    /// The edit that has to invalidate exactly one wrapper: the activation overload's signature is untouched, every
-    /// other host is untouched, and only this host's own generated file has anything new to say.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static string HostSourceWithAddedEvent(int index) => HostSource(index, true);
 
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
index 55f2ac8b..e89003d2 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
@@ -11,33 +11,7 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 
 /// <summary>What the observable-event generator itself costs on a build and on a keystroke.</summary>
-/// <remarks>
-/// <para>
-/// These run the generator only. <c>RunGeneratorsAndUpdateCompilation</c> would also fold the generated trees back
-/// into a new compilation, and at this corpus size that parse-and-rebuild is several times the generator's own
-/// work - large enough to hide the difference between a cached run and a cold one entirely. It is Roslyn's cost
-/// and it is paid whatever the generator does, so it is left out of the measurement.
-/// </para>
-/// <para>
-/// <c>Cold</c> is a driver that has generated nothing yet, over the whole corpus: the build cost, paid once.
-/// </para>
-/// <para>
-/// <c>Unchanged</c> is the control, and the one to read first: a primed driver re-run against the very compilation
-/// it was primed against. Nothing has changed, so every cache that can hit does. Whatever it still costs is the
-/// floor, and if that floor sits at the <c>Cold</c> number then the caching is not buying wall-clock - however
-/// thoroughly the driver's own step table reports each step as cached.
-/// </para>
-/// <para>
-/// The remaining two are what an editor pays per keystroke. <c>UnrelatedEdit</c> touches a file no request depends
-/// on; <c>EventEdit</c> adds an event to exactly one host. Both are only interesting relative to <c>Unchanged</c>:
-/// against <c>Cold</c> they flatter whatever the floor already is.
-/// </para>
-/// <para>
-/// CPU sampling rather than an allocation column: everything here runs inside Roslyn, whose own work dominates
-/// both the time and the bytes, so a single inclusive total says nothing about which half moved. The trace names
-/// the frames, which is the only way to tell the generator's cost from the compiler's.
-/// </para>
-/// </remarks>
+/// <remarks>Measures generator execution for cold, unchanged, unrelated-edit, and event-edit inputs, excluding compilation updates.</remarks>
 [System.Diagnostics.DebuggerDisplay("EventGeneratorDriverBenchmarks: {Size}")]
 [SimpleJob(warmupCount: 5, iterationCount: 15)]
 [EventPipeProfiler(EventPipeProfile.CpuSampling)]
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
index f8cb9b89..860acf58 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
@@ -14,17 +14,7 @@ namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 /// Allocation baselines for the generator's cold and incremental runs, with a GC-verbose trace naming the frames
 /// the allocations come from. Opt in with <c>--filter "*GcProfile*"</c>.
 /// </summary>
-/// <remarks>
-/// <para>
-/// Only the largest corpus is profiled: it is where an allocation per event or per file actually shows up against
-/// the compiler's own overhead.
-/// </para>
-/// <para>
-/// The trace is the measurement, not a summary column. An inclusive per-operation total is nearly all Roslyn here
-/// - parsing, symbols, and the driver's own state - so it moves with the compiler rather than with this generator.
-/// What is actionable is which frames allocated, which is what the GC-verbose trace carries.
-/// </para>
-/// </remarks>
+/// <remarks>Profiles allocation call stacks for the largest event corpus.</remarks>
 [ShortRunJob]
 [EventPipeProfiler(EventPipeProfile.GcVerbose)]
 [System.Diagnostics.DebuggerDisplay("EventGeneratorGcProfileBenchmarks: {nameof(EventGeneratorGcProfileBenchmarks),nq}")]
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
index 8b97eef4..9bc12082 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
@@ -34,25 +34,16 @@ internal static class GeneratorHarness
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateColdState(CorpusSize size) =>
         (BuildCompilation(size), CreateDriver());
 
-    /// <summary>Creates a primed driver and the very compilation it was primed against.</summary>
+    /// <summary>Runs the generator with unchanged inputs to measure cache reuse.</summary>
     /// <param name="size">The corpus size.</param>
     /// <returns>The unchanged compilation and a driver that has already generated once.</returns>
-    /// <remarks>
-    /// The control the other incremental cases are only meaningful against: nothing whatsoever has changed, so
-    /// every cache that can hit must hit. Whatever this still costs is the floor no amount of caching removes, and
-    /// if it sits at the cold number then the caching is not buying wall-clock however green the step table looks.
-    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUnchangedState(CorpusSize size) =>
         RunOnce(size);
 
-    /// <summary>Creates a primed driver and a compilation edited somewhere no request depends on.</summary>
+    /// <summary>Runs the generator after editing a file unrelated to event activation.</summary>
     /// <param name="size">The corpus size.</param>
     /// <returns>The edited compilation and a driver that has already generated once.</returns>
-    /// <remarks>
-    /// This is the keystroke case: the consumer typed in a file that declares no event and calls no activation, so
-    /// a pipeline that caches properly should do nothing beyond re-scanning the one new tree.
-    /// </remarks>
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUnrelatedEditState(CorpusSize size)
     {
         var primed = RunOnce(size);
@@ -61,13 +52,9 @@ internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUn
         return (edited, primed.Driver);
     }
 
-    /// <summary>Creates a primed driver and a compilation whose first host gained an event.</summary>
+    /// <summary>Runs the generator after changing one host's event declarations.</summary>
     /// <param name="size">The corpus size.</param>
     /// <returns>The edited compilation and a driver that has already generated once.</returns>
-    /// <remarks>
-    /// One host's file is replaced and no other. The edit changes what exactly one wrapper exposes, so the cost
-    /// here is the floor for a real change rather than for a full regeneration.
-    /// </remarks>
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateEventEditState(CorpusSize size)
     {
         var primed = RunOnce(size);
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
index ba433a3e..8a49dcb4 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
@@ -6,8 +6,7 @@
 
 namespace ReactiveUI.Disposables.Tests;
 
-/// <summary>Coverage for <see cref="DisposableBag"/> — inline-slot fill, overflow growth,
-/// add-after-dispose immediate disposal, three-arg constructor, and dispose-order guarantees.</summary>
+/// <summary>Tests bag growth, disposal order, and additions after disposal.</summary>
 public class DisposableBagTests
 {
     /// <summary>Verifies that the parameterless constructor accepts inline slot fills and disposes both.</summary>
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
index ad95c2d2..98c0d3a7 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Disposables.Tests;
 
-/// <summary>Direct RxVoid tests for <see cref="DisposableSlotHelper"/>. Covers every reachable
-/// branch — the already-disposed pre-check, the steady-state assign, the swap-disposes-previous
-/// path, and the idempotent <c>TryDispose</c> latch. The single race-recheck step that fires
-/// only under a real concurrent dispose is isolated in <c>DisposeIfRaced</c> and excluded from
-/// coverage there.</summary>
+/// <summary>Tests slot assignment, replacement disposal, and idempotent disposal.</summary>
 public class DisposableSlotHelperTests
 {
     /// <summary>Verifies that an incoming value is disposed immediately if the slot is already disposed.</summary>
@@ -107,6 +103,37 @@ public async Task WhenTryDisposeOpen_ThenLatchesAndDisposesInner()
         await Assert.That(inner.DisposeCount).IsEqualTo(1);
     }
 
+    /// <summary>Verifies assignment cleanup releases a value stored after holder disposal.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenAssignmentOverlapsDisposal_ThenReleasesStoredValueOnce()
+    {
+        CountingDisposable incoming = new();
+        IDisposable? slot = incoming;
+        var disposed = DisposableSlotHelper.DisposedSentinel;
+
+        DisposableSlotHelper.DisposeIfRaced(ref slot, ref disposed);
+        DisposableSlotHelper.DisposeIfRaced(ref slot, ref disposed);
+
+        await Assert.That(slot).IsNull();
+        await Assert.That(incoming.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies assignment cleanup leaves a live holder's value installed.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenAssignmentCompletesBeforeDisposal_ThenRetainsStoredValue()
+    {
+        CountingDisposable incoming = new();
+        IDisposable? slot = incoming;
+        var disposed = 0;
+
+        DisposableSlotHelper.DisposeIfRaced(ref slot, ref disposed);
+
+        await Assert.That(slot).IsSameReferenceAs(incoming);
+        await Assert.That(incoming.DisposeCount).IsEqualTo(0);
+    }
+
     /// <summary>Disposable used to verify dispose counts.</summary>
     private sealed class CountingDisposable : IDisposable
     {
diff --git a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
index a14d149f..ea249eb9 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
@@ -6,16 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Reactive.Tests;
 
-/// <summary>
-/// Exercises the scheduling seam the Reactive async leaf uses to give <c>IScheduler</c> the sequencer shape the
-/// shared source expects. Every overload must run the work it is handed on the supplied scheduler; the immediate
-/// scheduler used here runs it before <c>Schedule</c> returns.
-/// <para>
-/// This file deliberately does not import <c>System.Reactive.Concurrency</c>: the <c>Scheduler</c> class in that
-/// namespace carries extension methods with the same signatures, and importing it would make every call below
-/// ambiguous. The scheduler types are therefore spelled out in full.
-/// </para>
-/// </summary>
+/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
 public class SequencerSchedulingTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -112,10 +103,7 @@ public async Task WhenStatefulActionScheduledAfterRelativeDueTime_ThenTheStateIs
         await Assert.That(received).IsEqualTo(ScheduledState);
     }
 
-    /// <summary>
-    /// Records that the scheduler ran a plain action. Holding the flag here lets the action overloads be handed
-    /// <see cref="Record"/> as a method group, so the callback closes over nothing.
-    /// </summary>
+    /// <summary>Records action invocation through a method-group callback.</summary>
     private sealed class RunRecorder
     {
         /// <summary>Gets a value indicating whether the scheduler ran the action.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
index 4cc6cfab..d46068bd 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncPrimitiveContractTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Async;
+using ReactiveUI.Primitives.Async.Tests;
 using ReactiveUI.Primitives.Concurrency;
 using AsyncObs = ReactiveUI.Primitives.Async.SignalAsync;
 
@@ -115,9 +116,6 @@ public sealed class AsyncPrimitiveContractTests
     /// <summary>Expected sequence four, five.</summary>
     private static readonly int[] FourFive = [4, 5];
 
-    /// <summary>Expected sequence zero, one.</summary>
-    private static readonly long[] ZeroOne = [0, 1];
-
     /// <summary>Expected single-element sequence containing zero.</summary>
     private static readonly long[] ZeroOnly = [0];
 
@@ -168,9 +166,9 @@ public async Task PrimitivesFactoryAliasesCoverRemainingWrappers()
         var enumerable = await AsyncObs.FromEnumerable(FourFive).ToListAsync();
         var asyncEnumerable = await AsyncObs.FromAsyncEnumerable(ReadValuesAsync()).ToListAsync();
         var after = await AsyncObs.After(TimeSpan.Zero).ToListAsync();
-        var periodicAfter = await AsyncObs.After(TimeSpan.Zero, period).Take(Two).ToListAsync();
-        var every = await AsyncObs.Every(period).Take(1).ToListAsync();
-        var pulse = await AsyncObs.Pulse(period).Take(1).ToListAsync();
+        var periodicAfter = AsyncObs.After(TimeSpan.Zero, period);
+        var every = AsyncObs.Every(period);
+        var pulse = AsyncObs.Pulse(period);
         var chained = await AsyncObs.Chain(AsyncObs.Emit(FirstValue), AsyncObs.Emit(SecondValue)).ToListAsync();
         var blended = await AsyncObs.Blend(AsyncObs.Emit(ThirdValue), AsyncObs.Emit(FourthValue)).ToListAsync();
         List<int> subscribed = [];
@@ -179,9 +177,15 @@ public async Task PrimitivesFactoryAliasesCoverRemainingWrappers()
         await Assert.That(enumerable.SequenceEqual(FourFive)).IsTrue();
         await Assert.That(asyncEnumerable.SequenceEqual(FourFive)).IsTrue();
         await Assert.That(after.SequenceEqual(ZeroOnly)).IsTrue();
-        await Assert.That(periodicAfter.SequenceEqual(ZeroOne)).IsTrue();
-        await Assert.That(every.SequenceEqual(ZeroOnly)).IsTrue();
-        await Assert.That(pulse.SequenceEqual(ZeroOnly)).IsTrue();
+        await Assert.That(periodicAfter).IsTypeOf<TimerSignal>();
+        await Assert.That(every).IsTypeOf<TimerSignal>();
+        await Assert.That(pulse).IsTypeOf<TimerSignal>();
+        await Assert.That(((TimerSignal)periodicAfter).DueTime).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(((TimerSignal)periodicAfter).Period).IsEqualTo(period);
+        await Assert.That(((TimerSignal)every).DueTime).IsEqualTo(period);
+        await Assert.That(((TimerSignal)every).Period).IsEqualTo(period);
+        await Assert.That(((TimerSignal)pulse).DueTime).IsEqualTo(period);
+        await Assert.That(((TimerSignal)pulse).Period).IsEqualTo(period);
         await Assert.That(chained.SequenceEqual(OneTwo)).IsTrue();
         await Assert.That(blended.Count).IsEqualTo(BlendedCount);
         await Assert.That(blended).Contains(ThirdValue);
@@ -364,22 +368,11 @@ public async Task ObserveOnSequencerSchedulesDirectWorkItems()
     [Test]
     public async Task ShiftAndExpireAliasesUseTimeBasedOperators()
     {
-        const int EmittedValue = 3;
-        const int DelayMilliseconds = 1;
-        var shifted = await AsyncObs.Emit(EmittedValue).Shift(TimeSpan.FromMilliseconds(DelayMilliseconds))
-            .ToListAsync();
-        await Assert.That(shifted.SequenceEqual(ThreeOnly)).IsTrue();
-        TimeoutException? timeout = null;
-        try
-        {
-            await AsyncObs.Never<int>().Expire(TimeSpan.FromMilliseconds(DelayMilliseconds)).ToListAsync();
-        }
-        catch (TimeoutException exception)
-        {
-            timeout = exception;
-        }
-
-        await Assert.That(timeout).IsNotNull();
+        const int ThirdValue = 3;
+        var shifted = AsyncObs.Emit(ThirdValue).Shift(TimeSpan.FromSeconds(1));
+        var expired = AsyncObs.Never<int>().Expire(TimeSpan.FromSeconds(1));
+        await Assert.That(shifted).IsTypeOf<SignalAsyncExtensions.DelaySignal<int>>();
+        await Assert.That(expired).IsTypeOf<SignalAsyncExtensions.TimeoutSignal<int>>();
     }
 
     /// <summary>Drains queued sequencer work until the supplied task completes.</summary>
@@ -404,7 +397,7 @@ private static async Task<T> DrainUntilComplete<T>(Task<T> task, QueuedSequencer
         }
     }
 
-    /// <summary>Reads a short async enumerable sequence for factory alias coverage.</summary>
+    /// <summary>Yields two values after an asynchronous suspension.</summary>
     /// <returns>The async enumerable values.</returns>
     private static async IAsyncEnumerable<int> ReadValuesAsync()
     {
@@ -413,7 +406,6 @@ private static async IAsyncEnumerable<int> ReadValuesAsync()
         yield return FourFive[1];
     }
 
-    /// <summary>Test sequencer that queues scheduled work until drained explicitly.</summary>
     /// <summary>Verifies the asynchronous and stateful map/keep aliases forward to their canonical operators.</summary>
     /// <param name = "source">The 1..3 sequence under test.</param>
     /// <returns>A task to monitor completion.</returns>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
index 1406e851..7c5db18a 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
@@ -8,13 +8,67 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Covers renamed async internal members and scheduler adapters that are part of the current PR diff.</summary>
+/// <summary>Tests async context defaults and scheduler adapters.</summary>
 public sealed class AsyncRenameCoverageTests
 {
-    /// <summary>How long a test waits for work routed through the unhandled-exception hook or a sequencer.</summary>
-    private const int WaitTimeoutSeconds = 5;
+    /// <summary>Verifies that context capture prefers the current synchronization context.</summary>
+    /// <param name="installContext">Whether a synchronization context is installed.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenCapturingCurrentContext_ThenSynchronizationContextTakesPrecedence(bool installContext)
+    {
+        var originalContext = SynchronizationContext.Current;
+        var originalScheduler = TaskScheduler.Current;
+        var context = installContext ? new SynchronizationContext() : null;
+        AsyncContext captured;
+        try
+        {
+            SynchronizationContext.SetSynchronizationContext(context);
+            captured = AsyncContext.GetCurrent();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(originalContext);
+        }
+
+        await Assert.That(captured.SynchronizationContext).IsSameReferenceAs(context);
+        await Assert.That(captured.TaskScheduler).IsSameReferenceAs(installContext ? null : originalScheduler);
+    }
+
+    /// <summary>Verifies that context capture retains a manually executed task's scheduler.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenCapturingContextInsideScheduledTask_ThenUsesItsScheduler()
+    {
+        QueuedSequencer sequencer = new();
+        AsyncContext.SequencerTaskScheduler scheduler = new(sequencer);
+        var pending = Task.Factory.StartNew(
+            static () =>
+            {
+                var originalContext = SynchronizationContext.Current;
+                try
+                {
+                    SynchronizationContext.SetSynchronizationContext(null);
+                    return AsyncContext.GetCurrent();
+                }
+                finally
+                {
+                    SynchronizationContext.SetSynchronizationContext(originalContext);
+                }
+            },
+            CancellationToken.None,
+            TaskCreationOptions.DenyChildAttach,
+            scheduler);
+        await Assert.That(pending.IsCompleted).IsFalse();
+        sequencer.DrainAll();
+        var captured = await pending;
+        await Assert.That(captured.TaskScheduler).IsSameReferenceAs(scheduler);
+        await Assert.That(captured.SynchronizationContext).IsNull();
+    }
 
-    /// <summary>Verifies renamed <see cref = "AsyncContext"/> default-context and sequencer scheduler members.</summary>
+    /// <summary>Verifies default-context and sequencer scheduler behavior.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task AsyncContextRenamedMembersExposeDefaultAndSequencerSchedulerPaths()
@@ -46,7 +100,7 @@ public async Task AsyncContextRenamedMembersExposeDefaultAndSequencerSchedulerPa
             scheduler);
         await Assert.That(task.IsCompleted).IsFalse();
         sequencer.DrainAll();
-        await task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+        await task.ConfigureAwait(false);
         await Assert.That(probe.Ran).IsTrue();
         await Assert.That(probe.ObservedSameContext).IsTrue();
         await Assert.That(
@@ -70,7 +124,7 @@ public async Task AsyncContextSwitcherBranchesCoverCustomSchedulersAndCancellati
         var schedulerAwaitable = AsyncContext.From(CustomTaskScheduler.Instance)
             .SwitchContextAsync(true, CancellationToken.None);
         schedulerAwaitable.OnCompleted(scheduled.SetResult);
-        await scheduled.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+        await scheduled.Task.ConfigureAwait(false);
     }
 
     /// <summary>Verifies task-signal completion failures are routed through the unhandled exception hook.</summary>
@@ -83,7 +137,7 @@ public async Task TaskSignalSubscriptionCompleteWithFailureReportsThrownCompleti
         ThrowingCompletionWitness observer = new(expected);
         await TaskSignalSubscription<int>.CompleteWithFailureAsync(observer, new InvalidOperationException("source"))
             .ConfigureAwait(false);
-        var reported = await unhandled.WaitForAsync(expected.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+        var reported = await unhandled.WaitForAsync(expected.Message).ConfigureAwait(false);
         await Assert.That(reported).IsSameReferenceAs(expected);
     }
 
@@ -112,7 +166,7 @@ public async Task ObserverAsyncDisposeReportsAssignedSubscriptionFailure()
         RenameCoverageWitness observer = new();
         await observer.AssignSourceSubscriptionAsync(new ThrowingAsyncDisposable(expected)).ConfigureAwait(false);
         await observer.DisposeAsync().ConfigureAwait(false);
-        var reported = await unhandled.WaitForAsync(expected.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+        var reported = await unhandled.WaitForAsync(expected.Message).ConfigureAwait(false);
         await Assert.That(reported).IsSameReferenceAs(expected);
     }
 
@@ -127,7 +181,7 @@ public async Task RouteObserverErrorAsyncReportsCanceledAndThrownHandlerPaths()
         using CancellationTokenSource cancellation = new();
         await cancellation.CancelAsync().ConfigureAwait(false);
         await canceledObserver.RouteObserverErrorAsync(canceledError, cancellation.Token).ConfigureAwait(false);
-        var canceledReported = await unhandled.WaitForAsync(canceledError.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds))
+        var canceledReported = await unhandled.WaitForAsync(canceledError.Message)
             .ConfigureAwait(false);
         await Assert.That(canceledReported).IsSameReferenceAs(canceledError);
         InvalidOperationException operationCanceledError = new("route-operation-canceled");
@@ -135,13 +189,13 @@ public async Task RouteObserverErrorAsyncReportsCanceledAndThrownHandlerPaths()
         await operationCanceledObserver.RouteObserverErrorAsync(operationCanceledError, CancellationToken.None)
             .ConfigureAwait(false);
         var operationCanceledReported = await unhandled
-            .WaitForAsync(operationCanceledError.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+            .WaitForAsync(operationCanceledError.Message).ConfigureAwait(false);
         await Assert.That(operationCanceledReported).IsSameReferenceAs(operationCanceledError);
         InvalidOperationException handlerError = new("route-handler");
         RenameCoverageWitness throwingObserver = new((_, _) => throw handlerError);
         await throwingObserver.RouteObserverErrorAsync(new InvalidOperationException("source"), CancellationToken.None)
             .ConfigureAwait(false);
-        var handlerReported = await unhandled.WaitForAsync(handlerError.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds))
+        var handlerReported = await unhandled.WaitForAsync(handlerError.Message)
             .ConfigureAwait(false);
         await Assert.That(handlerReported).IsSameReferenceAs(handlerError);
     }
@@ -155,7 +209,7 @@ public async Task ObserverAsyncCompletionSlowPathReportsThrownCompletion()
         InvalidOperationException expected = new("completion-slow");
         RenameCoverageWitness observer = new(onCompleted: _ => new(Task.FromException(expected)));
         await observer.OnCompletedAsync(Result.Success).ConfigureAwait(false);
-        var reported = await unhandled.WaitForAsync(expected.Message, TimeSpan.FromSeconds(WaitTimeoutSeconds)).ConfigureAwait(false);
+        var reported = await unhandled.WaitForAsync(expected.Message).ConfigureAwait(false);
         await Assert.That(reported).IsSameReferenceAs(expected);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
index 6c23947b..04c8123c 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Coverage for <see cref="AsyncSerialGate"/> — uncontended fast path, same-thread reentry, contended slow path, double-dispose idempotency.</summary>
+/// <summary>Tests gate acquisition, reentry, contention and idempotent disposal.</summary>
 public class AsyncSerialGateTests
 {
     /// <summary>Verifies that the uncontended fast path acquires the gate via pure CAS.</summary>
@@ -54,49 +54,19 @@ public async Task WhenSameThreadReentry_ThenAllowedWithoutBlocking()
         }
     }
 
-    /// <summary>Verifies that a contended waiter resumes via the semaphore-signal slow path once the owning lock is released.</summary>
+    /// <summary>Verifies a waiting caller acquires the gate after its owner exits.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    /// <remarks>This intentionally avoids a "waiter has not resumed within Xms" timing assertion —
-    /// such a probe is unreliable across CI runners. What matters for coverage is that the slow path
-    /// (semaphore park + retry CAS) actually runs; we drive that by serialising two contenders so the
-    /// second must wait on the first's release.</remarks>
     [Test]
     public async Task WhenContendedWaiter_ThenResumesAfterRelease()
     {
-        const int ContentionTimeoutSeconds = 30;
         using AsyncSerialGate gate = new();
-        var first = await gate.EnterAsync();
-
-        TaskCompletionSource<bool> secondAcquired = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<bool> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        // Wait until the contender is either parked on the slow path (WaitersCount > 0) or
-        // has already acquired the gate via the same-thread reentry fast path (secondAcquired
-        // set). Either outcome is a valid configuration of AsyncSerialGate — what we care about for
-        // this test is that the contender ultimately gets the gate after we release it; the
-        // dual condition keeps the assertion stable across runners where Task.Run may reuse
-        // the test thread.
-        var contender = Task.Run(async () =>
-        {
-            using var lease = await gate.EnterAsync().ConfigureAwait(false);
-            _ = secondAcquired.TrySetResult(true);
-            await release.Task.ConfigureAwait(false);
-        });
-
-        var contenderReady = await AsyncTestHelpers.WaitForConditionAsync(
-            () => gate.WaitersCount >= 1 || secondAcquired.Task.IsCompleted,
-            TimeSpan.FromSeconds(ContentionTimeoutSeconds));
-        await Assert.That(contenderReady).IsTrue();
-
-        // Releasing the first acquisition is the only thing that can let a slow-path contender
-        // resume; a fast-path contender already completed and this is a no-op.
+        var first = await gate.EnterAsync(CancellationToken.None);
+        var second = gate.WaitForEntryAsync(CancellationToken.None);
+        await Assert.That(second.IsCompleted).IsFalse();
+        await Assert.That(gate.WaitersCount).IsEqualTo(1);
         first.Dispose();
-
-        var acquired = await secondAcquired.Task.WaitAsync(TimeSpan.FromSeconds(ContentionTimeoutSeconds));
-        await Assert.That(acquired).IsTrue();
-
-        _ = release.TrySetResult(true);
-        await contender;
+        using var lease = await second;
+        await Assert.That(gate.WaitersCount).IsEqualTo(0);
     }
 
     /// <summary>Verifies that double-dispose is idempotent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity10.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity10.cs
index b41c86c4..a5fad233 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity10.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity10.cs
@@ -116,7 +116,7 @@ public async Task WhenCombineLatest10OneSourceErrors_ThenCombinedErrorForwarded(
             });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -157,7 +157,7 @@ public async Task WhenCombineLatest10AllSourcesEmit_ThenSelectorResultEmitted()
                 },
                 null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
@@ -197,7 +197,7 @@ public async Task WhenCombineLatest10AllSourcesComplete_ThenCombinedCompletes()
             });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity11.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity11.cs
index 31b38fab..c6ee0ed5 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity11.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity11.cs
@@ -117,7 +117,7 @@ public async Task WhenCombineLatest11OneSourceErrors_ThenCombinedErrorForwarded(
         });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -153,7 +153,7 @@ public async Task WhenCombineLatest11AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) =>
                 v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10);
@@ -196,7 +196,7 @@ public async Task WhenCombineLatest11AllSourcesComplete_ThenCombinedCompletes()
         });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity12.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity12.cs
index a8ae6b2d..fa9b9b5a 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity12.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity12.cs
@@ -126,7 +126,7 @@ public async Task WhenCombineLatest12OneSourceErrors_ThenCombinedErrorForwarded(
             });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -164,7 +164,7 @@ public async Task WhenCombineLatest12AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) =>
                 v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10 + PlaceValue11);
@@ -212,7 +212,7 @@ public async Task WhenCombineLatest12AllSourcesComplete_ThenCombinedCompletes()
             });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity13.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity13.cs
index eb3b10d8..e48910db 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity13.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity13.cs
@@ -131,7 +131,7 @@ public async Task WhenCombineLatest13OneSourceErrors_ThenCombinedErrorForwarded(
             });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -171,7 +171,7 @@ public async Task WhenCombineLatest13AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) =>
                 v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10 + PlaceValue11 + PlaceValue12);
@@ -221,7 +221,7 @@ public async Task WhenCombineLatest13AllSourcesComplete_ThenCombinedCompletes()
             });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity14.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity14.cs
index fdc35945..3f8d88ce 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity14.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity14.cs
@@ -137,7 +137,7 @@ public async Task WhenCombineLatest14OneSourceErrors_ThenCombinedErrorForwarded(
             });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -179,7 +179,7 @@ public async Task WhenCombineLatest14AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) =>
                 v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10 + PlaceValue11 + PlaceValue12 + PlaceValue13);
@@ -231,7 +231,7 @@ public async Task WhenCombineLatest14AllSourcesComplete_ThenCombinedCompletes()
             });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity15.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity15.cs
index 2b8bf469..d6119581 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity15.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity15.cs
@@ -143,7 +143,7 @@ public async Task WhenCombineLatest15OneSourceErrors_ThenCombinedErrorForwarded(
             });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -187,7 +187,7 @@ public async Task WhenCombineLatest15AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) =>
                 v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10 + PlaceValue11 + PlaceValue12 + PlaceValue13
@@ -242,7 +242,7 @@ public async Task WhenCombineLatest15AllSourcesComplete_ThenCombinedCompletes()
             });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity16.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity16.cs
index 64233670..08801748 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity16.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity16.cs
@@ -147,7 +147,7 @@ public async Task WhenCombineLatest16OneSourceErrors_ThenCombinedErrorForwarded(
         });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -193,7 +193,7 @@ public async Task WhenCombineLatest16AllSourcesEmit_ThenSelectorResultEmitted()
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) => v1 + v2 + v3 + v4 + v5 + v6
                 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15 + v16).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8 + PlaceValue9
                                                 + PlaceValue10 + PlaceValue11 + PlaceValue12 + PlaceValue13
@@ -247,7 +247,7 @@ public async Task WhenCombineLatest16AllSourcesComplete_ThenCombinedCompletes()
         });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity9.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity9.cs
index 1b33aba1..2b8b80ce 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity9.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.Arity9.cs
@@ -11,9 +11,6 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// dispose guard, error forwarding, and the all-sources-emit happy path.</summary>
 public partial class CombineLatestArityTests
 {
-    /// <summary>How long an arity test waits for the combined sequence to emit, error, or complete.</summary>
-    private const int EmissionTimeoutSeconds = 5;
-
     /// <summary>The place values emitted by every source after the first, in selector order.</summary>
     private static readonly int[] TrailingPlaceValues =
     [
@@ -116,7 +113,7 @@ public async Task WhenCombineLatest9OneSourceErrors_ThenCombinedErrorForwarded()
                 });
         InvalidOperationException expected = new("source error");
         await s1.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await errorReceived.Task;
         await Assert.That(receivedError).IsEqualTo(expected);
     }
 
@@ -147,7 +144,7 @@ public async Task WhenCombineLatest9AllSourcesEmit_ThenSelectorResultEmitted()
             s9.Values,
             static (v1, v2, v3, v4, v5, v6, v7, v8, v9) => v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9).SubscribeAsync(RecordAndSignalValues(results, emitted), null);
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9);
-        await emitted.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        await emitted.Task;
         await Assert.That(results[0]).IsEqualTo(1 + PlaceValue1 + PlaceValue2 + PlaceValue3 + PlaceValue4
                                                 + PlaceValue5 + PlaceValue6 + PlaceValue7 + PlaceValue8);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9);
@@ -188,7 +185,7 @@ public async Task WhenCombineLatest9AllSourcesComplete_ThenCombinedCompletes()
                 });
         await EmitSeedAndPlaceValuesAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9);
         await CompleteAllAsync(s1, s2, s3, s4, s5, s6, s7, s8, s9);
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(EmissionTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.DisposedViaError.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.DisposedViaError.cs
index 6b59df8e..f7501bf5 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.DisposedViaError.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestArityTests.DisposedViaError.cs
@@ -42,7 +42,7 @@ public async Task WhenCombineLatest2DisposedViaError_ThenOnNextCombinedGuardHits
         await src1.EmitNext(1);
         await src2.EmitNext(SeedValue2);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src2.EmitNext(PostDisposeValue);
@@ -85,7 +85,7 @@ public async Task WhenCombineLatest2DisposedViaError_ThenOnErrorResumeGuardHits(
         await src1.EmitNext(1);
         await src2.EmitNext(SeedValue2);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src2.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -130,7 +130,7 @@ public async Task WhenCombineLatest3DisposedViaError_ThenOnNextCombinedGuardHits
         await src2.EmitNext(SeedValue2);
         await src3.EmitNext(SeedValue3);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src3.EmitNext(PostDisposeValue);
@@ -175,7 +175,7 @@ public async Task WhenCombineLatest3DisposedViaError_ThenOnErrorResumeGuardHits(
         await src2.EmitNext(SeedValue2);
         await src3.EmitNext(SeedValue3);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src3.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -222,7 +222,7 @@ public async Task WhenCombineLatest4DisposedViaError_ThenOnNextCombinedGuardHits
         await src3.EmitNext(SeedValue3);
         await src4.EmitNext(SeedValue4);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src4.EmitNext(PostDisposeValue);
@@ -269,7 +269,7 @@ public async Task WhenCombineLatest4DisposedViaError_ThenOnErrorResumeGuardHits(
         await src3.EmitNext(SeedValue3);
         await src4.EmitNext(SeedValue4);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src4.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -318,7 +318,7 @@ public async Task WhenCombineLatest5DisposedViaError_ThenOnNextCombinedGuardHits
         await src4.EmitNext(SeedValue4);
         await src5.EmitNext(SeedValue5);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src5.EmitNext(PostDisposeValue);
@@ -367,7 +367,7 @@ public async Task WhenCombineLatest5DisposedViaError_ThenOnErrorResumeGuardHits(
         await src4.EmitNext(SeedValue4);
         await src5.EmitNext(SeedValue5);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src5.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -418,7 +418,7 @@ public async Task WhenCombineLatest6DisposedViaError_ThenOnNextCombinedGuardHits
         await src5.EmitNext(SeedValue5);
         await src6.EmitNext(SeedValue6);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src6.EmitNext(PostDisposeValue);
@@ -469,7 +469,7 @@ public async Task WhenCombineLatest6DisposedViaError_ThenOnErrorResumeGuardHits(
         await src5.EmitNext(SeedValue5);
         await src6.EmitNext(SeedValue6);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src6.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -522,7 +522,7 @@ public async Task WhenCombineLatest7DisposedViaError_ThenOnNextCombinedGuardHits
         await src6.EmitNext(SeedValue6);
         await src7.EmitNext(SeedValue7);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src7.EmitNext(PostDisposeValue);
@@ -575,7 +575,7 @@ public async Task WhenCombineLatest7DisposedViaError_ThenOnErrorResumeGuardHits(
         await src6.EmitNext(SeedValue6);
         await src7.EmitNext(SeedValue7);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src7.EmitError(new InvalidOperationException(IgnoredMessage));
@@ -637,7 +637,7 @@ public async Task WhenCombineLatest8DisposedViaError_ThenOnNextCombinedGuardHits
         await src7.EmitNext(SeedValue7);
         await src8.EmitNext(SeedValue8);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src8.EmitNext(PostDisposeValue);
@@ -699,7 +699,7 @@ public async Task WhenCombineLatest8DisposedViaError_ThenOnErrorResumeGuardHits(
         await src7.EmitNext(SeedValue7);
         await src8.EmitNext(SeedValue8);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         await src8.EmitError(new InvalidOperationException(IgnoredMessage));
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestEnumerableInternalsTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestEnumerableInternalsTests.cs
index 26933879..917de991 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestEnumerableInternalsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestEnumerableInternalsTests.cs
@@ -6,15 +6,10 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Direct unit tests for the internal types inside
-/// <c>SyncLatestEnumerableSignal{TSource,TResult}</c> that the public API path doesn't
-/// fully exercise — specifically the contractual <see cref="IAsyncDisposable.DisposeAsync"/>
-/// stub on <c>IndexedWitness</c>.</summary>
+/// <summary>Tests disposal of per-source sync-latest observers.</summary>
 public class CombineLatestEnumerableInternalsTests
 {
-    /// <summary>Verifies the per-source <c>IndexedWitness</c>'s no-op <c>DisposeAsync</c> —
-    /// required by the <see cref="IObserverAsync{T}"/> contract but never invoked by the
-    /// pipeline, so coverage of the line otherwise relies on a direct call.</summary>
+    /// <summary>Verifies that disposing a per-source observer is a no-op.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenIndexedObserverDisposed_ThenNoOp()
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Combines4To8.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Combines4To8.cs
index 600ce094..05f81a93 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Combines4To8.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Combines4To8.cs
@@ -36,9 +36,7 @@ public async Task WhenCombineLatestFourSources_ThenCombinesAll()
         await s3.OnNextAsync(LargeStep1, CancellationToken.None);
         await s4.OnNextAsync(LargeStep3, CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ExpectedSum);
@@ -74,9 +72,7 @@ public async Task WhenCombineLatestFiveSources_ThenCombinesAll()
             await signals[i].OnNextAsync((i + 1) * ValueMultiplier, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ExpectedSum);
@@ -112,9 +108,7 @@ public async Task WhenCombineLatestSixSources_ThenCombinesAll()
             await signals[i].OnNextAsync(i + 1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ExpectedSum);
@@ -151,9 +145,7 @@ public async Task WhenCombineLatestSevenSources_ThenCombinesAll()
             await signals[i].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ExpectedSum);
@@ -191,9 +183,7 @@ public async Task WhenCombineLatestEightSources_ThenCombinesAll()
             await signals[i].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ExpectedSum);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableInitial.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableInitial.cs
index 475d8cb0..0d3fb2de 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableInitial.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableInitial.cs
@@ -36,9 +36,7 @@ public async Task WhenCombineLatestEnumerableErrorResume_ThenForwardedToObserver
             return default;
         });
         await s1.OnErrorResumeAsync(new InvalidOperationException("resume"), CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => received is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(received is not null).IsTrue();
         await Assert.That(received).IsNotNull();
         await Assert.That(received!.Message).IsEqualTo("resume");
     }
@@ -81,9 +79,7 @@ public async Task WhenCombineLatestEnumerableSourceCompletesWithoutEmitting_Then
 
         // s1 completes without emitting - should trigger completion since !_values[0].HasValue
         await s1.OnCompletedAsync(Result.Success);
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(completionResult is not null).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
index 2c617617..848021d7 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
@@ -150,9 +150,7 @@ public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCom
                 return default;
             });
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completion is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(completion is not null).IsTrue();
 
         await Assert.That(completion).IsNotNull();
         await Assert.That(completion!.Value.IsSuccess).IsTrue();
@@ -192,7 +190,7 @@ public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenReturnsEarly
         await src2.EmitNext(Source1Value);
 
         // Trigger failure on src1 → FinishAsync → _disposed=1 → blocks on OnCompletedAsync
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         // _disposed is 1, gate still alive → OnNextAsync should hit the guard
@@ -233,7 +231,7 @@ public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenRetur
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("test"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
         // _disposed is 1, gate still alive → OnErrorResumeAsync should hit the guard
@@ -312,35 +310,29 @@ public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCom
     [Test]
     public async Task WhenCombineLatestEnumerableDisposedDuringSubscribeLoop_ThenReturnsEarly()
     {
-        // First source triggers disposal when subscribed
-        TaskCompletionSource<IAsyncDisposable> disposeTrigger = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource entered = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var slowSource = AsyncObs.Create<int>(async (_, ct) =>
         {
-            var disp = await disposeTrigger.Task.WaitAsync(ct);
-            await disp.DisposeAsync();
+            IgnoredResult.Of(entered.TrySetResult());
+            await release.Task.WaitAsync(ct);
             return DisposableAsync.Empty;
         });
 
-        DirectSource<int> normalSource = new();
-        IObservableAsync<int>[] sources = [slowSource, normalSource];
-
-        // Cancel after 1s, not WaitTimeoutSeconds (5s): this test pure-waits for cancellation
-        // by design (nothing ever sets disposeTrigger) — the cancellation is the only exit,
-        // so we want the shortest window that reliably lets the subscribe loop start. 1s is
-        // safe even on slow CI runners.
-        using CancellationTokenSource cts = new(TimeSpan.FromSeconds(1));
-
-        try
-        {
-            var sub = await sources.CombineLatest()
-                .SubscribeAsync(static (_, _) => default, null, null, cts.Token);
-            disposeTrigger.SetResult(sub);
-            await sub.DisposeAsync();
-        }
-        catch (OperationCanceledException)
+        var normalSubscribed = false;
+        var normalSource = AsyncObs.Create<int>((_, _) =>
         {
-            // Expected
-        }
+            normalSubscribed = true;
+            return new(DisposableAsync.Empty);
+        });
+        IObservableAsync<int>[] sources = [slowSource, normalSource];
+        using CancellationTokenSource cts = new();
+        var pending = sources.CombineLatest()
+            .SubscribeAsync(static (_, _) => default, null, null, cts.Token);
+        await entered.Task;
+        await cts.CancelAsync();
+        await Assert.That(async () => await pending).Throws<OperationCanceledException>();
+        await Assert.That(normalSubscribed).IsFalse();
     }
 
     /// <summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Misc.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Misc.cs
index de75b50a..ee18a9e9 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Misc.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.Misc.cs
@@ -91,7 +91,6 @@ public async Task WhenCombineLatestWithReadOnlyListSources_ThenWorks()
     [Test]
     public async Task WhenCombineLatestSelectorThrows_ThenCompletesWithFailure()
     {
-        const int TerminalTimeoutSeconds = 5;
         var a = Signal.Create<int>();
         var b = Signal.Create<int>();
         IReadOnlyList<IObservableAsync<int>> sources = [a.Values, b.Values];
@@ -111,7 +110,7 @@ public async Task WhenCombineLatestSelectorThrows_ThenCompletesWithFailure()
         await a.OnNextAsync(1, CancellationToken.None);
         await b.OnNextAsync(SelectorThrowSecondValue, CancellationToken.None);
 
-        var terminal = await completed.Task.WaitAsync(TimeSpan.FromSeconds(TerminalTimeoutSeconds));
+        var terminal = await completed.Task;
         await Assert.That(terminal.IsFailure).IsTrue();
         await Assert.That(terminal.Exception).IsSameReferenceAs(expected);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity2And3.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity2And3.cs
index 156be24f..c1bf4c95 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity2And3.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity2And3.cs
@@ -29,7 +29,7 @@ public async Task WhenCombineLatest2Sources_Source1Errors_ThenFailurePropagates(
                 });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -54,7 +54,7 @@ public async Task WhenCombineLatest2Sources_Source2Errors_ThenFailurePropagates(
                 });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -83,7 +83,7 @@ public async Task WhenCombineLatest2Sources_Source1CompletesLast_ThenCombinedCom
         await s2.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -111,7 +111,7 @@ public async Task WhenCombineLatest2Sources_Source2CompletesLast_ThenCombinedCom
         await s1.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -187,7 +187,7 @@ public async Task WhenCombineLatest3Sources_Source1Errors_ThenFailurePropagates(
                 });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -213,7 +213,7 @@ public async Task WhenCombineLatest3Sources_Source2Errors_ThenFailurePropagates(
                 });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -239,7 +239,7 @@ public async Task WhenCombineLatest3Sources_Source3Errors_ThenFailurePropagates(
                 });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -271,7 +271,7 @@ public async Task WhenCombineLatest3Sources_Source1CompletesLast_ThenCombinedCom
         await s3.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -302,7 +302,7 @@ public async Task WhenCombineLatest3Sources_Source2CompletesLast_ThenCombinedCom
         await s3.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -333,7 +333,7 @@ public async Task WhenCombineLatest3Sources_Source3CompletesLast_ThenCombinedCom
         await s2.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity4.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity4.cs
index 8caead16..c97988d3 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity4.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity4.cs
@@ -32,7 +32,7 @@ public async Task WhenCombineLatest4Sources_Source1Errors_ThenFailurePropagates(
                 });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -60,7 +60,7 @@ public async Task WhenCombineLatest4Sources_Source2Errors_ThenFailurePropagates(
                 });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -88,7 +88,7 @@ public async Task WhenCombineLatest4Sources_Source3Errors_ThenFailurePropagates(
                 });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -116,7 +116,7 @@ public async Task WhenCombineLatest4Sources_Source4Errors_ThenFailurePropagates(
                 });
 
         await s4.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -152,7 +152,7 @@ public async Task WhenCombineLatest4Sources_Source1CompletesLast_ThenCombinedCom
         await s4.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -187,7 +187,7 @@ public async Task WhenCombineLatest4Sources_Source2CompletesLast_ThenCombinedCom
         await s4.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -222,7 +222,7 @@ public async Task WhenCombineLatest4Sources_Source3CompletesLast_ThenCombinedCom
         await s4.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -257,7 +257,7 @@ public async Task WhenCombineLatest4Sources_Source4CompletesLast_ThenCombinedCom
         await s3.OnCompletedAsync(Result.Success);
         await s4.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity5.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity5.cs
index 74365d2c..c85900e4 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity5.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity5.cs
@@ -36,7 +36,7 @@ public async Task WhenCombineLatest5Sources_Source1Errors_ThenFailurePropagates(
             });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -68,7 +68,7 @@ public async Task WhenCombineLatest5Sources_Source2Errors_ThenFailurePropagates(
             });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -100,7 +100,7 @@ public async Task WhenCombineLatest5Sources_Source3Errors_ThenFailurePropagates(
             });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -132,7 +132,7 @@ public async Task WhenCombineLatest5Sources_Source4Errors_ThenFailurePropagates(
             });
 
         await s4.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -164,7 +164,7 @@ public async Task WhenCombineLatest5Sources_Source5Errors_ThenFailurePropagates(
             });
 
         await s5.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -206,7 +206,7 @@ public async Task WhenCombineLatest5Sources_Source1CompletesLast_ThenCombinedCom
         await s5.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -247,7 +247,7 @@ public async Task WhenCombineLatest5Sources_Source2CompletesLast_ThenCombinedCom
         await s5.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -288,7 +288,7 @@ public async Task WhenCombineLatest5Sources_Source3CompletesLast_ThenCombinedCom
         await s5.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -329,7 +329,7 @@ public async Task WhenCombineLatest5Sources_Source4CompletesLast_ThenCombinedCom
         await s5.OnCompletedAsync(Result.Success);
         await s4.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -370,7 +370,7 @@ public async Task WhenCombineLatest5Sources_Source5CompletesLast_ThenCombinedCom
         await s4.OnCompletedAsync(Result.Success);
         await s5.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity6.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity6.cs
index 400d323a..e892a174 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity6.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity6.cs
@@ -38,7 +38,7 @@ public async Task WhenCombineLatest6Sources_Source1Errors_ThenFailurePropagates(
             });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -72,7 +72,7 @@ public async Task WhenCombineLatest6Sources_Source2Errors_ThenFailurePropagates(
             });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -106,7 +106,7 @@ public async Task WhenCombineLatest6Sources_Source3Errors_ThenFailurePropagates(
             });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -140,7 +140,7 @@ public async Task WhenCombineLatest6Sources_Source4Errors_ThenFailurePropagates(
             });
 
         await s4.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -174,7 +174,7 @@ public async Task WhenCombineLatest6Sources_Source5Errors_ThenFailurePropagates(
             });
 
         await s5.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -208,7 +208,7 @@ public async Task WhenCombineLatest6Sources_Source6Errors_ThenFailurePropagates(
             });
 
         await s6.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -254,7 +254,7 @@ public async Task WhenCombineLatest6Sources_Source1CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -299,7 +299,7 @@ public async Task WhenCombineLatest6Sources_Source2CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -344,7 +344,7 @@ public async Task WhenCombineLatest6Sources_Source3CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -389,7 +389,7 @@ public async Task WhenCombineLatest6Sources_Source4CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s4.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -434,7 +434,7 @@ public async Task WhenCombineLatest6Sources_Source5CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s5.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -479,7 +479,7 @@ public async Task WhenCombineLatest6Sources_Source6CompletesLast_ThenCombinedCom
         await s5.OnCompletedAsync(Result.Success);
         await s6.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity7.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity7.cs
index 2ab5086d..3b39d55e 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity7.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity7.cs
@@ -40,7 +40,7 @@ public async Task WhenCombineLatest7Sources_Source1Errors_ThenFailurePropagates(
             });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -76,7 +76,7 @@ public async Task WhenCombineLatest7Sources_Source2Errors_ThenFailurePropagates(
             });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -112,7 +112,7 @@ public async Task WhenCombineLatest7Sources_Source3Errors_ThenFailurePropagates(
             });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -148,7 +148,7 @@ public async Task WhenCombineLatest7Sources_Source4Errors_ThenFailurePropagates(
             });
 
         await s4.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -184,7 +184,7 @@ public async Task WhenCombineLatest7Sources_Source5Errors_ThenFailurePropagates(
             });
 
         await s5.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -220,7 +220,7 @@ public async Task WhenCombineLatest7Sources_Source6Errors_ThenFailurePropagates(
             });
 
         await s6.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -256,7 +256,7 @@ public async Task WhenCombineLatest7Sources_Source7Errors_ThenFailurePropagates(
             });
 
         await s7.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -306,7 +306,7 @@ public async Task WhenCombineLatest7Sources_Source1CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -355,7 +355,7 @@ public async Task WhenCombineLatest7Sources_Source2CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -404,7 +404,7 @@ public async Task WhenCombineLatest7Sources_Source3CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -453,7 +453,7 @@ public async Task WhenCombineLatest7Sources_Source4CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s4.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -502,7 +502,7 @@ public async Task WhenCombineLatest7Sources_Source5CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s5.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -551,7 +551,7 @@ public async Task WhenCombineLatest7Sources_Source6CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s6.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -600,7 +600,7 @@ public async Task WhenCombineLatest7Sources_Source7CompletesLast_ThenCombinedCom
         await s6.OnCompletedAsync(Result.Success);
         await s7.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Completes.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Completes.cs
index 398fe13e..8027550a 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Completes.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Completes.cs
@@ -58,7 +58,7 @@ public async Task WhenCombineLatest8Sources_Source1CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s1.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -111,7 +111,7 @@ public async Task WhenCombineLatest8Sources_Source2CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s2.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -164,7 +164,7 @@ public async Task WhenCombineLatest8Sources_Source3CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s3.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -217,7 +217,7 @@ public async Task WhenCombineLatest8Sources_Source4CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s4.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -270,7 +270,7 @@ public async Task WhenCombineLatest8Sources_Source5CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s5.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -323,7 +323,7 @@ public async Task WhenCombineLatest8Sources_Source6CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s6.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -376,7 +376,7 @@ public async Task WhenCombineLatest8Sources_Source7CompletesLast_ThenCombinedCom
         await s8.OnCompletedAsync(Result.Success);
         await s7.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -429,7 +429,7 @@ public async Task WhenCombineLatest8Sources_Source8CompletesLast_ThenCombinedCom
         await s7.OnCompletedAsync(Result.Success);
         await s8.OnCompletedAsync(Result.Success);
 
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Errors.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Errors.cs
index 8a8de5c3..1a26dc68 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Errors.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.PerArity8Errors.cs
@@ -42,7 +42,7 @@ public async Task WhenCombineLatest8Sources_Source1Errors_ThenFailurePropagates(
             });
 
         await s1.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -80,7 +80,7 @@ public async Task WhenCombineLatest8Sources_Source2Errors_ThenFailurePropagates(
             });
 
         await s2.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -118,7 +118,7 @@ public async Task WhenCombineLatest8Sources_Source3Errors_ThenFailurePropagates(
             });
 
         await s3.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -156,7 +156,7 @@ public async Task WhenCombineLatest8Sources_Source4Errors_ThenFailurePropagates(
             });
 
         await s4.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -194,7 +194,7 @@ public async Task WhenCombineLatest8Sources_Source5Errors_ThenFailurePropagates(
             });
 
         await s5.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -232,7 +232,7 @@ public async Task WhenCombineLatest8Sources_Source6Errors_ThenFailurePropagates(
             });
 
         await s6.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -270,7 +270,7 @@ public async Task WhenCombineLatest8Sources_Source7Errors_ThenFailurePropagates(
             });
 
         await s7.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
@@ -308,7 +308,7 @@ public async Task WhenCombineLatest8Sources_Source8Errors_ThenFailurePropagates(
             });
 
         await s8.OnCompletedAsync(Result.Failure(new InvalidOperationException("err")));
-        var result = await completed.Task.WaitAsync(TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var result = await completed.Task;
 
         await Assert.That(result.IsFailure).IsTrue();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.cs
index 17c3bd73..8c4ed785 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.cs
@@ -82,9 +82,6 @@ public partial class CombineLatestOperatorTests
     /// <summary>Sentinel value (99) used for late or post-disposal emissions.</summary>
     private const int SentinelValue = 99;
 
-    /// <summary>Timeout in seconds for awaiting test completion signals.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Index of source 2 within the sources array.</summary>
     private const int Source2Index = 2;
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
index 34bdf2e3..a58a991f 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Blend.cs
@@ -68,41 +68,40 @@ public async Task WhenMergeObservableOfObservables_ThenFlattens()
     [Test]
     public async Task WhenMergeWithMaxConcurrency_ThenRespectsLimit()
     {
-        const int SourceCount = 5;
+        const int SourceCount = 3;
         const int ConcurrencyLimit = 2;
-        var activeConcurrency = 0;
-        var maxConcurrency = 0;
-
-        // Each job parks until the gate opens, so the limit is observed with every slot occupied.
-        TaskCompletionSource limitReached = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource releaseJobs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var source = SignalAsync.Range(1, SourceCount).Select(i => SignalAsync.CreateAsBackgroundJob<int>(async (obs, ct) =>
+        var outer = Signal.Create<IObservableAsync<int>>();
+        List<IObserverAsync<int>> observers = [];
+        List<int> values = [];
+        var inner = SignalAsync.Create<int>((observer, _) =>
         {
-            lock (_gate)
-            {
-                activeConcurrency++;
-                maxConcurrency = Math.Max(maxConcurrency, activeConcurrency);
-                if (activeConcurrency == ConcurrencyLimit)
-                {
-                    IgnoredResult.Of(limitReached.TrySetResult());
-                }
-            }
+            observers.Add(observer);
+            return new(DisposableAsync.Empty);
+        });
+        await using var subscription = await outer.Values.Merge(ConcurrencyLimit).SubscribeAsync((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await outer.OnNextAsync(inner, CancellationToken.None);
+        await outer.OnNextAsync(inner, CancellationToken.None);
+        var thirdSubscription = outer.OnNextAsync(inner, CancellationToken.None);
+        await Assert.That(thirdSubscription.IsCompleted).IsFalse();
+        await Assert.That(observers).Count().IsEqualTo(ConcurrencyLimit);
 
-            await releaseJobs.Task;
-            lock (_gate)
-            {
-                activeConcurrency--;
-            }
+        await observers[0].OnNextAsync(1, CancellationToken.None);
+        await observers[0].OnCompletedAsync(Result.Success);
+        await thirdSubscription;
+        await Assert.That(observers).Count().IsEqualTo(SourceCount);
 
-            await obs.OnNextAsync(i, ct);
-            await obs.OnCompletedAsync(Result.Success);
-        }));
-        var merged = source.Merge(ConcurrencyLimit).ToListAsync().AsTask();
-        await limitReached.Task;
-        IgnoredResult.Of(releaseJobs.TrySetResult());
-        var result = await merged;
-        await Assert.That(result).Count().IsEqualTo(SourceCount);
-        await Assert.That(maxConcurrency).IsLessThanOrEqualTo(ConcurrencyLimit);
+        for (var i = 1; i < SourceCount; i++)
+        {
+            await observers[i].OnNextAsync(i + 1, CancellationToken.None);
+            await observers[i].OnCompletedAsync(Result.Success);
+        }
+
+        await outer.OnCompletedAsync(Result.Success);
+        await Assert.That(values).IsCollectionEqualTo([1, ConcurrencyLimit, SourceCount]);
     }
 
     /// <summary>
@@ -484,11 +483,6 @@ await Assert.That(async () => await goodSource.Merge(errorSource).ToListAsync())
 
     /// <summary>Tests Merge with max concurrency and error propagation.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    /// <remarks>Background jobs run with <c>startSynchronously: true</c> so the test does
-    /// not depend on free thread-pool threads — under heavy cross-assembly parallel test runs
-    /// the default <c>Task.Yield()</c> path used to starve and the test hit the 60s timeout.
-    /// The concurrency-limit contract being asserted (four sources flow through a Merge(2)
-    /// gate and all emit) is preserved.</remarks>
     [Test]
     public async Task WhenMergeConcurrencyWithSlowSource_ThenLimitsAndCompletes()
     {
@@ -591,7 +585,6 @@ public async Task WhenMergeEnumerableInnerSubscribeThrowsTaskCanceled_ThenHandle
     [Test]
     public async Task WhenMergeEnumerableInnerSubscribeThrows_ThenCompletesWithFailure()
     {
-        const int CompletionTimeoutSeconds = 5;
         Result? completionResult = null;
         var throwingSource = SignalAsync.Create<int>(static (_, _) =>
             ValueTask.FromException<IAsyncDisposable>(new InvalidOperationException(SubscribeBoomMessage)));
@@ -600,7 +593,7 @@ public async Task WhenMergeEnumerableInnerSubscribeThrows_ThenCompletesWithFailu
             completionResult = result;
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
         await Assert.That(completionResult.Value.Exception!.Message).Contains(SubscribeBoomMessage);
@@ -614,7 +607,6 @@ public async Task WhenMergeEnumerableInnerSubscribeThrows_ThenCompletesWithFailu
     [Test]
     public async Task WhenMergeEnumerableSecondSourceSubscribeThrows_ThenCompletesWithFailure()
     {
-        const int CompletionTimeoutSeconds = 5;
         Result? completionResult = null;
         DirectSource<int> goodSource = new();
         var throwingSource = SignalAsync.Create<int>(static (_, _) =>
@@ -627,7 +619,7 @@ public async Task WhenMergeEnumerableSecondSourceSubscribeThrows_ThenCompletesWi
                 completionResult = result;
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, TimeSpan.FromSeconds(CompletionTimeoutSeconds));
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
         await Assert.That(completionResult.Value.Exception!.Message).Contains("second subscribe boom");
@@ -638,7 +630,6 @@ public async Task WhenMergeEnumerableSecondSourceSubscribeThrows_ThenCompletesWi
     [Test]
     public async Task WhenMergeInnerSourceFails_ThenErrorPropagated()
     {
-        const int CompletionTimeoutSeconds = 5;
         InvalidOperationException error = new("inner-error");
         var inner = SignalAsync.Throw<int>(error);
         var outer = SignalAsync.Return(inner);
@@ -650,7 +641,7 @@ public async Task WhenMergeInnerSourceFails_ThenErrorPropagated()
             _ = completed.TrySetResult();
             return default;
         });
-        await completed.Task.WaitAsync(TimeSpan.FromSeconds(CompletionTimeoutSeconds));
+        await completed.Task;
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
     }
@@ -660,7 +651,6 @@ public async Task WhenMergeInnerSourceFails_ThenErrorPropagated()
     [Test]
     public async Task WhenMergeWithMaxConcurrencyInnerFails_ThenErrorPropagated()
     {
-        const int CompletionTimeoutSeconds = 5;
         InvalidOperationException error = new("merge-fail");
         var inner = SignalAsync.Throw<int>(error);
         var outer = SignalAsync.Return(inner);
@@ -672,7 +662,7 @@ public async Task WhenMergeWithMaxConcurrencyInnerFails_ThenErrorPropagated()
             _ = completed.TrySetResult();
             return default;
         });
-        await completed.Task.WaitAsync(TimeSpan.FromSeconds(CompletionTimeoutSeconds));
+        await completed.Task;
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
     }
@@ -812,9 +802,7 @@ public async Task WhenMergeEnumerableOnErrorResumeAsyncLockedAfterDispose_ThenDr
         await Assert.That(captured.Task.IsCompleted).IsFalse();
     }
 
-    /// <summary>Test observer used by direct-invocation Merge tests; captures the first
-    /// <c>OnNextAsync</c> or <c>OnErrorResumeAsync</c> via the supplied TCS so the assertion
-    /// can verify the post-dispose call did not deliver anything.</summary>
+    /// <summary>Signals the first value or resumable error.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     /// <param name = "onNext">Optional TCS for capturing the first <c>OnNextAsync</c> value.</param>
     /// <param name = "onError">Optional TCS for capturing the first <c>OnErrorResumeAsync</c> exception.</param>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendEnumerableDisposal.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendEnumerableDisposal.cs
index de11f788..7431f3f7 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendEnumerableDisposal.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendEnumerableDisposal.cs
@@ -151,7 +151,6 @@ public async Task WhenMergeEnumerableDisposed_ThenOnErrorResumeReturnsEarly()
     [Test]
     public async Task WhenMergeEnumerableCompletedTwiceWithError_ThenSecondErrorGoesToUnhandled()
     {
-        const int WaitTimeoutSeconds = 5;
         Exception? unhandledException = null;
         UnhandledExceptionHandler.Register(ex => unhandledException = ex);
 
@@ -170,9 +169,7 @@ public async Task WhenMergeEnumerableCompletedTwiceWithError_ThenSecondErrorGoes
         // Second source fails - already disposed, error goes to UnhandledExceptionHandler
         await signal2.OnCompletedAsync(Result.Failure(new InvalidOperationException(SecondLiteral)));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => unhandledException is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(unhandledException is not null).IsTrue();
 
         await Assert.That(unhandledException).IsNotNull();
     }
@@ -272,7 +269,6 @@ public async Task WhenMergeEnumerableDisposed_ThenOnErrorResumeReturnsEarlyViaDi
     [Test]
     public async Task WhenMergeEnumerableCompletedTwiceWithErrorViaDirectSource_ThenUnhandledExceptionFires()
     {
-        const int WaitTimeoutSeconds = 5;
         Exception? unhandledException = null;
         UnhandledExceptionHandler.Register(ex => unhandledException = ex);
 
@@ -291,9 +287,7 @@ public async Task WhenMergeEnumerableCompletedTwiceWithErrorViaDirectSource_Then
         // Second source fails – already disposed, error goes to UnhandledExceptionHandler
         await directSource2.Complete(Result.Failure(new InvalidOperationException(SecondLiteral)));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => unhandledException is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(unhandledException is not null).IsTrue();
 
         await Assert.That(unhandledException).IsNotNull();
     }
@@ -306,14 +300,10 @@ await AsyncTestHelpers.WaitForConditionAsync(
     [Test]
     public async Task WhenMergeEnumerableCompletionHandlerThrows_ThenOuterCatchRoutesToUnhandled()
     {
-        const int WaitTimeoutSeconds = 5;
         Exception? unhandledException = null;
         UnhandledExceptionHandler.Register(ex => unhandledException = ex);
 
-        // Use a single Return source that completes synchronously during subscription.
-        // The sentinel decrement triggers FinishAsync(Result.Success), and we make the
-        // observer's OnCompletedAsync throw, which escapes the inner try/finally and is
-        // caught by the outer try in BeginSubscribing.
+        // Completion occurs inside the subscription loop.
         IObservableAsync<int>[] sources = [SignalAsync.Return(1)];
 
         await using var sub = await sources.Merge()
@@ -322,9 +312,7 @@ public async Task WhenMergeEnumerableCompletionHandlerThrows_ThenOuterCatchRoute
                 null,
                 static _ => throw new InvalidOperationException("completion handler boom"));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => unhandledException is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(unhandledException is not null).IsTrue();
 
         await Assert.That(unhandledException).IsNotNull();
         await Assert.That(unhandledException!.Message).Contains("completion handler boom");
@@ -339,7 +327,6 @@ await AsyncTestHelpers.WaitForConditionAsync(
     [Test]
     public async Task WhenMergeEnumerableThrowsDuringIteration_ThenRoutesToUnhandled()
     {
-        const int WaitTimeoutSeconds = 5;
         using UnhandledExceptionCapture unhandled = new();
 
         // Use an enumerable whose GetEnumerator throws, triggering the error path
@@ -351,7 +338,7 @@ public async Task WhenMergeEnumerableThrowsDuringIteration_ThenRoutesToUnhandled
                 static (_, _) => default,
                 null);
 
-        var exception = await unhandled.WaitForAsync("enumerable boom", TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        var exception = await unhandled.WaitForAsync("enumerable boom");
 
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!.Message).Contains("enumerable boom");
@@ -365,59 +352,26 @@ public async Task WhenMergeEnumerableThrowsDuringIteration_ThenRoutesToUnhandled
     [Test]
     public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnNextReturnsPostGate()
     {
-        const int SecondEmissionValue = 2;
-        DirectSource<int> directSource = new();
-        List<int> items = [];
-        TaskCompletionSource gateHeld = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource proceedWithFirstEmission = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var sub = await new IObservableAsync<int>[] { directSource }
-            .Merge()
-            .SubscribeAsync(
-                async (x, _) =>
-                {
-                    lock (_gate)
-                    {
-                        items.Add(x);
-                    }
-
-                    if (x == 1)
-                    {
-                        gateHeld.SetResult();
-                        await proceedWithFirstEmission.Task;
-                    }
-                },
-                null);
-
-        // First emission holds the gate
-        var firstEmission = directSource.EmitNext(1, CancellationToken.None);
-        await gateHeld.Task;
-
-        // Second emission queues behind the gate
-        var secondEmissionTask = Task.Run(async () =>
+        const int SecondValue = 2;
+        List<int> values = [];
+        List<Exception> errors = [];
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
         {
-            try
-            {
-                await directSource.EmitNext(SecondEmissionValue, CancellationToken.None);
-            }
-            catch (OperationCanceledException)
-            {
-                // Expected
-            }
+            values.Add(value);
+            return default;
+        },
+            (exception, _) =>
+        {
+            errors.Add(exception);
+            return default;
         });
-
-        // Dispose while second emission waits for the gate
-        var disposeTask = sub.DisposeAsync();
-
-        // Release the first emission
-        proceedWithFirstEmission.SetResult();
-
-        await firstEmission;
-        await disposeTask;
-        await secondEmissionTask;
-
-        await Assert.That(items).Contains(1);
-        await Assert.That(items).DoesNotContain(SampleValue2);
+        SignalAsyncExtensions.BlendEnumerableSignal<int>.BlendSequenceCoordinator coordinator = new(observer, []);
+        coordinator.BeginSubscribing();
+        await coordinator.DisposeAsync();
+        await coordinator.RelayNextIfActiveAsync(SecondValue);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(errors).IsEmpty();
     }
 
     /// <summary>
@@ -428,57 +382,24 @@ public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnNextReturnsPost
     [Test]
     public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnErrorResumeReturnsPostGate()
     {
-        DirectSource<int> directSource = new();
+        List<int> values = [];
         List<Exception> errors = [];
-        TaskCompletionSource gateHeld = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource proceedWithFirstEmission = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var sub = await new IObservableAsync<int>[] { directSource }
-            .Merge()
-            .SubscribeAsync(
-                async (_, _) =>
-                {
-                    // Hold the gate on the first emission
-                    gateHeld.SetResult();
-                    await proceedWithFirstEmission.Task;
-                },
-                (ex, _) =>
-                {
-                    lock (_gate)
-                    {
-                        errors.Add(ex);
-                    }
-
-                    return default;
-                });
-
-        // First emission holds the gate
-        var firstEmission = directSource.EmitNext(1, CancellationToken.None);
-        await gateHeld.Task;
-
-        // Error emission queues behind the gate
-        var errorTask = Task.Run(async () =>
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
         {
-            try
-            {
-                await directSource.EmitError(new InvalidOperationException(LateErrorMessage), CancellationToken.None);
-            }
-            catch (OperationCanceledException)
-            {
-                // Expected
-            }
+            values.Add(value);
+            return default;
+        },
+            (exception, _) =>
+        {
+            errors.Add(exception);
+            return default;
         });
-
-        // Dispose while the error emission waits for the gate
-        var disposeTask = sub.DisposeAsync();
-
-        // Release the first emission
-        proceedWithFirstEmission.SetResult();
-
-        await firstEmission;
-        await disposeTask;
-        await errorTask;
-
+        SignalAsyncExtensions.BlendEnumerableSignal<int>.BlendSequenceCoordinator coordinator = new(observer, []);
+        coordinator.BeginSubscribing();
+        await coordinator.DisposeAsync();
+        await coordinator.RelayErrorIfActiveAsync(new InvalidOperationException("late"));
+        await Assert.That(values).IsEmpty();
         await Assert.That(errors).IsEmpty();
     }
 
@@ -490,7 +411,6 @@ public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnErrorResumeRetu
     [Test]
     public async Task WhenMergeEnumerableBeginSubscribingThrows_ThenRoutesToUnhandled()
     {
-        const int WaitTimeoutSeconds = 5;
         Exception? unhandled = null;
         UnhandledExceptionHandler.Register(ex => unhandled = ex);
 
@@ -500,9 +420,7 @@ public async Task WhenMergeEnumerableBeginSubscribingThrows_ThenRoutesToUnhandle
             static (_, _) => default,
             null);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => unhandled is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(unhandled is not null).IsTrue();
 
         await Assert.That(unhandled).IsNotNull();
     }
@@ -558,7 +476,6 @@ public async Task WhenMergeEnumerableAlreadyDisposedWithFailure_ThenRoutesToUnha
     [Test]
     public async Task WhenMergeEnumerableDisposedDuringEmission_ThenDropsValues()
     {
-        const int WaitTimeoutSeconds = 5;
         DirectSource<int> innerSource = new();
         List<int> results = [];
 
@@ -574,9 +491,7 @@ public async Task WhenMergeEnumerableDisposedDuringEmission_ThenDropsValues()
 
         await innerSource.EmitNext(1);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await sub.DisposeAsync();
 
@@ -594,7 +509,6 @@ await AsyncTestHelpers.WaitForConditionAsync(
     [Test]
     public async Task WhenMergeEnumerableDisposedDuringErrorResume_ThenDropsErrors()
     {
-        const int WaitTimeoutSeconds = 5;
         DirectSource<int> innerSource = new();
         List<Exception> errors = [];
 
@@ -610,9 +524,7 @@ public async Task WhenMergeEnumerableDisposedDuringErrorResume_ThenDropsErrors()
 
         await innerSource.EmitError(new InvalidOperationException(FirstLiteral));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => errors.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(errors.Count >= 1).IsTrue();
 
         await sub.DisposeAsync();
 
@@ -650,7 +562,7 @@ public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnNextPostGateRet
 
         await src1.EmitNext(1);
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("fail"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("fail")));
         await completionBlocked.Task;
 
         await src2.EmitNext(Sentinel99);
@@ -687,7 +599,7 @@ public async Task WhenMergeEnumerableDisposedWhileGateHeld_ThenOnErrorResumePost
                     await allowCompletion.Task;
                 });
 
-        var failTask = Task.Run(() => src1.Complete(Result.Failure(new InvalidOperationException("fail"))));
+        var failTask = src1.Complete(Result.Failure(new InvalidOperationException("fail")));
         await completionBlocked.Task;
 
         await src2.EmitError(new InvalidOperationException("post-dispose"));
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendSignalDisposal.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendSignalDisposal.cs
index 1cff49c7..5a6d64b0 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendSignalDisposal.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.BlendSignalDisposal.cs
@@ -99,7 +99,6 @@ await innerSignal.OnErrorResumeAsync(
     [Test]
     public async Task WhenMergeSignalDisposedBeforeInnerEmission_ThenRelayNextAsyncReturns()
     {
-        const int WaitTimeoutSeconds = 5;
         var source = Signal.Create<int>();
         var inner = Signal.Create<IObservableAsync<int>>();
         List<int> items = [];
@@ -123,9 +122,7 @@ public async Task WhenMergeSignalDisposedBeforeInnerEmission_ThenRelayNextAsyncR
         await inner.OnNextAsync(source.Values, CancellationToken.None);
         await inner.OnCompletedAsync(Result.Failure(new InvalidOperationException("force done")));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult is not null,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(completionResult is not null).IsTrue();
 
         // After dispose, forwarding should be a no-op
         await source.OnNextAsync(Sentinel42, CancellationToken.None);
@@ -267,70 +264,25 @@ public async Task WhenMergeSignalOfSignalsDisposed_ThenRelayErrorAsyncReturns()
     [Test]
     public async Task WhenMergeSignalOfSignalsDisposedWhileGateHeld_ThenRelayNextAsyncReturnsPostGate()
     {
-        const int SecondEmissionValue = 2;
-        DirectSource<int> innerSource = new();
-        DirectSource<IObservableAsync<int>> outerSource = new();
-        List<int> items = [];
-        TaskCompletionSource gateHeld = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource proceedWithFirstEmission = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var sub = await outerSource
-            .Merge()
-            .SubscribeAsync(
-                async (x, _) =>
-                {
-                    lock (_gate)
-                    {
-                        items.Add(x);
-                    }
-
-                    if (x == 1)
-                    {
-                        // Signal that the gate is being held by this OnNext call
-                        gateHeld.SetResult();
-
-                        // Wait here, keeping the gate held
-                        await proceedWithFirstEmission.Task;
-                    }
-                },
-                null);
-
-        // Subscribe the inner source through the outer
-        await outerSource.EmitNext(innerSource, CancellationToken.None);
-
-        // First emission holds the gate via the slow observer
-        var firstEmission = innerSource.EmitNext(1, CancellationToken.None);
-
-        // Wait until the gate is held
-        await gateHeld.Task;
-
-        // Start a second emission that will queue behind the gate
-        var secondEmissionTask = Task.Run(async () =>
+        const int SecondValue = 2;
+        List<int> values = [];
+        List<Exception> errors = [];
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
         {
-            try
-            {
-                await innerSource.EmitNext(SecondEmissionValue, CancellationToken.None);
-            }
-            catch (OperationCanceledException)
-            {
-                // Expected – the linked CTS may be cancelled
-            }
+            values.Add(value);
+            return default;
+        },
+            (exception, _) =>
+        {
+            errors.Add(exception);
+            return default;
         });
-
-        // Give the second emission time to start waiting for the gate
-        // Dispose while the second emission is waiting for the gate
-        var disposeTask = sub.DisposeAsync();
-
-        // Release the first emission so it completes and releases the gate
-        proceedWithFirstEmission.SetResult();
-
-        await firstEmission;
-        await disposeTask;
-        await secondEmissionTask;
-
-        // Only value 1 should have been emitted; value 2 hits the post-gate _disposed check
-        await Assert.That(items).Contains(1);
-        await Assert.That(items).DoesNotContain(SampleValue2);
+        SignalAsyncExtensions.BlendCoordinator<int> coordinator = new(observer);
+        await coordinator.DisposeAsync();
+        await coordinator.RelayNextIfActiveAsync(SecondValue);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(errors).IsEmpty();
     }
 
     /// <summary>
@@ -341,65 +293,23 @@ public async Task WhenMergeSignalOfSignalsDisposedWhileGateHeld_ThenRelayNextAsy
     [Test]
     public async Task WhenMergeSignalOfSignalsDisposedWhileGateHeld_ThenRelayErrorAsyncReturnsPostGate()
     {
-        DirectSource<int> innerSource = new();
-        DirectSource<IObservableAsync<int>> outerSource = new();
+        List<int> values = [];
         List<Exception> errors = [];
-        TaskCompletionSource gateHeld = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource proceedWithFirstEmission = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var sub = await outerSource
-            .Merge()
-            .SubscribeAsync(
-                async (_, _) =>
-                {
-                    // Hold the gate on the first emission
-                    gateHeld.SetResult();
-                    await proceedWithFirstEmission.Task;
-                },
-                (ex, _) =>
-                {
-                    lock (_gate)
-                    {
-                        errors.Add(ex);
-                    }
-
-                    return default;
-                });
-
-        // Subscribe the inner source through the outer
-        await outerSource.EmitNext(innerSource, CancellationToken.None);
-
-        // First emission holds the gate
-        var firstEmission = innerSource.EmitNext(1, CancellationToken.None);
-
-        // Wait until the gate is held
-        await gateHeld.Task;
-
-        // Start an error emission that will queue behind the gate
-        var errorTask = Task.Run(async () =>
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
         {
-            try
-            {
-                await innerSource.EmitError(new InvalidOperationException(LateErrorMessage), CancellationToken.None);
-            }
-            catch (OperationCanceledException)
-            {
-                // Expected
-            }
+            values.Add(value);
+            return default;
+        },
+            (exception, _) =>
+        {
+            errors.Add(exception);
+            return default;
         });
-
-        // Give the error emission time to start waiting for the gate
-        // Dispose while the error emission is waiting for the gate
-        var disposeTask = sub.DisposeAsync();
-
-        // Release the first emission
-        proceedWithFirstEmission.SetResult();
-
-        await firstEmission;
-        await disposeTask;
-        await errorTask;
-
-        // The error should not have been forwarded because the post-gate disposed check caught it
+        SignalAsyncExtensions.BlendCoordinator<int> coordinator = new(observer);
+        await coordinator.DisposeAsync();
+        await coordinator.RelayErrorIfActiveAsync(new InvalidOperationException("late"));
+        await Assert.That(values).IsEmpty();
         await Assert.That(errors).IsEmpty();
     }
 
@@ -482,7 +392,7 @@ public async Task WhenMergeSignalDisposedWhileGateHeld_ThenRelayNextAsyncReturns
         await outer.OnNextAsync(inner, CancellationToken.None);
         await inner.EmitNext(1);
 
-        var failTask = Task.Run(() => outer.OnCompletedAsync(Result.Failure(new InvalidOperationException("fail"))));
+        var failTask = outer.OnCompletedAsync(Result.Failure(new InvalidOperationException("fail")));
         await completionBlocked.Task;
 
         await inner.EmitNext(Sentinel99);
@@ -501,7 +411,6 @@ public async Task WhenMergeSignalDisposedWhileGateHeld_ThenRelayNextAsyncReturns
     [Test]
     public async Task WhenMergeOfSignalsDisposedDuringEmission_ThenDropsSubsequentValues()
     {
-        const int WaitTimeoutSeconds = 5;
         DirectSource<IObservableAsync<int>> outerSource = new();
         DirectSource<int> innerSource = new();
         List<int> results = [];
@@ -519,9 +428,7 @@ public async Task WhenMergeOfSignalsDisposedDuringEmission_ThenDropsSubsequentVa
         await outerSource.EmitNext(innerSource);
         await innerSource.EmitNext(1);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await sub.DisposeAsync();
 
@@ -539,7 +446,6 @@ await AsyncTestHelpers.WaitForConditionAsync(
     [Test]
     public async Task WhenMergeOfSignalsDisposedDuringErrorResume_ThenDropsSubsequentErrors()
     {
-        const int WaitTimeoutSeconds = 5;
         DirectSource<IObservableAsync<int>> outerSource = new();
         DirectSource<int> innerSource = new();
         List<Exception> errors = [];
@@ -557,9 +463,7 @@ public async Task WhenMergeOfSignalsDisposedDuringErrorResume_ThenDropsSubsequen
         await outerSource.EmitNext(innerSource);
         await innerSource.EmitError(new InvalidOperationException(FirstLiteral));
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => errors.Count >= 1,
-            TimeSpan.FromSeconds(WaitTimeoutSeconds));
+        await Assert.That(errors.Count >= 1).IsTrue();
 
         await sub.DisposeAsync();
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Chain.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Chain.cs
index 928b986c..4372d4f5 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Chain.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Chain.cs
@@ -582,7 +582,6 @@ public async Task WhenConcatEnumerableDoubleDisposeWithoutFailure_ThenNoUnhandle
     public async Task WhenConcatObservablesDoubleCompleteWithError_ThenRoutedToHandler()
     {
         UnhandledExceptionHandler.Register(static ex => _ = ex);
-        const int CompletionTimeoutSeconds = 5;
         var outer = Signal.Create<IObservableAsync<int>>();
         Result? completionResult = null;
         var sub = await outer.Values.Concat().SubscribeAsync(static (_, _) => default, null, result =>
@@ -593,13 +592,9 @@ public async Task WhenConcatObservablesDoubleCompleteWithError_ThenRoutedToHandl
 
         // Complete with failure first
         await outer.OnCompletedAsync(Result.Failure(new InvalidOperationException(FirstFailMessage)));
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult.HasValue,
-            TimeSpan.FromSeconds(CompletionTimeoutSeconds));
+        await Assert.That(completionResult.HasValue).IsTrue();
 
-        // Now dispose, which calls FinishAsync(null) but TrySetDisposed returns true
-        // (already disposed), and since result?.Exception is null for null result, no handler call.
-        // We need another approach: dispose first, then force another completion with an error.
+        // Disposal preserves the terminal failure.
         await sub.DisposeAsync();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Multicast.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Multicast.cs
index a2f9e7e6..917a4ea0 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Multicast.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Multicast.cs
@@ -354,7 +354,6 @@ public async Task WhenRoutePostDisposalExceptionWithSuccess_ThenNoExceptionRoute
     [Test]
     public async Task WhenRefCountDisposedWithActiveConnection_ThenConnectionIsDisposed()
     {
-        const int ItemWaitTimeoutSeconds = 5;
         var source = Signal.Create<int>();
         var connectable = source.Values.Publish();
         var refCounted = connectable.RefCount();
@@ -371,9 +370,7 @@ public async Task WhenRefCountDisposedWithActiveConnection_ThenConnectionIsDispo
 
         await source.OnNextAsync(Sentinel42, CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count == 1,
-            TimeSpan.FromSeconds(ItemWaitTimeoutSeconds));
+        await Assert.That(items.Count == 1).IsTrue();
 
         // Dispose the RefCountSignal via its IDisposable implementation.
         ((IDisposable)(object)refCounted).Dispose();
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.OnDispose.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.OnDispose.cs
index 6b31db6b..064485ee 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.OnDispose.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.OnDispose.cs
@@ -284,8 +284,7 @@ public async Task WhenBlendCoordinatorDisposedWhileGateHeld_ThenRelayNextAsyncPo
         SignalAsyncExtensions.BlendCoordinator<int> subscription = new(observer);
 
         // Trigger FinishAsync with failure - blocks on observer.OnCompletedAsync
-        var failTask = Task.Run(() =>
-            subscription.FinishAsync(Result.Failure(new InvalidOperationException("fail"))));
+        var failTask = subscription.FinishAsync(Result.Failure(new InvalidOperationException("fail")));
         await completionBlocked.Task;
 
         // _disposed is 1, gate is still alive → OnNextAsync acquires gate and hits post-gate check
@@ -321,8 +320,7 @@ public async Task WhenBlendCoordinatorDisposedWhileGateHeld_ThenRelayErrorAsyncP
 
         SignalAsyncExtensions.BlendCoordinator<int> subscription = new(observer);
 
-        var failTask = Task.Run(() =>
-            subscription.FinishAsync(Result.Failure(new InvalidOperationException("fail"))));
+        var failTask = subscription.FinishAsync(Result.Failure(new InvalidOperationException("fail")));
         await completionBlocked.Task;
 
         await subscription.RelayErrorAsync(new InvalidOperationException("post-dispose"), CancellationToken.None);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.PrependStartWith.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.PrependStartWith.cs
index 5456dce9..26cd32ff 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.PrependStartWith.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.PrependStartWith.cs
@@ -7,9 +7,6 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests for the Prepend and StartWith operators.</summary>
 public partial class CombiningOperatorTests
 {
-    /// <summary>Maximum time the combining-operator tests wait for emissions to arrive.</summary>
-    private static readonly TimeSpan CombiningWaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Tests Prepend value comes first.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -131,9 +128,7 @@ public async Task WhenPrependCancelledDuringValues_ThenOperationCanceledExceptio
             null,
             cts.Token);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count >= 5,
-            CombiningWaitTimeout);
+        await Assert.That(items.Count >= 5).IsTrue();
 
         await Assert.That(items).Contains(SampleValue5);
     }
@@ -163,9 +158,7 @@ public async Task WhenPrependSourceThrowsDuringSubscription_ThenCompletesWithFai
                     return default;
                 });
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult is not null,
-            CombiningWaitTimeout);
+        await Assert.That(completionResult is not null).IsTrue();
 
         await Assert.That(items).Contains(Sentinel42);
         await Assert.That(completionResult).IsNotNull();
@@ -229,9 +222,7 @@ public async Task WhenPrependCancelledDuringPrepend_ThenStopsGracefully()
             null,
             cts.Token);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Contains(SampleValue2),
-            CombiningWaitTimeout);
+        await Assert.That(items.Contains(SampleValue2)).IsTrue();
 
         // Should have emitted at least 1 and 2
         await Assert.That(items).Contains(SampleValue1);
@@ -274,9 +265,7 @@ public async Task WhenPrependCancelledDuringValues_ThenStopsEarly()
                 null);
 
         // Wait for prepended values to be emitted
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count >= 5,
-            CombiningWaitTimeout);
+        await Assert.That(items.Count >= 5).IsTrue();
 
         await sub.DisposeAsync();
 
@@ -305,9 +294,7 @@ public async Task WhenPrependSourceThrows_ThenCompletesWithFailure()
                     return default;
                 });
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult.HasValue,
-            CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
@@ -339,9 +326,7 @@ public async Task WhenPrependSourceCancelled_ThenSwallowsCancellation()
                 null,
                 static result => default);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count >= 2,
-            CombiningWaitTimeout);
+        await Assert.That(items.Count >= 2).IsTrue();
 
         await sub.DisposeAsync();
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Subscribe.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Subscribe.cs
index 0c94132d..8ea5466f 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Subscribe.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Subscribe.cs
@@ -21,9 +21,7 @@ public async Task WhenSubscribeAsyncWithActionOverload_ThenReceivesItems()
 
         await using var sub = await source.SubscribeAsync(items.Add, CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count >= SourceValueCount,
-            CombiningWaitTimeout);
+        await Assert.That(items.Count >= SourceValueCount).IsTrue();
 
         await Assert.That(items).IsCollectionEqualTo([SampleValue1, SampleValue2, SampleValue3]);
     }
@@ -44,9 +42,7 @@ public async Task WhenSubscribeAsyncSyncOverloadWithNullHandlers_ThenOnlyOnNextC
             null,
             CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => items.Count >= SourceValueCount,
-            CombiningWaitTimeout);
+        await Assert.That(items.Count >= SourceValueCount).IsTrue();
 
         await Assert.That(items).IsCollectionEqualTo([SampleValue1, SampleValue2, SampleValue3]);
     }
@@ -70,9 +66,7 @@ public async Task WhenSubscribeAsyncSyncOverloadWithErrorHandler_ThenErrorHandle
             null,
             CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => receivedError is not null,
-            CombiningWaitTimeout);
+        await Assert.That(receivedError is not null).IsTrue();
 
         await Assert.That(receivedError).IsNotNull();
         await Assert.That(receivedError!.Message).IsEqualTo("test error");
@@ -91,9 +85,7 @@ public async Task WhenSubscribeAsyncSyncOverloadWithCompletedHandler_ThenComplet
             (Action<Result>?)(result => completionResult = result),
             CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completionResult is not null,
-            CombiningWaitTimeout);
+        await Assert.That(completionResult is not null).IsTrue();
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.SwitchTo.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.SwitchTo.cs
index 1eff58be..6bfa4b3b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.SwitchTo.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.SwitchTo.cs
@@ -253,8 +253,7 @@ public async Task WhenSwitchInnerError_ThenOuterReceivesError()
         await outer.OnNextAsync(
             SignalAsync.Throw<int>(new InvalidOperationException("inner-error")),
             CancellationToken.None);
-        await Task.Yield();
-        await Assert.That(errors).Count().IsGreaterThanOrEqualTo(0);
+        await Assert.That(errors).IsEmpty();
     }
 
     /// <summary>Tests that Switch completes when outer completes with no inner sequences.</summary>
@@ -271,7 +270,7 @@ public async Task WhenSwitchOuterCompletesWithNoInner_ThenCompletes()
                 completionResult = result;
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
@@ -291,7 +290,7 @@ public async Task WhenSwitchInnerErrors_ThenErrorPropagated()
         await outer.OnNextAsync(
             SignalAsync.Throw<int>(new InvalidOperationException(InnerFailMessage)),
             CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
         await outer.DisposeAsync();
@@ -316,7 +315,7 @@ public async Task WhenSwitchInnerErrorResume_ThenForwarded()
             return default;
         });
         await outer.OnNextAsync(inner, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => errors.Count >= 1, CombiningWaitTimeout);
+        await Assert.That(errors.Count >= 1).IsTrue();
         await Assert.That(errors).Count().IsEqualTo(1);
         await outer.DisposeAsync();
     }
@@ -343,7 +342,7 @@ public async Task WhenSwitch_ThenEmitsFromLatestInnerSequence()
         await outer.OnNextAsync(inner2.Values, CancellationToken.None);
         await inner2.OnNextAsync(SampleValue10, CancellationToken.None);
         await inner2.OnNextAsync(SampleValue20, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => items.Contains(SampleValue10), CombiningWaitTimeout);
+        await Assert.That(items.Contains(SampleValue10)).IsTrue();
         await Assert.That(items).Contains(1);
         await Assert.That(items).Contains(SampleValue10);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Zip.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Zip.cs
index 882c8778..a0ad211b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Zip.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Zip.cs
@@ -186,7 +186,7 @@ public async Task WhenZipFirstSourceErrorResume_ThenForwardedToObserver()
                 return default;
             });
         await first.OnErrorResumeAsync(new InvalidOperationException("first error"), CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => received is not null, CombiningWaitTimeout);
+        await Assert.That(received is not null).IsTrue();
         await Assert.That(received).IsNotNull();
         await Assert.That(received!.Message).IsEqualTo("first error");
     }
@@ -207,7 +207,7 @@ public async Task WhenZipSecondSourceErrorResume_ThenForwardedToObserver()
                 return default;
             });
         await second.OnErrorResumeAsync(new InvalidOperationException("second error"), CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => received is not null, CombiningWaitTimeout);
+        await Assert.That(received is not null).IsTrue();
         await Assert.That(received).IsNotNull();
         await Assert.That(received!.Message).IsEqualTo("second error");
     }
@@ -236,7 +236,7 @@ public async Task WhenZipFirstSourceEmitsAfterDone_ThenIgnored()
 
         // Complete first with failure, setting done=true
         await first.OnCompletedAsync(Result.Failure(new InvalidOperationException("fail")));
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult is not null, CombiningWaitTimeout);
+        await Assert.That(completionResult is not null).IsTrue();
 
         // Items emitted after done should be ignored
         await first.OnNextAsync(Sentinel99, CancellationToken.None);
@@ -268,7 +268,7 @@ public async Task WhenZipSecondEmitsBeforeFirst_ThenBuffersAndPairs()
         await first.OnNextAsync(1, CancellationToken.None);
         await first.OnNextAsync(SampleValue2, CancellationToken.None);
         await first.OnCompletedAsync(Result.Success);
-        await AsyncTestHelpers.WaitForConditionAsync(() => items.Count >= 2, CombiningWaitTimeout);
+        await Assert.That(items.Count >= 2).IsTrue();
         await Assert.That(items).IsCollectionEqualTo(["1-a", "2-b"]);
     }
 
@@ -290,7 +290,7 @@ public async Task WhenZipFirstSourceCompletedTwice_ThenSecondCompletionIgnored()
             });
         await first.OnCompletedAsync(Result.Success);
         await second.OnCompletedAsync(Result.Success);
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionCount >= 1, CombiningWaitTimeout);
+        await Assert.That(completionCount >= 1).IsTrue();
 
         // Only one completion should have been forwarded
         await Assert.That(completionCount).IsEqualTo(1);
@@ -345,7 +345,7 @@ public async Task WhenZipFirstSourceFails_ThenCompletesWithFailure()
                 return default;
             });
         await first.OnCompletedAsync(Result.Failure(new InvalidOperationException(FirstFailMessage)));
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
         await first.DisposeAsync();
@@ -419,7 +419,7 @@ public async Task WhenZipOnNextAfterDone_ThenReturnsEarly()
 
         // Complete source1 with failure (sets _done = true)
         await source1.OnCompletedAsync(Result.Failure(new InvalidOperationException("done")));
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
 
         // Now emit on source2 - should be ignored because _done = true
         await source2.OnNextAsync("after", CancellationToken.None);
@@ -450,7 +450,7 @@ public async Task WhenZipOnNext1AfterDone_ThenReturnsEarly()
 
         // Complete source2 with failure (sets _done = true)
         await source2.OnCompletedAsync(Result.Failure(new InvalidOperationException("done")));
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, CombiningWaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
 
         // Now emit on source1 - should be ignored because _done = true
         await source1.OnNextAsync(Sentinel42, CancellationToken.None);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
index e52e1bac..76f0e3ad 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalBaseTests.cs
@@ -9,10 +9,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Coverage for the static fan-out helpers in
-/// <see cref="Concurrent"/> — exercises empty / single / multi-observer paths and the
-/// slow-path that uses <see cref="Task.WhenAll(Task[])"/> when at
-/// least one observer's <see cref="ValueTask"/> hasn't completed synchronously.</summary>
+/// <summary>Tests concurrent notification of empty, single and multiple observer collections.</summary>
 public class ConcurrentSignalBaseTests
 {
     /// <summary>Value forwarded by the <c>OnNext</c> fan-out tests.</summary>
@@ -75,15 +72,20 @@ public async Task WhenRelayNextAsyncSlowPath_ThenWhenAllForwarded()
         IntCapture a = new();
         IntCapture b = new();
         IntCapture c = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         ImmutableArray<IObserverAsync<int>> observers =
         [
-            MakeSlow(a),
+            MakeSlow(a, release.Task),
             MakeSync(b),
-            MakeSlow(c)
+            MakeSlow(c, release.Task)
         ];
 
-        await Concurrent.ForwardOnNextConcurrently(observers, ForwardedValue, default);
+        var forwarding = Concurrent.ForwardOnNextConcurrently(observers, ForwardedValue, default);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await Assert.That(b.Value).IsEqualTo(ForwardedValue);
+        release.SetResult();
+        await forwarding;
 
         await Assert.That(a.Value).IsEqualTo(ForwardedValue);
         await Assert.That(b.Value).IsEqualTo(ForwardedValue);
@@ -112,13 +114,18 @@ await Concurrent.ForwardOnErrorResumeConcurrently(
 
         ErrorCapture a = new();
         ErrorCapture b = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         ImmutableArray<IObserverAsync<int>> multi =
         [
-            new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSlow(a)),
+            new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSlow(a, release.Task)),
             new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSync(b))
         ];
         InvalidOperationException multiError = new("multi");
-        await Concurrent.ForwardOnErrorResumeConcurrently(multi, multiError, default);
+        var forwarding = Concurrent.ForwardOnErrorResumeConcurrently(multi, multiError, default);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await Assert.That(b.Error).IsSameReferenceAs(multiError);
+        release.SetResult();
+        await forwarding;
         await Assert.That(a.Error).IsSameReferenceAs(multiError);
         await Assert.That(b.Error).IsSameReferenceAs(multiError);
     }
@@ -141,12 +148,17 @@ public async Task WhenForwardOnCompleted_ThenAllBranchesForward()
 
         ResultCapture a = new();
         ResultCapture b = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         ImmutableArray<IObserverAsync<int>> multi =
         [
-            new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSlow(a)),
+            new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSlow(a, release.Task)),
             new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSync(b))
         ];
-        await Concurrent.ForwardOnCompletedConcurrently(multi, Result.Success);
+        var forwarding = Concurrent.ForwardOnCompletedConcurrently(multi, Result.Success);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await Assert.That(b.Result).IsEqualTo(Result.Success);
+        release.SetResult();
+        await forwarding;
         await Assert.That(a.Result).IsEqualTo(Result.Success);
         await Assert.That(b.Result).IsEqualTo(Result.Success);
     }
@@ -158,14 +170,19 @@ public async Task WhenSerialErrorBroadcastSlowPath_ThenRemainingObserversReceive
     {
         ErrorCapture a = new();
         ErrorCapture b = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         ImmutableArray<IObserverAsync<int>> observers =
         [
-            new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSlow(a)),
+            new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSlow(a, release.Task)),
             new CallbackWitnessAsync<int>(static (_, _) => default, MakeErrorSync(b))
         ];
         InvalidOperationException error = new("serial-error");
 
-        await SerialBroadcastHelpers.BroadcastOnErrorResumeAsync(observers, error, default);
+        var forwarding = SerialBroadcastHelpers.BroadcastOnErrorResumeAsync(observers, error, default);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await Assert.That(b.Error).IsNull();
+        release.SetResult();
+        await forwarding;
 
         await Assert.That(a.Error).IsSameReferenceAs(error);
         await Assert.That(b.Error).IsSameReferenceAs(error);
@@ -178,13 +195,18 @@ public async Task WhenSerialCompletionBroadcastSlowPath_ThenRemainingObserversRe
     {
         ResultCapture a = new();
         ResultCapture b = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         ImmutableArray<IObserverAsync<int>> observers =
         [
-            new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSlow(a)),
+            new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSlow(a, release.Task)),
             new CallbackWitnessAsync<int>(static (_, _) => default, null, MakeCompletedSync(b))
         ];
 
-        await SerialBroadcastHelpers.BroadcastOnCompletedAsync(observers, Result.Success);
+        var forwarding = SerialBroadcastHelpers.BroadcastOnCompletedAsync(observers, Result.Success);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await Assert.That(b.Result).IsNull();
+        release.SetResult();
+        await forwarding;
 
         await Assert.That(a.Result).IsEqualTo(Result.Success);
         await Assert.That(b.Result).IsEqualTo(Result.Success);
@@ -248,14 +270,14 @@ private static CallbackWitnessAsync<int> MakeSync(IntCapture capture) =>
             return default;
         });
 
-    /// <summary>Creates an OnNext observer that suspends before capturing — forces the slow path.</summary>
+    /// <summary>Creates an OnNext observer that waits for release before capturing.</summary>
     /// <param name="capture">The capture sink.</param>
+    /// <param name="release">The notification gate.</param>
     /// <returns>An observer whose <c>OnNextAsync</c> completes asynchronously.</returns>
-    private static CallbackWitnessAsync<int> MakeSlow(IntCapture capture) =>
+    private static CallbackWitnessAsync<int> MakeSlow(IntCapture capture, Task release) =>
         new(async (x, _) =>
         {
-            // Yielding guarantees the returned ValueTask is incomplete when the fan-out inspects it.
-            await Task.Yield();
+            await release;
             capture.Value = x;
         });
 
@@ -269,13 +291,14 @@ private static Func<Exception, CancellationToken, ValueTask> MakeErrorSync(Error
             return default;
         };
 
-    /// <summary>OnErrorResume handler that suspends before recording — forces the slow path.</summary>
+    /// <summary>Creates an error handler that waits for release before recording.</summary>
     /// <param name="capture">The capture sink.</param>
+    /// <param name="release">The notification gate.</param>
     /// <returns>An OnErrorResume delegate.</returns>
-    private static Func<Exception, CancellationToken, ValueTask> MakeErrorSlow(ErrorCapture capture) =>
+    private static Func<Exception, CancellationToken, ValueTask> MakeErrorSlow(ErrorCapture capture, Task release) =>
         async (ex, _) =>
         {
-            await Task.Yield();
+            await release;
             capture.Error = ex;
         };
 
@@ -289,13 +312,14 @@ private static Func<Result, ValueTask> MakeCompletedSync(ResultCapture capture)
             return default;
         };
 
-    /// <summary>OnCompleted handler that suspends before recording — forces the slow path.</summary>
+    /// <summary>Creates a completion handler that waits for release before recording.</summary>
     /// <param name="capture">The capture sink.</param>
+    /// <param name="release">The notification gate.</param>
     /// <returns>An OnCompleted delegate.</returns>
-    private static Func<Result, ValueTask> MakeCompletedSlow(ResultCapture capture) =>
+    private static Func<Result, ValueTask> MakeCompletedSlow(ResultCapture capture, Task release) =>
         async r =>
         {
-            await Task.Yield();
+            await release;
             capture.Result = r;
         };
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
index e5c64fdd..011c2212 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
@@ -2,6 +2,8 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>
@@ -34,5 +36,6 @@ protected override void QueueTask(Task task) =>
     /// <summary>Runs a queued task on the pool thread that picked it up.</summary>
     /// <param name="task">The queued task.</param>
     /// <returns><see langword="true"/> when the task was executed.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private bool ExecuteQueued(Task task) => TryExecuteTask(task);
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DirectSource.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DirectSource.cs
index 399268ad..000c2596 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/DirectSource.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DirectSource.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// An async observable source that stores observer references for direct method invocation in tests.
-/// Subscriptions return no-op disposables so that external disposal does not tear down observer access.
-/// This enables testing race-condition guards inside operators like CombineLatest.
-/// </summary>
+/// <summary>Retains subscribed observers for direct notification after disposal.</summary>
 /// <typeparam name="T">The element type.</typeparam>
 internal sealed class DirectSource<T> : IObservableAsync<T>
 {
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableAsyncSlotTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableAsyncSlotTests.cs
index c25aee67..3957bfb9 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableAsyncSlotTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableAsyncSlotTests.cs
@@ -112,6 +112,24 @@ public async Task WhenAssignedTwice_ThenThrowsInvalidOperation()
     public async Task WhenDisposedSlotMarkerDisposed_ThenCompletesSilently() =>
         await Assert.That(static async () => await DisposableAsyncSlot.DisposedSentinel.DisposeAsync()).ThrowsNothing();
 
+    /// <summary>Verifies a stale observation retries against the current slot state.</summary>
+    /// <param name="closed">Whether the slot closed after the observation.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenSwapObservationIsStale_ThenUsesCurrentSlot(bool closed)
+    {
+        RecordingAsyncDisposable previous = new();
+        RecordingAsyncDisposable incoming = new();
+        var slot = closed ? DisposableAsyncSlot.DisposedSentinel : previous;
+        await DisposableAsyncSlot.SwapObservedAsync(ref slot, incoming, null);
+        await Assert.That(incoming.DisposeCount).IsEqualTo(closed ? 1 : 0);
+        await Assert.That(previous.DisposeCount).IsEqualTo(closed ? 0 : 1);
+        await Assert.That(slot).IsSameReferenceAs(closed ? DisposableAsyncSlot.DisposedSentinel : incoming);
+        await DisposableAsyncSlot.DisposeAsync(ref slot);
+    }
+
     /// <summary>Recording async disposable that counts disposals.</summary>
     private sealed class RecordingAsyncDisposable : IAsyncDisposable
     {
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.SingleAssignment.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.SingleAssignment.cs
new file mode 100644
index 00000000..5a854360
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.SingleAssignment.cs
@@ -0,0 +1,87 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Async.Disposables;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests single-assignment ownership and disposal.</summary>
+public partial class DisposableTests
+{
+    /// <summary>Tests SingleAssignmentDisposableAsync disposes assigned.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsync_ThenDisposesAssigned()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        StrongBox<bool> disposed = new();
+        await sad.SetDisposableAsync(DisposableAsync.Create(disposed, static state =>
+        {
+            state.Value = true;
+            return default;
+        }));
+        await Assert.That(sad.IsDisposed).IsFalse();
+        await sad.DisposeAsync();
+        await Assert.That(sad.IsDisposed).IsTrue();
+        await Assert.That(disposed.Value).IsTrue();
+    }
+
+    /// <summary>Tests SingleAssignment dispose before set disposes immediately.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsyncDisposeBeforeSet_ThenSetDisposedImmediately()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        await sad.DisposeAsync();
+        StrongBox<bool> disposed = new();
+        await sad.SetDisposableAsync(DisposableAsync.Create(disposed, static state =>
+        {
+            state.Value = true;
+            return default;
+        }));
+        await Assert.That(disposed.Value).IsTrue();
+    }
+
+    /// <summary>Tests SingleAssignment double set throws.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsyncDoubleSet_ThenThrowsInvalidOperation()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        await sad.SetDisposableAsync(DisposableAsync.Empty);
+        await Assert.That(async () => await sad.SetDisposableAsync(DisposableAsync.Empty))
+            .ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleAssignment get before set returns null.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsyncGetBeforeSet_ThenReturnsNull()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        await Assert.That(sad.GetDisposable()).IsNull();
+    }
+
+    /// <summary>Tests SingleAssignment get after dispose returns non-null.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsyncGetAfterDispose_ThenReturnsEmpty()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        await sad.DisposeAsync();
+        await Assert.That(sad.GetDisposable()).IsNotNull();
+    }
+
+    /// <summary>Tests SingleAssignment get after set returns assigned.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAssignmentDisposableAsyncGetAfterSet_ThenReturnsAssigned()
+    {
+        SingleAssignmentDisposableAsync sad = new();
+        var original = DisposableAsync.Empty;
+        await sad.SetDisposableAsync(original);
+        await Assert.That(sad.GetDisposable()).IsSameReferenceAs(original);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
index 5637fc99..eb848fe7 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposableTests.cs
@@ -8,7 +8,7 @@
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>Tests for DisposableAsync, CompositeDisposableAsync, SingleAssignmentDisposableAsync, and SerialDisposableAsync.</summary>
-public class DisposableTests
+public partial class DisposableTests
 {
     /// <summary>Tests DisposableAsync.Empty dispose does nothing.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -196,81 +196,6 @@ public async Task WhenCompositeDisposableAsyncIsDisposed_ThenReturnsFalse()
         await Assert.That(composite.IsDisposed).IsFalse();
     }
 
-    /// <summary>Tests SingleAssignmentDisposableAsync disposes assigned.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsync_ThenDisposesAssigned()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        StrongBox<bool> disposed = new();
-        await sad.SetDisposableAsync(DisposableAsync.Create(disposed, static state =>
-        {
-            state.Value = true;
-            return default;
-        }));
-        await Assert.That(sad.IsDisposed).IsFalse();
-        await sad.DisposeAsync();
-        await Assert.That(sad.IsDisposed).IsTrue();
-        await Assert.That(disposed.Value).IsTrue();
-    }
-
-    /// <summary>Tests SingleAssignment dispose before set disposes immediately.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsyncDisposeBeforeSet_ThenSetDisposedImmediately()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        await sad.DisposeAsync();
-        StrongBox<bool> disposed = new();
-        await sad.SetDisposableAsync(DisposableAsync.Create(disposed, static state =>
-        {
-            state.Value = true;
-            return default;
-        }));
-        await Assert.That(disposed.Value).IsTrue();
-    }
-
-    /// <summary>Tests SingleAssignment double set throws.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsyncDoubleSet_ThenThrowsInvalidOperation()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        await sad.SetDisposableAsync(DisposableAsync.Empty);
-        await Assert.That(async () => await sad.SetDisposableAsync(DisposableAsync.Empty))
-            .ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleAssignment get before set returns null.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsyncGetBeforeSet_ThenReturnsNull()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        await Assert.That(sad.GetDisposable()).IsNull();
-    }
-
-    /// <summary>Tests SingleAssignment get after dispose returns non-null.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsyncGetAfterDispose_ThenReturnsEmpty()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        await sad.DisposeAsync();
-        await Assert.That(sad.GetDisposable()).IsNotNull();
-    }
-
-    /// <summary>Tests SingleAssignment get after set returns assigned.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAssignmentDisposableAsyncGetAfterSet_ThenReturnsAssigned()
-    {
-        SingleAssignmentDisposableAsync sad = new();
-        var original = DisposableAsync.Empty;
-        await sad.SetDisposableAsync(original);
-        await Assert.That(sad.GetDisposable()).IsSameReferenceAs(original);
-    }
-
     /// <summary>Tests SerialDisposableAsync replaces and disposes previous.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -481,29 +406,34 @@ public async Task WhenSerialSetNullAfterDispose_ThenCompletesWithoutError()
     /// </summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenSerialConcurrentSet_ThenAllPreviousDisposed()
+    public async Task WhenSerialReplacementPending_ThenFurtherReplacementDisposesCurrentValue()
     {
+        const int SecondValue = 2;
+        const int ThirdValue = 3;
         SingleReplaceableDisposableAsync serial = new();
-        StrongBox<int> disposedCount = new();
-
-        IAsyncDisposable MakeDisposable() => DisposableAsync.Create(disposedCount, static state =>
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<int> disposed = [];
+        await serial.SetDisposableAsync(DisposableAsync.Create((release, disposed), static async state =>
         {
-            _ = Interlocked.Increment(ref state.Value);
+            await state.release.Task;
+            state.disposed.Add(1);
+        }));
+        var replacement = serial.SetDisposableAsync(DisposableAsync.Create(disposed, static items =>
+        {
+            items.Add(SecondValue);
             return default;
-        });
-
-        const int ExpectedDisposedCount = 50;
-
-        // Rapid concurrent sets to exercise the CAS retry path
-        var tasks = Enumerable.Range(0, ExpectedDisposedCount)
-            .Select(_ => Task.Run(async () => await serial.SetDisposableAsync(MakeDisposable())));
-        await Task.WhenAll(tasks);
-
-        // Dispose the serial to clean up the final remaining disposable
+        }));
+        await Assert.That(replacement.IsCompleted).IsFalse();
+        await serial.SetDisposableAsync(DisposableAsync.Create(disposed, static items =>
+        {
+            items.Add(ThirdValue);
+            return default;
+        }));
         await serial.DisposeAsync();
-
-        // All 50 disposables should eventually be disposed (49 replaced + 1 final)
-        await Assert.That(disposedCount.Value).IsEqualTo(ExpectedDisposedCount);
+        await Assert.That(disposed).IsCollectionEqualTo([SecondValue, ThirdValue]);
+        release.SetResult();
+        await replacement;
+        await Assert.That(disposed).IsCollectionEqualTo([SecondValue, ThirdValue, 1]);
     }
 
     /// <summary>
@@ -804,35 +734,35 @@ public void WhenToDisposableAsyncNull_ThenThrowsArgumentNull() =>
     /// </summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenSerialSetConcurrently_ThenAllDisposablesAccountedFor()
+    public async Task WhenSerialReplacementPending_ThenDisposalClosesTheSlot()
     {
+        const int SecondValue = 2;
+        const int ThirdValue = 3;
         SingleReplaceableDisposableAsync serial = new();
-        StrongBox<int> disposedCount = new();
-
-        IAsyncDisposable MakeDisposable() => DisposableAsync.Create(disposedCount, static state =>
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<int> disposed = [];
+        await serial.SetDisposableAsync(DisposableAsync.Create((release, disposed), static async state =>
         {
-            _ = Interlocked.Increment(ref state.Value);
+            await state.release.Task;
+            state.disposed.Add(1);
+        }));
+        var replacement = serial.SetDisposableAsync(DisposableAsync.Create(disposed, static items =>
+        {
+            items.Add(SecondValue);
             return default;
-        });
-
-        // Bounded contention: enough parallel sets to overlap on the CAS, few enough that the
-        // total disposal count stays small. The count below holds for every interleaving.
-        const int Parallelism = 4;
-        const int IterationsPerTask = 5;
-        const int ExpectedDisposedCount = Parallelism * IterationsPerTask;
-        var tasks = Enumerable.Range(0, Parallelism).Select(_ => Task.Run(async () =>
+        }));
+        await Assert.That(replacement.IsCompleted).IsFalse();
+        await serial.DisposeAsync();
+        await serial.SetDisposableAsync(DisposableAsync.Create(disposed, static items =>
         {
-            for (var i = 0; i < IterationsPerTask; i++)
-            {
-                await serial.SetDisposableAsync(MakeDisposable());
-            }
+            items.Add(ThirdValue);
+            return default;
         }));
-        await Task.WhenAll(tasks);
         await serial.DisposeAsync();
-
-        // Every set disposable (Parallelism * IterationsPerTask) should be disposed —
-        // (Parallelism * IterationsPerTask - 1) replaced + 1 final dispose.
-        await Assert.That(disposedCount.Value).IsEqualTo(ExpectedDisposedCount);
+        await Assert.That(disposed).IsCollectionEqualTo([SecondValue, ThirdValue]);
+        release.SetResult();
+        await replacement;
+        await Assert.That(disposed).IsCollectionEqualTo([SecondValue, ThirdValue, 1]);
     }
 
     /// <summary>Verifies that the shared disposed sentinel DisposeAsync returns a completed ValueTask without throwing.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/DisposalHelperTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposalHelperTests.cs
new file mode 100644
index 00000000..6a68537c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/DisposalHelperTests.cs
@@ -0,0 +1,23 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Helpers;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests disposal ownership claims.</summary>
+public sealed class DisposalHelperTests
+{
+    /// <summary>Verifies that disposal ownership is granted only once.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenDisposalClaimedTwice_ThenSecondClaimFindsItDisposed()
+    {
+        var disposed = 0;
+        await Assert.That(DisposalHelper.HasDisposed(disposed)).IsFalse();
+        await Assert.That(DisposalHelper.TrySetDisposed(ref disposed)).IsFalse();
+        await Assert.That(DisposalHelper.HasDisposed(disposed)).IsTrue();
+        await Assert.That(DisposalHelper.TrySetDisposed(ref disposed)).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
index 40ce0ccc..5713d6d1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
@@ -14,12 +14,6 @@ public class ErrorHandlingOperatorTests
     /// <summary>Message of the resumable error raised by the source.</summary>
     private const string ResumeErrorMessage = "resume error";
 
-    /// <summary>Maximum time a test waits for a completion or error to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Window the retry test watches to confirm no completion is published.</summary>
-    private static readonly TimeSpan NoCompletionWindow = TimeSpan.FromMilliseconds(500);
-
     /// <summary>Tests Catch with fallback switches to fallback.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -81,7 +75,7 @@ public async Task WhenOnErrorResumeAsFailure_ThenConvertsErrorResumeToFailure()
             _ = completed.TrySetResult();
             return default;
         });
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(errorSent).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
@@ -194,7 +188,7 @@ public async Task WhenCatchWithoutErrorResumeCallback_ThenForwardsToDownstream()
                 });
         InvalidOperationException expected = new("catch-passthrough");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -238,7 +232,7 @@ public async Task WhenRetryWithCountZero_ThenPropagatesErrorImmediately()
             _ = completed.TrySetResult(result);
             return default;
         });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
         await Assert.That(attempt).IsEqualTo(1);
     }
@@ -265,7 +259,7 @@ public async Task WhenRetryCountExhausted_ThenPropagatesLastError()
             _ = completed.TrySetResult(result);
             return default;
         });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
     }
@@ -290,7 +284,7 @@ public async Task WhenRetryWithCountOne_ThenRetriesOnceAndPropagates()
             _ = completed.TrySetResult(result);
             return default;
         });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
     }
@@ -311,7 +305,7 @@ public async Task WhenCatchHandlerThrows_ThenCompletesWithHandlerException()
                     _ = completed.TrySetResult(result);
                     return default;
                 });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
         await Assert.That(completionResult.Exception).IsTypeOf<ArithmeticException>();
     }
@@ -331,7 +325,7 @@ public async Task WhenCatchDisposed_ThenDisposesSourceAndHandler()
         });
         var sub = await source.Catch(_ => handlerObservable)
             .SubscribeAsync(static (_, _) => default, null, static _ => default);
-        await handlerItemReceived.Task.WaitAsync(WaitTimeout);
+        await handlerItemReceived.Task;
 
         // Disposing should dispose both source and handler disposables
         await sub.DisposeAsync();
@@ -364,9 +358,9 @@ public async Task WhenCatchHandlerDisposeThrows_ThenRoutedToUnhandled()
             });
             var sub = await source.Catch(_ => handlerObservable)
                 .SubscribeAsync(static (_, _) => default, null, static _ => default);
-            await handlerSubscribed.Task.WaitAsync(WaitTimeout);
+            await handlerSubscribed.Task;
             await sub.DisposeAsync();
-            await unhandledTcs.Task.WaitAsync(WaitTimeout);
+            await unhandledTcs.Task;
             await Assert.That(unhandled).IsSameReferenceAs(disposeFailure);
         }
         finally
@@ -425,11 +419,8 @@ public async Task WhenRetryResubscriptionCancelled_ThenSwallowsCancellation()
             return default;
         });
 
-        // The OperationCanceledException is swallowed, so completion should not fire.
-        // Give a short window to verify no completion occurs.
-        var completedInTime = completed.Task.WaitAsync(NoCompletionWindow);
         const int ExpectedAttempts = 2;
-        await Assert.That(() => completedInTime).ThrowsExactly<TimeoutException>();
+        await Assert.That(completed.Task.IsCompleted).IsFalse();
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
     }
 
@@ -460,7 +451,7 @@ public async Task WhenRetryResubscriptionThrows_ThenCompletesWithFailure()
             _ = completed.TrySetResult(result);
             return default;
         });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
         const int ExpectedAttempts = 2;
         await Assert.That(completionResult.Exception).IsTypeOf<ArithmeticException>();
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
index 904c4162..f9fd33e3 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
@@ -2,9 +2,6 @@
 // ReactiveUI Association Incorporated 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;
-using ReactiveUI.Primitives.Async.Signals;
-
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>
@@ -14,172 +11,67 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// </summary>
 public class ExpireOperatorTests
 {
-    /// <summary>Seconds a test waits for a completion to arrive.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>The inter-element deadline used by the tests.</summary>
     private static readonly TimeSpan DueTime = TimeSpan.FromMilliseconds(20);
 
-    /// <summary>Maximum time a test waits for a completion to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
-    /// <summary>How long a test waits to prove a swallowed timer tick never produces a second completion.</summary>
-    private static readonly TimeSpan SecondTickSettleWindow = TimeSpan.FromMilliseconds(250);
-
     /// <summary>Verifies that a source which never produces a value trips the deadline and the sequence completes with a <see cref="TimeoutException"/>.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenNoValueArrivesWithinTheDeadline_ThenCompletesWithTimeoutException()
     {
-        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await SignalAsync.Never<int>().Expire(DueTime).SubscribeAsync(
-            static (_, _) => default,
-            null,
-            result =>
-            {
-                _ = completed.TrySetResult(result);
-                return default;
-            });
-
-        var result = await completed.Task.WaitAsync(WaitTimeout);
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Never<int>().Timeout(DueTime, time).FirstAsync().AsTask();
+        await time.FireNextAsync();
+        await Assert.That(() => pending).ThrowsExactly<TimeoutException>();
+    }
 
-        await Assert.That(result.IsFailure).IsTrue();
-        await Assert.That(result.Exception is TimeoutException).IsTrue();
+    /// <summary>Verifies that timer control becomes a no-op after disposal removes the timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenTimerDisposed_ThenRearmAndStopDoNothing()
+    {
+        ManualTimeProvider time = new();
+        List<Result> completions = [];
+        CallbackWitnessAsync<int> observer = new(static (_, _) => default, null, result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        SignalAsyncExtensions.TimeoutSignal<int>.TimeoutWitness witness = new(observer, DueTime, time);
+        witness.StartTimer(CancellationToken.None);
+        var timer = await time.NextTimerAsync();
+        witness.StopTimer();
+        await Assert.That(timer.DueTime).IsEqualTo(Timeout.InfiniteTimeSpan);
+        witness.RearmTimer();
+        await Assert.That(timer.DueTime).IsEqualTo(DueTime);
+        await witness.DisposeAsync();
+        witness.RearmTimer();
+        witness.StopTimer();
+        timer.Fire();
+        await Assert.That(completions).IsEmpty();
     }
 
-    /// <summary>
-    /// Verifies that the deadline tick is swallowed once the sequence has already expired. A source value that
-    /// arrives after the timeout rearms the deadline, so the timer fires a second time; that tick must not turn
-    /// into a second <see cref="TimeoutException"/> for a sequence that is already finished.
-    /// </summary>
+    /// <summary>Verifies that rearming an expired deadline cannot produce a second completion.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenTheRearmedDeadlineTicksAfterExpiry_ThenNoSecondCompletionIsSent()
     {
-        RearmableTimeProvider timeProvider = new();
-        var source = Signal.Create<int>();
+        ManualTimeProvider time = new();
         List<Result> completions = [];
-        TaskCompletionSource firstCompletion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        SignalAsyncExtensions.TimeoutSignal<int> expiring = new(source.Values, DueTime, timeProvider);
-
-        await using var sub = await expiring.SubscribeAsync(
-            static (_, _) => default,
-            null,
-            result =>
-            {
-                completions.Add(result);
-                IgnoredResult.Of(firstCompletion.TrySetResult());
-                return default;
-            });
-
-        timeProvider.FireAll();
-        await firstCompletion.Task.WaitAsync(WaitTimeout);
-
+        CallbackWitnessAsync<int> observer = new(static (_, _) => default, null, result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        await using SignalAsyncExtensions.TimeoutSignal<int>.TimeoutWitness witness = new(observer, DueTime, time);
+        witness.StartTimer(CancellationToken.None);
+        var timer = await time.NextTimerAsync();
+        timer.Fire();
         await Assert.That(completions).Count().IsEqualTo(1);
-        await Assert.That(completions[0].IsFailure).IsTrue();
-        await Assert.That(completions[0].Exception is TimeoutException).IsTrue();
-
-        // The late value rearms the deadline; the rearmed tick has to be ignored.
-        await source.OnNextAsync(1, CancellationToken.None);
-        timeProvider.FireAll();
-
-        var secondArrived = await AsyncTestHelpers.WaitForConditionAsync(
-            () => completions.Count > 1,
-            SecondTickSettleWindow);
-
-        await Assert.That(secondArrived).IsFalse();
+        await witness.OnNextAsync(1, CancellationToken.None);
+        await Assert.That(timer.DueTime).IsEqualTo(DueTime);
+        timer.Fire();
         await Assert.That(completions).Count().IsEqualTo(1);
-    }
-
-    /// <summary>
-    /// A <see cref="TimeProvider"/> whose timers stay armed: <see cref="FireAll"/> invokes every live timer's
-    /// callback each time it is called, so a test can replay the tick of a deadline that the operator rearmed.
-    /// </summary>
-    private sealed class RearmableTimeProvider : TimeProvider
-    {
-        /// <summary>Protects timer collection access.</summary>
-        private readonly Lock _gate = new();
-
-        /// <summary>The timers created by this provider.</summary>
-        private readonly List<RearmableTimer> _timers = [];
-
-        /// <summary>Creates a timer that only fires when the test says so.</summary>
-        /// <param name="callback">The callback to invoke when the timer is fired.</param>
-        /// <param name="state">The state object passed to the callback.</param>
-        /// <param name="dueTime">The initial delay (ignored; the test drives the tick).</param>
-        /// <param name="period">The interval (ignored; the test drives the tick).</param>
-        /// <returns>A manually fired <see cref="ITimer"/> instance.</returns>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
-        {
-            _ = dueTime;
-            _ = period;
-            RearmableTimer timer = new(callback, state);
-            lock (_gate)
-            {
-                _timers.Add(timer);
-            }
-
-            return timer;
-        }
-
-        /// <summary>Fires every timer this provider has handed out and has not seen disposed.</summary>
-        internal void FireAll()
-        {
-            RearmableTimer[] timers;
-            lock (_gate)
-            {
-                timers = [.. _timers];
-            }
-
-            foreach (var timer in timers)
-            {
-                timer.Fire();
-            }
-        }
-
-        /// <summary>A timer that can be fired any number of times until it is disposed.</summary>
-        /// <param name="callback">The callback to invoke.</param>
-        /// <param name="state">The state object passed to the callback.</param>
-        private sealed class RearmableTimer(TimerCallback callback, object? state) : ITimer
-        {
-            /// <summary>Non-zero once the timer has been disposed.</summary>
-            private int _disposed;
-
-            /// <summary>Reports whether the timer is still live; the new deadline is irrelevant to the test.</summary>
-            /// <param name="dueTime">The due time (ignored).</param>
-            /// <param name="period">The period (ignored).</param>
-            /// <returns><see langword="true"/> when the timer is still active.</returns>
-            public bool Change(TimeSpan dueTime, TimeSpan period)
-            {
-                _ = dueTime;
-                _ = period;
-                return Volatile.Read(ref _disposed) == 0;
-            }
-
-            /// <summary>Marks the timer as disposed.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Dispose() => Interlocked.Exchange(ref _disposed, 1);
-
-            /// <summary>Marks the timer as disposed.</summary>
-            /// <returns>A completed <see cref="ValueTask"/>.</returns>
-            public ValueTask DisposeAsync()
-            {
-                Dispose();
-                return default;
-            }
-
-            /// <summary>Invokes the callback unless the timer has been disposed.</summary>
-            internal void Fire()
-            {
-                if (Volatile.Read(ref _disposed) != 0)
-                {
-                    return;
-                }
-
-                callback(state);
-            }
-        }
+        await Assert.That(completions[0].Exception).IsTypeOf<TimeoutException>();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
index 045e69b5..1a5f4665 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
@@ -257,10 +257,13 @@ static async (observer, ct) =>
     [Test]
     public async Task WhenTimerSingleShot_ThenEmitsSingleValueAfterDelay()
     {
-        var source = SignalAsync.Timer(SingleShotDelay);
-        var result = await source.ToListAsync();
-        await Assert.That(result).Count().IsEqualTo(1);
-        await Assert.That(result[0]).IsEqualTo(0L);
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Timer(SingleShotDelay, time).ToListAsync().AsTask();
+        var timer = await time.NextTimerAsync();
+        await Assert.That(pending.IsCompleted).IsFalse();
+        await Assert.That(timer.DueTime).IsEqualTo(SingleShotDelay);
+        timer.Fire();
+        await Assert.That(await pending).IsCollectionEqualTo([0L]);
     }
 
     /// <summary>Tests Timer periodic emits multiple values.</summary>
@@ -268,25 +271,16 @@ public async Task WhenTimerSingleShot_ThenEmitsSingleValueAfterDelay()
     [Test]
     public async Task WhenTimerPeriodic_ThenEmitsMultipleValues()
     {
-        const int MinimumEmissions = 2;
-        var source = SignalAsync.Timer(PeriodicDueTime, PeriodicInterval);
-        List<long> items = [];
-        TaskCompletionSource minimumReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await source.SubscribeAsync(
-            (x, _) =>
-            {
-                items.Add(x);
-                if (items.Count >= MinimumEmissions)
-                {
-                    IgnoredResult.Of(minimumReceived.TrySetResult());
-                }
-
-                return default;
-            },
-            null);
-        await minimumReceived.Task;
-        await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinimumEmissions);
-        await Assert.That(items[0]).IsEqualTo(0L);
+        const int SecondValue = 2;
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Timer(PeriodicDueTime, PeriodicInterval, time).Take(SecondValue).ToListAsync().AsTask();
+        var first = await time.NextTimerAsync();
+        await Assert.That(first.DueTime).IsEqualTo(PeriodicDueTime);
+        first.Fire();
+        var second = await time.NextTimerAsync();
+        await Assert.That(second.DueTime).IsEqualTo(PeriodicInterval);
+        second.Fire();
+        await Assert.That(await pending).IsCollectionEqualTo([0L, 1L]);
     }
 
     /// <summary>Tests Timer negative due time.</summary>
@@ -370,46 +364,11 @@ public async Task WhenVoidTaskToAsyncSignal_ThenEmitsUnit()
     [Test]
     public async Task WhenIntervalWithCancellation_ThenEmitsPeriodicValues()
     {
-        const int MinimumEmissions = 2;
-        using CancellationTokenSource cts = new();
-        var source = SignalAsync.Interval(PeriodicInterval);
-        List<long> items = [];
-        TaskCompletionSource minimumReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var received = false;
-        try
-        {
-            await using var sub = await source.SubscribeAsync(
-                (x, _) =>
-                {
-                    items.Add(x);
-                    if (items.Count >= MinimumEmissions)
-                    {
-                        IgnoredResult.Of(minimumReceived.TrySetResult());
-                    }
-
-                    return default;
-                },
-                null,
-                null,
-                cts.Token);
-            await minimumReceived.Task;
-            received = true;
-        }
-        catch (OperationCanceledException)
-        {
-            // Expected — the timer is being cancelled to end the test.
-        }
-        finally
-        {
-            if (!cts.IsCancellationRequested)
-            {
-                await cts.CancelAsync();
-            }
-        }
-
-        await Assert.That(received).IsTrue();
-        await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinimumEmissions);
-        await Assert.That(items[0]).IsEqualTo(1L);
+        const int SecondValue = 2;
+        const long SecondTick = 2L;
+        ManualTimeProvider time = new();
+        var values = await time.RunAsync(SignalAsync.Interval(PeriodicInterval, time).Take(SecondValue).ToListAsync().AsTask());
+        await Assert.That(values).IsCollectionEqualTo([1L, SecondTick]);
     }
 
     /// <summary>Tests that enumerable subscription emission returns early when the cancellation token is already cancelled.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FilteringOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FilteringOperatorTests.cs
index cf0c6fce..c5b30876 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/FilteringOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FilteringOperatorTests.cs
@@ -46,9 +46,6 @@ public class FilteringOperatorTests
     /// <summary>Hoisted source array used by tests (was inline literal).</summary>
     private static readonly string[] SequenceAbcAbADefDe = ["abc", "ab", "a", "def", "de"];
 
-    /// <summary>Maximum time a test waits for a forwarded error to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Tests sync Where filters elements.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -383,7 +380,7 @@ public async Task WhenSkipWhileSyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("skip-while-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -407,7 +404,7 @@ public async Task WhenTakeWhileSyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("take-while-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -458,7 +455,7 @@ public async Task WhenSkipWhileAsyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("skip-while-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -480,7 +477,7 @@ public async Task WhenTakeWhileAsyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("take-while-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -501,7 +498,7 @@ public async Task WhenDistinctSourceErrorResume_ThenForwarded()
         });
         InvalidOperationException expected = new("distinct-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -523,7 +520,7 @@ public async Task WhenDistinctBySourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("distinct-by-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -545,7 +542,7 @@ public async Task WhenDistinctUntilChangedSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("distinct-until-changed-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -567,7 +564,7 @@ public async Task WhenDistinctUntilChangedBySourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("distinct-until-changed-by-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -590,7 +587,7 @@ public async Task WhenWhereSyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("where-sync-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -611,7 +608,7 @@ public async Task WhenSkipSourceErrorResume_ThenForwarded()
         });
         InvalidOperationException expected = new("skip-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -633,7 +630,7 @@ public async Task WhenTakeSourceErrorResume_ThenForwarded()
         });
         InvalidOperationException expected = new("take-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -655,7 +652,7 @@ public async Task WhenCastSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("cast-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -677,7 +674,7 @@ public async Task WhenOfTypeSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("of-type-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -700,7 +697,7 @@ public async Task WhenSelectSyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("select-sync-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -723,7 +720,7 @@ public async Task WhenSelectAsyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("select-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -746,7 +743,7 @@ public async Task WhenWhereAsyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("where-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FireAndForgetHelperTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FireAndForgetHelperTests.cs
new file mode 100644
index 00000000..15af7a23
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FireAndForgetHelperTests.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Helpers;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests detached action completion and exception reporting.</summary>
+public sealed class FireAndForgetHelperTests
+{
+    /// <summary>Verifies that asynchronous action completion includes exception reporting.</summary>
+    /// <param name="fail">Whether the released action throws.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenDetachedActionFinishes_ThenFailureIsReported(bool fail)
+    {
+        using UnhandledExceptionCapture capture = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        InvalidOperationException expected = new("action failed");
+        var completed = false;
+        var pending = FireAndForgetHelper.RunAsync(async () =>
+        {
+            await release.Task;
+            completed = true;
+            if (fail)
+            {
+                throw expected;
+            }
+        });
+        await Assert.That(pending.IsCompleted).IsFalse();
+        release.SetResult();
+        await pending;
+        await Assert.That(completed).IsTrue();
+        if (!fail)
+        {
+            return;
+        }
+
+        await Assert.That(await capture.WaitForAsync(expected.Message)).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that action validation rejects null delegates.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenDetachedActionIsNull_ThenValidationFails() =>
+        await Assert.That(static async () => await FireAndForgetHelper.RunAsync(null!)).ThrowsExactly<ArgumentNullException>();
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FlatMapCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FlatMapCoordinatorTests.cs
index 3537d7f9..23ab1a61 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/FlatMapCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FlatMapCoordinatorTests.cs
@@ -8,7 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Direct coverage for <see cref="FlatMapCoordinator{TResult}"/> lifecycle paths.</summary>
+/// <summary>Tests flat-map coordinator notification and disposal behavior.</summary>
 public class FlatMapCoordinatorTests
 {
     /// <summary>Sample integer value one.</summary>
@@ -143,7 +143,7 @@ public async Task WhenAlreadyDisposed_ThenIgnoresInnerAndRoutesLateFailure()
         await coordinator.FinishAsync(Result.Success);
         await coordinator.FinishAsync(Result.Failure(expected));
 
-        var captured = await capture.WaitForAsync(ex => ReferenceEquals(ex, expected), TimeSpan.FromSeconds(One));
+        var captured = await capture.WaitForAsync(ex => ReferenceEquals(ex, expected));
         await Assert.That(ignored.SubscribeCount).IsEqualTo(0);
         await Assert.That(observer.Completions.Count).IsEqualTo(0);
         await Assert.That(captured).IsSameReferenceAs(expected);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/Internals/PooledDelaySourceTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/Internals/PooledDelaySourceTests.cs
index 7b576939..1e81318b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/Internals/PooledDelaySourceTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/Internals/PooledDelaySourceTests.cs
@@ -10,9 +10,6 @@ public class PooledDelaySourceTests
     /// <summary>The delay used by the happy-path test.</summary>
     private static readonly TimeSpan ShortDelay = TimeSpan.FromMilliseconds(20);
 
-    /// <summary>Lower bound the elapsed time must clear to prove the delay was actually awaited.</summary>
-    private static readonly TimeSpan MinimumObservedDelay = TimeSpan.FromMilliseconds(5);
-
     /// <summary>A delay long enough that it can only end through cancellation.</summary>
     private static readonly TimeSpan DelayOutlivingTheTest = TimeSpan.FromSeconds(10);
 
@@ -24,7 +21,7 @@ public async Task WhenPreCancelledToken_ThenFailsWithOperationCanceled()
         using CancellationTokenSource cts = new();
         await cts.CancelAsync();
         var source = PooledDelaySource.Rent();
-        var task = source.BeginAsync(ShortDelay, new NonSystemTimeProvider(), cts.Token);
+        var task = source.BeginAsync(ShortDelay, new ManualTimeProvider(), cts.Token);
         var ex = await Assert.That(async () => await task).ThrowsExactly<OperationCanceledException>();
         await Assert.That(ex).IsNotNull();
     }
@@ -35,12 +32,26 @@ public async Task WhenPreCancelledToken_ThenFailsWithOperationCanceled()
     public async Task WhenTimerFires_ThenSourceCompletes()
     {
         var source = PooledDelaySource.Rent();
-        var start = TimeProvider.System.GetTimestamp();
-        await source.BeginAsync(ShortDelay, new NonSystemTimeProvider(), CancellationToken.None);
-        var elapsed = TimeProvider.System.GetElapsedTime(start);
+        ManualTimeProvider time = new();
+        var pending = source.BeginAsync(ShortDelay, time, CancellationToken.None);
+        var timer = await time.NextTimerAsync();
+        await Assert.That(pending.IsCompleted).IsFalse();
+        await Assert.That(timer.DueTime).IsEqualTo(ShortDelay);
+        timer.Fire();
+        await pending;
+    }
 
-        // Verify the delay actually happened — the source's timer-fired path completed it.
-        await Assert.That(elapsed).IsGreaterThanOrEqualTo(MinimumObservedDelay);
+    /// <summary>A callback fired during timer creation completes before cancellation registration.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenTimerFiresDuringCreation_ThenCompletesSynchronously()
+    {
+        using CancellationTokenSource cancellation = new();
+        var source = PooledDelaySource.Rent();
+        var pending = source.BeginAsync(ShortDelay, new ImmediateTimeProvider(), cancellation.Token);
+        await Assert.That(pending.IsCompletedSuccessfully).IsTrue();
+        await cancellation.CancelAsync();
+        await pending;
     }
 
     /// <summary>Verifies that a token cancelled mid-flight propagates an <see cref = "OperationCanceledException"/>.</summary>
@@ -50,17 +61,47 @@ public async Task WhenTokenCancelledMidFlight_ThenFailsWithOperationCanceled()
     {
         using CancellationTokenSource cts = new();
         var source = PooledDelaySource.Rent();
-        var task = source.BeginAsync(DelayOutlivingTheTest, new NonSystemTimeProvider(), cts.Token);
+        var task = source.BeginAsync(DelayOutlivingTheTest, new ManualTimeProvider(), cts.Token);
         await cts.CancelAsync();
         var ex = await Assert.That(async () => await task).ThrowsExactly<OperationCanceledException>();
         await Assert.That(ex).IsNotNull();
     }
 
-    /// <summary>Non-System <see cref = "TimeProvider"/> that forces BeginAsync down the non-System path.</summary>
-    private sealed class NonSystemTimeProvider : TimeProvider
+    /// <summary>The first terminal event owns the result even when the second event runs before consumption.</summary>
+    /// <param name="cancelFirst">Whether cancellation precedes the timer callback.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenTimerAndCancellationBothFire_ThenFirstEventWins(bool cancelFirst)
+    {
+        ManualTimeProvider time = new();
+        using CancellationTokenSource cancellation = new();
+        var source = PooledDelaySource.Rent();
+        var pending = source.BeginAsync(ShortDelay, time, cancellation.Token);
+        var timer = await time.NextTimerAsync();
+        if (cancelFirst)
+        {
+            await cancellation.CancelAsync();
+            timer.Fire();
+            await Assert.That(async () => await pending).ThrowsExactly<OperationCanceledException>();
+        }
+        else
+        {
+            timer.Fire();
+            await cancellation.CancelAsync();
+            await pending;
+        }
+    }
+
+    /// <summary>A provider that invokes its callback inside timer creation.</summary>
+    private sealed class ImmediateTimeProvider : TimeProvider
     {
         /// <inheritdoc/>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
-            System.CreateTimer(callback, state, dueTime, period);
+        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
+        {
+            callback(state);
+            return new ManualTimeProvider.ManualTimer(callback, state, dueTime);
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
index 5b69b25e..a44c2a24 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
@@ -14,52 +14,30 @@ public class IntervalOperatorTests
     /// <summary>The tick the handler disposes on.</summary>
     private const long DisposeOnTick = 2;
 
-    /// <summary>Seconds a test waits for the reentrant dispose to finish.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>The interval between ticks.</summary>
     private static readonly TimeSpan TickPeriod = TimeSpan.FromMilliseconds(20);
 
-    /// <summary>Maximum time a test waits for the reentrant dispose to finish.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
-    /// <summary>How long a test waits afterwards to prove no further tick is emitted.</summary>
-    private static readonly TimeSpan QuietWindow = TimeSpan.FromMilliseconds(200);
-
     /// <summary>Verifies that disposing the interval subscription from inside a tick handler ends the tick loop:
     /// the ticks seen so far start at one and are consecutive, and nothing arrives after the dispose.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenDisposedFromWithinATick_ThenTheTickLoopStops()
     {
-        TaskCompletionSource<IAsyncDisposable> handleReady = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource disposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        const long SecondTick = 2L;
+        ManualTimeProvider time = new();
         List<long> ticks = [];
-
-        var subscription = await SignalAsync.Interval(TickPeriod).SubscribeAsync(async (tick, _) =>
+        IAsyncDisposable? handle = null;
+        TaskCompletionSource disposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        handle = await SignalAsync.Interval(TickPeriod, time).SubscribeAsync(async (tick, _) =>
         {
             ticks.Add(tick);
-            if (tick < DisposeOnTick)
+            if (tick == DisposeOnTick)
             {
-                return;
+                await handle!.DisposeAsync();
+                disposed.SetResult();
             }
-
-            var handle = await handleReady.Task.ConfigureAwait(false);
-            await handle.DisposeAsync().ConfigureAwait(false);
-            IgnoredResult.Of(disposed.TrySetResult());
         });
-
-        handleReady.SetResult(subscription);
-        await disposed.Task.WaitAsync(WaitTimeout);
-
-        var ticksAtDispose = ticks.Count;
-        var keptTicking = await AsyncTestHelpers.WaitForConditionAsync(
-            () => ticks.Count > ticksAtDispose,
-            QuietWindow);
-
-        await Assert.That(keptTicking).IsFalse();
-        await Assert.That(ticks).Count().IsEqualTo(ticksAtDispose);
-        await Assert.That(ticks[0]).IsEqualTo(1L);
-        await Assert.That(ticks[^1]).IsEqualTo(DisposeOnTick);
+        await time.RunAsync(disposed.Task);
+        await Assert.That(ticks).IsCollectionEqualTo([1L, SecondTick]);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTimeProvider.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTimeProvider.cs
new file mode 100644
index 00000000..471587de
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTimeProvider.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using System.Threading.Channels;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Queues timer callbacks until the test explicitly advances them.</summary>
+internal sealed class ManualTimeProvider : TimeProvider
+{
+    /// <summary>Pending timer registrations in creation order.</summary>
+    private readonly Channel<ManualTimer> _timers = Channel.CreateUnbounded<ManualTimer>();
+
+    /// <summary>Gets the number of registrations not yet consumed by the test.</summary>
+    internal int PendingTimerCount => _timers.Reader.Count;
+
+    /// <inheritdoc/>
+    public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
+    {
+        ManualTimer timer = new(callback, state, dueTime);
+        _ = _timers.Writer.TryWrite(timer);
+        return timer;
+    }
+
+    /// <summary>Waits for the next timer registration without advancing it.</summary>
+    /// <returns>The registered timer.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal ValueTask<ManualTimer> NextTimerAsync() => _timers.Reader.ReadAsync();
+
+    /// <summary>Fires the next registered timer.</summary>
+    /// <returns>A task representing the callback invocation.</returns>
+    internal async Task FireNextAsync()
+    {
+        var timer = await NextTimerAsync();
+        timer.Fire();
+    }
+
+    /// <summary>Drives queued timers until the supplied operation completes.</summary>
+    /// <param name="operation">The operation whose timers should run.</param>
+    /// <returns>A task representing the operation.</returns>
+    internal async Task RunAsync(Task operation)
+    {
+        while (!operation.IsCompleted)
+        {
+            var ready = _timers.Reader.WaitToReadAsync().AsTask();
+            if (await Task.WhenAny(operation, ready) == operation)
+            {
+                break;
+            }
+
+            if (_timers.Reader.TryRead(out var timer))
+            {
+                timer.Fire();
+            }
+        }
+
+        await operation;
+    }
+
+    /// <summary>Drives queued timers until the supplied result is available.</summary>
+    /// <typeparam name="T">The result type.</typeparam>
+    /// <param name="operation">The operation whose timers should run.</param>
+    /// <returns>The completed result.</returns>
+    internal async Task<T> RunAsync<T>(Task<T> operation)
+    {
+        await RunAsync((Task)operation);
+        return await operation;
+    }
+
+    /// <summary>A timer whose callback is invoked explicitly by its owner.</summary>
+    /// <param name="callback">The timer callback.</param>
+    /// <param name="state">The callback state.</param>
+    /// <param name="dueTime">The initial due time.</param>
+    internal sealed class ManualTimer(TimerCallback callback, object? state, TimeSpan dueTime) : ITimer
+    {
+        /// <summary>Whether the timer has been disposed.</summary>
+        private bool _disposed;
+
+        /// <summary>Gets the most recently requested due time.</summary>
+        internal TimeSpan DueTime { get; private set; } = dueTime;
+
+        /// <inheritdoc/>
+        public bool Change(TimeSpan dueTime, TimeSpan period)
+        {
+            DueTime = dueTime;
+            return !_disposed;
+        }
+
+        /// <inheritdoc/>
+        public void Dispose() => _disposed = true;
+
+        /// <inheritdoc/>
+        public ValueTask DisposeAsync()
+        {
+            Dispose();
+            return default;
+        }
+
+        /// <summary>Fires an armed callback once; a changed timer can be fired again.</summary>
+        internal void Fire()
+        {
+            if (_disposed || DueTime == Timeout.InfiniteTimeSpan)
+            {
+                return;
+            }
+
+            DueTime = Timeout.InfiniteTimeSpan;
+            callback(state);
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
index 4f2d77d1..0eb0e4bf 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
@@ -16,9 +16,6 @@ public class ObserveOnAsyncSignalTests
     /// <summary>Single sentinel emitted by the happy-path tests.</summary>
     private const int Sentinel = 7;
 
-    /// <summary>Maximum time a test waits for a forwarded notification to arrive.</summary>
-    private static readonly TimeSpan ForwardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the <c>forceYielding: true</c> overload forwards values via the context-switching slow path.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -169,7 +166,7 @@ public async Task WhenForceYieldingSourceEmitsResumableError_ThenSlowPathForward
         InvalidOperationException expected = new("observeon-resume");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(ForwardTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -186,7 +183,7 @@ public async Task WhenForwardAfterContextSwitchAsyncInvokedDirectly_ThenValueFor
 
         await sut.ForwardAfterContextSwitchAsync(Sentinel, CancellationToken.None);
 
-        var received = await captured.Task.WaitAsync(ForwardTimeout);
+        var received = await captured.Task;
         await Assert.That(received).IsEqualTo(Sentinel);
     }
 
@@ -202,7 +199,7 @@ public async Task WhenForwardErrorAfterContextSwitchAsyncInvokedDirectly_ThenErr
 
         await sut.ForwardErrorAfterContextSwitchAsync(expected, CancellationToken.None);
 
-        var received = await captured.Task.WaitAsync(ForwardTimeout);
+        var received = await captured.Task;
         await Assert.That(received).IsSameReferenceAs(expected);
     }
 
@@ -217,7 +214,7 @@ public async Task WhenForwardCompletionAfterContextSwitchAsyncInvokedDirectly_Th
 
         await sut.ForwardCompletionAfterContextSwitchAsync(Result.Success);
 
-        var result = await captured.Task.WaitAsync(ForwardTimeout);
+        var result = await captured.Task;
         await Assert.That(result.IsSuccess).IsTrue();
     }
 
@@ -240,7 +237,7 @@ public async Task WhenContextSwitchSignalSubscribed_ThenValueForwarded()
 
         await signal.OnNextAsync(Sentinel, CancellationToken.None);
 
-        var value = await received.Task.WaitAsync(ForwardTimeout);
+        var value = await received.Task;
         await Assert.That(value).IsEqualTo(Sentinel);
     }
 
@@ -267,7 +264,7 @@ public async Task WhenContextSwitchSignalSourceEmitsResumableError_ThenErrorForw
         InvalidOperationException expected = new("context-switch-resume");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(ForwardTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
index ae1a4e6a..a8fa65bc 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserverAsyncDisposeTests.cs
@@ -2,6 +2,7 @@
 // ReactiveUI Association Incorporated 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;
 using ReactiveUI.Primitives.Async.Disposables;
 
 namespace ReactiveUI.Primitives.Async.Tests;
@@ -9,46 +10,45 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests for <see cref="WitnessAsync{T}"/> disposal behavior.</summary>
 public sealed class ObserverAsyncDisposeTests
 {
-    /// <summary>The value emitted by the hopping source.</summary>
+    /// <summary>The value emitted by the asynchronous source.</summary>
     private const int EmittedValue = 7;
 
     /// <summary>The value pushed after the external link has been cancelled; it must never be delivered.</summary>
     private const int PostCancellationValue = 8;
 
-    /// <summary>
-    /// How many times the dispose-versus-exiting-notification race is replayed. The interesting interleaving —
-    /// the in-flight call count reaching zero between the disposer reading it and re-reading it after publishing
-    /// its wait handle — is a nanosecond-wide window, so it is provoked repeatedly rather than once.
-    /// </summary>
-    private const int DisposeRaceAttempts = 256;
-
-    /// <summary>Verifies the reentrant dispose path lets an observer dispose itself from within its own in-flight
-    /// notification without deadlocking, even after the notification continuation has hopped to a different thread.</summary>
-    /// <returns>A task that completes when disposal finishes; a self-join deadlock leaves it pending.</returns>
+    /// <summary>Verifies that a resumed notification can dispose its own observer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenDisposedReentrantlyFromOwnNotificationAfterThreadHop_ThenDoesNotDeadlock()
+    public async Task WhenDisposedReentrantlyAfterNotificationResumes_ThenCompletes()
     {
-        SelfDisposingObserver observer = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        SelfDisposingObserver observer = new(release.Task);
 
-        await observer.OnNextAsync(1, CancellationToken.None);
+        var notification = observer.OnNextAsync(1, CancellationToken.None);
+        await Assert.That(notification.IsCompleted).IsFalse();
+        release.SetResult();
+        await notification;
 
         await Assert.That(observer.HasDisposed).IsTrue();
     }
 
-    /// <summary>Verifies the terminal-sink reentrant dispose path completes when the result resolves during a
-    /// notification whose continuation has hopped threads.</summary>
+    /// <summary>Verifies that FirstAsync resolves and disposes its source after a suspended subscription resumes.</summary>
     /// <returns>A task to monitor completion.</returns>
     [Test]
-    public async Task WhenFirstAsyncResolvesDuringHoppedNotification_ThenCompletes()
+    public async Task WhenFirstAsyncResolvesAfterSubscriptionResumes_ThenCompletes()
     {
-        var source = SignalAsync.Create<int>(static async (observer, _) =>
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = SignalAsync.Create<int>(async (observer, _) =>
         {
-            await Task.Yield();
+            await release.Task;
             await observer.OnNextAsync(EmittedValue, CancellationToken.None).ConfigureAwait(false);
             return DisposableAsync.Empty;
         });
 
-        var value = await source.FirstAsync();
+        var first = source.FirstAsync();
+        await Assert.That(first.IsCompleted).IsFalse();
+        release.SetResult();
+        var value = await first;
 
         await Assert.That(value).IsEqualTo(EmittedValue);
     }
@@ -75,25 +75,126 @@ public async Task WhenLinkedToItsOwnDisposeToken_ThenExternalLinkStillDisposesTh
         await Assert.That(observer.Received).IsCollectionEqualTo([EmittedValue]);
     }
 
-    /// <summary>Verifies that disposing an observer from one thread while a notification is still in flight on
-    /// another never hangs, including when that notification's call count drops to zero inside the disposer's
-    /// publish-then-recheck window — the case the disposer must self-signal to avoid waiting forever.</summary>
-    /// <returns>A task that completes when every attempt has disposed; a deadlocked wait leaves it pending.</returns>
+    /// <summary>Verifies that the last active notification signals an already published disposal waiter.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenCompletionWaiterPublishedBeforeNotificationExits_ThenExitSignalsWaiter()
+    {
+        RecordingObserver observer = new(CancellationToken.None);
+        var entered = observer.TryEnterOnSomethingCall(CancellationToken.None, out var scope);
+        await Assert.That(entered).IsTrue();
+        var waiter = observer.PublishCallCompletionWaiter();
+        await Assert.That(waiter.IsCompleted).IsFalse();
+        scope.Dispose();
+        await Assert.That(observer.ExitOnSomethingCall()).IsFalse();
+        await waiter;
+        await observer.DisposeAsync();
+        await Assert.That(observer.HasDisposed).IsTrue();
+    }
+
+    /// <summary>A notification that exits before waiter publication requires no further signal.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenDisposedFromAnotherThreadAsNotificationExits_ThenDoesNotDeadlock()
+    public async Task WhenNotificationExitsBeforeCompletionWaiterPublished_ThenWaiterIsCompleted()
     {
-        for (var attempt = 0; attempt < DisposeRaceAttempts; attempt++)
+        RecordingObserver observer = new(CancellationToken.None);
+        var entered = observer.TryEnterOnSomethingCall(CancellationToken.None, out var scope);
+        await Assert.That(entered).IsTrue();
+        scope.Dispose();
+        await Assert.That(observer.ExitOnSomethingCall()).IsTrue();
+        var waiter = observer.PublishCallCompletionWaiter();
+        await Assert.That(waiter.IsCompletedSuccessfully).IsTrue();
+        await waiter;
+        await observer.DisposeAsync();
+    }
+
+    /// <summary>Disposal waits for a notification owned by another thread before releasing its source subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenDisposedWithForeignNotificationOwner_ThenSourceWaitsForNotificationExit()
+    {
+        const int ForeignOwnerThread = -1;
+        RecordingObserver observer = new(CancellationToken.None);
+        StrongBox<bool> sourceDisposed = new();
+        await observer.AssignSourceSubscriptionAsync(DisposableAsync.Create(sourceDisposed, static state =>
         {
-            ParkedNotificationObserver observer = new();
-            var notification = Task.Run(async () =>
-                await observer.OnNextAsync(EmittedValue, CancellationToken.None));
+            state.Value = true;
+            return default;
+        }));
+        var entered = observer.TryEnterOnSomethingCall(ForeignOwnerThread, CancellationToken.None, out var scope);
+        await Assert.That(entered).IsTrue();
+
+        var disposal = observer.DisposeAsync();
+        await Assert.That(disposal.IsCompleted).IsFalse();
+        await Assert.That(sourceDisposed.Value).IsFalse();
+        scope.Dispose();
+        await Assert.That(observer.ExitOnSomethingCall()).IsFalse();
+        await disposal;
+
+        await Assert.That(sourceDisposed.Value).IsTrue();
+        await Assert.That(observer.HasDisposed).IsTrue();
+    }
 
-            await observer.Entered;
-            await observer.DisposeAsync();
-            await notification;
+    /// <summary>Verifies entry and exit retry against the current notification count after stale observations.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenCallStateChangesAfterObservation_ThenEntryAndExitRetry()
+    {
+        const int CallerThread = 1;
+        await using RecordingObserver observer = new(CancellationToken.None);
+        var empty = observer.ReadCallState();
+        var enteredFirst = observer.TryEnterOnSomethingCall(CallerThread, CancellationToken.None, out var firstScope);
+        var beforeSecondEntry = observer.ReadCallState();
+        var enteredSecond = observer.TryEnterObservedCallState(CallerThread, empty, CancellationToken.None, out var secondScope);
+        var waiter = observer.PublishCallCompletionWaiter();
+        firstScope.Dispose();
+        secondScope.Dispose();
+        await Assert.That(enteredFirst).IsTrue();
+        await Assert.That(enteredSecond).IsTrue();
+        await Assert.That(observer.ExitObservedCallState(beforeSecondEntry)).IsTrue();
+        await Assert.That(waiter.IsCompleted).IsFalse();
+        await Assert.That(observer.ExitOnSomethingCall()).IsFalse();
+        await waiter;
+    }
 
-            await Assert.That(observer.HasDisposed).IsTrue();
+    /// <summary>Verifies that competing source publications retain one source and preserve prior disposal.</summary>
+    /// <param name="disposeFirst">Whether disposal precedes source publication.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenDisposeSourcePublishedTwice_ThenFirstSourceIsRetained(bool disposeFirst)
+    {
+        RecordingObserver observer = new(CancellationToken.None);
+        if (disposeFirst)
+        {
+            await observer.DisposeAsync();
         }
+
+        var first = observer.MaterializeDisposeCts();
+        var second = observer.MaterializeDisposeCts();
+        await Assert.That(second).IsSameReferenceAs(first);
+        await Assert.That(first.IsCancellationRequested).IsEqualTo(disposeFirst);
+        await observer.DisposeAsync();
+    }
+
+    /// <summary>Verifies that the last call either signals the disposal waiter or performs disposal itself.</summary>
+    /// <param name="publishWaiter">Whether another caller is waiting for disposal.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenLastCallCompletes_ThenDisposalFollowsWaiterOwnership(bool publishWaiter)
+    {
+        RecordingObserver observer = new(CancellationToken.None);
+        var entered = observer.TryEnterOnSomethingCall(CancellationToken.None, out var scope);
+        await Assert.That(entered).IsTrue();
+        var waiter = publishWaiter ? observer.PublishCallCompletionWaiter() : Task.CompletedTask;
+        scope.Dispose();
+        await observer.CompleteOrChainDispose();
+        await waiter;
+        await Assert.That(observer.HasDisposed).IsEqualTo(!publishWaiter);
+        await observer.DisposeAsync();
     }
 
     /// <summary>Observer that records every value it is handed, constructed with an external dispose link.</summary>
@@ -118,49 +219,14 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
         protected override ValueTask OnCompletedAsyncCore(Result result) => default;
     }
 
-    /// <summary>Observer whose notification stays in flight until disposal releases it, so the call exits while the
-    /// disposer is inside its publish-then-recheck window rather than long before or long after it.</summary>
-    private sealed class ParkedNotificationObserver : WitnessAsync<int>
-    {
-        /// <summary>Completes once the notification has been entered and the in-flight call count is non-zero.</summary>
-        private readonly TaskCompletionSource _entered = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <summary>Completes when disposal releases the parked notification.</summary>
-        private readonly TaskCompletionSource _released = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <summary>Gets a task that completes once the notification is in flight.</summary>
-        internal Task Entered => _entered.Task;
-
-        /// <inheritdoc/>
-        protected override async ValueTask OnNextAsyncCore(int value, CancellationToken cancellationToken)
-        {
-            IgnoredResult.Of(_entered.TrySetResult());
-            await _released.Task.ConfigureAwait(false);
-        }
-
-        /// <inheritdoc/>
-        protected override ValueTask OnErrorResumeAsyncCore(Exception error, CancellationToken cancellationToken) =>
-            default;
-
-        /// <inheritdoc/>
-        protected override ValueTask OnCompletedAsyncCore(Result result) => default;
-
-        /// <inheritdoc/>
-        protected override ValueTask DisposeAsyncCore()
-        {
-            // Release before the base waits on in-flight calls: the notification exits as the gate is published.
-            IgnoredResult.Of(_released.TrySetResult());
-            return base.DisposeAsyncCore();
-        }
-    }
-
-    /// <summary>Observer whose OnNext hops threads then disposes itself via the reentrant path.</summary>
-    private sealed class SelfDisposingObserver : WitnessAsync<int>
+    /// <summary>Observer that disposes itself when a suspended notification resumes.</summary>
+    /// <param name="release">The notification gate.</param>
+    private sealed class SelfDisposingObserver(Task release) : WitnessAsync<int>
     {
         /// <inheritdoc/>
         protected override async ValueTask OnNextAsyncCore(int value, CancellationToken cancellationToken)
         {
-            await Task.Yield();
+            await release;
             await ((IReentrantAsyncDisposable)this).DisposeFromNotificationAsync().ConfigureAwait(false);
         }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersFilterFusionsTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersFilterFusionsTests.cs
index 17611cd3..279ce69a 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersFilterFusionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersFilterFusionsTests.cs
@@ -6,15 +6,9 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Coverage for the error-forwarding and edge cases of the fused
-/// async filter operators in <c>ParityHelpers.FilterFusions</c> —
-/// <c>SkipWhileNull</c>, <c>WhereIsNotNull</c>, <c>LatestOrDefault</c>,
-/// <c>WaitUntil</c>, <c>AsSignal</c>, <c>Not</c>, <c>WhereTrue</c>, <c>WhereFalse</c>.</summary>
+/// <summary>Tests filtering and error forwarding in fused async operators.</summary>
 public class ParityHelpersFilterFusionsTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Sentinel "found" sentinel string.</summary>
     private const string Hit = "hit";
 
@@ -33,9 +27,6 @@ public class ParityHelpersFilterFusionsTests
     /// <summary>Three-element ascending source sequence.</summary>
     private static readonly int[] Sequence123 = [1, 2, 3];
 
-    /// <summary>Maximum time a test waits for a forwarded notification to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Verifies that <c>SkipWhileNull</c> drops leading nulls then forwards every value.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -47,11 +38,7 @@ public async Task WhenSkipWhileNull_ThenDropsLeadingNullsThenLatches()
             .SkipWhileNull()
             .ToListAsync();
 
-        // After the first non-null, the gate opens and every subsequent value (including null!) flows.
-        // The implementation forwards `value!` past the gate; we assert the non-null prefix is correct
-        // and we receive at least the values after the gate opened.
-        await Assert.That(result.Count).IsGreaterThanOrEqualTo(1);
-        await Assert.That(result[0]).IsEqualTo("a");
+        await Assert.That(result).IsCollectionEqualTo(["a", null!, "b"]);
     }
 
     /// <summary>Verifies that <c>WhereIsNotNull</c> strips nulls and forwards non-nulls.</summary>
@@ -196,9 +183,7 @@ public async Task WhenWhereIsNotNullSourceErrorResume_ThenForwarded()
 
         await signal.OnErrorResumeAsync(new InvalidOperationException(Hit), CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => received is not null,
-            WaitTimeout);
+        await Assert.That(received is not null).IsTrue();
 
         await Assert.That(received).IsNotNull();
         await Assert.That(received!.Message).IsEqualTo(Hit);
@@ -225,7 +210,7 @@ public async Task WhenPairwiseSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("pairwise-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -250,7 +235,7 @@ public async Task WhenSkipWhileNullSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("skip-while-null-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -275,7 +260,7 @@ public async Task WhenLatestOrDefaultSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("latest-or-default-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -300,7 +285,7 @@ public async Task WhenWaitUntilSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("wait-until-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -325,7 +310,7 @@ public async Task WhenAsSignalSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("as-signal-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -350,7 +335,7 @@ public async Task WhenAsyncNotSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("not-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -375,7 +360,7 @@ public async Task WhenWhereTrueSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("where-true-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -400,7 +385,7 @@ public async Task WhenWhereFalseSourceErrorResume_ThenForwarded()
         InvalidOperationException expected = new("where-false-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
 
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
index 3cac112f..7876f024 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityHelpersOperatorFusionsTests.cs
@@ -8,16 +8,9 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Edge-case coverage for the fused async operators in
-/// <c>ParityHelpers.OperatorFusions</c> — async <c>ScanWithInitial</c>,
-/// <c>ThrottleDistinct</c> upstream/downstream filtering, <c>DebounceUntil</c>
-/// immediate-bypass branch, and the typed fast paths in <c>ForEach</c>
-/// (array / IReadOnlyList / general IEnumerable).</summary>
+/// <summary>Tests filtering, accumulation and flattening in fused async operators.</summary>
 public class ParityHelpersOperatorFusionsTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Message thrown by a downstream observer in the scan fusion tests.</summary>
     private const string DownstreamThrowsMessage = "downstream-throws";
 
@@ -48,15 +41,12 @@ public class ParityHelpersOperatorFusionsTests
     /// <summary>Sentinel four.</summary>
     private const int Four = 4;
 
-    /// <summary>Debounce window long enough that only the condition can release a value.</summary>
+    /// <summary>Debounce window used by manually fired bypass tests.</summary>
     private static readonly TimeSpan DebounceWindow = TimeSpan.FromHours(1);
 
-    /// <summary>Debounce window short enough that the test can wait for it to elapse.</summary>
+    /// <summary>Debounce window used by manually fired delay tests.</summary>
     private static readonly TimeSpan ShortDebounceWindow = TimeSpan.FromMilliseconds(80);
 
-    /// <summary>Maximum time a test waits for a notification to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Array sentinels for the array fast-path test.</summary>
     private static readonly int[] ArraySlice1 = [One, Two];
 
@@ -110,63 +100,37 @@ public async Task WhenScanWithInitialAsync_ThenSeedThenAsyncFolded()
     [Test]
     public async Task WhenThrottleDistinctConsecutiveDuplicates_ThenSuppressesUpstream()
     {
+        ManualTimeProvider time = new();
         var result = await ThrottleDuplicateInputs.ToAsyncSignal()
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds))
+            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), time)
             .ToListAsync();
 
-        // All inputs are equal — only one emission is ever scheduled, and the source completes
-        // before the throttle window elapses, so the pending emission must still flush exactly once.
-        await Assert.That(result.Count).IsLessThanOrEqualTo(1);
+        await Assert.That(result).IsEmpty();
+        await Assert.That(time.PendingTimerCount).IsEqualTo(1);
     }
 
-    /// <summary>Verifies that <c>ThrottleDistinct</c> with distinct rapid values respects the
-    /// no-consecutive-duplicates contract and never emits more than the input count.
-    /// (Pending throttled emissions are superseded by source completion — this is the
-    /// documented behavior, so a count-bound assertion is the appropriate check rather than
-    /// "at least one emission".)</summary>
+    /// <summary>Verifies that completion suppresses pending distinct values.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenThrottleDistinctRapidDistinctValues_ThenNoConsecutiveDuplicates()
     {
         var result = await ThrottleRapidInputs.ToAsyncSignal()
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds))
-            .ToListAsync();
-
-        await Assert.That(result.Count).IsLessThanOrEqualTo(ThrottleRapidInputs.Length);
-        for (var i = 1; i < result.Count; i++)
-        {
-            await Assert.That(result[i]).IsNotEqualTo(result[i - 1]);
-        }
-    }
-
-    /// <summary>Verifies that the time-provider overload of <c>ThrottleDistinct</c> keeps the
-    /// upstream duplicate suppression when an explicit provider is supplied.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenThrottleDistinctWithTimeProviderAndConsecutiveDuplicates_ThenSuppressesUpstream()
-    {
-        var result = await ThrottleDuplicateInputs.ToAsyncSignal()
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), TimeProvider.System)
+            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), new ManualTimeProvider())
             .ToListAsync();
 
-        await Assert.That(result.Count).IsLessThanOrEqualTo(1);
+        await Assert.That(result).IsEmpty();
     }
 
-    /// <summary>Verifies that the time-provider overload of <c>ThrottleDistinct</c> falls back to the
-    /// system provider when the caller passes <see langword="null"/>, and still throttles.</summary>
+    /// <summary>Verifies that a null provider supports a zero throttle window.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenThrottleDistinctWithNullTimeProvider_ThenStillThrottles()
     {
         var result = await ThrottleRapidInputs.ToAsyncSignal()
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), null)
+            .ThrottleDistinct(TimeSpan.Zero, null)
             .ToListAsync();
 
-        await Assert.That(result.Count).IsLessThanOrEqualTo(ThrottleRapidInputs.Length);
-        for (var i = 1; i < result.Count; i++)
-        {
-            await Assert.That(result[i]).IsNotEqualTo(result[i - 1]);
-        }
+        await Assert.That(result).IsCollectionEqualTo(ThrottleRapidInputs);
     }
 
     /// <summary>Verifies that <c>DebounceUntil</c> with an always-true condition bypasses the debounce window and emits inline.</summary>
@@ -188,7 +152,7 @@ public async Task WhenDebounceUntilConditionAlwaysTrue_ThenEmitsImmediately()
     public async Task WhenDebounceUntilWithTimeProviderAndConditionAlwaysTrue_ThenEmitsImmediately()
     {
         var result = await DebounceInputs.ToAsyncSignal()
-            .DebounceUntil(DebounceWindow, static _ => true, TimeProvider.System)
+            .DebounceUntil(DebounceWindow, static _ => true, new ManualTimeProvider())
             .ToListAsync();
 
         await Assert.That(result).IsCollectionEqualTo(DebounceInputs);
@@ -390,7 +354,7 @@ public async Task WhenThrottleDistinctSourceErrorResumes_ThenForwardsDownstream(
         TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         await using var sub = await signal.Values
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds))
+            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), new ManualTimeProvider())
             .SubscribeAsync(
                 static (_, _) => default,
                 (ex, _) =>
@@ -417,7 +381,7 @@ public async Task WhenDebounceUntilSourceErrorResumes_ThenForwardsDownstream()
         TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         await using var sub = await signal.Values
-            .DebounceUntil(DebounceWindow, static _ => false)
+            .DebounceUntil(DebounceWindow, static _ => false, new ManualTimeProvider())
             .SubscribeAsync(
                 static (_, _) => default,
                 (ex, _) =>
@@ -488,43 +452,32 @@ public async Task WhenDropIfBusySourceErrorResumes_ThenForwardsDownstream()
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
-    /// <summary>Verifies that <c>DropIfBusy</c> with a sync action but an asynchronously-completing
-    /// downstream takes the <c>AwaitForwardAsync</c> slow path and resets the busy flag in
-    /// its <c>finally</c>.</summary>
+    /// <summary>Verifies that a pending downstream notification drops overlapping values and releases the busy flag on completion.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenDropIfBusySyncActionAsyncDownstream_ThenAwaitForwardSlowPathResets()
     {
-        var signal = Signal.Create<int>();
         List<int> values = [];
-        TaskCompletionSource<int> emittedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await signal.Values
-            .DropIfBusy(static (_, _) => default)
-            .SubscribeAsync(async (v, _) =>
-            {
-                await Task.Yield();
-                values.Add(v);
-                IgnoredResult.Of(emittedTcs.TrySetResult(v));
-            });
-
-        await signal.OnNextAsync(One, CancellationToken.None);
-        await emittedTcs.Task;
-
-        // After the slow path resets _isBusy, a second emission must also flow through.
-        TaskCompletionSource secondTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub2 = await signal.Values
-            .DropIfBusy(static (_, _) => default)
-            .SubscribeAsync(async (_, _) =>
-            {
-                await Task.Yield();
-                _ = secondTcs.TrySetResult();
-            });
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        CallbackWitnessAsync<int> downstream = new(async (value, _) =>
+        {
+            await release.Task;
+            values.Add(value);
+        });
+        await using SignalAsyncExtensions.DropIfBusySignal<int>.DropIfBusyWitness witness = new(
+            downstream,
+            static (_, _) => default,
+            CancellationToken.None);
 
-        await signal.OnNextAsync(Two, CancellationToken.None);
-        await secondTcs.Task;
+        var forwarding = witness.OnNextAsync(One, CancellationToken.None);
+        await Assert.That(forwarding.IsCompleted).IsFalse();
+        await witness.OnNextAsync(Two, CancellationToken.None);
+        await Assert.That(values).IsEmpty();
+        release.SetResult();
+        await forwarding;
+        await witness.OnNextAsync(Three, CancellationToken.None);
 
-        await Assert.That(values).Contains(One);
+        await Assert.That(values).IsCollectionEqualTo([One, Three]);
     }
 
     /// <summary>Verifies that the async-accumulator <c>ScanWithInitial</c> overload forwards upstream non-terminal errors downstream.</summary>
@@ -595,6 +548,33 @@ public async Task WhenFusedOperatorSubscribedWithAlreadyCancelledToken_ThenSinkC
         }
     }
 
+    /// <summary>Verifies that stale distinct delays finish without forwarding their superseded values.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctDelayIsSuperseded_ThenOnlyCurrentDelayEmits()
+    {
+        ManualTimeProvider time = new();
+        List<int> values = [];
+        CallbackWitnessAsync<int> downstream = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await using SignalAsyncExtensions.ThrottleDistinctSignal<int>.ThrottleDistinctWitness observer = new(
+            downstream,
+            ShortDebounceWindow,
+            time,
+            CancellationToken.None);
+        var first = observer.StartDelayAsync(One, CancellationToken.None);
+        var second = observer.StartDelayAsync(Two, CancellationToken.None);
+        await time.FireNextAsync();
+        await first;
+        await Assert.That(values).IsEmpty();
+        await time.FireNextAsync();
+        await second;
+        await Assert.That(values).IsCollectionEqualTo([Two]);
+    }
+
     /// <summary>Verifies that an unhandled exception thrown by the downstream observer inside
     /// <c>ThrottleDistinct</c>'s delayed-emit task is routed to
     /// <see cref="UnhandledExceptionHandler"/>.</summary>
@@ -603,16 +583,18 @@ public async Task WhenFusedOperatorSubscribedWithAlreadyCancelledToken_ThenSinkC
     public async Task WhenThrottleDistinctDownstreamThrowsInDelay_ThenRoutedToUnhandled()
     {
         using UnhandledExceptionCapture unhandled = new();
+        ManualTimeProvider time = new();
 
         var signal = Signal.Create<int>();
         ThrowingAsyncWitness<int> throwingObserver = new(new InvalidOperationException(DownstreamThrowsMessage));
 
         await using var sub = await signal.Values
-            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds))
+            .ThrottleDistinct(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), time)
             .SubscribeAsync(throwingObserver, CancellationToken.None);
 
         await signal.OnNextAsync(One, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(DownstreamThrowsMessage, WaitTimeout);
+        await time.FireNextAsync();
+        var exception = await unhandled.WaitForAsync(DownstreamThrowsMessage);
 
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!.Message).IsEqualTo(DownstreamThrowsMessage);
@@ -626,46 +608,48 @@ public async Task WhenThrottleDistinctDownstreamThrowsInDelay_ThenRoutedToUnhand
     public async Task WhenThrottleDownstreamThrowsInDelay_ThenRoutedToUnhandled()
     {
         using UnhandledExceptionCapture unhandled = new();
+        ManualTimeProvider time = new();
 
         var signal = Signal.Create<int>();
         ThrowingAsyncWitness<int> throwingObserver = new(new InvalidOperationException(ThrottleDownstreamThrowsMessage));
 
         await using var sub = await signal.Values
-            .Throttle(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds))
+            .Throttle(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), time)
             .SubscribeAsync(throwingObserver, CancellationToken.None);
 
         await signal.OnNextAsync(One, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(ThrottleDownstreamThrowsMessage, WaitTimeout);
+        await time.FireNextAsync();
+        var exception = await unhandled.WaitForAsync(ThrottleDownstreamThrowsMessage);
 
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!.Message).IsEqualTo(ThrottleDownstreamThrowsMessage);
     }
 
-    /// <summary>Exercises the <c>!IsCurrentEmission(id)</c> guard inside <c>DebounceUntil</c>'s
-    /// <c>DelayAndEmitAsync</c> — when a later emission supersedes the current pending one
-    /// before its debounce window elapses, the older delayed-emit task wakes, sees its id is
-    /// stale, and returns early without forwarding.</summary>
+    /// <summary>Verifies that a newer pending value suppresses an older delay.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenDebounceUntilSecondEmissionSupersedesFirst_ThenStaleDelayDropsValue()
     {
-        var signal = Signal.Create<int>();
+        ManualTimeProvider time = new();
         List<int> values = [];
-        TaskCompletionSource emitted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await signal.Values
-            .DebounceUntil(ShortDebounceWindow, static _ => false)
-            .SubscribeAsync((v, _) =>
+        SignalAsyncExtensions.DebounceUntilSignal<int>.DebounceUntilWitness observer = new(
+            new CallbackWitnessAsync<int>((v, _) =>
             {
                 values.Add(v);
-                IgnoredResult.Of(emitted.TrySetResult());
                 return default;
-            });
-
-        await signal.OnNextAsync(One, CancellationToken.None);
-        await signal.OnNextAsync(Two, CancellationToken.None);
-
-        await emitted.Task;
+            }),
+            ShortDebounceWindow,
+            static _ => false,
+            time,
+            CancellationToken.None);
+        await using var subscription = observer;
+        var first = observer.StartDelayAsync(One, CancellationToken.None);
+        var second = observer.StartDelayAsync(Two, CancellationToken.None);
+        await time.FireNextAsync();
+        await first;
+        await Assert.That(values).IsEmpty();
+        await time.FireNextAsync();
+        await second;
 
         await Assert.That(values).IsCollectionEqualTo([Two]);
     }
@@ -677,16 +661,18 @@ public async Task WhenDebounceUntilSecondEmissionSupersedesFirst_ThenStaleDelayD
     public async Task WhenDebounceUntilDownstreamThrowsInDelay_ThenRoutedToUnhandled()
     {
         using UnhandledExceptionCapture unhandled = new();
+        ManualTimeProvider time = new();
 
         var signal = Signal.Create<int>();
         ThrowingAsyncWitness<int> throwingObserver = new(new InvalidOperationException(DebounceDownstreamThrowsMessage));
 
         await using var sub = await signal.Values
-            .DebounceUntil(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), static _ => false)
+            .DebounceUntil(TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds), static _ => false, time)
             .SubscribeAsync(throwingObserver, CancellationToken.None);
 
         await signal.OnNextAsync(One, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(DebounceDownstreamThrowsMessage, WaitTimeout);
+        await time.FireNextAsync();
+        var exception = await unhandled.WaitForAsync(DebounceDownstreamThrowsMessage);
 
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!.Message).IsEqualTo(DebounceDownstreamThrowsMessage);
@@ -726,7 +712,7 @@ public async Task WhenThrottleDistinctTryClaimEmissionSuperseded_ThenReturnsFals
         SignalAsyncExtensions.ThrottleDistinctSignal<int>.ThrottleDistinctWitness observer = new(
             new NoOpAsyncWitness<int>(),
             TimeSpan.FromHours(1),
-            TimeProvider.System,
+            new ManualTimeProvider(),
             CancellationToken.None);
 
         // Drive _id forward by two emissions; the first pending delay's id (1) is then stale.
@@ -746,7 +732,7 @@ public async Task WhenThrottleDistinctTryClaimEmissionDuplicate_ThenReturnsFalse
         SignalAsyncExtensions.ThrottleDistinctSignal<int>.ThrottleDistinctWitness observer = new(
             new NoOpAsyncWitness<int>(),
             TimeSpan.FromHours(1),
-            TimeProvider.System,
+            new ManualTimeProvider(),
             CancellationToken.None);
 
         await observer.OnNextAsync(One, CancellationToken.None);
@@ -757,8 +743,7 @@ public async Task WhenThrottleDistinctTryClaimEmissionDuplicate_ThenReturnsFalse
         // Drive another upstream so id matches the second claim.
         await observer.OnNextAsync(Two, CancellationToken.None);
 
-        // Re-claim with the previously-emitted value at the new id — rejected by the
-        // downstream-distinct check.
+        // Equal values remain suppressed across generation changes.
         var secondClaim = observer.TryClaimEmission(One, SecondEmissionId);
 
         await Assert.That(firstClaim).IsTrue();
@@ -774,7 +759,7 @@ public async Task WhenDebounceUntilIsCurrentEmission_ThenMatchesIdState()
             new NoOpAsyncWitness<int>(),
             TimeSpan.FromHours(1),
             static _ => false,
-            TimeProvider.System,
+            new ManualTimeProvider(),
             CancellationToken.None);
 
         await observer.OnNextAsync(One, CancellationToken.None);
@@ -819,6 +804,29 @@ public async Task WhenPartitionTryAttachSourceSubscriptionAndBranchAlive_ThenRet
         await Assert.That(attached).IsTrue();
     }
 
+    /// <summary>Verifies that an upstream subscription arriving after both branches leave is disposed.</summary>
+    /// <param name="branchAlive">Whether one branch remains subscribed.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenPartitionSubscriptionArrives_ThenOwnershipFollowsBranchState(bool branchAlive)
+    {
+        await using var signal = Signal.Create<int>();
+        SignalAsyncExtensions.PartitionCoordinator<int> coordinator = new(signal.Values, static _ => true);
+        await using var branch = branchAlive
+            ? await coordinator.TrueBranch.SubscribeAsync(static (_, _) => default)
+            : DisposableAsync.Empty;
+        StrongBox<bool> disposed = new();
+        var incoming = DisposableAsync.Create(disposed, static state =>
+        {
+            state.Value = true;
+            return default;
+        });
+        await coordinator.AttachOrDisposeStaleSubscriptionAsync(incoming);
+        await Assert.That(disposed.Value).IsEqualTo(!branchAlive);
+    }
+
     /// <summary>Yields values as a generic <see cref="IEnumerable{T}"/> (neither array nor list) to drive the slow-path branch of <c>ForEach</c>.</summary>
     /// <param name="values">Values to yield.</param>
     /// <returns>A lazily-evaluated enumerable.</returns>
@@ -830,11 +838,7 @@ private static IEnumerable<int> Enumerate(params int[] values)
         }
     }
 
-    /// <summary>Bare-bones downstream async observer that throws a given exception inside
-    /// <c>OnNextAsync</c>. Bypassing the <see cref="WitnessAsync{T}"/> base class is intentional
-    /// — the base class would otherwise swallow synchronous throws and route them through
-    /// <see cref="UnhandledExceptionHandler"/>, never letting the exception propagate up to the
-    /// upstream operator's <c>catch (Exception e)</c> block under test.</summary>
+    /// <summary>Throws directly from OnNextAsync without handling the exception.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="error">The exception to throw on every emission.</param>
     private sealed class ThrowingAsyncWitness<T>(Exception error) : IObserverAsync<T>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.ObserveOn.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.ObserveOn.cs
new file mode 100644
index 00000000..2c6f3cf7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.ObserveOn.cs
@@ -0,0 +1,115 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using AsyncObs = ReactiveUI.Primitives.Async.SignalAsync;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests optional context and scheduler selection.</summary>
+public partial class ParityOperatorTests
+{
+    /// <summary>Tests that ObserveOnSafe with a null AsyncContext returns the source unchanged.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnSafeAsyncContext_WithNull_ThenReturnsSourceUnchanged()
+    {
+        var source = AsyncObs.Return(1);
+
+        var observed = source.ObserveOnSafe((AsyncContext?)null);
+
+        var result = await observed.FirstAsync();
+        await Assert.That(result).IsEqualTo(1);
+    }
+
+    /// <summary>Tests that ObserveOnSafe with a non-null AsyncContext applies ObserveOn.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnSafeAsyncContext_WithValue_ThenAppliesObserveOn()
+    {
+        var context = AsyncContext.Default;
+
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnSafe(context)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+
+    /// <summary>Tests that ObserveOnSafe with a null TaskScheduler returns the source unchanged.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnSafeTaskScheduler_WithNull_ThenReturnsSourceUnchanged()
+    {
+        var source = AsyncObs.Return(1);
+
+        var observed = source.ObserveOnSafe((TaskScheduler?)null);
+
+        var result = await observed.FirstAsync();
+        await Assert.That(result).IsEqualTo(1);
+    }
+
+    /// <summary>Tests that ObserveOnSafe with a non-null TaskScheduler applies ObserveOn.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnSafeTaskScheduler_WithValue_ThenAppliesObserveOn()
+    {
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnSafe(TaskScheduler.Default)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+
+    /// <summary>Tests that ObserveOnIf with true condition applies ObserveOn with AsyncContext.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfAsyncContext_WithTrueCondition_ThenAppliesObserveOn()
+    {
+        var context = AsyncContext.Default;
+
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnIf(true, context)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+
+    /// <summary>Tests that ObserveOnIf with false condition returns the source unchanged for AsyncContext.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfAsyncContext_WithFalseCondition_ThenReturnsSourceUnchanged()
+    {
+        var context = AsyncContext.Default;
+
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnIf(false, context)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+
+    /// <summary>Tests that ObserveOnIf with true condition applies ObserveOn with TaskScheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfTaskScheduler_WithTrueCondition_ThenAppliesObserveOn()
+    {
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnIf(true, TaskScheduler.Default)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+
+    /// <summary>Tests that ObserveOnIf with false condition returns the source unchanged for TaskScheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfTaskScheduler_WithFalseCondition_ThenReturnsSourceUnchanged()
+    {
+        var result = await AsyncObs.Return(CanonicalAnswer)
+            .ObserveOnIf(false, TaskScheduler.Default)
+            .FirstAsync();
+
+        await Assert.That(result).IsEqualTo(CanonicalAnswer);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.cs
index 54e4ff6f..b86b0d98 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ParityOperatorTests.cs
@@ -8,11 +8,8 @@
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>Tests for async parity helpers that mirror the synchronous helper surface in the repository.</summary>
-public class ParityOperatorTests
+public partial class ParityOperatorTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Sentinel value (42) used by tests.</summary>
     private const int CanonicalAnswer = 42;
 
@@ -43,9 +40,6 @@ public class ParityOperatorTests
     /// <summary>Window used by the throttle and debounce timing tests.</summary>
     private static readonly TimeSpan ThrottleWindow = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>Maximum time a test waits for an emission to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Tests that WhereIsNotNull filters null values and narrows the result type.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -397,8 +391,6 @@ public async Task WhenDropIfBusy_WithBusyAction_ThenDropsValues()
         var emitTask = signal.OnNextAsync(1, CancellationToken.None).AsTask();
 
         // Emit values 2 and 3 while the action for value 1 is still running - these should be dropped
-        // We need a small yield to ensure value 1's handler has started
-        await Task.Yield();
         await signal.OnNextAsync(DroppedValueA, CancellationToken.None);
         await signal.OnNextAsync(DroppedValueB, CancellationToken.None);
 
@@ -520,110 +512,6 @@ public async Task WhenWaitUntil_ThenEmitsFirstMatchingValue()
         await Assert.That(result).IsCollectionEqualTo([FirstMatch]);
     }
 
-    /// <summary>Tests that ObserveOnSafe with a null AsyncContext returns the source unchanged.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnSafeAsyncContext_WithNull_ThenReturnsSourceUnchanged()
-    {
-        var source = AsyncObs.Return(1);
-
-        var observed = source.ObserveOnSafe((AsyncContext?)null);
-
-        var result = await observed.FirstAsync();
-        await Assert.That(result).IsEqualTo(1);
-    }
-
-    /// <summary>Tests that ObserveOnSafe with a non-null AsyncContext applies ObserveOn.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnSafeAsyncContext_WithValue_ThenAppliesObserveOn()
-    {
-        var context = AsyncContext.Default;
-
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnSafe(context)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
-    /// <summary>Tests that ObserveOnSafe with a null TaskScheduler returns the source unchanged.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnSafeTaskScheduler_WithNull_ThenReturnsSourceUnchanged()
-    {
-        var source = AsyncObs.Return(1);
-
-        var observed = source.ObserveOnSafe((TaskScheduler?)null);
-
-        var result = await observed.FirstAsync();
-        await Assert.That(result).IsEqualTo(1);
-    }
-
-    /// <summary>Tests that ObserveOnSafe with a non-null TaskScheduler applies ObserveOn.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnSafeTaskScheduler_WithValue_ThenAppliesObserveOn()
-    {
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnSafe(TaskScheduler.Default)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
-    /// <summary>Tests that ObserveOnIf with true condition applies ObserveOn with AsyncContext.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnIfAsyncContext_WithTrueCondition_ThenAppliesObserveOn()
-    {
-        var context = AsyncContext.Default;
-
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnIf(true, context)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
-    /// <summary>Tests that ObserveOnIf with false condition returns the source unchanged for AsyncContext.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnIfAsyncContext_WithFalseCondition_ThenReturnsSourceUnchanged()
-    {
-        var context = AsyncContext.Default;
-
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnIf(false, context)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
-    /// <summary>Tests that ObserveOnIf with true condition applies ObserveOn with TaskScheduler.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnIfTaskScheduler_WithTrueCondition_ThenAppliesObserveOn()
-    {
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnIf(true, TaskScheduler.Default)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
-    /// <summary>Tests that ObserveOnIf with false condition returns the source unchanged for TaskScheduler.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnIfTaskScheduler_WithFalseCondition_ThenReturnsSourceUnchanged()
-    {
-        var result = await AsyncObs.Return(CanonicalAnswer)
-            .ObserveOnIf(false, TaskScheduler.Default)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(CanonicalAnswer);
-    }
-
     /// <summary>Tests that ReplayLastOnSubscribe replays the initial value and subsequent source values.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -641,12 +529,13 @@ public async Task WhenReplayLastOnSubscribe_ThenReplaysInitialAndSourceValues()
     [Test]
     public async Task WhenThrottleDistinct_ThenEmitsDistinctThrottledValues()
     {
+        ManualTimeProvider time = new();
         var signal = Signal.Create<int>();
         List<int> results = [];
         TaskCompletionSource firstReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         await using var sub = await signal.Values
-            .ThrottleDistinct(ThrottleWindow)
+            .ThrottleDistinct(ThrottleWindow, time)
             .SubscribeAsync(
                 (value, _) =>
                 {
@@ -656,19 +545,15 @@ public async Task WhenThrottleDistinct_ThenEmitsDistinctThrottledValues()
                 },
                 null);
 
-        // Emit duplicate values quickly - DistinctUntilChanged collapses them
         await signal.OnNextAsync(1, CancellationToken.None);
         await signal.OnNextAsync(1, CancellationToken.None);
-
-        // Wait for throttle to emit the first distinct value
-        var received = await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            WaitTimeout);
+        await Assert.That(results).IsEmpty();
+        await time.FireNextAsync();
+        await firstReceived.Task;
 
         await signal.OnCompletedAsync(Result.Success);
 
-        await Assert.That(received).IsTrue();
-        await Assert.That(results[0]).IsEqualTo(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
     }
 
     /// <summary>Tests that the async ScanWithInitial overload emits the seed followed by accumulated values.</summary>
@@ -721,31 +606,29 @@ public async Task WhenDebounceUntil_WithConditionTrue_ThenEmitsImmediately()
     public async Task WhenDebounceUntil_WithConditionFalse_ThenDelaysEmission()
     {
         const int UnreachableThreshold = 100;
-
+        ManualTimeProvider time = new();
+        TaskCompletionSource received = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var signal = Signal.Create<int>();
         List<int> results = [];
 
         await using var sub = await signal.Values
-            .DebounceUntil(ThrottleWindow, static v => v > UnreachableThreshold)
+            .DebounceUntil(ThrottleWindow, static v => v > UnreachableThreshold, time)
             .SubscribeAsync(
                 (value, _) =>
                 {
                     results.Add(value);
+                    IgnoredResult.Of(received.TrySetResult());
                     return default;
                 },
                 null);
 
-        // Value 1 does not satisfy condition, should be delayed by 50ms
         await signal.OnNextAsync(1, CancellationToken.None);
-
-        // Wait for the delayed value to arrive
-        var received = await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count >= 1,
-            WaitTimeout);
+        await Assert.That(results).IsEmpty();
+        await time.FireNextAsync();
+        await received.Task;
 
         await signal.OnCompletedAsync(Result.Success);
 
-        await Assert.That(received).IsTrue();
         await Assert.That(results[0]).IsEqualTo(1);
     }
 
@@ -1082,9 +965,7 @@ public async Task WhenDropIfBusy_WithConcurrentEmission_ThenDroppedValueIsDiscar
         var emit1Task = source.EmitNext(1).AsTask();
 
         // Wait until the action for value 1 has actually started.
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => Volatile.Read(ref actionStarted) >= 1,
-            WaitTimeout);
+        await Assert.That(Volatile.Read(ref actionStarted) >= 1).IsTrue();
 
         // Emit value 2 while value 1 is still processing - it should be dropped.
         await source.EmitNext(DroppedValue);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj b/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
index 3632a9fc..5c5df252 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
@@ -12,10 +12,6 @@
     <PackageReference Include="Microsoft.Reactive.Testing"/>
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs"/>
-  </ItemGroup>
-
   <ItemGroup>
     <Using Include="System"/>
     <Using Include="System.Collections.Generic"/>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ReplayLatestSignalAsyncStateObserverLeaseTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ReplayLatestSignalAsyncStateObserverLeaseTests.cs
new file mode 100644
index 00000000..12b6f3b7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ReplayLatestSignalAsyncStateObserverLeaseTests.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests replay observer removal during cancellation and teardown.</summary>
+public sealed class ReplayLatestSignalAsyncStateObserverLeaseTests
+{
+    /// <summary>The gate has been disposed independently of its signal state.</summary>
+    private const int GateDisposed = 2;
+
+    /// <summary>The whole signal state has been disposed.</summary>
+    private const int StateDisposed = 3;
+
+    /// <summary>Verifies replay lease removal tolerates cancellation and prior state or gate disposal.</summary>
+    /// <param name="stateKind">The state present when lease disposal starts.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(0)]
+    [Arguments(1)]
+    [Arguments(GateDisposed)]
+    [Arguments(StateDisposed)]
+    public async Task WhenReplayLeaseDisposed_ThenRemovalFollowsState(int stateKind)
+    {
+        ReplayLatestSignalAsyncState<int> state = new(default);
+        try
+        {
+            CallbackWitnessAsync<int> observer = new(static (_, _) => default);
+            state.Observers = [observer];
+            state.IsDisposed = stateKind == StateDisposed;
+            ReplayLatestSignalAsyncStateObserverLease<int> lease = new(state, observer);
+            using AsyncSerialGate.Lease? held = stateKind is 1 or GateDisposed
+                ? await state.Gate.EnterForThreadAsync(-1, CancellationToken.None)
+                : null;
+            switch (stateKind)
+            {
+                case 1:
+                {
+                    await state.DisposedCts.CancelAsync();
+                    break;
+                }
+
+                case GateDisposed:
+                {
+                    state.Gate.Dispose();
+                    break;
+                }
+
+                case StateDisposed:
+                {
+                    state.Dispose();
+                    break;
+                }
+            }
+
+            await lease.DisposeAsync();
+            await lease.DisposeAsync();
+            await Assert.That(state.Observers.Contains(observer)).IsEqualTo(stateKind is 1 or GateDisposed or StateDisposed);
+        }
+        finally
+        {
+            state.Dispose();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ResultAndInfrastructureTests.Multicast.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ResultAndInfrastructureTests.Multicast.cs
index 08d0bffc..957f549f 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ResultAndInfrastructureTests.Multicast.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ResultAndInfrastructureTests.Multicast.cs
@@ -13,18 +13,12 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Multicast / RefCount tests.</summary>
 public class ResultAndInfrastructureTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Number of values in the range sources used by the multicast tests.</summary>
     private const int SourceValueCount = 3;
 
     /// <summary>Value emitted by the single-value multicast source.</summary>
     private const int MulticastValue = 42;
 
-    /// <summary>Maximum time a test waits for a notification to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Verifies concurrent observer exception constructors preserve messages and inner exceptions.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -82,38 +76,24 @@ public async Task WhenObserverOnNextThrowsOperationCanceledSynchronously_ThenCal
         await Assert.That(observer.Cancelled).IsTrue();
     }
 
-    /// <summary>Verifies concurrent cross-thread observer calls are reported through the unhandled exception handler.</summary>
+    /// <summary>Verifies that an overlapping call from a different thread identifier is rejected and reported.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenObserverCalledConcurrentlyFromDifferentThread_ThenUnhandledExceptionReported()
     {
-        const int ConcurrentValue = 2;
+        const int FirstThreadId = 1;
+        const int SecondThreadId = 2;
         using UnhandledExceptionCapture capture = new();
-        BlockingObserver observer = new();
-        var first = Task.Factory.StartNew(
-            static async state =>
-            {
-                var blockingObserver = (BlockingObserver)state!;
-                await blockingObserver.OnNextAsync(1, CancellationToken.None);
-            },
-            observer,
-            CancellationToken.None,
-            TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach,
-            TaskScheduler.Default).Unwrap();
-        try
-        {
-            await observer.Entered.Task.WaitAsync(WaitTimeout);
-            await observer.OnNextAsync(ConcurrentValue, CancellationToken.None);
-        }
-        finally
-        {
-            _ = observer.Release.TrySetResult();
-        }
-
-        await first.WaitAsync(WaitTimeout);
+        await using CallbackWitnessAsync<int> observer = new(static (_, _) => default);
+        var entered = observer.TryEnterOnSomethingCall(FirstThreadId, CancellationToken.None, out var scope);
+        var concurrentEntered = observer.TryEnterOnSomethingCall(SecondThreadId, CancellationToken.None, out var rejectedScope);
+        scope.Dispose();
+        rejectedScope.Dispose();
+        _ = observer.ExitOnSomethingCall();
+        await Assert.That(entered).IsTrue();
+        await Assert.That(concurrentEntered).IsFalse();
         var reported = await capture.WaitForAsync(
-            static exception => exception is ConcurrentWitnessCallsException,
-            WaitTimeout);
+            static exception => exception is ConcurrentWitnessCallsException);
         await Assert.That(reported).IsNotNull();
     }
 
@@ -326,7 +306,7 @@ public async Task WhenMulticastSubscribeAndConnect_ThenItemsFlowThroughSignal()
                 return default;
             });
         await using var conn = await connectable.ConnectAsync(CancellationToken.None);
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(items).IsCollectionEqualTo([FirstValue, SecondValue]);
     }
 
@@ -374,7 +354,7 @@ public async Task WhenRefCountSourceErrorResume_ThenForwardsToSubscriber()
                 captured = ex;
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => captured is not null, WaitTimeout);
+        await Assert.That(captured is not null).IsTrue();
         await Assert.That(items).Contains(1);
         await Assert.That(captured).IsNotNull();
         await Assert.That(captured!.Message).IsEqualTo("refcount-error");
@@ -400,28 +380,4 @@ protected override ValueTask OnErrorResumeAsyncCore(Exception error, Cancellatio
         /// <inheritdoc/>
         protected override ValueTask OnCompletedAsyncCore(Result result) => default;
     }
-
-    /// <summary>Observer that blocks OnNext until explicitly released.</summary>
-    private sealed class BlockingObserver : WitnessAsync<int>
-    {
-        /// <summary>Gets the signal set after the first OnNext call has entered.</summary>
-        public TaskCompletionSource Entered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <summary>Gets the signal that releases the blocked OnNext call.</summary>
-        public TaskCompletionSource Release { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <inheritdoc/>
-        protected override async ValueTask OnNextAsyncCore(int value, CancellationToken cancellationToken)
-        {
-            _ = Entered.TrySetResult();
-            await Release.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        /// <inheritdoc/>
-        protected override ValueTask OnErrorResumeAsyncCore(Exception error, CancellationToken cancellationToken) =>
-            default;
-
-        /// <inheritdoc/>
-        protected override ValueTask OnCompletedAsyncCore(Result result) => default;
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.BehaviorAndReplay.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.BehaviorAndReplay.cs
index 53b9faa1..884b395b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.BehaviorAndReplay.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.BehaviorAndReplay.cs
@@ -7,7 +7,7 @@
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>BehaviorSignal and ReplayLatest tests for <see cref="SignalTests"/>.</summary>
-[System.Diagnostics.DebuggerDisplay("SignalTests: WaitTimeout = {WaitTimeout}")]
+[System.Diagnostics.DebuggerDisplay("SignalTests")]
 public partial class SignalTests
 {
     /// <summary>Tests behavior Signal with start value emits latest first to new subscriber.</summary>
@@ -29,7 +29,7 @@ public async Task WhenBehaviorSignalWithStartValue_ThenNewSubscriberReceivesLate
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(StartValue);
@@ -59,7 +59,7 @@ public async Task WhenBehaviorSignalConcurrent_ThenNewSubscriberReceivesLatest()
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(StartValue);
@@ -88,7 +88,7 @@ public async Task WhenReplayLatestSignal_ThenLateSubscriberGetsLatestValue()
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(LatestValue);
@@ -120,7 +120,7 @@ public async Task WhenReplayLatestSignalConcurrent_ThenLateSubscriberGetsLatest(
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(PushedValue);
@@ -145,7 +145,7 @@ public async Task WhenBehaviorSignalStateless_ThenEmitsStartValueToNewSubscriber
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo("initial");
@@ -173,7 +173,7 @@ public async Task WhenReplayLatestStateless_ThenEmitsLatestToNewSubscriber()
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(PushedValue);
@@ -205,7 +205,7 @@ public async Task WhenConcurrentStatelessReplayLatest_ThenEmitsLatest()
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(PushedValue);
@@ -396,7 +396,7 @@ public async Task WhenConcurrentStatelessBehavior_ThenEmitsStartValue()
             },
             null);
 
-        await firstReceived.Task.WaitAsync(WaitTimeout);
+        await firstReceived.Task;
 
         await Assert.That(items).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(items[0]).IsEqualTo(StartValue);
@@ -658,7 +658,7 @@ public async Task WhenReplayLatestOnNextWithCustomToken_ThenForwardsValue()
         const int LinkedCtsValue = 11;
         await signal.OnNextAsync(LinkedCtsValue, cts.Token);
 
-        var received = await tcs.Task.WaitAsync(WaitTimeout);
+        var received = await tcs.Task;
         await Assert.That(received).IsEqualTo(LinkedCtsValue);
     }
 
@@ -683,7 +683,7 @@ public async Task WhenReplayLatestOnErrorResumeWithCustomToken_ThenForwardsError
         using CancellationTokenSource cts = new();
         await signal.OnErrorResumeAsync(expected, cts.Token);
 
-        var received = await tcs.Task.WaitAsync(WaitTimeout);
+        var received = await tcs.Task;
         await Assert.That(received).IsSameReferenceAs(expected);
     }
 
@@ -706,7 +706,7 @@ public async Task WhenStatelessReplayLatestOnNextWithCustomToken_ThenForwardsVal
         const int LinkedCtsValue = 17;
         await signal.OnNextAsync(LinkedCtsValue, cts.Token);
 
-        var received = await tcs.Task.WaitAsync(WaitTimeout);
+        var received = await tcs.Task;
         await Assert.That(received).IsEqualTo(LinkedCtsValue);
     }
 
@@ -731,7 +731,7 @@ public async Task WhenStatelessReplayLatestOnErrorResumeWithCustomToken_ThenForw
         using CancellationTokenSource cts = new();
         await signal.OnErrorResumeAsync(expected, cts.Token);
 
-        var received = await tcs.Task.WaitAsync(WaitTimeout);
+        var received = await tcs.Task;
         await Assert.That(received).IsSameReferenceAs(expected);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.CreationOptions.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.CreationOptions.cs
index 3b7ae94b..4aad4ae1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.CreationOptions.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.CreationOptions.cs
@@ -36,7 +36,7 @@ public async Task WhenCreateWithSerialStatefulOptions_ThenPublishesToSubscribers
 
         await signal.OnNextAsync(OptionsStartValue, CancellationToken.None);
 
-        var value = await received.Task.WaitAsync(WaitTimeout);
+        var value = await received.Task;
         await Assert.That(value).IsEqualTo(OptionsStartValue);
     }
 
@@ -55,7 +55,7 @@ public async Task WhenCreateBehaviorWithSerialStatefulOptions_ThenReplaysStartVa
             return default;
         });
 
-        var value = await received.Task.WaitAsync(WaitTimeout);
+        var value = await received.Task;
         await Assert.That(value).IsEqualTo(OptionsStartValue);
     }
 
@@ -76,7 +76,7 @@ public async Task WhenCreateReplayLatestWithSerialStatefulOptions_ThenReplaysLat
             return default;
         });
 
-        var value = await received.Task.WaitAsync(WaitTimeout);
+        var value = await received.Task;
         await Assert.That(value).IsEqualTo(OptionsLatestValue);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
index ac78959d..30c4d4ca 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
@@ -40,7 +40,7 @@ public async Task WhenMapValues_ThenTransformsObservable()
         await mapped.OnNextAsync(FirstInput, CancellationToken.None);
         await mapped.OnNextAsync(SecondInput, CancellationToken.None);
         await mapped.OnCompletedAsync(Result.Success);
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(items).IsCollectionEqualTo([FirstMapped, SecondMapped]);
     }
 
@@ -545,7 +545,7 @@ public async Task WhenConcurrentSignalWithMultipleObservers_ThenAllReceiveOnComp
             return default;
         });
         await signal.OnCompletedAsync(Result.Success);
-        await completed1.Task.WaitAsync(WaitTimeout);
-        await completed2.Task.WaitAsync(WaitTimeout);
+        await completed1.Task;
+        await completed2.Task;
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.cs
index 0735a093..a5ced384 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.cs
@@ -9,12 +9,6 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests for SignalAsync factory, all Signal variants, and SignalExtensions.</summary>
 public partial class SignalTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
-    /// <summary>Maximum time a test waits for a signal notification to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
 #if NET9_0_OR_GREATER
     /// <summary>Synchronization gate used by tests.</summary>
     private readonly Lock _gate = new();
@@ -54,7 +48,7 @@ public async Task WhenSerialSignalPushValues_ThenAllObserversReceiveInOrder()
         await signal.OnNextAsync(ThirdValue, CancellationToken.None);
         await signal.OnCompletedAsync(Result.Success);
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(items).IsCollectionEqualTo([FirstValue, SecondValue, ThirdValue]);
     }
@@ -94,7 +88,7 @@ public async Task WhenConcurrentSignalPushValues_ThenAllObserversReceive()
         await signal.OnNextAsync(SecondValue, CancellationToken.None);
         await signal.OnCompletedAsync(Result.Success);
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(items).Count().IsEqualTo(ExpectedCount);
     }
@@ -126,7 +120,7 @@ public async Task WhenSerialStatelessSignalPushValues_ThenObserversReceive()
         await signal.OnNextAsync("b", CancellationToken.None);
         await signal.OnCompletedAsync(Result.Success);
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(items).IsCollectionEqualTo(["a", "b"]);
     }
@@ -163,7 +157,7 @@ public async Task WhenConcurrentStatelessSignalPushValues_ThenObserversReceive()
         await signal.OnNextAsync(PushedValue, CancellationToken.None);
         await signal.OnCompletedAsync(Result.Success);
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(items).IsCollectionEqualTo([PushedValue]);
     }
@@ -187,7 +181,7 @@ public async Task WhenSignalOnErrorResume_ThenObserverReceivesError()
             });
 
         await signal.OnErrorResumeAsync(new InvalidOperationException("test"), CancellationToken.None);
-        await errorReceived.Task.WaitAsync(WaitTimeout);
+        await errorReceived.Task;
 
         const int ExpectedErrorCount = 1;
         await Assert.That(errors).Count().IsEqualTo(ExpectedErrorCount);
@@ -214,7 +208,7 @@ public async Task WhenSignalOnCompleted_ThenObserverReceivesCompletion()
             });
 
         await signal.OnCompletedAsync(Result.Success);
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
@@ -240,7 +234,7 @@ public async Task WhenSignalOnCompletedWithFailure_ThenObserverReceivesFailure()
             });
 
         await signal.OnCompletedAsync(Result.Failure(new InvalidOperationException("fatal")));
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
@@ -290,7 +284,7 @@ public async Task WhenMultipleObservers_ThenAllReceiveValues()
         await signal.OnNextAsync(SecondValue, CancellationToken.None);
         await signal.OnCompletedAsync(Result.Success);
 
-        await Task.WhenAll(completed1.Task, completed2.Task).WaitAsync(WaitTimeout);
+        await Task.WhenAll(completed1.Task, completed2.Task);
 
         await Assert.That(items1).IsCollectionEqualTo([FirstValue, SecondValue]);
         await Assert.That(items2).IsCollectionEqualTo([FirstValue, SecondValue]);
@@ -326,7 +320,7 @@ public async Task WhenAsObserverAsync_ThenForwardsToSignal()
         await observer.OnNextAsync(SecondValue, CancellationToken.None);
         await observer.OnCompletedAsync(Result.Success);
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
 
         await Assert.That(items).IsCollectionEqualTo([FirstValue, SecondValue]);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/StatelessReplayLatestSignalAsyncStateObserverLeaseTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/StatelessReplayLatestSignalAsyncStateObserverLeaseTests.cs
new file mode 100644
index 00000000..df9bbdfc
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/StatelessReplayLatestSignalAsyncStateObserverLeaseTests.cs
@@ -0,0 +1,83 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests stateless replay observer removal and initial-value restoration.</summary>
+public sealed class StatelessReplayLatestSignalAsyncStateObserverLeaseTests
+{
+    /// <summary>The gate has been disposed independently of its signal state.</summary>
+    private const int GateDisposed = 2;
+
+    /// <summary>The whole signal state has been disposed.</summary>
+    private const int StateDisposed = 3;
+
+    /// <summary>A second observer remains after removal.</summary>
+    private const int AnotherObserver = 4;
+
+    /// <summary>Verifies the final stateless replay lease restores its initial value.</summary>
+    /// <param name="stateKind">The state present when lease disposal starts.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(0)]
+    [Arguments(1)]
+    [Arguments(GateDisposed)]
+    [Arguments(StateDisposed)]
+    [Arguments(AnotherObserver)]
+    public async Task WhenStatelessReplayLeaseDisposed_ThenLastRemovalResetsValue(int stateKind)
+    {
+        const int InitialValue = 1;
+        const int PublishedValue = 2;
+        StatelessReplayLatestSignalAsyncState<int> state = new(new(InitialValue));
+        try
+        {
+            CallbackWitnessAsync<int> observer = new(static (_, _) => default);
+            state.Observers = stateKind == AnotherObserver
+                ? [observer, new CallbackWitnessAsync<int>(static (_, _) => default)]
+                : [observer];
+            state.Value = new(PublishedValue);
+            state.IsDisposed = stateKind == StateDisposed;
+            StatelessReplayLatestSignalAsyncStateObserverLease<int> lease = new(state, observer);
+            using AsyncSerialGate.Lease? held = stateKind is 1 or GateDisposed
+                ? await state.Gate.EnterForThreadAsync(-1, CancellationToken.None)
+                : null;
+            switch (stateKind)
+            {
+                case 1:
+                {
+                    await state.DisposedCts.CancelAsync();
+                    break;
+                }
+
+                case GateDisposed:
+                {
+                    state.Gate.Dispose();
+                    break;
+                }
+
+                case StateDisposed:
+                {
+                    state.Dispose();
+                    break;
+                }
+            }
+
+            await lease.DisposeAsync();
+            await lease.DisposeAsync();
+            await Assert.That(state.Observers.Contains(observer)).IsEqualTo(stateKind is 1 or GateDisposed or StateDisposed);
+            if (stateKind == StateDisposed)
+            {
+                return;
+            }
+
+            await Assert.That(state.Value.Value).IsEqualTo(stateKind == 0 ? InitialValue : PublishedValue);
+        }
+        finally
+        {
+            state.Dispose();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.HighArity.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.HighArity.cs
index 2f7dd195..8792e9b0 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.HighArity.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.HighArity.cs
@@ -44,7 +44,7 @@ public async Task WhenSyncLatestTwelveSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityTwelve);
@@ -86,7 +86,7 @@ public async Task WhenSyncLatestThirteenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityThirteen);
@@ -130,7 +130,7 @@ public async Task WhenSyncLatestFourteenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityFourteen);
@@ -175,7 +175,7 @@ public async Task WhenSyncLatestFifteenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityFifteen);
@@ -221,7 +221,7 @@ public async Task WhenSyncLatestSixteenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(AritySixteen);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.LowArity.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.LowArity.cs
index 74e45ac3..7c9891b3 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.LowArity.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.LowArity.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Tests for the arity-3 through arity-7 <c>SyncLatest</c> spelling of the combine-latest operator. The
-/// <c>CombineLatest</c> spelling of these overloads is exercised elsewhere; these cover the <c>SyncLatest</c>
-/// alias methods, which forward to the same signal. Each source contributes a value of one, so the projected
-/// result equals the arity once every source has produced a value.
-/// </summary>
+/// <summary>Tests SyncLatest with three through seven sources, each contributing one to the projected sum.</summary>
 public partial class SyncLatestOperatorTests
 {
     /// <summary>Number of sources combined by the arity-3 overload.</summary>
@@ -55,7 +50,7 @@ public async Task WhenSyncLatestThreeSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityThree);
@@ -88,7 +83,7 @@ public async Task WhenSyncLatestFourSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityFour);
@@ -122,7 +117,7 @@ public async Task WhenSyncLatestFiveSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityFive);
@@ -157,7 +152,7 @@ public async Task WhenSyncLatestSixSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(AritySix);
@@ -193,7 +188,7 @@ public async Task WhenSyncLatestSevenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(AritySeven);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.cs
index 87f6b7bb..bdcada2b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SyncLatestOperatorTests.cs
@@ -13,9 +13,6 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// </summary>
 public partial class SyncLatestOperatorTests
 {
-    /// <summary>Seconds a test waits for a combined emission before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Index of source 3 in the per-test source list.</summary>
     private const int SourceIndex2 = 2;
 
@@ -88,9 +85,6 @@ public partial class SyncLatestOperatorTests
     /// <summary>Value emitted by the second source in the enumerable tests.</summary>
     private const int SecondValue = 2;
 
-    /// <summary>Maximum time a test waits for a combined emission to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Verifies the enumerable <c>SyncLatest</c> emits a snapshot of the latest value of every source
     /// once all of them have produced one.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
@@ -116,7 +110,7 @@ public async Task WhenSyncLatestOverEnumerable_ThenEmitsSnapshotOfLatestValues()
         await first.OnNextAsync(1, CancellationToken.None);
         await second.OnNextAsync(SecondValue, CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => snapshots.Count >= 1, WaitTimeout);
+        await Assert.That(snapshots.Count >= 1).IsTrue();
 
         await Assert.That(snapshots).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(snapshots[0]).IsCollectionEqualTo([1, SecondValue]);
@@ -143,7 +137,7 @@ public async Task WhenSyncLatestOverEnumerableWithSelector_ThenProjectsSnapshot(
         await first.OnNextAsync(1, CancellationToken.None);
         await second.OnNextAsync(SecondValue, CancellationToken.None);
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(1 + SecondValue);
@@ -180,7 +174,7 @@ public async Task WhenSyncLatestEightSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityEight);
@@ -218,7 +212,7 @@ public async Task WhenSyncLatestNineSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityNine);
@@ -257,7 +251,7 @@ public async Task WhenSyncLatestTenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityTen);
@@ -297,7 +291,7 @@ public async Task WhenSyncLatestElevenSources_ThenCombinesAll()
             await signals[index].OnNextAsync(1, CancellationToken.None);
         }
 
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, WaitTimeout);
+        await Assert.That(results.Count >= 1).IsTrue();
 
         await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(results[0]).IsEqualTo(ArityEleven);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
index 3763de44..ea9d05d7 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.CompletionDelegate.cs
@@ -8,7 +8,7 @@
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>TakeUntil operator tests — CompletionSignalDelegate overload and option behavior.</summary>
-[System.Diagnostics.DebuggerDisplay("TakeUntilOperatorTests: WaitTimeout = {WaitTimeout}")]
+[System.Diagnostics.DebuggerDisplay("TakeUntilOperatorTests")]
 public partial class TakeUntilOperatorTests
 {
     /// <summary>String literal "subscribe failed" used by multiple tests.</summary>
@@ -737,7 +737,7 @@ public async Task WhenTakeUntilCompletionDelegateNotifiesTwice_ThenSecondNotific
     /// <summary>An <see cref = "IAsyncDisposable"/> that records how many times it has been disposed.</summary>
     private sealed class DisposeCountingAsyncDisposable : IAsyncDisposable
     {
-        /// <summary>Signals the first disposal so a test can await it instead of polling the count.</summary>
+        /// <summary>Signals the first disposal.</summary>
         private readonly TaskCompletionSource _disposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         /// <summary>The number of times <see cref = "DisposeAsync"/> has been called.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.DisposalAndErrors.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.DisposalAndErrors.cs
index 96df1c0f..02dc7b5c 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.DisposalAndErrors.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.DisposalAndErrors.cs
@@ -14,15 +14,6 @@ public partial class TakeUntilOperatorTests
     /// <summary>Message thrown by an observer from its completion callback.</summary>
     private const string ObserverCompletionThrowsMessage = "observer completion throws";
 
-    /// <summary>Time allowed for a stop signal to propagate before the next emission.</summary>
-    private static readonly TimeSpan PropagationDelay = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>Time allowed for a post-stop emission to be observed, had it not been suppressed.</summary>
-    private static readonly TimeSpan SuppressedEmissionDelay = TimeSpan.FromMilliseconds(50);
-
-    /// <summary>Time the swallowed-exception tests idle to prove nothing crashes the test host.</summary>
-    private static readonly TimeSpan SwallowedExceptionWindow = TimeSpan.FromMilliseconds(200);
-
     /// <summary>Tests TakeUntil(predicate) DisposeAsyncCore when subscription is not null.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -57,17 +48,16 @@ public async Task WhenCancellationStopSignalCanceled_ThenCompletionForwarded()
     {
         using CancellationTokenSource cts = new();
         var source = Signal.Create<int>();
-        Result? completionResult = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         await using var sub = await source.Values.TakeUntil(cts.Token).SubscribeAsync(static (_, _) => default, null, result =>
         {
-            completionResult = result;
+            IgnoredResult.Of(completed.TrySetResult(result));
             return default;
         });
         await source.OnNextAsync(1, CancellationToken.None);
         await cts.CancelAsync();
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult is not null, WaitTimeout);
-        await Assert.That(completionResult).IsNotNull();
-        await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
+        var completion = await completed.Task;
+        await Assert.That(completion.IsSuccess).IsTrue();
     }
 
     /// <summary>
@@ -80,21 +70,19 @@ public async Task WhenTakeUntilCompletionDelegateDisposableThrows_ThenCaughtGrac
     {
         var source = Signal.Create<int>();
         Result? completionResult = null;
+        Action<Result>? notify = null;
         await using var sub = await source.Values.TakeUntil(stop =>
         {
-            _ = Task.Run(async () =>
-            {
-                await Task.Yield();
-                stop(Result.Success);
-            });
+            notify = stop;
             return DisposableAsync.Create(static () => throw new InvalidOperationException("dispose fail"));
         }).SubscribeAsync(static (_, _) => default, null, result =>
         {
             completionResult = result;
             return default;
         });
+        notify!(Result.Success);
         await source.OnNextAsync(1, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult is not null, WaitTimeout);
+        await Assert.That(completionResult is not null).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
@@ -117,9 +105,7 @@ public async Task WhenTakeUntilObservable_ThenStopsOnSignal()
         await source.OnNextAsync(1, CancellationToken.None);
         await source.OnNextAsync(SecondItem, CancellationToken.None);
         await stopper.OnNextAsync("stop", CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, PropagationDelay);
         await source.OnNextAsync(ThirdItem, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SuppressedEmissionDelay);
         await Assert.That(items).Contains(1);
         await Assert.That(items).DoesNotContain(ThirdItem);
     }
@@ -148,11 +134,9 @@ public async Task WhenTaskStopSignal_ThenStopsOnTaskCompletion()
         await source.OnNextAsync(1, CancellationToken.None);
         tcs.SetResult();
 
-        // Wait for the sequence to have actually stopped rather than for a delay to elapse, so a slow
-        // machine cannot let the second value through before the stop has been relayed.
-        _ = await stopped.Task.WaitAsync(WaitTimeout);
+        // Completion must be delivered before the next source value.
+        _ = await stopped.Task;
         await source.OnNextAsync(SecondItem, CancellationToken.None);
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SuppressedEmissionDelay);
         await Assert.That(items).Contains(1);
         await Assert.That(items).DoesNotContain(SecondItem);
     }
@@ -174,7 +158,6 @@ public async Task WhenCancellationStopSignal_ThenStopsOnCancellation()
             null);
         await source.OnNextAsync(1, CancellationToken.None);
         await cts.CancelAsync();
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, PropagationDelay);
         await Assert.That(items).Contains(1);
     }
 
@@ -226,10 +209,9 @@ public async Task WhenTakeUntilDelegateOtherFailsAndOptionFalse_ThenErrorResumeF
         var source = Signal.Create<int>();
         List<Exception> errors = [];
         await using var sub = await source.Values.TakeUntil(
-            notifyStop =>
+            static notifyStop =>
             {
-                // Fire stop with failure after a brief moment
-                _ = Task.Run(() => notifyStop(Result.Failure(new InvalidOperationException("delegate fail"))));
+                notifyStop(Result.Failure(new InvalidOperationException("delegate fail")));
                 return DisposableAsync.Empty;
             },
             new TakeUntilOptions { SourceFailsWhenOtherFails = false }).SubscribeAsync(
@@ -244,7 +226,7 @@ public async Task WhenTakeUntilDelegateOtherFailsAndOptionFalse_ThenErrorResumeF
                 return default;
             },
             static _ => default);
-        await AsyncTestHelpers.WaitForConditionAsync(() => errors.Count >= 1, WaitTimeout);
+        await Assert.That(errors.Count >= 1).IsTrue();
         await Assert.That(errors).Count().IsGreaterThanOrEqualTo(1);
     }
 
@@ -256,9 +238,9 @@ public async Task WhenTakeUntilDelegateOtherFailsAndOptionTrue_ThenCompletesWith
         var source = Signal.Create<int>();
         Result? completionResult = null;
         await using var sub = await source.Values.TakeUntil(
-            notifyStop =>
+            static notifyStop =>
             {
-                _ = Task.Run(() => notifyStop(Result.Failure(new InvalidOperationException("delegate fail"))));
+                notifyStop(Result.Failure(new InvalidOperationException("delegate fail")));
                 return DisposableAsync.Empty;
             },
             new TakeUntilOptions { SourceFailsWhenOtherFails = true }).SubscribeAsync(static (_, _) => default, null, result =>
@@ -266,7 +248,7 @@ public async Task WhenTakeUntilDelegateOtherFailsAndOptionTrue_ThenCompletesWith
             completionResult = result;
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, WaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
     }
@@ -291,7 +273,7 @@ public async Task WhenTaskStopSignalAwaitStopThenCompleteFailsOptionFalse_ThenEr
 
                     return default;
                 });
-        await AsyncTestHelpers.WaitForConditionAsync(() => errors.Count >= 1, WaitTimeout);
+        await Assert.That(errors.Count >= 1).IsTrue();
         await Assert.That(errors).Count().IsGreaterThanOrEqualTo(1);
     }
 
@@ -312,7 +294,7 @@ public async Task WhenTaskStopSignalAwaitStopThenCompleteFailsOptionTrue_ThenCom
                     completionResult = result;
                     return default;
                 });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, WaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
     }
@@ -348,7 +330,7 @@ public async Task WhenTaskStopSignalSourceEmitsErrorResume_ThenErrorIsForwarded(
                 completionResult = result;
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, WaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(errors).Count().IsGreaterThanOrEqualTo(1);
         await Assert.That(completionResult).IsNotNull();
     }
@@ -397,7 +379,7 @@ public async Task WhenTakeUntilDelegateSignalFailsAndOptionFalse_ThenSendsErrorR
 
         // Fire the stop signal with a failure
         storedNotifyStop!(Result.Failure(new InvalidOperationException("signal error")));
-        await AsyncTestHelpers.WaitForConditionAsync(() => errors.Count >= 1, WaitTimeout);
+        await Assert.That(errors.Count >= 1).IsTrue();
         await Assert.That(errors).Count().IsGreaterThanOrEqualTo(1);
     }
 
@@ -427,7 +409,7 @@ public async Task WhenTakeUntilDelegateSignalFailsAndOptionTrue_ThenCompletesWit
                     return default;
                 });
         storedNotifyStop!(Result.Failure(new InvalidOperationException("signal error")));
-        await AsyncTestHelpers.WaitForConditionAsync(() => completionResult.HasValue, WaitTimeout);
+        await Assert.That(completionResult.HasValue).IsTrue();
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsFailure).IsTrue();
     }
@@ -456,9 +438,6 @@ public async Task WhenTakeUntilDelegateForwardingThrows_ThenOuterCatchSwallows()
 
         // Fire the stop signal with success; OnCompletedAsync will throw because observer throws
         storedNotifyStop!(Result.Success);
-
-        // The outer catch block should swallow the exception; no crash
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SwallowedExceptionWindow);
         await sub.DisposeAsync();
     }
 
@@ -476,9 +455,6 @@ public async Task WhenTaskStopSignalForwardingThrows_ThenOuterCatchSwallows()
 
         // Complete the task; OnCompletedAsync will throw because observer throws
         tcs.SetResult();
-
-        // The outer catch block should swallow the exception; no crash
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SwallowedExceptionWindow);
         await sub.DisposeAsync();
     }
 
@@ -499,9 +475,6 @@ public async Task WhenCancellationStopSignalForwardingThrows_ThenOuterCatchSwall
 
         // Cancel the token; CompleteFromCancellation will call OnCompletedAsync which will throw
         await cts.CancelAsync();
-
-        // The outer catch block should swallow the exception; no crash
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SwallowedExceptionWindow);
         await sub.DisposeAsync();
     }
 
@@ -529,9 +502,6 @@ public async Task WhenTakeUntilDelegateErrorResumeThrows_ThenOuterCatchSwallows(
 
         // Signal a failure; SourceFailsWhenOtherFails=false so OnErrorResumeAsync is called, which throws
         storedNotifyStop!(Result.Failure(new InvalidOperationException("stop error")));
-
-        // The outer catch block should swallow the exception
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SwallowedExceptionWindow);
         await sub.DisposeAsync();
     }
 
@@ -554,9 +524,6 @@ public async Task WhenTaskStopSignalErrorResumeThrows_ThenOuterCatchSwallows()
 
         // Fault the task; SourceFailsWhenOtherFails=false so OnErrorResumeAsync is called, which throws
         tcs.SetException(new InvalidOperationException("task error"));
-
-        // The outer catch block should swallow the exception
-        await AsyncTestHelpers.WaitForConditionAsync(static () => true, SwallowedExceptionWindow);
         await sub.DisposeAsync();
     }
 
@@ -611,7 +578,7 @@ public async Task WhenCancellationStopSignal_ThenCompletesOnCancel()
             });
         await source.EmitNext(1);
         await cts.CancelAsync();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(items).Contains(1);
     }
 
@@ -638,7 +605,7 @@ public async Task WhenTaskStopSignalCompletes_ThenSourceCompletes()
             });
         await source.EmitNext(1);
         tcs.SetResult();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(items).Contains(1);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.cs
index 74682372..46c151f6 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TakeUntilOperatorTests.cs
@@ -8,11 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Deep coverage tests for all TakeUntil operator overloads:
-/// TakeUntil(observable), TakeUntil(Task), TakeUntil(CancellationToken),
-/// TakeUntil(predicate), TakeUntil(asyncPredicate), TakeUntil(CompletionSignalDelegate).
-/// </summary>
+/// <summary>Tests TakeUntil termination through signals, tasks, cancellation, predicates and callbacks.</summary>
 public partial class TakeUntilOperatorTests
 {
     /// <summary>String literal "warning" used by multiple tests.</summary>
@@ -32,9 +28,6 @@ public partial class TakeUntilOperatorTests
 
     /// <summary>A predicate threshold no element of the test sources ever reaches.</summary>
     private const int UnreachableThreshold = 10;
-
-    /// <summary>Maximum time a test waits for a completion signal to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
 #if NET9_0_OR_GREATER
 
     /// <summary>Synchronization gate used by tests.</summary>
@@ -228,7 +221,7 @@ public async Task WhenTaskStopSignalFailsAndOptionTrue_ThenCompletesWithFailure(
                 });
         await source.OnNextAsync(1, CancellationToken.None);
         tcs.SetException(new InvalidOperationException("task failed"));
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsFailure).IsTrue();
     }
 
@@ -238,20 +231,17 @@ public async Task WhenTaskStopSignalFailsAndOptionTrue_ThenCompletesWithFailure(
     public async Task WhenTaskStopSignalFailsAndOptionFalse_ThenSendsErrorResume()
     {
         TaskCompletionSource tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> errorReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var source = Signal.Create<int>();
-        List<Exception> errors = [];
         await using var sub = await source.Values.TakeUntil(tcs.Task).SubscribeAsync(static (_, _) => default, (ex, _) =>
         {
-            errors.Add(ex);
+            IgnoredResult.Of(errorReceived.TrySetResult(ex));
             return default;
         });
         await source.OnNextAsync(1, CancellationToken.None);
-        tcs.SetException(new InvalidOperationException("task failed"));
-
-        // Wait for the error to be relayed rather than assuming the task's continuation ran inline.
-        var resumed = await AsyncTestHelpers.WaitForConditionAsync(() => errors.Count == 1, WaitTimeout);
-        await Assert.That(resumed).IsTrue();
-        await Assert.That(errors).Count().IsEqualTo(1);
+        InvalidOperationException expected = new("task failed");
+        tcs.SetException(expected);
+        await Assert.That(await errorReceived.Task).IsSameReferenceAs(expected);
     }
 
     /// <summary>Tests that an already-completed task completes the sequence immediately.</summary>
@@ -326,7 +316,7 @@ public async Task WhenTakeUntilAlreadyCanceledToken_ThenCompletesImmediately()
             _ = completed.TrySetResult(result);
             return default;
         });
-        var completionResult = await completed.Task.WaitAsync(WaitTimeout);
+        var completionResult = await completed.Task;
         await Assert.That(completionResult.IsSuccess).IsTrue();
     }
 
@@ -600,7 +590,7 @@ public async Task WhenTakeUntilOtherWithCancellationToken_ThenCompletesOnCancell
                 return default;
             });
         await cts.CancelAsync();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
     }
 
     /// <summary>Verifies the two-argument <c>TakeUntil(task, cancellationToken)</c> overload.</summary>
@@ -621,7 +611,7 @@ public async Task WhenTaskStopSignalWithCancellationToken_ThenCompletesOnCancell
                 return default;
             });
         await cts.CancelAsync();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
     }
 
     /// <summary>Verifies the predicate overload with a cancellable token reaches the CT-linked branch.</summary>
@@ -641,7 +631,7 @@ public async Task WhenPredicateStopSignalWithCancellationToken_ThenCompletesOnCa
                 return default;
             });
         await cts.CancelAsync();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
     }
 
     /// <summary>Verifies the async-predicate overload with a cancellable token reaches the CT-linked branch.</summary>
@@ -661,6 +651,6 @@ public async Task WhenTakeUntilAsyncPredicateWithCancellationToken_ThenCompletes
                 return default;
             });
         await cts.CancelAsync();
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TaskSignalSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TaskSignalSubscriptionTests.cs
index 54013540..087579e1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TaskSignalSubscriptionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TaskSignalSubscriptionTests.cs
@@ -9,14 +9,10 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests for <see cref="TaskSignalSubscription{T}"/> lifecycle and disposal behavior.</summary>
 public sealed class TaskSignalSubscriptionTests
 {
-    /// <summary>Maximum time a reentrant dispose may take before it is treated as a deadlock.</summary>
-    private static readonly TimeSpan ReentrantDisposeTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Verifies a reentrant dispose issued from within the job's own async flow does not deadlock,
-    /// even after the notification continuation has hopped to a different thread.</summary>
-    /// <returns>A task that completes when the subscription disposes; faults on timeout if a deadlock occurs.</returns>
+    /// <summary>Verifies that a resumed notification can dispose its own task subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenDisposedReentrantlyAfterThreadHop_ThenDoesNotDeadlock()
+    public async Task WhenDisposedReentrantlyAfterNotificationResumes_ThenCompletes()
     {
         TaskSignalSubscription<int>? subscription = null;
         TaskCompletionSource subscriptionReady = new(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -25,7 +21,6 @@ public async Task WhenDisposedReentrantlyAfterThreadHop_ThenDoesNotDeadlock()
         ReentrantDisposingObserver observer = new(async () =>
         {
             await subscriptionReady.Task.ConfigureAwait(false);
-            await Task.Yield();
             await subscription!.DisposeAsync().ConfigureAwait(false);
             disposed.SetResult();
         });
@@ -35,7 +30,7 @@ static async (obs, ct) => await obs.OnNextAsync(1, ct).ConfigureAwait(false),
             observer);
         subscriptionReady.SetResult();
 
-        await disposed.Task.WaitAsync(ReentrantDisposeTimeout);
+        await disposed.Task;
     }
 
     /// <summary>Observer that runs a supplied callback from its OnNext notification.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ElementSelection.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ElementSelection.cs
new file mode 100644
index 00000000..55fcbe6a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ElementSelection.cs
@@ -0,0 +1,507 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Disposables;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests first, last and single-element terminal selection.</summary>
+public partial class TerminalOperatorTests
+{
+    /// <summary>Tests FirstAsync returns first element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsync_ThenReturnsFirstElement()
+    {
+        const int ExpectedFirst = 10;
+        var result = await SignalAsync.Range(ExpectedFirst, ShortSourceValueCount).FirstAsync();
+        await Assert.That(result).IsEqualTo(ExpectedFirst);
+    }
+
+    /// <summary>Tests FirstAsync with predicate returns first match.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsyncWithPredicate_ThenReturnsFirstMatch()
+    {
+        const int ExpectedFirstMatch = 4;
+        var result = await SignalAsync.Range(1, SourceValueCount).FirstAsync(static x => x > MatchThreshold);
+        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
+    }
+
+    /// <summary>Tests FirstAsync reports an empty source with the no-elements message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsyncOnEmpty_ThenThrowsInvalidOperation()
+    {
+        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().FirstAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
+    }
+
+    /// <summary>Tests FirstAsync with predicate when no elements match throws InvalidOperationException with matching message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsyncWithPredicateNoMatch_ThenThrowsInvalidOperationWithMatchingMessage()
+    {
+        var ex = await Assert.That(
+            static async () => await SignalAsync.Range(1, SourceValueCount)
+                .FirstAsync(static x => x > UnmatchableThreshold))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
+    }
+
+    /// <summary>Tests FirstAsync propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsyncSourceEmitsErrorResume_ThenThrowsSourceException()
+    {
+        InvalidOperationException expectedError = new(ResumeErrorMessage);
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.FirstAsync()).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
+    }
+
+    /// <summary>Tests FirstAsync propagates error when source completes with failure result.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstAsyncSourceCompletesWithFailure_ThenThrowsSourceException()
+    {
+        InvalidOperationException expectedError = new(SourceFailedMessage);
+        var source = SignalAsync.Create<int>(async (observer, _) =>
+        {
+            await observer.OnCompletedAsync(new(expectedError));
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.FirstAsync()).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
+    }
+
+    /// <summary>Tests FirstOrDefault on empty returns default.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultOnEmpty_ThenReturnsDefault()
+    {
+        var result = await SignalAsync.Empty<int>().FirstOrDefaultAsync();
+        await Assert.That(result).IsEqualTo(0);
+    }
+
+    /// <summary>Tests FirstOrDefault with predicate match returns first.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultWithMatch_ThenReturnsFirst()
+    {
+        const int ExpectedFirstMatch = 4;
+        var result = await SignalAsync.Range(1, SourceValueCount).Where(static x => x > MatchThreshold).FirstOrDefaultAsync(0);
+        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
+    }
+
+    /// <summary>Tests FirstOrDefaultAsync with predicate returns first matching element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultAsyncWithPredicate_ThenReturnsFirstMatch()
+    {
+        const int ExpectedFirstMatch = 4;
+        var result = await SignalAsync.Range(1, SourceValueCount).FirstOrDefaultAsync(static x => x > MatchThreshold, -1);
+        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
+    }
+
+    /// <summary>Tests FirstOrDefaultAsync with predicate and no match returns specified default value.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
+    {
+        var result = await SignalAsync.Range(1, SourceValueCount).FirstOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
+        await Assert.That(result).IsEqualTo(-1);
+    }
+
+    /// <summary>Tests FirstOrDefaultAsync with predicate propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultAsyncWithPredicateSourceEmitsErrorResume_ThenThrows()
+    {
+        InvalidOperationException expectedError = new(ResumeErrorMessage);
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.FirstOrDefaultAsync(static x => x > 0, -1))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
+    }
+
+    /// <summary>Tests FirstOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
+    {
+        InvalidOperationException expectedError = new(ResumeErrorMessage);
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.FirstOrDefaultAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
+    }
+
+    /// <summary>Tests LastAsync returns last element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsync_ThenReturnsLastElement()
+    {
+        const int ExpectedLast = 5;
+        var result = await SignalAsync.Range(1, SourceValueCount).LastAsync();
+        await Assert.That(result).IsEqualTo(ExpectedLast);
+    }
+
+    /// <summary>Tests LastAsync with predicate returns last match.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncWithPredicate_ThenReturnsLastMatch()
+    {
+        const int ExpectedLastMatch = 3;
+        var result = await SignalAsync.Range(1, SourceValueCount).LastAsync(static x => x < UpperMatchBound);
+        await Assert.That(result).IsEqualTo(ExpectedLastMatch);
+    }
+
+    /// <summary>Tests LastAsync on empty throws.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncOnEmpty_ThenThrowsInvalidOperation() => await Assert
+        .That(static async () => await SignalAsync.Empty<int>().LastAsync())
+        .ThrowsExactly<InvalidOperationException>();
+
+    /// <summary>Tests LastAsync with predicate and no match throws with matching-elements message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncWithPredicateNoMatch_ThenThrowsWithMatchingMessage()
+    {
+        var ex = await Assert.That(
+            static async () => await SignalAsync.Range(1, SourceValueCount)
+                .LastAsync(static x => x > UnmatchableThreshold))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
+    }
+
+    /// <summary>Tests LastAsync on empty throws with no-elements message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncOnEmpty_ThenThrowsWithNoElementsMessage()
+    {
+        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().LastAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
+    }
+
+    /// <summary>Tests LastAsync propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncSourceEmitsErrorResume_ThenThrowsSourceException()
+    {
+        InvalidOperationException expectedError = new(ResumeErrorMessage);
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnNextAsync(1, ct);
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.LastAsync()).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
+    }
+
+    /// <summary>Tests LastAsync propagates error when source completes with failure result.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastAsyncSourceCompletesWithFailure_ThenThrowsSourceException()
+    {
+        InvalidOperationException expectedError = new(SourceFailedMessage);
+        var source = SignalAsync.Create<int>(async (observer, _) =>
+        {
+            await observer.OnCompletedAsync(new(expectedError));
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.LastAsync()).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
+    }
+
+    /// <summary>Tests LastOrDefault on empty returns default.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultOnEmpty_ThenReturnsDefault()
+    {
+        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync();
+        await Assert.That(result).IsEqualTo(0);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync with predicate returns the last matching element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncWithPredicate_ThenReturnsLastMatch()
+    {
+        const int ExpectedLastMatch = 3;
+        var result = await SignalAsync.Range(1, SourceValueCount).LastOrDefaultAsync(static x => x < UpperMatchBound, -1);
+        await Assert.That(result).IsEqualTo(ExpectedLastMatch);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync with predicate returns default when no elements match.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
+    {
+        var result = await SignalAsync.Range(1, SourceValueCount).LastOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
+        await Assert.That(result).IsEqualTo(-1);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync with predicate on empty returns default value.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncWithPredicateOnEmpty_ThenReturnsDefaultValue()
+    {
+        const int DefaultValue = 42;
+        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync(static _ => true, DefaultValue);
+        await Assert.That(result).IsEqualTo(DefaultValue);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync with custom default value on empty returns that default.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncWithDefaultValueOnEmpty_ThenReturnsCustomDefault()
+    {
+        const int CustomDefault = 99;
+        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync(CustomDefault);
+        await Assert.That(result).IsEqualTo(CustomDefault);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
+    {
+        InvalidOperationException expectedError = new(ResumeErrorMessage);
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnNextAsync(1, ct);
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.LastOrDefaultAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
+    }
+
+    /// <summary>Tests LastOrDefaultAsync propagates error when source completes with failure.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastOrDefaultAsyncSourceCompletesWithFailure_ThenThrows()
+    {
+        InvalidOperationException expectedError = new(SourceFailedMessage);
+        var source = SignalAsync.Create<int>(async (observer, _) =>
+        {
+            await observer.OnCompletedAsync(new(expectedError));
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.LastOrDefaultAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
+    }
+
+    /// <summary>Tests SingleAsync returns single element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAsync_ThenReturnsSingleElement()
+    {
+        const int SingleValue = 42;
+        var result = await SignalAsync.Return(SingleValue).SingleAsync();
+        await Assert.That(result).IsEqualTo(SingleValue);
+    }
+
+    /// <summary>Tests SingleAsync multiple elements throws.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenSingleAsyncMultipleElements_ThenThrowsInvalidOperation()
+    {
+        const int MultipleElementCount = 3;
+        await Assert.That(static async () => await SignalAsync.Range(1, MultipleElementCount).SingleAsync())
+            .ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleAsync reports an empty source with the no-elements message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAsyncOnEmpty_ThenThrowsInvalidOperation()
+    {
+        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().SingleAsync())
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
+    }
+
+    /// <summary>Tests SingleAsync reports an unmatched predicate with the no-matching-elements message.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleAsyncWithPredicateNoMatch_ThenThrowsInvalidOperationWithMatchingMessage()
+    {
+        var ex = await Assert.That(
+            static async () => await SignalAsync.Range(1, SourceValueCount)
+                .SingleAsync(static x => x > UnmatchableThreshold))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
+    }
+
+    /// <summary>Tests SingleOrDefault on empty returns default.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultOnEmpty_ThenReturnsDefault()
+    {
+        var result = await SignalAsync.Empty<int>().SingleOrDefaultAsync();
+        await Assert.That(result).IsEqualTo(0);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with predicate returns matching element.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithPredicate_ThenReturnsMatchingElement()
+    {
+        const int ExpectedMatch = 3;
+        var result = await SignalAsync.Range(1, SourceValueCount).SingleOrDefaultAsync(static x => x == ExpectedMatch, -1);
+        await Assert.That(result).IsEqualTo(ExpectedMatch);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with predicate and no match returns default value.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
+    {
+        var result = await SignalAsync.Range(1, SourceValueCount).SingleOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
+        await Assert.That(result).IsEqualTo(-1);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with predicate matching multiple elements throws.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithPredicateMultipleMatches_ThenThrowsInvalidOperation()
+    {
+        const int SourceCount = 5;
+        const int Threshold = 2;
+        await Assert
+            .That(static async () =>
+                await SignalAsync.Range(1, SourceCount).SingleOrDefaultAsync(static x => x > Threshold, -1))
+            .ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with no predicate and multiple elements throws.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncMultipleElements_ThenThrowsInvalidOperation()
+    {
+        const int MultipleElementCount = 3;
+        await Assert.That(
+            static async () => await SignalAsync.Range(1, MultipleElementCount).SingleOrDefaultAsync(0))
+            .ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with custom default value on empty returns that default.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithDefaultValueOnEmpty_ThenReturnsCustomDefault()
+    {
+        const int CustomDefault = 99;
+        var result = await SignalAsync.Empty<int>().SingleOrDefaultAsync(CustomDefault);
+        await Assert.That(result).IsEqualTo(CustomDefault);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
+    {
+        var source = SignalAsync.Create<int>(static async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        await Assert.That(async () => await source.SingleOrDefaultAsync()).ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync propagates error from source completing with failure.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncSourceCompletesWithError_ThenThrows()
+    {
+        var source = SignalAsync.Create<int>(static async (observer, _) =>
+        {
+            await observer.OnCompletedAsync(Result.Failure(new InvalidOperationException("fail")));
+            return DisposableAsync.Empty;
+        });
+        await Assert.That(async () => await source.SingleOrDefaultAsync()).ThrowsExactly<InvalidOperationException>();
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync without predicate reports correct message when multiple elements exist.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncMultipleElementsNoPredicate_ThenMessageReportsMoreThanOneElement()
+    {
+        var ex = await Assert.That(
+            static async () => await SignalAsync.Range(1, ShortSourceValueCount).SingleOrDefaultAsync(0))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(MoreThanOneElementMessage);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync with predicate reports correct message when multiple elements match.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task
+        WhenSingleOrDefaultAsyncMultipleMatchesWithPredicate_ThenMessageReportsMoreThanOneMatchingElement()
+    {
+        var ex = await Assert.That(
+            static async () => await SignalAsync.Range(1, SourceValueCount)
+                .SingleOrDefaultAsync(static x => x > MultiMatchThreshold, -1))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo(MoreThanOneMatchingElementMessage);
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync propagates error from OnErrorResumeAsync with the defaultValue overload.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithDefaultValueSourceEmitsErrorResume_ThenThrowsWithCorrectMessage()
+    {
+        InvalidOperationException expectedError = new("resume error detail");
+        var source = SignalAsync.Create<int>(async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(expectedError, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.SingleOrDefaultAsync(0))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo("resume error detail");
+    }
+
+    /// <summary>Tests SingleOrDefaultAsync propagates failure result from OnCompletedAsync with the defaultValue overload.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleOrDefaultAsyncWithDefaultValueSourceCompletesWithFailure_ThenThrowsWithCorrectMessage()
+    {
+        InvalidOperationException expectedError = new("completion failure detail");
+        var source = SignalAsync.Create<int>(async (observer, _) =>
+        {
+            await observer.OnCompletedAsync(Result.Failure(expectedError));
+            return DisposableAsync.Empty;
+        });
+        var ex = await Assert.That(async () => await source.SingleOrDefaultAsync(0))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(ex!.Message).IsEqualTo("completion failure detail");
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.OverloadShortcuts.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.OverloadShortcuts.cs
index 049ab4e3..aa7c36b6 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.OverloadShortcuts.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.OverloadShortcuts.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Direct coverage for the cancellation-token / comparer "shortcut" overloads on the
-/// terminal async operators (<c>CountAsync</c>, <c>LongCountAsync</c>, <c>FirstOrDefaultAsync</c>,
-/// <c>LastOrDefaultAsync</c>, <c>SingleOrDefaultAsync</c>, <c>ContainsAsync</c>). Each shortcut
-/// forwards to the full overload with a defaulted optional argument and was previously uncovered.</summary>
+/// <summary>Tests cancellation-token and comparer overloads of terminal async operators.</summary>
 public partial class TerminalOperatorTests
 {
     /// <summary>Exercises the <c>CountAsync(cancellationToken)</c> overload — the no-predicate
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ReduceCoverage.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ReduceCoverage.cs
index b0bb2d6a..aff9973c 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ReduceCoverage.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.ReduceCoverage.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Coverage tests for ReduceAsync compatibility overloads and async witness failure paths.</summary>
+/// <summary>Tests ReduceAsync compatibility overloads and async witness failures.</summary>
 public partial class TerminalOperatorTests
 {
     /// <summary>Expected sum for the sequence 1, 2, 3.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.cs
index 55cd7a9e..97112c14 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TerminalOperatorTests.cs
@@ -64,511 +64,12 @@ public partial class TerminalOperatorTests
     /// <summary>Divisor of the even-number predicate.</summary>
     private const int EvenDivisor = 2;
 
-    /// <summary>Hoisted source array used by tests (was inline literal).</summary>
+    /// <summary>Strings with distinct lengths for dictionary tests.</summary>
     private static readonly string[] SequenceABbCcc = ["a", "bb", "ccc"];
 
-    /// <summary>Hoisted source array used by tests (was inline literal).</summary>
+    /// <summary>Strings used by key and element selector tests.</summary>
     private static readonly string[] SequenceHelloWorld = ["Hello", "World"];
 
-    /// <summary>Tests FirstAsync returns first element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsync_ThenReturnsFirstElement()
-    {
-        const int ExpectedFirst = 10;
-        var result = await SignalAsync.Range(ExpectedFirst, ShortSourceValueCount).FirstAsync();
-        await Assert.That(result).IsEqualTo(ExpectedFirst);
-    }
-
-    /// <summary>Tests FirstAsync with predicate returns first match.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsyncWithPredicate_ThenReturnsFirstMatch()
-    {
-        const int ExpectedFirstMatch = 4;
-        var result = await SignalAsync.Range(1, SourceValueCount).FirstAsync(static x => x > MatchThreshold);
-        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
-    }
-
-    /// <summary>Tests FirstAsync on empty throws InvalidOperationException with the no-elements
-    /// message — exercises the predicate-null branch of <c>FirstTaskObserver.OnCompletedAsyncCore</c>.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsyncOnEmpty_ThenThrowsInvalidOperation()
-    {
-        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().FirstAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
-    }
-
-    /// <summary>Tests FirstAsync with predicate when no elements match throws InvalidOperationException with matching message.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsyncWithPredicateNoMatch_ThenThrowsInvalidOperationWithMatchingMessage()
-    {
-        var ex = await Assert.That(
-            static async () => await SignalAsync.Range(1, SourceValueCount)
-                .FirstAsync(static x => x > UnmatchableThreshold))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
-    }
-
-    /// <summary>Tests FirstAsync propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsyncSourceEmitsErrorResume_ThenThrowsSourceException()
-    {
-        InvalidOperationException expectedError = new(ResumeErrorMessage);
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.FirstAsync()).ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
-    }
-
-    /// <summary>Tests FirstAsync propagates error when source completes with failure result.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstAsyncSourceCompletesWithFailure_ThenThrowsSourceException()
-    {
-        InvalidOperationException expectedError = new(SourceFailedMessage);
-        var source = SignalAsync.Create<int>(async (observer, _) =>
-        {
-            await observer.OnCompletedAsync(new(expectedError));
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.FirstAsync()).ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
-    }
-
-    /// <summary>Tests FirstOrDefault on empty returns default.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultOnEmpty_ThenReturnsDefault()
-    {
-        var result = await SignalAsync.Empty<int>().FirstOrDefaultAsync();
-        await Assert.That(result).IsEqualTo(0);
-    }
-
-    /// <summary>Tests FirstOrDefault with predicate match returns first.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultWithMatch_ThenReturnsFirst()
-    {
-        const int ExpectedFirstMatch = 4;
-        var result = await SignalAsync.Range(1, SourceValueCount).Where(static x => x > MatchThreshold).FirstOrDefaultAsync(0);
-        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
-    }
-
-    /// <summary>Tests FirstOrDefaultAsync with predicate returns first matching element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultAsyncWithPredicate_ThenReturnsFirstMatch()
-    {
-        const int ExpectedFirstMatch = 4;
-        var result = await SignalAsync.Range(1, SourceValueCount).FirstOrDefaultAsync(static x => x > MatchThreshold, -1);
-        await Assert.That(result).IsEqualTo(ExpectedFirstMatch);
-    }
-
-    /// <summary>Tests FirstOrDefaultAsync with predicate and no match returns specified default value.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
-    {
-        var result = await SignalAsync.Range(1, SourceValueCount).FirstOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
-        await Assert.That(result).IsEqualTo(-1);
-    }
-
-    /// <summary>Tests FirstOrDefaultAsync with predicate propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultAsyncWithPredicateSourceEmitsErrorResume_ThenThrows()
-    {
-        InvalidOperationException expectedError = new(ResumeErrorMessage);
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.FirstOrDefaultAsync(static x => x > 0, -1))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
-    }
-
-    /// <summary>Tests FirstOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenFirstOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
-    {
-        InvalidOperationException expectedError = new(ResumeErrorMessage);
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.FirstOrDefaultAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
-    }
-
-    /// <summary>Tests LastAsync returns last element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsync_ThenReturnsLastElement()
-    {
-        const int ExpectedLast = 5;
-        var result = await SignalAsync.Range(1, SourceValueCount).LastAsync();
-        await Assert.That(result).IsEqualTo(ExpectedLast);
-    }
-
-    /// <summary>Tests LastAsync with predicate returns last match.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncWithPredicate_ThenReturnsLastMatch()
-    {
-        const int ExpectedLastMatch = 3;
-        var result = await SignalAsync.Range(1, SourceValueCount).LastAsync(static x => x < UpperMatchBound);
-        await Assert.That(result).IsEqualTo(ExpectedLastMatch);
-    }
-
-    /// <summary>Tests LastAsync on empty throws.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncOnEmpty_ThenThrowsInvalidOperation() => await Assert
-        .That(static async () => await SignalAsync.Empty<int>().LastAsync())
-        .ThrowsExactly<InvalidOperationException>();
-
-    /// <summary>Tests LastAsync with predicate and no match throws with matching-elements message.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncWithPredicateNoMatch_ThenThrowsWithMatchingMessage()
-    {
-        var ex = await Assert.That(
-            static async () => await SignalAsync.Range(1, SourceValueCount)
-                .LastAsync(static x => x > UnmatchableThreshold))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
-    }
-
-    /// <summary>Tests LastAsync on empty throws with no-elements message.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncOnEmpty_ThenThrowsWithNoElementsMessage()
-    {
-        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().LastAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
-    }
-
-    /// <summary>Tests LastAsync propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncSourceEmitsErrorResume_ThenThrowsSourceException()
-    {
-        InvalidOperationException expectedError = new(ResumeErrorMessage);
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnNextAsync(1, ct);
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.LastAsync()).ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
-    }
-
-    /// <summary>Tests LastAsync propagates error when source completes with failure result.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastAsyncSourceCompletesWithFailure_ThenThrowsSourceException()
-    {
-        InvalidOperationException expectedError = new(SourceFailedMessage);
-        var source = SignalAsync.Create<int>(async (observer, _) =>
-        {
-            await observer.OnCompletedAsync(new(expectedError));
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.LastAsync()).ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
-    }
-
-    /// <summary>Tests LastOrDefault on empty returns default.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultOnEmpty_ThenReturnsDefault()
-    {
-        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync();
-        await Assert.That(result).IsEqualTo(0);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync with predicate returns the last matching element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncWithPredicate_ThenReturnsLastMatch()
-    {
-        const int ExpectedLastMatch = 3;
-        var result = await SignalAsync.Range(1, SourceValueCount).LastOrDefaultAsync(static x => x < UpperMatchBound, -1);
-        await Assert.That(result).IsEqualTo(ExpectedLastMatch);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync with predicate returns default when no elements match.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
-    {
-        var result = await SignalAsync.Range(1, SourceValueCount).LastOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
-        await Assert.That(result).IsEqualTo(-1);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync with predicate on empty returns default value.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncWithPredicateOnEmpty_ThenReturnsDefaultValue()
-    {
-        const int DefaultValue = 42;
-        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync(static _ => true, DefaultValue);
-        await Assert.That(result).IsEqualTo(DefaultValue);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync with custom default value on empty returns that default.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncWithDefaultValueOnEmpty_ThenReturnsCustomDefault()
-    {
-        const int CustomDefault = 99;
-        var result = await SignalAsync.Empty<int>().LastOrDefaultAsync(CustomDefault);
-        await Assert.That(result).IsEqualTo(CustomDefault);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
-    {
-        InvalidOperationException expectedError = new(ResumeErrorMessage);
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnNextAsync(1, ct);
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.LastOrDefaultAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(ResumeErrorMessage);
-    }
-
-    /// <summary>Tests LastOrDefaultAsync propagates error when source completes with failure.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenLastOrDefaultAsyncSourceCompletesWithFailure_ThenThrows()
-    {
-        InvalidOperationException expectedError = new(SourceFailedMessage);
-        var source = SignalAsync.Create<int>(async (observer, _) =>
-        {
-            await observer.OnCompletedAsync(new(expectedError));
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.LastOrDefaultAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(SourceFailedMessage);
-    }
-
-    /// <summary>Tests SingleAsync returns single element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAsync_ThenReturnsSingleElement()
-    {
-        const int SingleValue = 42;
-        var result = await SignalAsync.Return(SingleValue).SingleAsync();
-        await Assert.That(result).IsEqualTo(SingleValue);
-    }
-
-    /// <summary>Tests SingleAsync multiple elements throws.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenSingleAsyncMultipleElements_ThenThrowsInvalidOperation()
-    {
-        const int MultipleElementCount = 3;
-        await Assert.That(static async () => await SignalAsync.Range(1, MultipleElementCount).SingleAsync())
-            .ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleAsync on empty throws — exercises the predicate-null branch of
-    /// <c>SingleElementObserver.OnCompletedAsyncCore</c>'s message construction.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAsyncOnEmpty_ThenThrowsInvalidOperation()
-    {
-        var ex = await Assert.That(static async () => await SignalAsync.Empty<int>().SingleAsync())
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoElementsMessage);
-    }
-
-    /// <summary>Tests SingleAsync with predicate on no-match throws — exercises the
-    /// predicate-non-null branch of <c>SingleElementObserver.OnCompletedAsyncCore</c>.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleAsyncWithPredicateNoMatch_ThenThrowsInvalidOperationWithMatchingMessage()
-    {
-        var ex = await Assert.That(
-            static async () => await SignalAsync.Range(1, SourceValueCount)
-                .SingleAsync(static x => x > UnmatchableThreshold))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(NoMatchingElementsMessage);
-    }
-
-    /// <summary>Tests SingleOrDefault on empty returns default.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultOnEmpty_ThenReturnsDefault()
-    {
-        var result = await SignalAsync.Empty<int>().SingleOrDefaultAsync();
-        await Assert.That(result).IsEqualTo(0);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with predicate returns matching element.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithPredicate_ThenReturnsMatchingElement()
-    {
-        const int ExpectedMatch = 3;
-        var result = await SignalAsync.Range(1, SourceValueCount).SingleOrDefaultAsync(static x => x == ExpectedMatch, -1);
-        await Assert.That(result).IsEqualTo(ExpectedMatch);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with predicate and no match returns default value.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithPredicateNoMatch_ThenReturnsDefaultValue()
-    {
-        var result = await SignalAsync.Range(1, SourceValueCount).SingleOrDefaultAsync(static x => x > UnmatchableThreshold, -1);
-        await Assert.That(result).IsEqualTo(-1);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with predicate matching multiple elements throws.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithPredicateMultipleMatches_ThenThrowsInvalidOperation()
-    {
-        const int SourceCount = 5;
-        const int Threshold = 2;
-        await Assert
-            .That(static async () =>
-                await SignalAsync.Range(1, SourceCount).SingleOrDefaultAsync(static x => x > Threshold, -1))
-            .ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with no predicate and multiple elements throws.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncMultipleElements_ThenThrowsInvalidOperation()
-    {
-        const int MultipleElementCount = 3;
-        await Assert.That(
-            static async () => await SignalAsync.Range(1, MultipleElementCount).SingleOrDefaultAsync(0))
-            .ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with custom default value on empty returns that default.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithDefaultValueOnEmpty_ThenReturnsCustomDefault()
-    {
-        const int CustomDefault = 99;
-        var result = await SignalAsync.Empty<int>().SingleOrDefaultAsync(CustomDefault);
-        await Assert.That(result).IsEqualTo(CustomDefault);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync propagates error from OnErrorResumeAsync.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncSourceEmitsErrorResume_ThenThrows()
-    {
-        var source = SignalAsync.Create<int>(static async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        await Assert.That(async () => await source.SingleOrDefaultAsync()).ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync propagates error from source completing with failure.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncSourceCompletesWithError_ThenThrows()
-    {
-        var source = SignalAsync.Create<int>(static async (observer, _) =>
-        {
-            await observer.OnCompletedAsync(Result.Failure(new InvalidOperationException("fail")));
-            return DisposableAsync.Empty;
-        });
-        await Assert.That(async () => await source.SingleOrDefaultAsync()).ThrowsExactly<InvalidOperationException>();
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync without predicate reports correct message when multiple elements exist.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncMultipleElementsNoPredicate_ThenMessageReportsMoreThanOneElement()
-    {
-        var ex = await Assert.That(
-            static async () => await SignalAsync.Range(1, ShortSourceValueCount).SingleOrDefaultAsync(0))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(MoreThanOneElementMessage);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync with predicate reports correct message when multiple elements match.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task
-        WhenSingleOrDefaultAsyncMultipleMatchesWithPredicate_ThenMessageReportsMoreThanOneMatchingElement()
-    {
-        var ex = await Assert.That(
-            static async () => await SignalAsync.Range(1, SourceValueCount)
-                .SingleOrDefaultAsync(static x => x > MultiMatchThreshold, -1))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo(MoreThanOneMatchingElementMessage);
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync propagates error from OnErrorResumeAsync with the defaultValue overload.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithDefaultValueSourceEmitsErrorResume_ThenThrowsWithCorrectMessage()
-    {
-        InvalidOperationException expectedError = new("resume error detail");
-        var source = SignalAsync.Create<int>(async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(expectedError, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.SingleOrDefaultAsync(0))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo("resume error detail");
-    }
-
-    /// <summary>Tests SingleOrDefaultAsync propagates failure result from OnCompletedAsync with the defaultValue overload.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSingleOrDefaultAsyncWithDefaultValueSourceCompletesWithFailure_ThenThrowsWithCorrectMessage()
-    {
-        InvalidOperationException expectedError = new("completion failure detail");
-        var source = SignalAsync.Create<int>(async (observer, _) =>
-        {
-            await observer.OnCompletedAsync(Result.Failure(expectedError));
-            return DisposableAsync.Empty;
-        });
-        var ex = await Assert.That(async () => await source.SingleOrDefaultAsync(0))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(ex!.Message).IsEqualTo("completion failure detail");
-    }
-
     /// <summary>Tests CountAsync returns element count.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
index 1415c0ca..aa33dac9 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
@@ -2,1021 +2,450 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Async.Signals;
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Tests for time-based operators: Throttle, Delay, Timeout, Timer, Interval.</summary>
+/// <summary>Tests timer-controlled emissions, deadlines, and cancellation.</summary>
 public class TimeBasedOperatorTests
 {
-    /// <summary>Message of the resumable error raised by the source.</summary>
-    private const string TestErrorMessage = "test error";
+    /// <summary>The resumable source failure message.</summary>
+    private const string SourceErrorMessage = "source error";
 
-    /// <summary>Message thrown by an observer from the immediate-fire callback.</summary>
-    private const string ImmediateFireObserverExplodedMessage = "immediate fire observer exploded";
+    /// <summary>The virtual delay requested by the operators.</summary>
+    private static readonly TimeSpan Window = TimeSpan.FromSeconds(1);
 
-    /// <summary>Message thrown by an observer from its completion callback.</summary>
-    private const string CompletionFailedMessage = "completion-failed";
-
-    /// <summary>Expected value42 for assertions.</summary>
-    private const int ExpectedValue42 = 42;
-
-    /// <summary>Fallback value99 (99).</summary>
-    private const int FallbackValue99 = 99;
-
-    /// <summary>Maximum time a test waits for an emission that is expected to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(10);
-
-    /// <summary>Maximum time a test waits for a completion or an unhandled-exception report.</summary>
-    private static readonly TimeSpan CompletionWaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Window given to confirm that no further emissions arrive after disposal.</summary>
-    private static readonly TimeSpan NoFurtherEmissionWindow = TimeSpan.FromMilliseconds(200);
-
-    /// <summary>Throttle window used by the tests that emit a burst and expect one value.</summary>
-    private static readonly TimeSpan BurstThrottleWindow = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>Throttle window used by the tests that wait for the throttled value to land.</summary>
-    private static readonly TimeSpan ThrottleWindow = TimeSpan.FromMilliseconds(50);
-
-    /// <summary>Throttle window used by the custom-time-provider supersede test.</summary>
-    private static readonly TimeSpan CustomProviderThrottleWindow = TimeSpan.FromMilliseconds(80);
-
-    /// <summary>Throttle window long enough for the test to supersede the pending value.</summary>
-    private static readonly TimeSpan SupersedingThrottleWindow = TimeSpan.FromMilliseconds(200);
-
-    /// <summary>Throttle window long enough that an error arrives before the pending value fires.</summary>
-    private static readonly TimeSpan UnfiredThrottleWindow = TimeSpan.FromMilliseconds(500);
-
-    /// <summary>Delay applied to a single emission.</summary>
-    private static readonly TimeSpan EmissionDelay = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>Lower bound the delayed emission's elapsed time must clear.</summary>
-    private static readonly TimeSpan MinimumEmissionDelay = TimeSpan.FromMilliseconds(80);
-
-    /// <summary>Delay applied to every element of a sequence.</summary>
-    private static readonly TimeSpan SequenceDelay = TimeSpan.FromMilliseconds(30);
-
-    /// <summary>Timeout short enough that a never-emitting source trips it.</summary>
-    private static readonly TimeSpan ExpiringTimeout = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>Timeout short enough that a never-emitting source trips it immediately.</summary>
-    private static readonly TimeSpan ImmediateTimeout = TimeSpan.FromMilliseconds(10);
-
-    /// <summary>Timeout long enough that a prompt source never trips it.</summary>
-    private static readonly TimeSpan GenerousTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Timeout long enough that only the source's error can end the wait.</summary>
-    private static readonly TimeSpan NonExpiringTimeout = TimeSpan.FromSeconds(30);
-
-    /// <summary>Interval between the ticks of the periodic-timer tests.</summary>
-    private static readonly TimeSpan TickInterval = TimeSpan.FromMilliseconds(20);
-
-    /// <summary>Interval between the ticks of the cancellation tests.</summary>
-    private static readonly TimeSpan FastTickInterval = TimeSpan.FromMilliseconds(10);
-
-    /// <summary>Tests Throttle only last in burst is emitted.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Only the latest value survives when all pending debounce callbacks run.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottle_ThenOnlyLastInBurstIsEmitted()
+    public async Task WhenThrottleReceivesRapidValues_ThenOnlyEmitsLatest()
     {
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        await using var sub = await signal.Values.Throttle(BurstThrottleWindow).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null);
         const int SecondValue = 2;
-        const int LastValue = 3;
-        await signal.OnNextAsync(1, CancellationToken.None);
-        await signal.OnNextAsync(SecondValue, CancellationToken.None);
-        await signal.OnNextAsync(LastValue, CancellationToken.None);
-        var resultReceived =
-            await AsyncTestHelpers.WaitForConditionAsync(() => results.Count == 1, WaitTimeout);
-        await signal.OnCompletedAsync(Result.Success);
-        await Assert.That(resultReceived).IsTrue();
-        await Assert.That(results).Count().IsEqualTo(1);
-        await Assert.That(results[0]).IsEqualTo(LastValue);
-    }
-
-    /// <summary>Tests Throttle with spaced items all are emitted.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+        const int ThirdValue = 3;
+        ManualTimeProvider time = new();
+        List<int> values = [];
+        CallbackWitnessAsync<int> observer = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await using SignalAsyncExtensions.ThrottleSignal<int>.ThrottleWitness witness = new(observer, Window, time);
+        var firstPending = witness.StartDelayAsync(1, CancellationToken.None);
+        var secondPending = witness.StartDelayAsync(SecondValue, CancellationToken.None);
+        var thirdPending = witness.StartDelayAsync(ThirdValue, CancellationToken.None);
+        var first = await time.NextTimerAsync();
+        var second = await time.NextTimerAsync();
+        var third = await time.NextTimerAsync();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(first.DueTime).IsEqualTo(Window);
+        first.Fire();
+        await firstPending;
+        second.Fire();
+        await secondPending;
+        third.Fire();
+        await thirdPending;
+        await Assert.That(values).IsCollectionEqualTo([ThirdValue]);
+    }
+
+    /// <summary>Each quiet period forwards its own value.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task WhenThrottleWithSpacedItems_ThenAllAreEmitted()
     {
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        TaskCompletionSource<bool> firstReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<bool> secondReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await signal.Values.Throttle(ThrottleWindow).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                if (results.Count == 1)
-                {
-                    IgnoredResult.Of(firstReceived.TrySetResult(true));
-                }
-                else if (results.Count == 2)
-                {
-                    IgnoredResult.Of(secondReceived.TrySetResult(true));
-                }
-
-                return default;
-            },
-            null);
-        const int SpacingDelayMillis = 75;
         const int SecondValue = 2;
-        await signal.OnNextAsync(1, CancellationToken.None);
-        await firstReceived.Task;
-        await Task.Delay(SpacingDelayMillis);
-        await signal.OnNextAsync(SecondValue, CancellationToken.None);
-        await secondReceived.Task;
-        await Assert.That(results).IsCollectionEqualTo([1, SecondValue]);
-    }
-
-    /// <summary>Tests Throttle negative due time throws.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [Test]
-    public void WhenThrottleNegativeDueTime_ThenThrowsArgumentOutOfRange() =>
-        Assert.Throws<ArgumentOutOfRangeException>(
-            static () => SignalAsync.Return(1).Throttle(TimeSpan.FromMilliseconds(-1)));
-
-    /// <summary>Tests Delay elements are time shifted.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDelay_ThenElementsAreTimeShifted()
-    {
-        var start = Stopwatch.GetTimestamp();
-        var result = await SignalAsync.Return(ExpectedValue42).Delay(EmissionDelay).FirstAsync();
-        var elapsed = Stopwatch.GetElapsedTime(start);
-        await Assert.That(result).IsEqualTo(ExpectedValue42);
-        await Assert.That(elapsed).IsGreaterThanOrEqualTo(MinimumEmissionDelay);
-    }
-
-    /// <summary>Tests Delay zero causes no delay.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDelayZero_ThenNoDelay()
-    {
-        var result = await SignalAsync.Return(ExpectedValue42).Delay(TimeSpan.Zero).FirstAsync();
-        await Assert.That(result).IsEqualTo(ExpectedValue42);
-    }
-
-    /// <summary>Tests Delay negative throws.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [Test]
-    public void WhenDelayNegative_ThenThrowsArgumentOutOfRange() =>
-        Assert.Throws<ArgumentOutOfRangeException>(static () => SignalAsync.Return(1).Delay(TimeSpan.FromMilliseconds(-1)));
-
-    /// <summary>Tests Delay sequence delays all elements.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDelaySequence_ThenAllElementsDelayed()
-    {
-        const int ExpectedSecond = 2;
-        const int ExpectedThird = 3;
-        const int SourceValueCount = 3;
-
-        var result = await SignalAsync.Range(1, SourceValueCount).Delay(SequenceDelay).ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-    }
+        ManualTimeProvider time = new();
+        List<int> values = [];
+        CallbackWitnessAsync<int> observer = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await using SignalAsyncExtensions.ThrottleSignal<int>.ThrottleWitness witness = new(observer, Window, time);
+        await time.RunAsync(witness.StartDelayAsync(1, CancellationToken.None));
+        await time.RunAsync(witness.StartDelayAsync(SecondValue, CancellationToken.None));
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue]);
+    }
+
+    /// <summary>Errors, completion, and disposal invalidate pending debounce identifiers.</summary>
+    /// <param name="terminal">The terminal transition to apply.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments("error")]
+    [Arguments("completion")]
+    [Arguments("dispose")]
+    public async Task WhenThrottleTerminated_ThenPendingValueIsDiscarded(string terminal)
+    {
+        ManualTimeProvider time = new();
+        List<int> values = [];
+        List<Exception> errors = [];
+        List<Result> completions = [];
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
+        {
+            values.Add(value);
+            return default;
+        },
+            (error, _) =>
+        {
+            errors.Add(error);
+            return default;
+        },
+            result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        await using SignalAsyncExtensions.ThrottleSignal<int>.ThrottleWitness witness = new(observer, Window, time);
+        var pending = witness.FireAfterDelayAsync(1, 0, CancellationToken.None);
+        InvalidOperationException error = new(SourceErrorMessage);
+        if (terminal == "error")
+        {
+            await witness.OnErrorResumeAsync(error, CancellationToken.None);
+            await Assert.That(errors).Count().IsEqualTo(1);
+            await Assert.That(errors[0]).IsSameReferenceAs(error);
+        }
+        else if (terminal == "completion")
+        {
+            await witness.OnCompletedAsync(Result.Success);
+            await Assert.That(completions).Count().IsEqualTo(1);
+        }
+        else
+        {
+            await witness.DisposeAsync();
+        }
 
-    /// <summary>Tests Timeout not exceeded completes normally.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTimeoutNotExceeded_ThenCompletesNormally()
-    {
-        var result = await SignalAsync.Return(ExpectedValue42).Timeout(GenerousTimeout).FirstAsync();
-        await Assert.That(result).IsEqualTo(ExpectedValue42);
+        await time.RunAsync(pending);
+        await Assert.That(values).IsEmpty();
     }
 
-    /// <summary>Tests Timeout exceeded throws TimeoutException.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Observer failures from delayed emission reach the unhandled exception handler.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenTimeoutExceeded_ThenThrowsTimeoutException()
+    public async Task WhenThrottleOnNextThrows_ThenRoutedToUnhandledExceptionHandler()
     {
-        var source = SignalAsync.Never<int>().Timeout(ExpiringTimeout);
-        await Assert.That(async () => await source.FirstAsync()).ThrowsExactly<TimeoutException>();
+        ManualTimeProvider time = new();
+        using UnhandledExceptionCapture capture = new();
+        CallbackWitnessAsync<int> observer = new(static (_, _) => throw new InvalidOperationException("observer failed"));
+        await using SignalAsyncExtensions.ThrottleSignal<int>.ThrottleWitness witness = new(observer, Window, time);
+        await time.RunAsync(witness.FireAfterDelayAsync(1, 0, CancellationToken.None));
+        var exception = await capture.WaitForAsync("observer failed");
+        await Assert.That(exception).IsTypeOf<InvalidOperationException>();
     }
 
-    /// <summary>Tests Timeout with fallback switches to fallback.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Cancellation of a pending debounce delay does not report an unhandled failure.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenTimeoutWithFallback_ThenSwitchesToFallback()
+    public async Task WhenThrottleDelayCancelled_ThenNoValueIsForwarded()
     {
-        var source = SignalAsync.Never<int>().Timeout(ExpiringTimeout, SignalAsync.Return(FallbackValue99));
-        var result = await source.FirstAsync();
-        await Assert.That(result).IsEqualTo(FallbackValue99);
+        ManualTimeProvider time = new();
+        using CancellationTokenSource cancellation = new();
+        List<int> values = [];
+        CallbackWitnessAsync<int> observer = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await using SignalAsyncExtensions.ThrottleSignal<int>.ThrottleWitness witness = new(observer, Window, time);
+        var pending = witness.FireAfterDelayAsync(1, 0, cancellation.Token);
+        await cancellation.CancelAsync();
+        await pending;
+        await Assert.That(values).IsEmpty();
     }
 
-    /// <summary>Tests Timeout zero duration throws.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    /// <summary>An element stays pending until its registered delay fires.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public void WhenTimeoutZeroDuration_ThenThrowsArgumentOutOfRange() =>
-        Assert.Throws<ArgumentOutOfRangeException>(static () => SignalAsync.Return(1).Timeout(TimeSpan.Zero));
-
-    /// <summary>Tests Timeout negative duration throws.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [Test]
-    public void WhenTimeoutNegativeDuration_ThenThrowsArgumentOutOfRange() =>
-        Assert.Throws<ArgumentOutOfRangeException>(
-            static () => SignalAsync.Return(1).Timeout(TimeSpan.FromMilliseconds(-1)));
-
-    /// <summary>Tests Timeout with null fallback throws.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [Test]
-    public void WhenTimeoutWithFallbackNull_ThenThrowsArgumentNull() => Assert.Throws<ArgumentNullException>(
-        static () => SignalAsync.Return(1).Timeout(TimeSpan.FromSeconds(1), (IObservableAsync<int>)null!));
-
-    /// <summary>
-    /// Verifies that when the downstream observer throws a non-cancellation exception
-    /// during OnNext from a throttled delay callback, the exception is routed to the
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// This covers the Throttle exception routing path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenThrottleOnNextThrows_ThenRoutedToUnhandledExceptionHandler()
+    public async Task WhenDelay_ThenElementsAreTimeShifted()
     {
-        using UnhandledExceptionCapture unhandled = new();
-        var signal = Signal.Create<int>();
-        await using var sub = await signal.Values.Throttle(ThrottleWindow)
-            .SubscribeAsync(static (_, _) => throw new InvalidOperationException("observer exploded"), null);
-        await signal.OnNextAsync(ExpectedValue42, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync("observer exploded", WaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
+        const int ExpectedValue = 42;
+        ManualTimeProvider time = new();
+        var result = SignalAsync.Return(ExpectedValue).Delay(Window, time).FirstAsync().AsTask();
+        var timer = await time.NextTimerAsync();
+        await Assert.That(result.IsCompleted).IsFalse();
+        await Assert.That(timer.DueTime).IsEqualTo(Window);
+        timer.Fire();
+        await Assert.That(await result).IsEqualTo(ExpectedValue);
     }
 
-    /// <summary>
-    /// Verifies that when the downstream observer throws a non-cancellation exception
-    /// during OnCompleted from a timeout callback, the exception is routed to the
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// This covers the Timeout OnCompleted exception routing path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Every element requests its own delay and preserves source order.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenTimeoutOnCompletedThrows_ThenRoutedToUnhandledExceptionHandler()
+    public async Task WhenDelaySequence_ThenAllElementsDelayed()
     {
-        using UnhandledExceptionCapture unhandled = new();
-        var source = SignalAsync.Never<int>().Timeout(ThrottleWindow);
-        await using var sub = await source.SubscribeAsync(
-            static (_, _) => default,
-            null,
-            static _ => throw new InvalidOperationException("completion handler exploded"));
-        var exception = await unhandled.WaitForAsync("completion handler exploded", WaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
+        const int ThirdValue = 3;
+        const int SecondValue = 2;
+        ManualTimeProvider time = new();
+        var result = await time.RunAsync(SignalAsync.Range(1, ThirdValue).Delay(Window, time).ToListAsync().AsTask());
+        await Assert.That(result).IsCollectionEqualTo([1, SecondValue, ThirdValue]);
     }
 
-    /// <summary>
-    /// Verifies that <see cref = "SignalAsync.Interval(TimeSpan, TimeProvider? )"/>
-    /// uses the custom <see cref = "TimeProvider"/> path when a non-system provider is supplied.
-    /// This covers the Interval TimeProvider code path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>A zero delay preserves the original source instance.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenIntervalWithNonSystemTimeProvider_ThenUsesTimerPath()
+    public async Task WhenDelayZero_ThenNoDelay()
     {
-        CustomTimeProvider customProvider = new();
-        List<long> results = [];
-        await using var sub = await SignalAsync.Interval(ThrottleWindow, customProvider).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null);
-        var receivedTwo =
-            await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 2, WaitTimeout);
-        const long ExpectedSecondTick = 2L;
-        await Assert.That(receivedTwo).IsTrue();
-        await Assert.That(results[0]).IsEqualTo(1L);
-        await Assert.That(results[1]).IsEqualTo(ExpectedSecondTick);
+        const int ExpectedValue = 42;
+        var source = SignalAsync.Return(ExpectedValue);
+        await Assert.That(source.Delay(TimeSpan.Zero)).IsSameReferenceAs(source);
+        await Assert.That(await source.Delay(TimeSpan.Zero).FirstAsync()).IsEqualTo(ExpectedValue);
     }
 
-    /// <summary>
-    /// Verifies that a periodic <see cref = "SignalAsync.Timer(TimeSpan, TimeSpan, TimeProvider? )"/>
-    /// stops emitting values once the subscription is disposed.
-    /// This covers the cancellation loop exit in the periodic timer.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Resumable errors pass through delay without creating a timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenPeriodicTimerCancelled_ThenStopsEmitting()
+    public async Task WhenDelaySourceEmitsErrorResume_ThenErrorForwarded()
     {
-        List<long> results = [];
-        var sub = await SignalAsync.Timer(TimeSpan.Zero, ThrottleWindow).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null);
-        var receivedTwo =
-            await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 2, WaitTimeout);
-        await Assert.That(receivedTwo).IsTrue();
-        var countAtDispose = results.Count;
-        await sub.DisposeAsync();
-
-        // Allow a brief window to confirm no further emissions
-        var noMoreEmissions = await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count == countAtDispose,
-            NoFurtherEmissionWindow);
-        await Assert.That(noMoreEmissions).IsTrue();
+        ManualTimeProvider time = new();
+        var source = Signal.Create<int>();
+        Exception? actual = null;
+        await using var subscription = await source.Values.Delay(Window, time).SubscribeAsync(static (_, _) => default, (error, _) =>
+        {
+            actual = error;
+            return default;
+        });
+        InvalidOperationException expected = new(SourceErrorMessage);
+        await source.OnErrorResumeAsync(expected, CancellationToken.None);
+        await Assert.That(actual).IsSameReferenceAs(expected);
     }
 
-    /// <summary>
-    /// Verifies that <see cref = "SignalAsyncExtensions.Throttle{T}(IObservableAsync{T}, TimeSpan, TimeProvider? )"/> uses the non-system
-    /// <see cref = "TimeProvider"/> code path in <c>DelayAsync</c> when a
-    /// custom provider is supplied, and still correctly debounces values.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>A source that completes before its deadline preserves its values.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleWithCustomTimeProvider_ThenUsesTimerPath()
+    public async Task WhenTimeoutNotExceeded_ThenCompletesNormally()
     {
-        CustomTimeProvider customProvider = new();
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        TaskCompletionSource<bool> resultReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await signal.Values.Throttle(ThrottleWindow, customProvider)
-            .SubscribeAsync(
-                (x, _) =>
-                {
-                    results.Add(x);
-                    IgnoredResult.Of(resultReceived.TrySetResult(true));
-                    return default;
-                },
-                null);
+        const int ThirdValue = 3;
         const int SecondValue = 2;
-        const int LastValue = 3;
-        await signal.OnNextAsync(1, CancellationToken.None);
-        await signal.OnNextAsync(SecondValue, CancellationToken.None);
-        await signal.OnNextAsync(LastValue, CancellationToken.None);
-        await resultReceived.Task;
-        await signal.OnCompletedAsync(Result.Success);
-        await Assert.That(results).Count().IsEqualTo(1);
-        await Assert.That(results[0]).IsEqualTo(LastValue);
+        ManualTimeProvider time = new();
+        var values = await SignalAsync.Range(1, ThirdValue).Timeout(Window, time).ToListAsync();
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue, ThirdValue]);
     }
 
-    /// <summary>
-    /// Verifies that when two values are emitted in quick succession with a custom
-    /// <see cref = "TimeProvider"/>, the first value is superseded and only
-    /// the second is forwarded, exercising the non-system <c>DelayAsync</c> path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Firing the deadline fails a source that has not emitted.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleWithCustomTimeProviderValueSuperseded_ThenOlderValueDropped()
+    public async Task WhenTimeoutExceeded_ThenThrowsTimeoutException()
     {
-        CustomTimeProvider customProvider = new();
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        TaskCompletionSource<bool> resultReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await signal.Values.Throttle(CustomProviderThrottleWindow, customProvider)
-            .SubscribeAsync(
-                (x, _) =>
-                {
-                    results.Add(x);
-                    IgnoredResult.Of(resultReceived.TrySetResult(true));
-                    return default;
-                },
-                null);
-        const int FirstValue = 10;
-        const int LastValue = 20;
-
-        // Emit two values rapidly; first should be superseded
-        await signal.OnNextAsync(FirstValue, CancellationToken.None);
-        await signal.OnNextAsync(LastValue, CancellationToken.None);
-        await resultReceived.Task;
-        await signal.OnCompletedAsync(Result.Success);
-        await Assert.That(results).Count().IsEqualTo(1);
-        await Assert.That(results[0]).IsEqualTo(LastValue);
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Never<int>().Timeout(Window, time).FirstAsync().AsTask();
+        await Assert.That(pending.IsCompleted).IsFalse();
+        await time.FireNextAsync();
+        await Assert.That(() => pending).ThrowsExactly<TimeoutException>();
     }
 
-    /// <summary>
-    /// Verifies that when the downstream observer throws during a throttled emission
-    /// with a custom <see cref = "TimeProvider"/>, the exception is routed to
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>A fired deadline subscribes to the fallback source.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleWithCustomTimeProviderOnNextThrows_ThenRoutedToUnhandledExceptionHandler()
+    public async Task WhenTimeoutWithFallback_ThenSwitchesToFallback()
     {
-        using UnhandledExceptionCapture unhandled = new();
-        CustomTimeProvider customProvider = new();
-        var signal = Signal.Create<int>();
-        await using var sub = await signal.Values.Throttle(ThrottleWindow, customProvider)
-            .SubscribeAsync(
-                static (_, _) => throw new InvalidOperationException("custom provider observer exploded"),
-                null);
-        await signal.OnNextAsync(1, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync("custom provider observer exploded", WaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
+        const int FallbackValue = 99;
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Never<int>().Timeout(Window, SignalAsync.Return(FallbackValue), time).FirstAsync().AsTask();
+        await time.FireNextAsync();
+        await Assert.That(await pending).IsEqualTo(FallbackValue);
     }
 
-    /// <summary>
-    /// Verifies that when <c>OnErrorResumeAsync</c> is called on a throttled sequence,
-    /// the pending timer is cancelled and the error is forwarded to the downstream observer
-    /// in the Throttle operator.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Each value rearms the same deadline timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleOnErrorResume_ThenCancelsTimerAndForwardsError()
-    {
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        List<Exception> errors = [];
-        TaskCompletionSource<bool> errorReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await signal.Values.Throttle(UnfiredThrottleWindow).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            (ex, _) =>
-            {
-                errors.Add(ex);
-                IgnoredResult.Of(errorReceived.TrySetResult(true));
-                return default;
-            });
-
-        // Emit a value (starts a 500ms timer)
-        await signal.OnNextAsync(1, CancellationToken.None);
-
-        // Immediately send an error before the throttle timer fires
-        await signal.OnErrorResumeAsync(new InvalidOperationException(TestErrorMessage), CancellationToken.None);
-        await errorReceived.Task;
-
-        // Error should be forwarded, and the pending value should NOT be emitted
-        await Assert.That(errors).Count().IsEqualTo(1);
-        await Assert.That(errors[0]).IsTypeOf<InvalidOperationException>();
-        await Assert.That(results).Count().IsEqualTo(0);
-    }
-
-    /// <summary>
-    /// Verifies that when the <see cref = "TimeProvider"/> throws a non-cancellation exception
-    /// during the delay inside <c>OnTimeoutAsync</c>, the exception is routed to the
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// This covers the Timeout delay exception routing path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTimeoutDelayThrowsNonCancellation_ThenRoutedToUnhandledExceptionHandler()
+    public async Task WhenTimeoutResetsOnValue_ThenDoesNotFire()
     {
-        using UnhandledExceptionCapture unhandled = new();
-        ThrowingTimeProvider throwingProvider = new();
-        DirectSource<int> source = new();
-        await using var sub = await source.Timeout(ExpiringTimeout, throwingProvider)
-            .SubscribeAsync(static (_, _) => default, null);
-        var exception = await unhandled.WaitForAsync("timer creation failed", WaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
-    }
-
-    /// <summary>
-    /// Verifies that when the source emits an error via <c>OnErrorResumeAsync</c>,
-    /// the <c>TimeoutWitness</c> cancels the timer and forwards the error downstream.
-    /// This covers the <c>OnErrorResumeAsyncCore</c> path in the Timeout operator.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+        const int SecondValue = 2;
+        ManualTimeProvider time = new();
+        var source = Signal.Create<int>();
+        List<int> values = [];
+        await using var subscription = await source.Values.Timeout(Window, time).SubscribeAsync((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        var timer = await time.NextTimerAsync();
+        await source.OnNextAsync(1, CancellationToken.None);
+        await Assert.That(timer.DueTime).IsEqualTo(Window);
+        await source.OnNextAsync(SecondValue, CancellationToken.None);
+        await Assert.That(timer.DueTime).IsEqualTo(Window);
+        await source.OnCompletedAsync(Result.Success);
+        await Assert.That(timer.DueTime).IsEqualTo(Timeout.InfiniteTimeSpan);
+        timer.Fire();
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue]);
+    }
+
+    /// <summary>A resumable source error disables the deadline and reaches the observer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task WhenTimeoutSourceEmitsErrorResume_ThenForwardsAndCancelsTimer()
     {
-        List<Exception> errors = [];
-        TaskCompletionSource<bool> errorReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        DirectSource<int> source = new();
-        await using var sub = await source.Timeout(NonExpiringTimeout).SubscribeAsync(
-            static (_, _) => default,
-            (ex, _) =>
-            {
-                errors.Add(ex);
-                IgnoredResult.Of(errorReceived.TrySetResult(true));
-                return default;
-            });
-        InvalidOperationException testError = new(TestErrorMessage);
-        await source.EmitError(testError);
-        await errorReceived.Task;
-        await Assert.That(errors).Count().IsEqualTo(1);
-        await Assert.That(errors[0]).IsTypeOf<InvalidOperationException>();
-        await Assert.That(errors[0].Message).IsEqualTo(TestErrorMessage);
-    }
-
-    /// <summary>
-    /// Verifies that Delay forwards non-terminal errors via OnErrorResumeAsync.
-    /// Covers the OnErrorResumeAsyncCore path in DelayObserver.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDelaySourceEmitsErrorResume_ThenErrorForwarded()
-    {
-        DirectSource<int> source = new();
-        List<Exception> errors = [];
-        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await source.Delay(TimeSpan.FromMilliseconds(1)).SubscribeAsync(
-            static (_, _) => default,
-            (ex, _) =>
-            {
-                errors.Add(ex);
-                return default;
-            },
-            _ =>
-            {
-                IgnoredResult.Of(completed.TrySetResult());
-                return default;
-            });
-        InvalidOperationException expectedError = new("resume error");
-        await source.EmitError(expectedError);
-        await source.Complete(Result.Success);
-        await completed.Task;
-        await Assert.That(errors).Count().IsEqualTo(1);
-        await Assert.That(errors[0]).IsSameReferenceAs(expectedError);
+        ManualTimeProvider time = new();
+        var source = Signal.Create<int>();
+        Exception? actual = null;
+        await using var subscription = await source.Values.Timeout(Window, time).SubscribeAsync(static (_, _) => default, (error, _) =>
+        {
+            actual = error;
+            return default;
+        });
+        var timer = await time.NextTimerAsync();
+        InvalidOperationException expected = new(SourceErrorMessage);
+        await source.OnErrorResumeAsync(expected, CancellationToken.None);
+        await Assert.That(actual).IsSameReferenceAs(expected);
+        await Assert.That(timer.DueTime).IsEqualTo(Timeout.InfiniteTimeSpan);
     }
 
-    /// <summary>
-    /// Verifies that Throttle drops a value when superseded by a newer emission,
-    /// exercising the id-mismatch early return in FireAfterDelayAsync.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Deadline completion failures reach the unhandled exception handler.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleValueSuperseded_ThenOlderValueDropped()
+    public async Task WhenTimeoutOnCompletedThrows_ThenRoutedToUnhandledExceptionHandler()
     {
-        var signal = Signal.Create<int>();
-        List<int> results = [];
-        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await signal.Values.Throttle(SupersedingThrottleWindow).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null,
-            _ =>
-            {
-                IgnoredResult.Of(completed.TrySetResult());
-                return default;
-            });
-        const int LastValue = 2;
-
-        // Emit two values in rapid succession; first should be superseded
-        await signal.OnNextAsync(1, CancellationToken.None);
-        await signal.OnNextAsync(LastValue, CancellationToken.None);
-
-        // Wait for the throttled value to arrive before completing
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 1, CompletionWaitTimeout);
-        await signal.OnCompletedAsync(Result.Success);
-        await completed.Task;
-
-        // Only the last value (2) should have been emitted
-        await Assert.That(results).Contains(LastValue);
+        ManualTimeProvider time = new();
+        using UnhandledExceptionCapture capture = new();
+        await using var subscription = await SignalAsync.Never<int>().Timeout(Window, time).SubscribeAsync(
+            new ThrowingCompletionWitness(),
+            CancellationToken.None);
+        await time.FireNextAsync();
+        await Assert.That(await capture.WaitForAsync("completion failed")).IsTypeOf<InvalidOperationException>();
     }
 
-    /// <summary>
-    /// Verifies that Throttle routes non-cancellation exceptions to the unhandled exception handler.
-    /// Covers the catch(Exception) block in ThrottleWitness.FireAfterDelayAsync.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Failure to create a deadline timer is reported without failing subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleFireThrowsNonCancellation_ThenRoutedToUnhandledHandler()
+    public async Task WhenTimeoutDelayThrowsNonCancellation_ThenRoutedToUnhandledExceptionHandler()
     {
-        using UnhandledExceptionCapture unhandled = new();
-        InvalidOperationException expectedError = new("downstream error");
-        DirectSource<int> source = new();
-        await using var sub = await source.Throttle(TimeSpan.FromMilliseconds(1))
-            .SubscribeAsync((_, _) => throw expectedError, null);
-        await source.EmitNext(1);
-        var exception = await unhandled.WaitForAsync("downstream error", CompletionWaitTimeout);
-        await Assert.That(exception).IsNotNull();
+        using UnhandledExceptionCapture capture = new();
+        await using var subscription = await SignalAsync.Never<int>().Timeout(Window, new ThrowingTimeProvider()).SubscribeAsync(static (_, _) => default);
+        await Assert.That(await capture.WaitForAsync("timer creation failed")).IsTypeOf<InvalidOperationException>();
     }
 
-    /// <summary>
-    /// Verifies that a periodic Timer emits multiple ticks before cancellation.
-    /// Covers the while-loop body in the periodic Timer factory.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Periodic timers emit zero-based ticks only when their delays are fired.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task WhenPeriodicTimerEmitsMultipleTicks_ThenAllTicksReceived()
     {
-        List<long> results = [];
-        var sub = await SignalAsync.Timer(TimeSpan.Zero, TickInterval).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null);
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 3, WaitTimeout);
-        await sub.DisposeAsync();
-        const int MinTickCount = 3;
-        const int ThirdTickIndex = 2;
-        const long ExpectedThirdTick = 2L;
-        await Assert.That(results.Count).IsGreaterThanOrEqualTo(MinTickCount);
-        await Assert.That(results[0]).IsEqualTo(0L);
-        await Assert.That(results[1]).IsEqualTo(1L);
-        await Assert.That(results[ThirdTickIndex]).IsEqualTo(ExpectedThirdTick);
+        const int ThirdValue = 3;
+        const long SecondTick = 2L;
+        ManualTimeProvider time = new();
+        var pending = SignalAsync.Timer(Window, Window, time).Take(ThirdValue).ToListAsync().AsTask();
+        var values = await time.RunAsync(pending);
+        await Assert.That(values).IsCollectionEqualTo([0L, 1L, SecondTick]);
     }
 
-    /// <summary>
-    /// Verifies that a periodic <see cref = "SignalAsync.Timer(TimeSpan, TimeSpan, TimeProvider? )"/>
-    /// with a custom <see cref = "TimeProvider"/> emits at least two ticks before disposal,
-    /// exercising the loop continuation on line 90 of Timer.cs through the non-system delay path.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Disposing a pending timer prevents the registered callback from emitting.</summary>
+    /// <param name="interval">Whether to use the interval factory.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenPeriodicTimerWithCustomTimeProvider_ThenLoopContinuesUntilDisposed()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenPeriodicTimerCancelled_ThenStopsEmitting(bool interval)
     {
-        CustomTimeProvider customProvider = new();
-        List<long> results = [];
-        var sub = await SignalAsync.Timer(TimeSpan.Zero, TickInterval, customProvider).SubscribeAsync(
-            (x, _) =>
-            {
-                results.Add(x);
-                return default;
-            },
-            null);
-        var receivedTwo =
-            await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 2, WaitTimeout);
-        await Assert.That(receivedTwo).IsTrue();
-        var countAtDispose = results.Count;
-        await sub.DisposeAsync();
-        var noMoreEmissions = await AsyncTestHelpers.WaitForConditionAsync(
-            () => results.Count == countAtDispose,
-            NoFurtherEmissionWindow);
-        await Assert.That(noMoreEmissions).IsTrue();
-        await Assert.That(results[0]).IsEqualTo(0L);
-        await Assert.That(results[1]).IsEqualTo(1L);
-    }
-
-    /// <summary>
-    /// Verifies that when the downstream observer throws a non-cancellation exception
-    /// during OnNext from a throttled emission using an immediate-fire
-    /// <see cref = "TimeProvider"/>, the exception is routed to the
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// This deterministically covers lines 162-163 in ThrottleWitness.FireAfterDelayAsync.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenThrottleImmediateFireOnNextThrows_ThenRoutedToUnhandledExceptionHandler()
-    {
-        using UnhandledExceptionCapture unhandled = new();
-        ImmediateFireTimeProvider immediateProvider = new();
-        var signal = Signal.Create<int>();
-        await using var sub = await signal.Values.Throttle(BurstThrottleWindow, immediateProvider)
-            .SubscribeAsync(
-                static (_, _) => throw new InvalidOperationException(ImmediateFireObserverExplodedMessage),
-                null);
-        await signal.OnNextAsync(1, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(ImmediateFireObserverExplodedMessage, CompletionWaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
-        await Assert.That(exception!.Message).IsEqualTo(ImmediateFireObserverExplodedMessage);
-    }
-
-    /// <summary>Tests Interval stops when cancelled.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenIntervalCancelled_ThenStops()
-    {
-        const int MinItemCount = 2;
-        CancellationTokenSource cts = new();
-        List<long> items = [];
-        TaskCompletionSource cancelled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await SignalAsync.Interval(FastTickInterval).SubscribeAsync(
-            async (x, _) =>
-            {
-                items.Add(x);
-                if (x < MinItemCount)
-                {
-                    return;
-                }
-
-                await cts.CancelAsync();
-                IgnoredResult.Of(cancelled.TrySetResult());
-            },
-            null,
-            null,
-            cts.Token);
-        await cancelled.Task;
-        await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinItemCount);
-    }
-
-    /// <summary>Tests Timer with period stops when cancelled.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTimerWithPeriodCancelled_ThenStops()
-    {
-        const int MinItemCount = 2;
-        CancellationTokenSource cts = new();
-        List<long> items = [];
-        TaskCompletionSource cancelled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await SignalAsync.Timer(TimeSpan.FromMilliseconds(1), FastTickInterval)
-            .SubscribeAsync(
-                async (x, _) =>
-                {
-                    items.Add(x);
-                    if (x < MinItemCount)
-                    {
-                        return;
-                    }
-
-                    await cts.CancelAsync();
-                    IgnoredResult.Of(cancelled.TrySetResult());
-                },
-                null,
-                null,
-                cts.Token);
-        await cancelled.Task;
-        await Assert.That(items.Count).IsGreaterThanOrEqualTo(MinItemCount);
-    }
-
-    /// <summary>Tests Throttle supersedes older values and only emits latest.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+        ManualTimeProvider time = new();
+        List<long> values = [];
+        var source = interval ? SignalAsync.Interval(Window, time) : SignalAsync.Timer(Window, Window, time);
+        var subscription = await source.SubscribeAsync((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        var timer = await time.NextTimerAsync();
+        await subscription.DisposeAsync();
+        timer.Fire();
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Cancellation completes a pending periodic delay and suppresses its registered callback.</summary>
+    /// <param name="interval">Whether to use the interval subscription.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task WhenPeriodicSubscriptionCancelled_ThenPendingTickIsSuppressed(bool interval)
+    {
+        ManualTimeProvider time = new();
+        using CancellationTokenSource cancellation = new();
+        List<long> values = [];
+        CallbackWitnessAsync<long> observer = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        await using TaskSignalSubscription<long> subscription = interval
+            ? new IntervalSubscription(observer, Window, time)
+            : new TimerSubscription(observer, Window, Window, time);
+        var execution = subscription.ExecuteAsync(cancellation.Token).AsTask();
+        await time.FireNextAsync();
+        var pendingTimer = await time.NextTimerAsync();
+        await cancellation.CancelAsync();
+        await execution;
+        pendingTimer.Fire();
+        await Assert.That(values).IsCollectionEqualTo([interval ? 1L : 0L]);
+    }
+
+    /// <summary>Intervals emit consecutive values starting at one.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenThrottleReceivesRapidValues_ThenOnlyEmitsLatest()
+    public async Task WhenIntervalWithNonSystemTimeProvider_ThenUsesTimerPath()
     {
         const int SecondValue = 2;
-        const int LastValue = 3;
-        ManualTimeProvider manualProvider = new();
-        DirectSource<int> source = new();
-        List<int> items = [];
-        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await source.Throttle(ThrottleWindow, manualProvider).SubscribeAsync(
-            async (x, ct) =>
-            {
-                _ = ct;
-                items.Add(x);
-
-                // Drive completion re-entrantly from the throttled emission itself. The emission
-                // runs on a pooled timer continuation; completing the source from the test thread
-                // would race that still-unwinding OnNext call and trip the witness's concurrent-call
-                // guard, silently dropping the completion. Completing from inside the handler keeps
-                // both notifications on the same thread, where re-entrant calls are permitted.
-                if (x == LastValue)
-                {
-                    await source.Complete(Result.Success);
-                }
-            },
-            null,
-            _ =>
-            {
-                IgnoredResult.Of(completed.TrySetResult());
-                return default;
-            });
-        await source.EmitNext(1);
-        await source.EmitNext(SecondValue);
-        await source.EmitNext(LastValue);
-
-        await Assert.That(manualProvider.TimerCount).IsEqualTo(LastValue);
-        manualProvider.FireAll();
-        await completed.Task;
-        await Assert.That(items).Contains(LastValue);
+        const long SecondTick = 2L;
+        ManualTimeProvider time = new();
+        var values = await time.RunAsync(SignalAsync.Interval(Window, time).Take(SecondValue).ToListAsync().AsTask());
+        await Assert.That(values).IsCollectionEqualTo([1L, SecondTick]);
     }
 
-    /// <summary>Tests Timeout fires when source is slow.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>The default-provider overload constructs a throttle signal without starting a timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenTimeoutFires_ThenThrowsTimeoutException() => await Assert
-        .That(static async () => await SignalAsync.Never<int>().Timeout(ImmediateTimeout).FirstAsync())
-        .ThrowsExactly<TimeoutException>();
+    public async Task WhenThrottleUsesDefaultProvider_ThenCreatesThrottleSignal() =>
+        await Assert.That(SignalAsync.Return(1).Throttle(Window)).IsTypeOf<SignalAsyncExtensions.ThrottleSignal<int>>();
 
-    /// <summary>Tests Timeout with fallback observable.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Negative debounce intervals are rejected.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
-    public async Task WhenTimeoutWithFallback_ThenFallbackUsed()
-    {
-        var result = await SignalAsync.Never<int>().Timeout(ImmediateTimeout, SignalAsync.Return(FallbackValue99))
-            .FirstAsync();
-        await Assert.That(result).IsEqualTo(FallbackValue99);
-    }
+    public void WhenThrottleNegativeDueTime_ThenThrowsArgumentOutOfRange() =>
+        Assert.Throws<ArgumentOutOfRangeException>(static () => SignalAsync.Return(1).Throttle(TimeSpan.FromTicks(-1)));
 
-    /// <summary>Tests Timeout resets on each value and does not fire.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Negative delays are rejected.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
-    public async Task WhenTimeoutResetsOnValue_ThenDoesNotFire()
-    {
-        const int ExpectedSecond = 2;
-        const int ExpectedThird = 3;
-        const int SourceValueCount = 3;
-
-        var result = await SignalAsync.Range(1, SourceValueCount).Timeout(GenerousTimeout).ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-    }
+    public void WhenDelayNegative_ThenThrowsArgumentOutOfRange() =>
+        Assert.Throws<ArgumentOutOfRangeException>(static () => SignalAsync.Return(1).Delay(TimeSpan.FromTicks(-1)));
 
-    /// <summary>Verifies that an exception thrown by the downstream observer's <c>OnCompletedAsync</c> during a <c>Timeout</c> firing is routed to <see cref = "UnhandledExceptionHandler"/>.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Deadlines require a positive interval.</summary>
+    /// <param name="ticks">The invalid interval in ticks.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
-    public async Task WhenTimeoutFiresAndDownstreamCompletionThrows_ThenRoutedToUnhandled()
-    {
-        using UnhandledExceptionCapture unhandled = new();
-        TimeoutThrowingWitness<int> throwing = new(new InvalidOperationException(CompletionFailedMessage));
-        await using var sub = await SignalAsync.Never<int>().Timeout(TimeSpan.FromMilliseconds(1))
-            .SubscribeAsync(throwing, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(CompletionFailedMessage, CompletionWaitTimeout);
-        await Assert.That(exception).IsNotNull();
-        await Assert.That(exception!.Message).IsEqualTo(CompletionFailedMessage);
-    }
-
-    /// <summary>
-    /// A custom <see cref = "TimeProvider"/> that delegates timer creation to the system provider.
-    /// Used to exercise the non-system <see cref = "TimeProvider"/> code paths in Interval and Timer operators.
-    /// </summary>
-    private sealed class CustomTimeProvider : TimeProvider
-    {
-        /// <summary>Creates a timer by delegating to the system <see cref = "TimeProvider"/>.</summary>
-        /// <param name = "callback">The callback to invoke when the timer fires.</param>
-        /// <param name = "state">The state object passed to the callback.</param>
-        /// <param name = "dueTime">The initial delay before the first invocation.</param>
-        /// <param name = "period">The interval between subsequent invocations.</param>
-        /// <returns>An <see cref = "ITimer"/> instance.</returns>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
-            System.CreateTimer(callback, state, dueTime, period);
-    }
+    [Arguments(0L)]
+    [Arguments(-1L)]
+    public void WhenTimeoutNonPositive_ThenThrowsArgumentOutOfRange(long ticks) =>
+        Assert.Throws<ArgumentOutOfRangeException>(() => SignalAsync.Return(1).Timeout(TimeSpan.FromTicks(ticks)));
 
-    /// <summary>A <see cref = "TimeProvider"/> that throws from <see cref = "CreateTimer"/> to exercise the non-cancellation catch.</summary>
-    private sealed class ThrowingTimeProvider : TimeProvider
-    {
-        /// <summary>Throws an <see cref = "InvalidOperationException"/> instead of creating a timer.</summary>
-        /// <param name = "callback">The callback (unused).</param>
-        /// <param name = "state">The state (unused).</param>
-        /// <param name = "dueTime">The due time (unused).</param>
-        /// <param name = "period">The period (unused).</param>
-        /// <returns>Never returns; always throws.</returns>
-        /// <exception cref = "InvalidOperationException">Always thrown.</exception>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
-            throw new InvalidOperationException("timer creation failed");
-    }
-
-    /// <summary>A <see cref = "TimeProvider"/> that records one-shot timers and exposes an explicit fire point for deterministic debounce supersession tests.</summary>
-    private sealed class ManualTimeProvider : TimeProvider
-    {
-        /// <summary>Protects timer collection access.</summary>
-        private readonly Lock _gate = new();
-
-        /// <summary>The timers created by this provider.</summary>
-        private readonly List<ManualTimer> _timers = [];
-
-        /// <summary>Gets the number of timers created by this provider.</summary>
-        internal int TimerCount
-        {
-            get
-            {
-                lock (_gate)
-                {
-                    return _timers.Count;
-                }
-            }
-        }
-
-        /// <summary>Creates a manual timer and stores it until <see cref = "FireAll"/> is invoked.</summary>
-        /// <param name = "callback">The callback to invoke when the timer is fired.</param>
-        /// <param name = "state">The state object passed to the callback.</param>
-        /// <param name = "dueTime">The initial delay (recorded by caller behavior, not elapsed by this provider).</param>
-        /// <param name = "period">The interval (ignored; timers are one-shot in these tests).</param>
-        /// <returns>A manual <see cref = "ITimer"/> instance.</returns>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
-        {
-            _ = dueTime;
-            _ = period;
-            ManualTimer timer = new(callback, state);
-            lock (_gate)
-            {
-                _timers.Add(timer);
-            }
-
-            return timer;
-        }
-
-        /// <summary>Fires every timer that has been created so far.</summary>
-        internal void FireAll()
-        {
-            ManualTimer[] timers;
-            lock (_gate)
-            {
-                timers = [.. _timers];
-            }
-
-            foreach (var timer in timers)
-            {
-                timer.Fire();
-            }
-        }
-
-        /// <summary>Manual one-shot timer used by <see cref = "ManualTimeProvider"/>.</summary>
-        /// <param name = "callback">The callback to invoke.</param>
-        /// <param name = "state">The state object passed to the callback.</param>
-        private sealed class ManualTimer(TimerCallback callback, object? state) : ITimer
-        {
-            /// <summary>Non-zero once the timer has been disposed.</summary>
-            private int _disposed;
-
-            /// <summary>Non-zero once the timer has fired.</summary>
-            private int _fired;
-
-            /// <summary>No-op change; returns whether the timer is still active.</summary>
-            /// <param name = "dueTime">The due time (ignored).</param>
-            /// <param name = "period">The period (ignored).</param>
-            /// <returns><see langword = "true"/> when the timer is still active.</returns>
-            public bool Change(TimeSpan dueTime, TimeSpan period)
-            {
-                _ = dueTime;
-                _ = period;
-                return Volatile.Read(ref _disposed) == 0;
-            }
-
-            /// <summary>Marks the timer as disposed.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Dispose() => Interlocked.Exchange(ref _disposed, 1);
-
-            /// <summary>Marks the timer as disposed.</summary>
-            /// <returns>A completed <see cref = "ValueTask"/>.</returns>
-            public ValueTask DisposeAsync()
-            {
-                Dispose();
-                return default;
-            }
-
-            /// <summary>Invokes the callback once if the timer has not been disposed.</summary>
-            internal void Fire()
-            {
-                if (Volatile.Read(ref _disposed) != 0
-                    || Interlocked.Exchange(ref _fired, 1) != 0)
-                {
-                    return;
-                }
-
-                callback(state);
-            }
-        }
-    }
-
-    /// <summary>
-    /// A <see cref = "TimeProvider"/> that fires the timer callback synchronously during
-    /// <see cref = "CreateTimer"/>, completing the delay immediately. Used to deterministically
-    /// test the id-mismatch early return and exception routing paths in ThrottleWitness.
-    /// </summary>
-    private sealed class ImmediateFireTimeProvider : TimeProvider
-    {
-        /// <summary>Invokes the timer callback synchronously and returns a no-op timer.</summary>
-        /// <param name = "callback">The callback to invoke immediately.</param>
-        /// <param name = "state">The state object passed to the callback.</param>
-        /// <param name = "dueTime">The initial delay (ignored; fires immediately).</param>
-        /// <param name = "period">The interval (ignored; fires only once).</param>
-        /// <returns>A no-op <see cref = "ITimer"/> instance.</returns>
-        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
-        {
-            callback(state);
-            return new NoOpTimer();
-        }
-
-        /// <summary>A timer that performs no operations. Used as the return value from <see cref = "CreateTimer"/>.</summary>
-        private sealed class NoOpTimer : ITimer
-        {
-            /// <summary>No-op change; returns true.</summary>
-            /// <param name = "dueTime">The due time (ignored).</param>
-            /// <param name = "period">The period (ignored).</param>
-            /// <returns>Always returns true.</returns>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Change(TimeSpan dueTime, TimeSpan period) => true;
-
-            /// <summary>No-op dispose.</summary>
-            public void Dispose()
-            {
-            }
-
-            /// <summary>No-op async dispose.</summary>
-            /// <returns>A completed <see cref = "ValueTask"/>.</returns>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask DisposeAsync() => default;
-        }
-    }
+    /// <summary>A fallback observable is required by the fallback overload.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [Test]
+    public void WhenTimeoutWithFallbackNull_ThenThrowsArgumentNull() =>
+        Assert.Throws<ArgumentNullException>(static () => SignalAsync.Return(1).Timeout(Window, (IObservableAsync<int>)null!));
 
-    /// <summary>Bare-bones downstream observer that throws from <c>OnCompletedAsync</c> to
-    /// exercise the catch block in <c>Timeout</c>'s <c>FireTimeoutAsync</c>.</summary>
-    /// <typeparam name = "T">The element type.</typeparam>
-    /// <param name = "error">The exception to throw on completion.</param>
-    private sealed class TimeoutThrowingWitness<T>(Exception error) : IObserverAsync<T>
+    /// <summary>Throws directly from completion without an observer wrapper catching it.</summary>
+    private sealed class ThrowingCompletionWitness : IObserverAsync<int>
     {
         /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public ValueTask OnNextAsync(T value, CancellationToken cancellationToken) => default;
+        public ValueTask OnNextAsync(int value, CancellationToken cancellationToken) => default;
 
         /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken) => default;
 
         /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
-        public ValueTask OnCompletedAsync(Result result) => throw error;
+        public ValueTask OnCompletedAsync(Result result) => throw new InvalidOperationException("completion failed");
 
         /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask DisposeAsync() => default;
     }
+
+    /// <summary>A provider that rejects timer creation.</summary>
+    private sealed class ThrowingTimeProvider : TimeProvider
+    {
+        /// <inheritdoc/>
+        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
+            throw new InvalidOperationException("timer creation failed");
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.SideEffects.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.SideEffects.cs
new file mode 100644
index 00000000..0ad3892e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.SideEffects.cs
@@ -0,0 +1,205 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Disposables;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests Do and Tap notification side effects.</summary>
+public partial class TransformationOperatorTests
+{
+    /// <summary>Tests Tap and Do null callback overloads return the original source.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTapAndDoCallbacksAreNull_ThenReturnSource()
+    {
+        var source = SignalAsync.Return(1);
+        await Assert.That(source.Tap((Func<int, CancellationToken, ValueTask>?)null, null, null))
+            .IsSameReferenceAs(source);
+        await Assert.That(source.Tap((Action<int>)null!)).IsSameReferenceAs(source);
+        await Assert.That(source.Do((Action<int>?)null, null, null)).IsSameReferenceAs(source);
+    }
+
+    /// <summary>Tests synchronous Do callbacks receive values, resumable errors and completion.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoSyncWithAllCallbacks_ThenInvokesAndForwards()
+    {
+        const int ExpectedFirst = 7;
+        const int ExpectedSecond = 8;
+        List<int> nextValues = [];
+        List<Exception> errors = [];
+        List<Result> completions = [];
+        TaskCompletionSource errored = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = SignalAsync.Create<int>(static async (observer, ct) =>
+        {
+            await observer.OnNextAsync(ExpectedFirst, ct);
+            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
+            await observer.OnNextAsync(ExpectedSecond, ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        await using var sub = await source.Do(
+            nextValues.Add,
+            exception =>
+            {
+                errors.Add(exception);
+                _ = errored.TrySetResult();
+            },
+            result =>
+            {
+                completions.Add(result);
+                _ = completed.TrySetResult();
+            }).SubscribeAsync(static (_, _) => default);
+        await Task.WhenAll(errored.Task, completed.Task);
+        await Assert.That(nextValues).IsCollectionEqualTo([ExpectedFirst, ExpectedSecond]);
+        await Assert.That(errors).Count().IsEqualTo(1);
+        await Assert.That(completions).Count().IsEqualTo(1);
+    }
+
+    /// <summary>Tests Do with only a completion callback forwards resumable errors.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoSyncWithOnlyCompletionCallbackAndSourceEmitsErrorResume_ThenForwardsError()
+    {
+        List<Exception> caughtErrors = [];
+        List<Result> completions = [];
+        TaskCompletionSource done = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = SignalAsync.Create<int>(static async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(new InvalidOperationException("sync completion-only"), ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        await using var sub = await source.Do((Action<int>?)null, null, completions.Add)
+            .SubscribeAsync(
+                static (_, _) => default,
+                (ex, _) =>
+                {
+                    caughtErrors.Add(ex);
+                    return default;
+                },
+                _ =>
+                {
+                    IgnoredResult.Of(done.TrySetResult());
+                    return default;
+                });
+        await done.Task;
+        await Assert.That(caughtErrors).Count().IsEqualTo(1);
+        await Assert.That(completions).Count().IsEqualTo(1);
+    }
+
+    /// <summary>Tests Tap with only an asynchronous completion callback invokes it.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTapAsyncWithOnlyCompletionCallback_ThenInvokesCallback()
+    {
+        Result? completion = null;
+        await SignalAsync.Return(1).Tap((Func<int, CancellationToken, ValueTask>?)null, null, result =>
+        {
+            completion = result;
+            return default;
+        }).WaitCompletionAsync();
+        await Assert.That(completion).IsNotNull();
+        await Assert.That(completion!.Value.IsSuccess).IsTrue();
+    }
+
+    /// <summary>Tests Do without callbacks forwards resumable errors and completion.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoWithNoCallbacksAndSourceEmitsErrorResume_ThenForwardsBoth()
+    {
+        Exception? caught = null;
+        var completed = false;
+        TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource completionTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = SignalAsync.Create<int>(static async (observer, ct) =>
+        {
+            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
+            await observer.OnCompletedAsync(Result.Success);
+            return DisposableAsync.Empty;
+        });
+        await using var sub = await source.Do().SubscribeAsync(
+            static (_, _) => default,
+            (ex, _) =>
+            {
+                caught = ex;
+                IgnoredResult.Of(errorTcs.TrySetResult());
+                return default;
+            },
+            _ =>
+            {
+                completed = true;
+                IgnoredResult.Of(completionTcs.TrySetResult());
+                return default;
+            });
+        await Task.WhenAll(errorTcs.Task, completionTcs.Task);
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Tests Do without callbacks forwards source values.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoWithNoCallbacks_ThenPassesThroughValues()
+    {
+        const int ExpectedSecond = 2;
+        const int ExpectedThird = 3;
+        const int SourceValueCount = 3;
+
+        var result = await SignalAsync.Range(1, SourceValueCount).Do().ToListAsync();
+        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
+    }
+
+    /// <summary>Tests sync Do invokes side effects.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoSync_ThenInvokesSideEffects()
+    {
+        const int ExpectedSecond = 2;
+        const int ExpectedThird = 3;
+        const int SourceValueCount = 3;
+
+        List<int> sideEffects = [];
+        var result = await SignalAsync.Range(1, SourceValueCount).Do((x, _) =>
+        {
+            sideEffects.Add(x);
+            return default;
+        }).ToListAsync();
+        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
+        await Assert.That(sideEffects).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
+    }
+
+    /// <summary>Tests async Do invokes side effects.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoAsync_ThenInvokesSideEffects()
+    {
+        const int ExpectedSecond = 2;
+        const int ExpectedThird = 3;
+        const int SourceValueCount = 3;
+
+        List<int> sideEffects = [];
+        var result = await SignalAsync.Range(1, SourceValueCount).Do(async (x, _) =>
+        {
+            await Task.Yield();
+            sideEffects.Add(x);
+        }).ToListAsync();
+        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
+        await Assert.That(sideEffects).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
+    }
+
+    /// <summary>Tests Do with completion handler invokes on completed.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDoWithCompletionHandler_ThenInvokesOnCompleted()
+    {
+        Result? completion = null;
+        await SignalAsync.Empty<int>().Do((Action<int>?)null, (Action<Exception>?)null, r => completion = r)
+            .WaitCompletionAsync();
+        await Assert.That(completion).IsNotNull();
+        await Assert.That(completion!.Value.IsSuccess).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
index 3ca20dd6..c92b2511 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
@@ -10,11 +10,8 @@
 namespace ReactiveUI.Primitives.Async.Tests;
 
 /// <summary>Tests for transformation operators: Select, SelectMany, Scan, Do, Cast, OfType.</summary>
-public class TransformationOperatorTests
+public partial class TransformationOperatorTests
 {
-    /// <summary>Seconds a test waits for a notification before giving up.</summary>
-    private const int WaitTimeoutSeconds = 5;
-
     /// <summary>Message thrown by an observer from its completion callback.</summary>
     private const string CompletionFailedMessage = "completion failed";
 
@@ -48,9 +45,6 @@ public class TransformationOperatorTests
     /// <summary>Mixed-type source in which no element is a string.</summary>
     private static readonly object[] OfTypeMisses = [1, 2, 3];
 
-    /// <summary>Maximum time a test waits for a notification to arrive.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(WaitTimeoutSeconds);
-
     /// <summary>Tests sync Select projects each element.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -171,9 +165,7 @@ public async Task WhenSelectManyOuterCompletesBeforeInner_ThenWaitsForInnerCompl
         await Assert.That(completion.HasValue).IsFalse();
 
         await inner.Complete(Result.Success);
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completion.HasValue,
-            WaitTimeout);
+        await Assert.That(completion.HasValue).IsTrue();
 
         await Assert.That(values).Contains(Two);
         await Assert.That(completion!.Value.IsSuccess).IsTrue();
@@ -202,9 +194,7 @@ public async Task WhenSelectManyInnerFails_ThenCompletesWithFailure()
 
         await outer.EmitNext(One);
         await inner.Complete(Result.Failure(expected));
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completion.HasValue,
-            WaitTimeout);
+        await Assert.That(completion.HasValue).IsTrue();
 
         await Assert.That(completion!.Value.IsFailure).IsTrue();
         await Assert.That(completion.Value.Exception).IsSameReferenceAs(expected);
@@ -216,7 +206,7 @@ await AsyncTestHelpers.WaitForConditionAsync(
     public async Task WhenSelectManyInnerSubscribeThrows_ThenCompletesWithFailure()
     {
         InvalidOperationException expected = new("select-many-subscribe");
-        Result? completion = null;
+        TaskCompletionSource<Result> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         await using var subscription = await SignalAsync
             .Return(One)
@@ -226,16 +216,13 @@ public async Task WhenSelectManyInnerSubscribeThrows_ThenCompletesWithFailure()
                 null,
                 result =>
                 {
-                    completion = result;
+                    IgnoredResult.Of(completed.TrySetResult(result));
                     return default;
                 });
 
-        await AsyncTestHelpers.WaitForConditionAsync(
-            () => completion.HasValue,
-            WaitTimeout);
-
-        await Assert.That(completion!.Value.IsFailure).IsTrue();
-        await Assert.That(completion.Value.Exception).IsSameReferenceAs(expected);
+        var completion = await completed.Task;
+        await Assert.That(completion.IsFailure).IsTrue();
+        await Assert.That(completion.Exception).IsSameReferenceAs(expected);
     }
 
     /// <summary>Tests SelectMany null selector throws.</summary>
@@ -282,205 +269,6 @@ public async Task WhenScanAsync_ThenEmitsRunningAccumulation()
     public void WhenScanNullAccumulator_ThenThrowsArgumentNull() =>
         Assert.Throws<ArgumentNullException>(static () => SignalAsync.Return(1).Scan(0, (Func<int, int, int>)null!));
 
-    /// <summary>Tests Tap and Do null callback overloads return the original source.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTapAndDoCallbacksAreNull_ThenReturnSource()
-    {
-        var source = SignalAsync.Return(1);
-        await Assert.That(source.Tap((Func<int, CancellationToken, ValueTask>?)null, null, null))
-            .IsSameReferenceAs(source);
-        await Assert.That(source.Tap((Action<int>)null!)).IsSameReferenceAs(source);
-        await Assert.That(source.Do((Action<int>?)null, null, null)).IsSameReferenceAs(source);
-    }
-
-    /// <summary>Exercises the sync-action <c>Do&lt;T&gt;(Action&lt;T&gt;, Action&lt;Exception&gt;, Action&lt;Result&gt;)</c>
-    /// overload's non-null-callback branches in <c>SyncSideEffectObserver</c>'s OnNext / OnErrorResume / OnCompleted.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoSyncWithAllCallbacks_ThenInvokesAndForwards()
-    {
-        const int ExpectedFirst = 7;
-        const int ExpectedSecond = 8;
-        List<int> nextValues = [];
-        List<Exception> errors = [];
-        List<Result> completions = [];
-        TaskCompletionSource errored = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var source = SignalAsync.Create<int>(static async (observer, ct) =>
-        {
-            await observer.OnNextAsync(ExpectedFirst, ct);
-            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
-            await observer.OnNextAsync(ExpectedSecond, ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        await using var sub = await source.Do(
-            nextValues.Add,
-            exception =>
-            {
-                errors.Add(exception);
-                _ = errored.TrySetResult();
-            },
-            result =>
-            {
-                completions.Add(result);
-                _ = completed.TrySetResult();
-            }).SubscribeAsync(static (_, _) => default);
-        await Task.WhenAll(errored.Task, completed.Task).WaitAsync(WaitTimeout);
-        await Assert.That(nextValues).IsCollectionEqualTo([ExpectedFirst, ExpectedSecond]);
-        await Assert.That(errors).Count().IsEqualTo(1);
-        await Assert.That(completions).Count().IsEqualTo(1);
-    }
-
-    /// <summary>Tests Do with only a completion callback still forwards resumable errors.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoSyncWithOnlyCompletionCallbackAndSourceEmitsErrorResume_ThenForwardsError()
-    {
-        List<Exception> caughtErrors = [];
-        List<Result> completions = [];
-        TaskCompletionSource done = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var source = SignalAsync.Create<int>(static async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(new InvalidOperationException("sync completion-only"), ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        await using var sub = await source.Do((Action<int>?)null, null, completions.Add)
-            .SubscribeAsync(
-                static (_, _) => default,
-                (ex, _) =>
-                {
-                    caughtErrors.Add(ex);
-                    return default;
-                },
-                _ =>
-                {
-                    IgnoredResult.Of(done.TrySetResult());
-                    return default;
-                });
-        await done.Task.WaitAsync(WaitTimeout);
-        await Assert.That(caughtErrors).Count().IsEqualTo(1);
-        await Assert.That(completions).Count().IsEqualTo(1);
-    }
-
-    /// <summary>Tests Tap with only an asynchronous completion callback invokes it.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTapAsyncWithOnlyCompletionCallback_ThenInvokesCallback()
-    {
-        Result? completion = null;
-        await SignalAsync.Return(1).Tap((Func<int, CancellationToken, ValueTask>?)null, null, result =>
-        {
-            completion = result;
-            return default;
-        }).WaitCompletionAsync();
-        await Assert.That(completion).IsNotNull();
-        await Assert.That(completion!.Value.IsSuccess).IsTrue();
-    }
-
-    /// <summary>Exercises the no-arg <c>Do&lt;T&gt;()</c> overload's null-callback branches on
-    /// the resumable-error and completion paths — pushes an <c>OnErrorResumeAsync</c> followed
-    /// by a successful completion through <c>Do()</c> with all callbacks null, hitting the
-    /// <c>onErrorResume?.Invoke</c> null arm and the <c>onCompleted?.Invoke</c> null arm.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoWithNoCallbacksAndSourceEmitsErrorResume_ThenForwardsBoth()
-    {
-        Exception? caught = null;
-        var completed = false;
-        TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource completionTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var source = SignalAsync.Create<int>(static async (observer, ct) =>
-        {
-            await observer.OnErrorResumeAsync(new InvalidOperationException("resume"), ct);
-            await observer.OnCompletedAsync(Result.Success);
-            return DisposableAsync.Empty;
-        });
-        await using var sub = await source.Do().SubscribeAsync(
-            static (_, _) => default,
-            (ex, _) =>
-            {
-                caught = ex;
-                IgnoredResult.Of(errorTcs.TrySetResult());
-                return default;
-            },
-            _ =>
-            {
-                completed = true;
-                IgnoredResult.Of(completionTcs.TrySetResult());
-                return default;
-            });
-        await Task.WhenAll(errorTcs.Task, completionTcs.Task).WaitAsync(WaitTimeout);
-        await Assert.That(caught).IsNotNull();
-        await Assert.That(completed).IsTrue();
-    }
-
-    /// <summary>Exercises the no-arg <c>Do&lt;T&gt;()</c> overload — a pure pass-through that
-    /// constructs a <c>DoSyncSignal</c> with all callbacks set to null.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoWithNoCallbacks_ThenPassesThroughValues()
-    {
-        const int ExpectedSecond = 2;
-        const int ExpectedThird = 3;
-        const int SourceValueCount = 3;
-
-        var result = await SignalAsync.Range(1, SourceValueCount).Do().ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-    }
-
-    /// <summary>Tests sync Do invokes side effects.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoSync_ThenInvokesSideEffects()
-    {
-        const int ExpectedSecond = 2;
-        const int ExpectedThird = 3;
-        const int SourceValueCount = 3;
-
-        List<int> sideEffects = [];
-        var result = await SignalAsync.Range(1, SourceValueCount).Do((x, _) =>
-        {
-            sideEffects.Add(x);
-            return default;
-        }).ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-        await Assert.That(sideEffects).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-    }
-
-    /// <summary>Tests async Do invokes side effects.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoAsync_ThenInvokesSideEffects()
-    {
-        const int ExpectedSecond = 2;
-        const int ExpectedThird = 3;
-        const int SourceValueCount = 3;
-
-        List<int> sideEffects = [];
-        var result = await SignalAsync.Range(1, SourceValueCount).Do(async (x, _) =>
-        {
-            await Task.Yield();
-            sideEffects.Add(x);
-        }).ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-        await Assert.That(sideEffects).IsCollectionEqualTo([1, ExpectedSecond, ExpectedThird]);
-    }
-
-    /// <summary>Tests Do with completion handler invokes on completed.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenDoWithCompletionHandler_ThenInvokesOnCompleted()
-    {
-        Result? completion = null;
-        await SignalAsync.Empty<int>().Do((Action<int>?)null, (Action<Exception>?)null, r => completion = r)
-            .WaitCompletionAsync();
-        await Assert.That(completion).IsNotNull();
-        await Assert.That(completion!.Value.IsSuccess).IsTrue();
-    }
-
     /// <summary>
     /// Verifies that Cast completes with a failure containing an <see cref = "InvalidCastException"/>
     /// when the source emits an element that cannot be cast to the target type.
@@ -498,7 +286,7 @@ public async Task WhenCastIncompatibleType_ThenCompletesWithFailure()
             _ = tcs.TrySetResult();
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsFalse();
         await Assert.That(completionResult.Value.Exception).IsTypeOf<InvalidCastException>();
@@ -560,7 +348,7 @@ public async Task WhenPrependCancelledBeforeAllValues_ThenEarlyReturn()
             },
             null);
         const int MinReceivedCount = 3;
-        await AsyncTestHelpers.WaitForConditionAsync(() => received.Count >= 3, WaitTimeout);
+        await Assert.That(received.Count >= 3).IsTrue();
         await Assert.That(received.Count).IsGreaterThanOrEqualTo(MinReceivedCount);
     }
 
@@ -587,7 +375,7 @@ public async Task WhenPrependSourceThrowsAndCompletionAlsoThrows_ThenRoutedToHan
             ValueTask.FromException<IAsyncDisposable>(new ApplicationException("source error")));
         var pipeline = source.Prepend(SentinelValue);
         await using var sub = await pipeline.SubscribeAsync(static (_, _) => default, null, _ => throw completionException);
-        var exception = await unhandled.WaitForAsync(CompletionFailedMessage, WaitTimeout);
+        var exception = await unhandled.WaitForAsync(CompletionFailedMessage);
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
         await Assert.That(exception!.Message).IsEqualTo(CompletionFailedMessage);
@@ -631,7 +419,7 @@ public async Task WhenDoAsyncWithOnErrorResume_ThenInvokesCallbackAndForwardsErr
                 IgnoredResult.Of(tcs.TrySetResult());
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(resumedErrors).Count().IsEqualTo(1);
         await Assert.That(resumedErrors[0].Message).IsEqualTo("test error");
         await Assert.That(downstreamErrors).Count().IsEqualTo(1);
@@ -659,7 +447,7 @@ public async Task WhenDoAsyncWithOnCompleted_ThenInvokesCallback()
             IgnoredResult.Of(tcs.TrySetResult());
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(capturedResult).IsNotNull();
         await Assert.That(capturedResult!.Value.IsSuccess).IsTrue();
     }
@@ -696,7 +484,7 @@ public async Task WhenDoSyncWithOnErrorResume_ThenInvokesCallbackAndForwardsErro
                     IgnoredResult.Of(tcs.TrySetResult());
                     return default;
                 });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(resumedErrors).Count().IsEqualTo(1);
         await Assert.That(resumedErrors[0].Message).IsEqualTo("sync error");
         await Assert.That(downstreamErrors).Count().IsEqualTo(1);
@@ -752,7 +540,7 @@ public async Task WhenObserveOnSourceEmitsResumableError_ThenForwardsErrorDownst
                 IgnoredResult.Of(tcs.TrySetResult());
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(receivedValues).IsCollectionEqualTo([1, ExpectedSecond]);
         await Assert.That(downstreamErrors).Count().IsEqualTo(1);
         await Assert.That(downstreamErrors[0]).IsTypeOf<InvalidOperationException>();
@@ -789,13 +577,7 @@ public async Task WhenPrependTokenCancelledBeforeIteration_ThenEmitsNoValues()
         await Assert.That(received.Count).IsLessThan(MaxReceivedCount);
     }
 
-    /// <summary>
-    /// Verifies that when the source observable passed to Prepend throws an exception during
-    /// subscription and the downstream observer's OnCompletedAsync handler also throws,
-    /// the secondary exception from the completion handler is routed to the
-    /// <see cref = "UnhandledExceptionHandler"/>.
-    /// This covers the inner catch block that guards against completion handler failures.
-    /// </summary>
+    /// <summary>Verifies that a completion callback failure after Prepend subscription failure reaches the unhandled exception handler.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     [SuppressMessage(
@@ -814,12 +596,10 @@ public async Task WhenPrependSourceThrowsAndOnCompletedThrows_ThenSecondaryExcep
         var source = SignalAsync.Create<int>(static (_, _) =>
             ValueTask.FromException<IAsyncDisposable>(new ApplicationException("source failure")));
 
-        // Prepend a single value so the prepend loop completes, then SubscribeAsync on the
-        // throwing source triggers the catch path. The completion handler throws a second
-        // exception, which should be routed to the unhandled exception handler.
+        // Source subscription fails after the prepended value is delivered.
         var pipeline = source.Prepend(1);
         await using var sub = await pipeline.SubscribeAsync(static (_, _) => default, null, _ => throw secondaryException);
-        var exception = await unhandled.WaitForAsync(OnCompletedBlewUpMessage, WaitTimeout);
+        var exception = await unhandled.WaitForAsync(OnCompletedBlewUpMessage);
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
         await Assert.That(exception!.Message).IsEqualTo(OnCompletedBlewUpMessage);
@@ -861,7 +641,7 @@ public async Task WhenYield_ThenForwardsCompletion()
             _ = tcs.TrySetResult();
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(capturedResult).IsNotNull();
         await Assert.That(capturedResult!.Value.IsSuccess).IsTrue();
     }
@@ -885,7 +665,7 @@ public async Task WhenYieldSourceErrors_ThenForwardsError()
             _ = tcs.TrySetResult();
             return default;
         });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(capturedResult).IsNotNull();
         await Assert.That(capturedResult!.Value.IsSuccess).IsFalse();
     }
@@ -942,7 +722,7 @@ await group.SubscribeAsync(
                 IgnoredResult.Of(tcs.TrySetResult());
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(groups).Count().IsEqualTo(ExpectedGroupCount);
         await Assert.That(groups[1]).IsCollectionEqualTo([1, OddSecond, OddThird]);
         await Assert.That(groups[0]).IsCollectionEqualTo([EvenFirst, EvenSecond, EvenThird]);
@@ -975,20 +755,13 @@ static async (group, ct) => await group.SubscribeAsync(static (_, _) => default,
                 IgnoredResult.Of(tcs.TrySetResult());
                 return default;
             });
-        await AsyncTestHelpers.WaitForConditionAsync(() => tcs.Task.IsCompleted, WaitTimeout);
+        await tcs.Task;
         await Assert.That(downstreamErrors).Count().IsEqualTo(1);
         await Assert.That(downstreamErrors[0]).IsTypeOf<InvalidOperationException>();
         await Assert.That(downstreamErrors[0].Message).IsEqualTo("group error");
     }
 
-    /// <summary>
-    /// Verifies that when Prepend's source throws during subscription and the raw observer's
-    /// <see cref = "IObserverAsync{T}.OnCompletedAsync"/> also throws, the secondary exception
-    /// from the completion handler is routed to the <see cref = "UnhandledExceptionHandler"/>.
-    /// This exercises the inner catch block (lines 73-74) that guards against completion handler failures
-    /// by using a raw <see cref = "IObserverAsync{T}"/> implementation that bypasses the
-    /// <see cref = "WitnessAsync{T}"/> base class exception swallowing.
-    /// </summary>
+    /// <summary>Verifies that a raw observer's completion failure after Prepend subscription failure reaches the unhandled exception handler.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     [SuppressMessage(
@@ -1009,7 +782,7 @@ public async Task WhenPrependSourceThrowsAndRawObserverCompletionThrows_ThenRout
         var pipeline = source.Prepend(1);
         ThrowingOnCompletedWitness<int> rawObserver = new(completionException);
         await using var sub = await pipeline.SubscribeAsync(rawObserver, CancellationToken.None);
-        var exception = await unhandled.WaitForAsync(RawObserverCompletionFailedMessage, WaitTimeout);
+        var exception = await unhandled.WaitForAsync(RawObserverCompletionFailedMessage);
         await Assert.That(exception).IsNotNull();
         await Assert.That(exception!).IsTypeOf<InvalidOperationException>();
         await Assert.That(exception!.Message).IsEqualTo(RawObserverCompletionFailedMessage);
@@ -1100,7 +873,7 @@ public async Task WhenScanSyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("scan-sync-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
@@ -1122,16 +895,11 @@ public async Task WhenScanAsyncSourceErrorResume_ThenForwarded()
             });
         InvalidOperationException expected = new("scan-async-error");
         await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-        await errorTcs.Task.WaitAsync(WaitTimeout);
+        await errorTcs.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
-    /// <summary>
-    /// A raw <see cref = "IObserverAsync{T}"/> implementation that throws a specified exception
-    /// from <see cref = "OnCompletedAsync"/>. Unlike <see cref = "WitnessAsync{T}"/>, this
-    /// implementation does not catch exceptions internally, allowing callers to observe
-    /// the thrown exception directly.
-    /// </summary>
+    /// <summary>Throws directly from OnCompletedAsync without catching the exception.</summary>
     /// <typeparam name = "T">The type of elements received by the observer.</typeparam>
     /// <param name = "completionException">The exception to throw when <see cref = "OnCompletedAsync"/> is called.</param>
     private sealed class ThrowingOnCompletedWitness<T>(Exception completionException) : IObserverAsync<T>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
index e0a117b3..4118c091 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
@@ -9,9 +9,6 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Captures unhandled async exceptions while restoring the previous process-wide handler on disposal.</summary>
 internal sealed class UnhandledExceptionCapture : IDisposable
 {
-    /// <summary>The polling interval used while waiting for delayed fire-and-forget callbacks.</summary>
-    private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(10);
-
     /// <summary>Synchronizes access to the captured exception list.</summary>
     private readonly Lock _gate = new();
 
@@ -21,6 +18,9 @@ internal sealed class UnhandledExceptionCapture : IDisposable
     /// <summary>The handler that was active before this capture was installed.</summary>
     private readonly Action<Exception> _previousHandler;
 
+    /// <summary>Signals the next captured exception.</summary>
+    private TaskCompletionSource _arrival = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
     /// <summary>Tracks whether the capture has already restored the previous handler.</summary>
     private int _disposed;
 
@@ -37,45 +37,35 @@ public UnhandledExceptionCapture()
 
     /// <summary>Waits for an exception with the expected message.</summary>
     /// <param name="message">The expected exception message.</param>
-    /// <param name="timeout">Maximum time to wait.</param>
-    /// <returns>The matched exception, or <see langword="null"/> if no match is observed.</returns>
-    internal Task<Exception?> WaitForAsync(string message, TimeSpan timeout)
+    /// <returns>The matching exception.</returns>
+    internal Task<Exception?> WaitForAsync(string message)
     {
         ArgumentNullException.ThrowIfNull(message);
-        return WaitForAsync(ex => ex.Message == message, timeout);
+        return WaitForAsync(ex => ex.Message == message);
     }
 
     /// <summary>Waits for a captured exception that satisfies the supplied predicate.</summary>
     /// <param name="predicate">The predicate used to find the expected exception.</param>
-    /// <param name="timeout">Maximum time to wait.</param>
-    /// <returns>The matched exception, or <see langword="null"/> if no match is observed.</returns>
-    internal async Task<Exception?> WaitForAsync(Func<Exception, bool> predicate, TimeSpan timeout)
+    /// <returns>The matching exception.</returns>
+    internal async Task<Exception?> WaitForAsync(Func<Exception, bool> predicate)
     {
         ArgumentNullException.ThrowIfNull(predicate);
-        ArgumentOutOfRangeException.ThrowIfLessThan(timeout, TimeSpan.Zero);
-
-        var deadline = TimeProvider.System.GetUtcNow().Add(timeout);
-        var match = Find(predicate);
-
-        if (match is not null)
-        {
-            return match;
-        }
-
-        using PeriodicTimer poll = new(PollInterval);
-
-        while (TimeProvider.System.GetUtcNow() < deadline
-               && await poll.WaitForNextTickAsync(CancellationToken.None))
+        while (true)
         {
-            match = Find(predicate);
-
-            if (match is not null)
+            Task arrival;
+            lock (_gate)
             {
-                return match;
+                var match = _exceptions.FirstOrDefault(predicate);
+                if (match is not null)
+                {
+                    return match;
+                }
+
+                arrival = _arrival.Task;
             }
-        }
 
-        return Find(predicate);
+            await arrival;
+        }
     }
 
     /// <summary>Stores an exception routed through the temporary handler.</summary>
@@ -85,17 +75,9 @@ private void Capture(Exception exception)
         lock (_gate)
         {
             _exceptions.Add(exception);
-        }
-    }
-
-    /// <summary>Finds the first captured exception that matches the predicate.</summary>
-    /// <param name="predicate">The predicate used to find the expected exception.</param>
-    /// <returns>The matched exception, or <see langword="null"/> if none match.</returns>
-    private Exception? Find(Func<Exception, bool> predicate)
-    {
-        lock (_gate)
-        {
-            return _exceptions.FirstOrDefault(predicate);
+            var arrival = _arrival;
+            _arrival = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            arrival.SetResult();
         }
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
index 7df6bbc4..62c51891 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
@@ -11,15 +11,6 @@ namespace ReactiveUI.Primitives.Avalonia.Reactive.Tests;
 /// <summary>Tests for <see cref="AvaloniaScheduler"/> against a pumped Avalonia headless dispatcher.</summary>
 public sealed class AvaloniaSchedulerTests
 {
-    /// <summary>Delay used to exercise the native dispatcher-timer path.</summary>
-    private static readonly TimeSpan DelayedDueTime = TimeSpan.FromMilliseconds(50);
-
-    /// <summary>Delay used for work that is cancelled before its timer fires.</summary>
-    private static readonly TimeSpan CancellationDueTime = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>Delay for work that falls due after the cancelled work, on the same dispatcher and priority.</summary>
-    private static readonly TimeSpan FollowingDueTime = TimeSpan.FromMilliseconds(200);
-
     /// <summary>Verifies constructor validation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -29,23 +20,22 @@ public async Task ConstructorRejectsNullDispatcher() =>
     /// <summary>Verifies the singleton uses Avalonia's UI dispatcher and legacy background priority.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task InstanceUsesUiDispatcherAndBackgroundPriority() =>
-        await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                await Assert.That(AvaloniaScheduler.Instance.Dispatcher).IsSameReferenceAs(Dispatcher.UIThread);
-                await Assert.That(AvaloniaScheduler.Instance.Priority).IsEqualTo(DispatcherPriority.Background);
-                await Assert.That(AvaloniaScheduler.Instance).IsSameReferenceAs(AvaloniaScheduler.Instance);
-            },
+    public async Task InstanceUsesUiDispatcherAndBackgroundPriority()
+    {
+        var (scheduler, dispatcher) = await AvaloniaTestSession.Instance.Dispatch(
+            static () => (AvaloniaScheduler.Instance, Dispatcher.UIThread),
             CancellationToken.None);
 
+        await Assert.That(scheduler.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(scheduler).IsSameReferenceAs(AvaloniaScheduler.Instance);
+    }
+
     /// <summary>Verifies immediate scheduler work is posted to and executed on the selected dispatcher thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ImmediateScheduleExecutesOnDispatcherThread()
     {
-        // The session only awaits a dispatched delegate that returns a result, so the facts to assert come back
-        // out of the dispatch; an assertion left inside it past the first await is never observed.
         var (dispatcherThreadId, executionThreadId) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
@@ -64,10 +54,10 @@ static async () =>
         await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
     }
 
-    /// <summary>Verifies delayed scheduler work runs on a timer bound to the selected dispatcher.</summary>
+    /// <summary>Verifies due work runs on the selected dispatcher at the configured priority.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnDispatcherThread()
+    public async Task DueScheduleExecutesOnDispatcherThread()
     {
         var (dispatcherThreadId, executionThreadId, priority) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
@@ -78,7 +68,7 @@ static async () =>
                     new(TaskCreationOptions.RunContinuationsAsynchronously);
 
                 _ = scheduler.Schedule(
-                    DelayedDueTime,
+                    TimeSpan.Zero,
                     () => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
                 return (
@@ -92,10 +82,10 @@ static async () =>
         await Assert.That(priority).IsEqualTo(DispatcherPriority.Normal);
     }
 
-    /// <summary>Verifies disposing delayed work stops its dispatcher timer before execution.</summary>
+    /// <summary>Verifies disposing queued work prevents execution.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleCanBeCancelled()
+    public async Task DueScheduleCanBeCancelled()
     {
         var executed = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
@@ -105,14 +95,11 @@ static async () =>
                 var executed = false;
 
                 var disposable = scheduler.Schedule(
-                    CancellationDueTime,
+                    TimeSpan.Zero,
                     () => executed = true);
                 disposable.Dispose();
 
-                // The following work is due after the cancelled work and shares its dispatcher and priority, so the
-                // dispatcher passes the cancelled due time first: the follower running means the cancelled action was
-                // skipped rather than merely still pending.
-                _ = scheduler.Schedule(FollowingDueTime, following.SetResult);
+                _ = scheduler.Schedule(TimeSpan.Zero, following.SetResult);
 
                 await following.Task;
                 return executed;
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
index b10961da..5bf305e3 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using Avalonia.Threading;
 using ReactiveUI.Primitives.Concurrency;
@@ -12,12 +11,6 @@ namespace ReactiveUI.Primitives.Avalonia.Tests;
 /// <summary>Tests for <see cref="AvaloniaScheduler"/> against a pumped Avalonia headless dispatcher.</summary>
 public sealed class AvaloniaSchedulerTests
 {
-    /// <summary>Maximum time to wait for dispatcher work.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Future scheduling delay in stopwatch ticks.</summary>
-    private static readonly long ScheduleDelayTicks = Stopwatch.Frequency / 20;
-
     /// <summary>Verifies constructor validation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -27,74 +20,67 @@ public async Task ConstructorRejectsNullDispatcher() =>
     /// <summary>Verifies the singleton uses Avalonia's UI dispatcher and legacy background priority.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task InstanceUsesUiDispatcherAndBackgroundPriority() =>
-        await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                await Assert.That(AvaloniaScheduler.Instance.Dispatcher).IsSameReferenceAs(Dispatcher.UIThread);
-                await Assert.That(AvaloniaScheduler.Instance.Priority).IsEqualTo(DispatcherPriority.Background);
-                await Assert.That(AvaloniaScheduler.Instance).IsSameReferenceAs(AvaloniaScheduler.Instance);
-                await Assert.That(AvaloniaScheduler.Instance.Now).IsGreaterThan(DateTimeOffset.MinValue);
-            },
+    public async Task InstanceUsesUiDispatcherAndBackgroundPriority()
+    {
+        var (scheduler, dispatcher) = await AvaloniaTestSession.Instance.Dispatch(
+            static () => (AvaloniaScheduler.Instance, Dispatcher.UIThread),
             CancellationToken.None);
+        await Assert.That(scheduler.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(scheduler).IsSameReferenceAs(AvaloniaScheduler.Instance);
+        await Assert.That(scheduler.Now).IsGreaterThan(DateTimeOffset.MinValue);
+    }
 
     /// <summary>Verifies immediate work is posted to and executed on the selected dispatcher thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread() =>
-        await AvaloniaTestSession.Instance.Dispatch(
+    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    {
+        var (dispatcherThreadId, executionThreadId) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
                 var dispatcherThreadId = Environment.CurrentManagedThreadId;
                 AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
-                TaskCompletionSource<int> completion =
-                    new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-                scheduler.Schedule(
-                    new DelegateWorkItem(
-                        () => completion.TrySetResult(Environment.CurrentManagedThreadId)));
-
-                var executionThreadId = await completion.Task.WaitAsync(WaitTimeout);
-                await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+                TaskCompletionSource<int> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+                scheduler.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
+                return (dispatcherThreadId, await completion.Task);
             },
             CancellationToken.None);
+        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+    }
 
-    /// <summary>Verifies future work runs through a timer bound to the selected dispatcher.</summary>
+    /// <summary>Verifies due work executes on the selected dispatcher.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnDispatcherThread() =>
-        await AvaloniaTestSession.Instance.Dispatch(
+    public async Task DueScheduleExecutesOnDispatcherThread()
+    {
+        var (dispatcherThreadId, executionThreadId, priority) = await AvaloniaTestSession.Instance.Dispatch(
             static async () =>
             {
                 var dispatcherThreadId = Environment.CurrentManagedThreadId;
                 AvaloniaScheduler scheduler = new(Dispatcher.UIThread, DispatcherPriority.Normal);
-                TaskCompletionSource<int> completion =
-                    new(TaskCreationOptions.RunContinuationsAsynchronously);
-
+                TaskCompletionSource<int> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
                 scheduler.Schedule(
-                    new DelegateWorkItem(
-                        () => completion.TrySetResult(Environment.CurrentManagedThreadId)),
-                    scheduler.Timestamp + ScheduleDelayTicks);
-
-                var executionThreadId = await completion.Task.WaitAsync(WaitTimeout);
-                await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
-                await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Normal);
+                    new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)),
+                    scheduler.Timestamp);
+                return (dispatcherThreadId, await completion.Task, scheduler.Priority);
             },
             CancellationToken.None);
+        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+        await Assert.That(priority).IsEqualTo(DispatcherPriority.Normal);
+    }
 
     /// <summary>Verifies the sequencer validates both work-item overloads.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ScheduleRejectsNullWorkItems() =>
-        await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
-
-                await Assert.That(() => scheduler.Schedule(null!)).ThrowsExactly<ArgumentNullException>();
-                await Assert.That(() => scheduler.Schedule(null!, scheduler.Timestamp)).ThrowsExactly<ArgumentNullException>();
-            },
+    public async Task ScheduleRejectsNullWorkItems()
+    {
+        var scheduler = await AvaloniaTestSession.Instance.Dispatch(
+            static () => new AvaloniaScheduler(Dispatcher.UIThread),
             CancellationToken.None);
+        await Assert.That(() => scheduler.Schedule(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(() => scheduler.Schedule(null!, scheduler.Timestamp)).ThrowsExactly<ArgumentNullException>();
+    }
 
     /// <summary>Work item backed by an action.</summary>
     /// <param name="action">Action to invoke.</param>
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
index ac3ced4c..f6bf6180 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
@@ -17,9 +17,6 @@ public sealed class BlazorRendererSequencerTests
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the constructor rejects a null renderer delegate.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -49,7 +46,7 @@ public async Task DispatcherSchedulerExecutesWork()
 
         _ = scheduler.Schedule(() => executed.TrySetResult(true));
 
-        await Assert.That(await executed.Task.WaitAsync(GuardTimeout)).IsTrue();
+        await Assert.That(await executed.Task).IsTrue();
     }
 
     /// <summary>Verifies renderer-task faults reach the unhandled-exception handler instead of vanishing.</summary>
@@ -64,7 +61,7 @@ public async Task FaultedRendererTaskRoutesToHandler()
 
         _ = scheduler.Schedule(static () => { });
 
-        await Assert.That(await observed.Task.WaitAsync(GuardTimeout)).IsSameReferenceAs(fault);
+        await Assert.That(await observed.Task).IsSameReferenceAs(fault);
     }
 
     /// <summary>Verifies reactive component observation guards reject null inputs.</summary>
@@ -154,7 +151,7 @@ public async Task ImmediateBurstExecutesInOrder()
             _ = scheduler.Schedule(() => values.Add(captured));
         }
 
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
     /// <summary>Fake renderer that runs marshalled work synchronously and records how often it was invoked.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
index e708c43d..75b30157 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
@@ -2,17 +2,14 @@
 // ReactiveUI Association Incorporated 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.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Reactive.Concurrency;
 
 namespace ReactiveUI.Primitives.Blazor.Reactive.Tests;
 
-/// <summary>
-/// Tests for <see cref="CoalescingDispatchScheduler"/>, driven through a test subclass that controls what its
-/// dispatcher <c>Post</c> does: whether it accepts the drain, defers it, rejects it, or throws. This exercises
-/// the immediate and delayed scheduling paths and the coalescing/drain bookkeeping without a real UI dispatcher.
-/// </summary>
+/// <summary>Tests dispatch acceptance, rejection, reentrancy, and delayed delivery using explicit drain callbacks.</summary>
 public sealed class CoalescingDispatchSchedulerTests
 {
     /// <summary>The scheduled state value the tests pass through the scheduler.</summary>
@@ -21,9 +18,6 @@ public sealed class CoalescingDispatchSchedulerTests
     /// <summary>The number of posts expected once a second drain has been requested.</summary>
     private const int TwoPosts = 2;
 
-    /// <summary>Guard timeout for the timer-driven delayed dispatch.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>A short but non-zero due time that forces the delayed dispatch path.</summary>
     private static readonly TimeSpan ShortDelay = TimeSpan.FromMilliseconds(20);
 
@@ -68,12 +62,13 @@ public async Task ZeroDueTimeSchedulesImmediately()
         await Assert.That(ran).IsTrue();
     }
 
-    /// <summary>A positive due time defers the work through the default dispatcher timer path.</summary>
+    /// <summary>A positive due time defers work until the delay scheduler advances.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task PositiveDueTimeRunsThroughTheDispatcherTimerPath()
+    public async Task PositiveDueTimeRunsAfterTheDelaySchedulerAdvances()
     {
-        TestDispatchScheduler scheduler = new() { RunDrainInline = true };
+        HistoricalScheduler clock = new();
+        TestDispatchScheduler scheduler = new(clock) { RunDrainInline = true };
         TaskCompletionSource ran = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         using var handle = scheduler.Schedule(State, ShortDelay, (_, _) =>
@@ -82,7 +77,9 @@ public async Task PositiveDueTimeRunsThroughTheDispatcherTimerPath()
             return Disposable.Empty;
         });
 
-        await ran.Task.WaitAsync(GuardTimeout);
+        await Assert.That(ran.Task.IsCompleted).IsFalse();
+        clock.AdvanceBy(ShortDelay);
+        await Assert.That(ran.Task.IsCompletedSuccessfully).IsTrue();
     }
 
     /// <summary>A dispatcher that refuses the drain resets the coalescing gate so a later drain can be posted.</summary>
@@ -165,12 +162,50 @@ public async Task WorkQueuedDuringADrainRepostsAnotherDrain()
         await Assert.That(scheduler.PostCount).IsEqualTo(TwoPosts);
     }
 
+    /// <summary>Verifies a nested drain may empty the queue before the outer batch finishes.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task NestedDrainClaimsRemainingItemsExactlyOnce()
+    {
+        const int First = 1;
+        const int Second = 2;
+        const int Third = 3;
+        TestDispatchScheduler scheduler = new();
+        List<int> values = [];
+        _ = scheduler.Schedule(First, (owner, value) =>
+        {
+            values.Add(value);
+            _ = owner.Schedule(Third, (_, next) =>
+            {
+                values.Add(next);
+                return Disposable.Empty;
+            });
+            return Disposable.Empty;
+        });
+        _ = scheduler.Schedule(Second, (_, value) =>
+        {
+            values.Add(value);
+            return Disposable.Empty;
+        });
+        scheduler.RunDrainInline = true;
+        scheduler.RunPostedDrains();
+
+        await Assert.That(values).IsEquivalentTo([First, Second, Third], EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
+    }
+
     /// <summary>A <see cref="CoalescingDispatchScheduler"/> whose dispatcher post the test drives explicitly.</summary>
     private sealed class TestDispatchScheduler : CoalescingDispatchScheduler
     {
         /// <summary>Drains handed to <see cref="Post"/> that have not yet been run.</summary>
         private readonly Queue<Action> _postedDrains = new();
 
+        /// <summary>Initializes a new instance of the <see cref="TestDispatchScheduler"/> class.</summary>
+        /// <param name="clock">The delay scheduler.</param>
+        public TestDispatchScheduler(IScheduler? clock = null)
+            : base(clock ?? new HistoricalScheduler())
+        {
+        }
+
         /// <summary>Gets the number of times the dispatcher was asked to post a drain.</summary>
         public int PostCount { get; private set; }
 
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
index b3d5457e..d3efac81 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
@@ -17,9 +17,6 @@ public sealed class BlazorRendererSequencerTests
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the constructor rejects a null renderer delegate.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -49,7 +46,7 @@ public async Task DispatcherSequencerExecutesWork()
 
         sequencer.Schedule(new DelegateWorkItem(() => executed.TrySetResult(true)));
 
-        await Assert.That(await executed.Task.WaitAsync(GuardTimeout)).IsTrue();
+        await Assert.That(await executed.Task).IsTrue();
     }
 
     /// <summary>Verifies renderer-task faults reach the unhandled-exception handler instead of vanishing.</summary>
@@ -64,7 +61,7 @@ public async Task FaultedRendererTaskRoutesToHandler()
 
         sequencer.Schedule(new DelegateWorkItem(static () => { }));
 
-        await Assert.That(await observed.Task.WaitAsync(GuardTimeout)).IsSameReferenceAs(fault);
+        await Assert.That(await observed.Task).IsSameReferenceAs(fault);
     }
 
     /// <summary>Verifies reactive component observation guards reject null inputs.</summary>
@@ -154,7 +151,7 @@ public async Task ImmediateBurstExecutesInOrder()
             sequencer.Schedule(new DelegateWorkItem(() => values.Add(captured)));
         }
 
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
     /// <summary>Work item that invokes a delegate when executed.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
index 934b6345..2307fcc2 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
@@ -7,13 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Reactive.Tests;
 
-/// <summary>
-/// Verifies the seam that gives a System.Reactive scheduler the sequencer scheduling shape the shared Extensions
-/// source calls. This leaf recompiles its own copy of the seam, so the Reactive leaf's tests do not cover it.
-/// The file deliberately does not import <c>System.Reactive.Concurrency</c>: the <c>Scheduler</c> class in that
-/// namespace carries extension methods with the same signatures, and importing it would make every call below
-/// ambiguous. The scheduler types are therefore spelled out in full.
-/// </summary>
+/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
 public class SequencerSchedulingExtensionsTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -112,10 +106,7 @@ private sealed class CountingWorkItem : IWorkItem
         public void Execute() => ExecuteCount++;
     }
 
-    /// <summary>
-    /// Counts how often the scheduler ran a plain action. Holding the count here lets the action overloads be
-    /// handed <see cref="Record"/> as a method group, so the callback closes over nothing.
-    /// </summary>
+    /// <summary>Counts action invocations through a method-group callback.</summary>
     private sealed class RunCounter
     {
         /// <summary>Gets the number of times the scheduler ran the action.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
index d7880dcd..16fc6902 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
@@ -14,9 +14,6 @@ public class ContinuationTests
     /// <summary>Item pushed while the continuation is already locked; the barrier is expected to drop it.</summary>
     private const int DroppedItem = 2;
 
-    /// <summary>Guard timeout to keep barrier rendezvous from hanging the test run.</summary>
-    private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies <see cref="Continuation.LockValueTask{T}"/> pushes the item downstream, locks, and completes once the phase is signalled by an unlock.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -29,8 +26,8 @@ public async Task WhenLockValueTaskNotLocked_ThenEmitsAndCompletesOnUnlock()
         var lockTask = continuation.LockValueTask(1, observer);
         var unlockTask = continuation.UnLock();
 
-        await lockTask.AsTask().WaitAsync(Timeout);
-        await unlockTask.WaitAsync(Timeout);
+        await lockTask.AsTask();
+        await unlockTask;
 
         await Assert.That(values.Count).IsEqualTo(1);
         await Assert.That(values[0]).IsEqualTo(1);
@@ -53,8 +50,8 @@ public async Task WhenLockValueTaskAlreadyLocked_ThenReturnsDefaultAndDropsItem(
         await second;
 
         var unlockTask = continuation.UnLock();
-        await first.AsTask().WaitAsync(Timeout);
-        await unlockTask.WaitAsync(Timeout);
+        await first.AsTask();
+        await unlockTask;
 
         await Assert.That(values.Count).IsEqualTo(1);
         await Assert.That(values[0]).IsEqualTo(1);
@@ -72,8 +69,8 @@ public async Task WhenLockNotLocked_ThenEmitsAndCompletesOnUnlock()
         var lockTask = continuation.Lock(1, observer);
         var unlockTask = continuation.UnLock();
 
-        await lockTask.WaitAsync(Timeout);
-        await unlockTask.WaitAsync(Timeout);
+        await lockTask;
+        await unlockTask;
 
         await Assert.That(values.Count).IsEqualTo(1);
     }
@@ -93,8 +90,8 @@ public async Task WhenLockAlreadyLocked_ThenReturnsCompletedAndDropsItem()
         await Assert.That(second.IsCompleted).IsTrue();
 
         var unlockTask = continuation.UnLock();
-        await first.WaitAsync(Timeout);
-        await unlockTask.WaitAsync(Timeout);
+        await first;
+        await unlockTask;
 
         await Assert.That(values.Count).IsEqualTo(1);
     }
@@ -106,7 +103,7 @@ public async Task WhenUnlockNotLocked_ThenCompletesImmediately()
     {
         using Continuation continuation = new();
 
-        await continuation.UnLock().WaitAsync(Timeout);
+        await continuation.UnLock();
 
         await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
index bc3eda1f..2c0d3058 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
@@ -4,9 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
-/// <summary>Multi-observer and post-terminal coverage for <see cref = "CurrentValueSubject{T}"/>
-/// — copy-on-write growth, mid-array unsubscribe, collapse back to single-observer, late
-/// subscribers after error or completion, and dispose with active observers.</summary>
+/// <summary>Tests multiple subscribers, unsubscribe, late subscribers, and disposal with active observers.</summary>
 public partial class CurrentValueSubjectTests
 {
     /// <summary>Initial value for multi-observer tests.</summary>
@@ -229,12 +227,7 @@ public async Task WhenSubscriptionDisposedTwice_ThenIdempotent()
         await Assert.That(values).IsCollectionEqualTo([MultiInitialValue]);
     }
 
-    /// <summary>Verifies the multi-observer Unsubscribe path tolerates a stale dispose —
-    /// after a middle observer is detached from a 4-observer array, disposing its returned
-    /// subscription a second time hits the <c>Array.IndexOf</c> not-found early-return.
-    /// The 4-observer setup keeps <c>_observers</c> non-null after the first dispose (the
-    /// 2-observer setup collapses back to the single-observer fast path, which hits a
-    /// different short-circuit instead of the IndexOf path).</summary>
+    /// <summary>Verifies repeated unsubscribe leaves every remaining observer attached.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenMultiObserverDisposedTwice_ThenSecondDisposeIsNoOp()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs
deleted file mode 100644
index af9aa9e9..00000000
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-namespace ReactiveUI.Primitives.Extensions.Tests;
-
-/// <summary>Configures assembly-wide TUnit defaults via a <see cref="TestDiscovery"/> hook so they are in place before any test executes.</summary>
-internal static class GlobalTestSetup
-{
-    /// <summary>The worker-thread floor for the test process; see <see cref="ConfigureDefaults"/>.</summary>
-    private const int MinPoolThreads = 32;
-
-    /// <summary>The per-test time cap for the whole assembly; see <see cref="ConfigureDefaults"/>.</summary>
-    private static readonly TimeSpan DefaultTestTimeout = TimeSpan.FromSeconds(60);
-
-    /// <summary>
-    /// Caps every test at 60 seconds and raises the thread-pool worker floor before any test runs.
-    /// <para>
-    /// The 60s cap: without a default, a single flaky test that hangs stalls the entire assembly (the
-    /// whole suite is serialised via <c>[assembly: NotInParallel(nameof(UnhandledExceptionHandler))]</c>)
-    /// and we lose the per-test failure signal — CI just reports the workflow-level timeout. 60s is far
-    /// above every legitimate test (slowest non-cancellation test is ~5s) so any future hang fails its
-    /// own test with a clear message instead of killing the whole run.
-    /// </para>
-    /// <para>
-    /// The thread-pool floor: several tests rendezvous two blocking work items on the default pool
-    /// (e.g. <c>Continuation</c>'s <c>Barrier.SignalAndWait</c>, scheduled retries). A busy CI runner can
-    /// saturate the pool, which only hill-climbs new workers ~1/sec, so a rendezvous needing a second
-    /// thread can miss its guard window and time out. Raising the floor makes those threads available
-    /// immediately rather than starved behind unrelated work.
-    /// </para>
-    /// </summary>
-    /// <param name="context">The TUnit test-discovery context exposing programmatic settings.</param>
-    [Before(TestDiscovery)]
-    public static void ConfigureDefaults(BeforeTestDiscoveryContext context)
-    {
-        context.Settings.Timeouts.DefaultTestTimeout = DefaultTestTimeout;
-
-        ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
-        _ = ThreadPool.SetMinThreads(
-            Math.Max(workerThreads, MinPoolThreads),
-            Math.Max(completionPortThreads, MinPoolThreads));
-    }
-}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
index 4d9726d8..59c0b401 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
@@ -22,9 +22,6 @@ public class FirstAsValueTaskHelperTests
     /// <summary>Value used to verify subsequent values are ignored.</summary>
     private const int SecondValue = 11;
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the helper completes with the first value the source emits.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -97,7 +94,7 @@ public async Task WhenAwaitedBeforeEmission_ThenCompletesOnLaterValue()
         Subject<int> subject = new();
         var pending = FirstAsValueTaskHelper<int>.FirstAsValueTask(subject).AsTask();
         subject.OnNext(FirstValue);
-        var result = await pending.WaitAsync(GuardTimeout);
+        var result = await pending;
         await Assert.That(result).IsEqualTo(FirstValue);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
index 1290bec0..505e9ce7 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
-/// <summary>Coverage for the scheduler-routed overloads of the WaitFor* helpers on
-/// <see cref = "ObservableSubscriptionExtensions"/>. The non-scheduler overloads are
-/// already covered in the companion file; these dispatch the subscribe call via a
-/// scheduler before blocking.</summary>
+/// <summary>Tests helpers that schedule subscription before waiting for values or termination.</summary>
 public partial class ObservableSubscriptionExtensionsTests
 {
     /// <summary>Sentinel value emitted by single-value scheduler tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
index 4403d08c..c84123ae 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Linq;
-using System.Reactive.Subjects;
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
@@ -17,7 +16,7 @@ public partial class ObservableSubscriptionExtensionsTests
     private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
 
     /// <summary>Deadline handed to the blocking helpers when the source never terminates, so the wait must expire.</summary>
-    private static readonly TimeSpan ExpiredTimeout = TimeSpan.FromMilliseconds(50);
+    private static readonly TimeSpan ExpiredTimeout = TimeSpan.Zero;
 
     /// <summary>Verifies that <c>SubscribeGetValue</c> returns the last synchronously-emitted value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -102,9 +101,6 @@ public async Task WhenWaitForValueTimesOut_ThenTimeoutException()
     [Test]
     public async Task WhenWaitForCompletion_ThenReturnsAfterTerminal()
     {
-        // Helper returns void on success; the absence of TimeoutException after a synchronous
-        // completion is the contract under test. Use the value-returning sibling for the actual
-        // assertion so TUnit has a real check.
         Observable.Return(RxVoid.Default).WaitForCompletion(WaitTimeout);
         var subsequent = Observable.Return(RxVoid.Default).SubscribeGetValue();
         await Assert.That(subsequent).IsEqualTo(RxVoid.Default);
@@ -183,17 +179,8 @@ public async Task WhenWaitForErrorTimesOut_ThenTimeoutException()
     /// pass-through to the scheduler-aware core with default timeout.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenWaitForCompletionUnitDefault_ThenReturnsOnCompletion()
-    {
-        Subject<RxVoid> subject = new();
-        var pump = Task.Run(() =>
-        {
-            subject.OnNext(RxVoid.Default);
-            subject.OnCompleted();
-        });
-        subject.WaitForCompletion();
-        await pump;
-    }
+    public async Task WhenWaitForCompletionUnitDefault_ThenReturnsOnCompletion() =>
+        await Assert.That(static () => Observable.Return(RxVoid.Default).WaitForCompletion()).ThrowsNothing();
 
     /// <summary>Exercises the no-op <c>OnError</c> body of <c>ValueCaptureWitness</c> —
     /// <c>SubscribeGetValue</c> on an erroring source still returns the last captured value
@@ -227,10 +214,7 @@ public async Task WhenSubscribeGetErrorSourceCompletesWithValue_ThenReturnsNull(
     [Test]
     public async Task WhenWaitForValueSourceErrors_ThenGateSignalledAndDefaultReturned()
     {
-        Subject<int> subject = new();
-        var pump = Task.Run(() => subject.OnError(new InvalidOperationException("source-error")));
-        var value = subject.WaitForValue();
-        await pump;
+        var value = Observable.Throw<int>(new InvalidOperationException("source-error")).WaitForValue();
         await Assert.That(value).IsEqualTo(0);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs
index 78a0c0ed..9044ff1d 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the boolean-reduce operators backed by
-/// <c>BooleanReduceObservable</c> — empty-source short-circuit, partial-value
-/// suppression, target match/mismatch, error broadcast.</summary>
+/// <summary>Tests boolean aggregation of empty and partially populated sources and error forwarding.</summary>
 public class BooleanReduceObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs
index de105049..dcc81021 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the factory overload of <c>CatchAndReturn</c>
-/// backed by <c>CatchAndReturnWithFactoryObservable&lt;T, TException&gt;</c> —
-/// matching exception path, non-matching exception passthrough, and
-/// factory-error propagation.</summary>
+/// <summary>Tests exception filtering and fallback factory error propagation.</summary>
 public class CatchAndReturnWithFactoryObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs
index 0c167ab4..a1f360f6 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>CatchIgnore&lt;TSource, TException&gt;</c> backed by
-/// <c>CatchIgnoreObservable&lt;TSource, TException&gt;</c> — exception filtering and the
-/// action-throws branch.</summary>
+/// <summary>Tests exception filtering and recovery action failures.</summary>
 public class CatchIgnoreObservableTests
 {
     /// <summary>Verifies that <c>CatchIgnore</c> invokes the action and completes on a matching exception.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
index 44f414ec..5656de05 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
@@ -9,10 +9,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the <c>Conflate</c> operator backed by
-/// <c>ConflateObservable&lt;T&gt;</c> — source-error path through the scheduler
-/// marshaller, completion-while-throttled, fast-path interruption by a newer value,
-/// and dispose mid-drain.</summary>
+/// <summary>Tests conflated value replacement, scheduled termination, and disposal during delivery.</summary>
 public class ConflateObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -70,10 +67,7 @@ public async Task WhenConflateNewerValueDuringThrottle_ThenReplacesPending()
         subject.OnNext(Third);
         scheduler.AdvanceBy(UpdatePeriodTicks * SettleMultiplier);
 
-        // Inside the throttle window: the first pending value is replaced by the newer one.
-        await Assert.That(results.Count).IsGreaterThanOrEqualTo(1);
-        await Assert.That(results).DoesNotContain(First);
-        await Assert.That(results).Contains(Second);
+        await Assert.That(results).IsCollectionEqualTo([Second, Third]);
     }
 
     /// <summary>Verifies that completion before any throttled emission flushes through.</summary>
@@ -107,10 +101,7 @@ public async Task WhenConflateDisposedBeforeScheduledEmission_ThenSuppressed()
         sub.Dispose();
         scheduler.AdvanceBy(UpdatePeriodTicks);
 
-        // Initial value may or may not have fired before disposal but no late emission must arrive.
-        var snapshot = results.Count;
-        scheduler.AdvanceBy(UpdatePeriodTicks);
-        await Assert.That(results.Count).IsEqualTo(snapshot);
+        await Assert.That(results).IsEmpty();
     }
 
     /// <summary>Verifies that an <c>OnNext</c> arriving after the source has completed is silently dropped.</summary>
@@ -175,10 +166,7 @@ public async Task WhenOnCompletedAfterError_ThenDropped()
         await Assert.That(completed).IsFalse();
     }
 
-    /// <summary>Verifies <see cref = "ConflateObservable{T}.ConflateSink"/>'s
-    /// post-dispose <c>Enqueue</c> guard by constructing the sink directly, disposing it, and then
-    /// pushing notifications — exercising the defensive branch that is otherwise unreachable
-    /// through the front-door <c>Conflate</c> pipeline.</summary>
+    /// <summary>Verifies disposal suppresses queued notifications and callbacks already removed from the queue.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSinkEnqueuedAfterDispose_ThenSilentlyDropped()
@@ -193,15 +181,16 @@ public async Task WhenSinkEnqueuedAfterDispose_ThenSilentlyDropped()
         sink.OnNext(1);
         sink.OnError(new InvalidOperationException("late"));
         sink.OnCompleted();
+        sink.ProcessNext(First);
+        sink.ForwardError(new InvalidOperationException("dequeued"));
+        sink.ForwardCompleted();
         scheduler.AdvanceBy(UpdatePeriodTicks);
         await Assert.That(downstream.Values).IsEmpty();
         await Assert.That(downstream.Error).IsNull();
         await Assert.That(downstream.Completed).IsFalse();
     }
 
-    /// <summary>Verifies <see cref = "ConflateObservable{T}.ConflateSink"/>'s
-    /// after-terminal guards on <c>OnNext</c>, <c>OnError</c>, and <c>OnCompleted</c> by constructing
-    /// the sink directly, terminating via <c>OnError</c>, and then pushing follow-up notifications.</summary>
+    /// <summary>Verifies notifications received after termination are ignored.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSinkEventsAfterTerminated_ThenDropped()
@@ -224,9 +213,7 @@ public async Task WhenSinkEventsAfterTerminated_ThenDropped()
         await Assert.That(downstream.Completed).IsFalse();
     }
 
-    /// <summary>Recording observer used to verify direct-invocation tests of the conflate sink
-    /// and marshaller — does not race with a scheduler, so the assertion sees exactly the
-    /// notifications that were forwarded.</summary>
+    /// <summary>Records notifications delivered by explicitly invoked sink operations.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class RecordingWitness<T> : IObserver<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
index 89cc4e27..0093facf 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Coverage for <c>DetectStaleObservable</c>'s subscription-teardown branch — when the source
-/// terminates synchronously during subscribe, the sink is already done by the time the upstream handle
-/// is attached, so the attach disposes it instead of recording it.</summary>
+/// <summary>Tests disposal of an upstream subscription returned after synchronous source termination.</summary>
 public class DetectStaleObservableTests
 {
     /// <summary>Staleness window used by the tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs
index 7cf94151..ac8333f0 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs
@@ -6,8 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Coverage for <c>DoOnDisposeObservable</c> — the dispose action fires exactly once even when
-/// the subscription is disposed multiple times, and the upstream is torn down before the action runs.</summary>
+/// <summary>Tests that the disposal action runs once after upstream disposal.</summary>
 public class DoOnDisposeObservableTests
 {
     /// <summary>Verifies the dispose action fires once and the upstream is detached on first dispose, and a
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
index b69dfef7..7b5c1702 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
@@ -2,11 +2,13 @@
 // ReactiveUI Association Incorporated 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.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>DropIfBusyObservable&lt;T&gt;</c>.</summary>
+/// <summary>Tests handler completion and error delivery around source termination.</summary>
 public class DropIfBusyObservableTests
 {
     /// <summary>Verifies a handler completion after source completion does not emit the value.</summary>
@@ -14,22 +16,14 @@ public class DropIfBusyObservableTests
     [Test]
     public async Task WhenHandlerCompletesAfterSourceDone_ThenValueDropped()
     {
-        Subject<int> subject = new();
-
-        // The release gate completes its continuations inline, so the handler's tail runs here.
-        TaskCompletionSource release = new();
-        TaskCompletionSource handlerResumed = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> values = [];
         var completed = false;
-        using var sub = subject.DropIfBusy(async _ =>
-        {
-            await release.Task.ConfigureAwait(false);
-            handlerResumed.SetResult();
-        }).Subscribe(values.Add, () => completed = true);
-        subject.OnNext(1);
-        subject.OnCompleted();
+        using DropIfBusyObservable<int>.DropIfBusySink sink = new(Observer.Create<int>(values.Add, () => completed = true), _ => new ValueTask(release.Task));
+        var processing = sink.OnNextAsync(1);
+        sink.OnCompleted();
         release.SetResult();
-        await handlerResumed.Task;
+        await processing;
         await Assert.That(values).IsEmpty();
         await Assert.That(completed).IsTrue();
     }
@@ -39,24 +33,24 @@ public async Task WhenHandlerCompletesAfterSourceDone_ThenValueDropped()
     [Test]
     public async Task WhenHandlerThrowsAfterSourceDone_ThenErrorDropped()
     {
-        Subject<int> subject = new();
-
-        // The release gate completes its continuations inline, so the handler throws here.
-        TaskCompletionSource release = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new("late-handler");
         Exception? caught = null;
         var completed = false;
-        using var sub = subject.DropIfBusy(async _ =>
-        {
-            await release.Task.ConfigureAwait(false);
-            throw expected;
-        }).Subscribe(
-            static _ => { },
-            ex => caught = ex,
-            () => completed = true);
-        subject.OnNext(1);
-        subject.OnCompleted();
+        using DropIfBusyObservable<int>.DropIfBusySink sink = new(
+            Observer.Create<int>(
+                static _ => { },
+                ex => caught = ex,
+                () => completed = true),
+            async _ =>
+            {
+                await release.Task.ConfigureAwait(false);
+                throw expected;
+            });
+        var processing = sink.OnNextAsync(1);
+        sink.OnCompleted();
         release.SetResult();
+        await processing;
         await Assert.That(caught).IsNull();
         await Assert.That(completed).IsTrue();
     }
@@ -82,8 +76,8 @@ public async Task WhenSourceErrorsBeforeDone_ThenForwardsError()
     public async Task WhenHandlerThrowsBeforeDone_ThenForwardsError()
     {
         Subject<int> subject = new();
-        TaskCompletionSource release = new();
-        TaskCompletionSource<Exception> error = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<Exception> error = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new("handler");
         using var sub = subject.DropIfBusy(async _ =>
         {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
index ad7f72aa..e0bd4599 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
@@ -8,10 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Coverage for the asynchronous-projection path of
-/// <c>FirstMatchFromCandidates</c> backed by <c>FirstMatchFromCandidatesObservable</c>
-/// — empty candidate list, async-projection match, async-projection no-match falls back,
-/// async-projection error skips, and dispose during the async walk.</summary>
+/// <summary>Tests asynchronous candidate matching, fallback, errors, and cancellation.</summary>
 public class FirstMatchFromCandidatesAsyncPathTests
 {
     /// <summary>Fallback value emitted when no candidate matches.</summary>
@@ -29,9 +26,6 @@ public class FirstMatchFromCandidatesAsyncPathTests
     /// <summary>Candidate key whose projection emits the match value.</summary>
     private const string HitKey = "hit";
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that an empty candidate list emits the fallback and completes.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -67,7 +61,7 @@ public async Task WhenAsyncProjectionMatches_ThenEmitsMatch()
                 Fallback).Subscribe(results.Add, () => completed.TrySetResult(true));
         emissionGate.OnNext(HitKey);
         emissionGate.OnCompleted();
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
@@ -90,7 +84,7 @@ public async Task WhenAsyncProjectionNeverMatches_ThenFallback()
                 Fallback).Subscribe(results.Add, () => completed.TrySetResult(true));
         subject.OnNext("nope");
         subject.OnCompleted();
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(results).IsCollectionEqualTo([Fallback]);
     }
 
@@ -114,7 +108,7 @@ public async Task WhenAsyncProjectionErrors_ThenSkipsToNextCandidate()
         badSubject.OnError(new InvalidOperationException("bad failed"));
         goodSubject.OnNext("good");
         goodSubject.OnCompleted();
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(results).IsCollectionEqualTo(["good"]);
     }
 
@@ -132,9 +126,6 @@ public async Task WhenDisposedDuringAsyncWalk_ThenStops()
             .Subscribe(results.Add, () => completed = true);
         sub.Dispose();
 
-        // Second dispose hits the Interlocked.Exchange null-loser branch in AsyncSink.Dispose
-        // — the first call swapped in null and disposed the previous subscription, so the
-        // second call sees null and the `?.Dispose()` no-op fires.
         sub.Dispose();
         firstSubject.OnNext("late");
         firstSubject.OnCompleted();
@@ -220,7 +211,7 @@ public async Task WhenAsyncCandidateEmitsAfterMatch_ThenDroppedByDoneGuard()
             .FirstMatchFromCandidates(_ => subject, static raw => raw, static value => value == HitKey, Fallback)
             .Subscribe(results.Add, () => completed.TrySetResult());
         subject.OnNext(HitKey);
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         subject.OnNext("ignored-late");
         subject.OnError(new InvalidOperationException("ignored-late"));
         subject.OnCompleted();
@@ -234,10 +225,7 @@ public async Task WhenAsyncCandidateEmitsAfterMatch_ThenDroppedByDoneGuard()
     [Test]
     public async Task WhenAsyncSinkWalkHitsSyncErroringCandidate_ThenLoopingGuardSkipsAhead()
     {
-        // First candidate's projection is async (never completes during Subscribe), forcing
-        // TrySyncLoop to hand off to AsyncSink. Second candidate's projection synchronously
-        // errors during AsyncSink.TryNext's loop iteration, hitting AsyncSink.OnError with
-        // _looping == true.
+        // The second candidate errors synchronously after the first asynchronous candidate completes.
         string[] keys = [AsyncKey, SyncErrorKey, HitKey];
         Subject<string> asyncSubject = new();
         List<string> results = [];
@@ -253,12 +241,9 @@ public async Task WhenAsyncSinkWalkHitsSyncErroringCandidate_ThenLoopingGuardSki
             static value => value == HitKey,
             Fallback).Subscribe(results.Add, () => completed.TrySetResult());
 
-        // Complete the async subject — AsyncSink.OnCompleted runs (outside TryNext, so _looping
-        // is false), which invokes TryNext. The next iteration projects SyncErrorKey whose
-        // SyncErroringObservable.Subscribe calls observer.OnError synchronously, re-entering
-        // AsyncSink.OnError while _looping is still true — hitting the looping-guard return.
+        // Completing the first candidate starts the synchronously failing candidate.
         asyncSubject.OnCompleted();
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
@@ -284,7 +269,7 @@ public async Task WhenAsyncSinkWalkHitsSyncCompletingCandidate_ThenLoopingGuardS
             static value => value == HitKey,
             Fallback).Subscribe(results.Add, () => completed.TrySetResult());
         asyncSubject.OnCompleted();
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
index e03af031..fd4d54ec 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
@@ -30,9 +30,6 @@ public class ForEachObservableTests
     /// <summary>Scheduler-delivered sentinel.</summary>
     private const int ScheduledThirty = 30;
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that a null inner enumerable is ignored and subsequent batches continue flowing.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -56,8 +53,10 @@ public async Task WhenForEachWithScheduler_ThenDeliversAllValues()
         var source = batches.ToObservable();
         TaskCompletionSource<List<int>> done = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
-        using var sub = source.ForEach(Sequencer.Default).Subscribe(results.Add, () => done.TrySetResult(results));
-        var output = await done.Task.WaitAsync(GuardTimeout);
+        VirtualClock scheduler = new();
+        using var sub = source.ForEach(scheduler).Subscribe(results.Add, () => done.TrySetResult(results));
+        scheduler.Start();
+        var output = await done.Task;
         await Assert.That(output).IsCollectionEqualTo([ScheduledTen, ScheduledTwenty, ScheduledThirty]);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
index b13df8e2..9c87ba86 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>Heartbeat</c> backed by
-/// <c>HeartbeatObservable&lt;T&gt;</c> — heartbeat-on-quiet, error/completion
-/// forwarding, and post-terminal timer suppression.</summary>
+/// <summary>Tests heartbeats during source inactivity and cancellation after termination.</summary>
 public class HeartbeatObservableTests
 {
     /// <summary>Heartbeat period for the scheduler-driven tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
index 90e8af85..74161728 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the <c>GetMin</c> / <c>GetMax</c> operators
-/// backed by <c>MinMaxObservable&lt;T&gt;</c> — partial-source suppression,
-/// max/min selection over multiple updates, and source-error propagation.</summary>
+/// <summary>Tests extrema across source updates, missing initial values, and source errors.</summary>
 public class MinMaxObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
index 311cb6c0..bc56ce74 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
@@ -7,17 +7,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the reactive-condition <c>ObserveOnIf</c> overload
-/// backed by <c>ObserveOnIfObservable&lt;T&gt;</c> — condition switching, error forwarding,
-/// and completion forwarding.</summary>
+/// <summary>Tests scheduler selection from condition changes and terminal notification forwarding.</summary>
 public class ObserveOnIfObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that values dispatch on the false-scheduler before any condition arrives.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -32,7 +27,7 @@ public async Task WhenObserveOnIfNoCondition_ThenUsesFalseScheduler()
         using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
             .Subscribe(v => emitted.TrySetResult(v));
         source.OnNext(Value);
-        var v2 = await emitted.Task.WaitAsync(GuardTimeout);
+        var v2 = await emitted.Task;
         await Assert.That(v2).IsEqualTo(Value);
         await Assert.That(falseScheduler.ScheduleCount).IsGreaterThanOrEqualTo(1);
         await Assert.That(trueScheduler.ScheduleCount).IsEqualTo(0);
@@ -53,7 +48,7 @@ public async Task WhenObserveOnIfConditionTrue_ThenUsesTrueScheduler()
             .Subscribe(v => emitted.TrySetResult(v));
         condition.OnNext(true);
         source.OnNext(Value);
-        var v2 = await emitted.Task.WaitAsync(GuardTimeout);
+        var v2 = await emitted.Task;
         await Assert.That(v2).IsEqualTo(Value);
         await Assert.That(trueScheduler.ScheduleCount).IsGreaterThanOrEqualTo(1);
     }
@@ -67,7 +62,7 @@ public async Task WhenObserveOnIfSourceErrors_ThenForwardsError()
         Subject<bool> condition = new();
         Exception? caught = null;
         InvalidOperationException expected = new(SourceErrorMessage);
-        using var sub = source.ObserveOnIf(condition, TaskPoolSequencer.Default, Sequencer.Immediate).Subscribe(
+        using var sub = source.ObserveOnIf(condition, new RecordingScheduler(), Sequencer.Immediate).Subscribe(
             static _ => { },
             ex => caught = ex);
         source.OnError(expected);
@@ -82,7 +77,7 @@ public async Task WhenObserveOnIfSourceCompletes_ThenForwardsCompletion()
         Subject<int> source = new();
         Subject<bool> condition = new();
         var completed = false;
-        using var sub = source.ObserveOnIf(condition, TaskPoolSequencer.Default, Sequencer.Immediate).Subscribe(
+        using var sub = source.ObserveOnIf(condition, new RecordingScheduler(), Sequencer.Immediate).Subscribe(
             static _ => { },
             () => completed = true);
         source.OnCompleted();
@@ -180,14 +175,14 @@ public async Task WhenObserveOnIfConditionDuplicate_ThenSilentlyShortCircuits()
 
         // Sanity: subsequent value still routes through the true-scheduler (the duplicate did
         // not corrupt the captured state).
-        await Assert.That(values.Count).IsLessThanOrEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([1]);
     }
 
     /// <summary>Sequencer that delegates to the default thread-pool sequencer but records each scheduled work item.</summary>
     private sealed class RecordingScheduler : ISequencer
     {
         /// <summary>Backing scheduler used to actually dispatch work.</summary>
-        private readonly TaskPoolSequencer _inner = TaskPoolSequencer.Default;
+        private readonly ImmediateSequencer _inner = Sequencer.Immediate;
 
         /// <summary>Gets the number of recorded schedule calls.</summary>
         public int ScheduleCount { get; private set; }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
index 79111667..e00a6485 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
@@ -9,9 +9,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Coverage for <c>ObserveOnObservable</c> (reached via <c>ObserveOnSafe</c>) — the
-/// immediate-scheduler passthrough, the queue-and-drain marshaller's value / error / completion
-/// forwarding, dispose teardown, and the attach-after-terminated branch of the shared drain state.</summary>
+/// <summary>Tests immediate delivery, scheduled notifications, and subscription disposal.</summary>
 public class ObserveOnObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -146,9 +144,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Scheduler that runs scheduled work synchronously on the calling thread, so a drain pass
-    /// executes inline during the schedule call. Distinct instance from <see cref = "Sequencer.Immediate"/>
-    /// so the operator's immediate-scheduler passthrough does not apply.</summary>
+    /// <summary>Runs work inline while retaining the operator's queued delivery path.</summary>
     private sealed class InlineScheduler : ISequencer
     {
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
index 47b1c064..bbb0d56c 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
@@ -11,12 +11,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Covers the consistent <c>if (_done) return;</c> after-terminal guards on the
-/// remaining sync operators that share the pattern but lacked dedicated coverage —
-/// <c>RetryWithDelay</c>, <c>OnErrorRetry</c>, <c>TakeUntilInclusive</c>, <c>SwitchIfEmpty</c>,
-/// <c>ThrottleOnScheduler</c>, <c>BufferUntilIdle</c>, <c>ObserveOnIf</c>. Each test drives a
-/// <see cref = "SyncDirectSource{T}"/> through one terminal event, then pushes additional
-/// notifications past the terminal to verify the guard silently drops them.</summary>
+/// <summary>Tests suppression of notifications after source termination.</summary>
 public class OperatorAfterTerminalGuardTests
 {
     /// <summary>Retry delay handed to the retry operators under test.</summary>
@@ -230,10 +225,7 @@ public async Task WhenDropIfBusyEventsAfterCompleted_ThenDropped()
     [Test]
     public async Task WhenWhileDownstreamDisposesInsideOnNext_ThenIterateGuardSkipsNextPredicate()
     {
-        // The scheduler indirection lets us defer the first iteration to after Subscribe has
-        // returned (so the SingleAssignmentDisposable can capture the subscription), then run
-        // the inner iterations synchronously enough that the OnNext-side dispose hits before
-        // the second Iterate evaluates the predicate.
+        // Capture the subscription before running the iteration that disposes it.
         VirtualClock scheduler = new();
         var actionCalls = 0;
         SingleAssignmentDisposable sub = new();
@@ -463,7 +455,7 @@ public async Task WhenScheduledSourceActionThrows_ThenForwardsError()
     public async Task WhenSubscribeSynchronousOmitsErrorAndCompletedCallbacks_ThenNullPathsTaken()
     {
         Subject<int> subject = new();
-        TaskCompletionSource processed = new();
+        TaskCompletionSource processed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SubscribeSynchronous(value =>
         {
             _ = processed.TrySetResult();
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs
index 3d844f6e..6c259191 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Coverage for the multi-subscriber and idempotent-dispose paths of
-/// <c>Partition</c> backed by <c>PartitionObservable&lt;T&gt;</c> — three observers on
-/// one side, mid-array removal, and double-dispose of a side subscription.</summary>
+/// <summary>Tests multiple partition subscribers and idempotent subscriber removal.</summary>
 public partial class PartitionObservableTests
 {
     /// <summary>Verifies that three observers on the same side each receive every matching value.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs
index 73d1cf1d..5d7ae27d 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>Partition</c> backed by
-/// <c>PartitionObservable&lt;T&gt;</c> — both-sides routing, single-side disposal,
-/// error broadcast, completion broadcast, and re-subscription after both sides drop.</summary>
+/// <summary>Tests partition routing, shared source lifetime, and terminal notifications.</summary>
 public partial class PartitionObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -167,8 +165,7 @@ public async Task WhenSubscriptionDisposedAfterParentSinkTornDown_ThenNoOp()
         var first = evens.Subscribe(static _ => { });
         first.Dispose();
 
-        // Subscribe again to create a fresh sink, then dispose the OLD disposable a second time
-        // (which now finds _sink == null because the prior tear-down already nulled it).
+        // Repeated disposal must leave the replacement subscription active.
         using var second = evens.Subscribe(static _ => { });
         first.Dispose();
         List<int> results = [];
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs
index cbde3952..705cfd3b 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>ToPropertyObservable</c> backed by
-/// <c>PropertyChangedObservable&lt;T, TProperty&gt;</c> — initial-value emission,
-/// matching-name forwarding, unmatched-name filtering, getter-throws forwarding,
-/// and dispose detaches the handler.</summary>
+/// <summary>Tests initial property values, name filtering, getter errors, and handler removal.</summary>
 public class PropertyChangedObservableTests
 {
     /// <summary>Initial property value.</summary>
@@ -114,16 +111,13 @@ public async Task WhenPropertyEventFiresAfterDispose_ThenHandlerGuardSkipsForwar
 
         sub.Dispose();
 
-        // Even after Dispose, the retaining owner still references the handler — invoking the
-        // event delivers to it, but the handler observes _disposed != 0 and returns early.
+        // The owner retains the handler after disposal; further events must be ignored.
         owner.Raise();
 
         await Assert.That(results).IsCollectionEqualTo([0]);
     }
 
-    /// <summary>INPC owner that retains every handler ever attached and exposes a manual
-    /// <c>Raise</c> so a test can fire the PropertyChanged event after the subscription that
-    /// added the handler has already been disposed.</summary>
+    /// <summary>Retains removed event handlers so tests can invoke callbacks after disposal.</summary>
     private sealed class RetainingObservableOwner : INotifyPropertyChanged
     {
         /// <summary>The retained handler list.</summary>
@@ -139,9 +133,7 @@ public event PropertyChangedEventHandler? PropertyChanged
             }
         }
 
-        /// <summary>Gets the observed property. This fixture never writes it, so every read yields zero —
-        /// what is under test is the notification, not the value. It stays an instance auto-property
-        /// because that is what the <c>ToPropertyObservable</c> expression tree resolves against.</summary>
+        /// <summary>Gets the observed property, whose value remains zero.</summary>
         public int Value { get; }
 
         /// <summary>Invokes the retained handler with a <c>PropertyChanged</c> event for <see cref="Value"/>.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs
index 7e8f80df..92986704 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs
@@ -8,12 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for several small synchronous operators:
-/// <c>WhereSelect</c>, <c>FromArray</c>, <c>RetryWithDelay</c>,
-/// <c>RetryForeverWithDelay</c>, <c>ThrottleOnScheduler</c>,
-/// <c>ThrottleDistinct</c> (sync), <c>SubscribeAndComplete</c> error path,
-/// <c>Schedule</c> with side-effect and transform overloads,
-/// <c>ToReadOnlyBehavior</c>, and <c>Pairwise</c> after-error path.</summary>
+/// <summary>Tests retry, throttle, scheduling, and source factory termination.</summary>
 public class RetryAndThrottleAndFactoryOperatorTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -135,14 +130,14 @@ public async Task WhenFromArrayEnumerationThrows_ThenForwardsError()
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
-    /// <summary>Verifies that <c>RetryWithDelay</c> retries the configured number of times with
-    /// a zero delay (so retries happen synchronously on the default scheduler).</summary>
+    /// <summary>Verifies zero-delay retries exhaust the configured count and forward the source error.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenRetryWithDelayAlwaysFails_ThenRetriesThenErrors()
     {
         const int RetryCount = 3;
         var attempts = 0;
+        Exception? caught = null;
         InvalidOperationException expected = new("attempt failed");
         var source = Observable.Create<int>(o =>
         {
@@ -152,10 +147,10 @@ public async Task WhenRetryWithDelayAlwaysFails_ThenRetriesThenErrors()
         });
         using var sub = source.RetryWithDelay(RetryCount, static _ => TimeSpan.Zero).Subscribe(
             static _ => { },
-            static _ => { });
+            error => caught = error);
 
-        // Initial attempt + RetryCount retries = RetryCount+1 total invocations.
-        await Assert.That(attempts).IsGreaterThan(1);
+        await Assert.That(attempts).IsEqualTo(RetryCount + 1);
+        await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
     /// <summary>Verifies that <c>RetryForeverWithDelay</c> keeps retrying after failures.</summary>
@@ -181,7 +176,7 @@ public async Task WhenRetryForeverWithDelay_ThenKeepsRetrying()
         });
         List<int> results = [];
         using var sub = source.RetryForeverWithDelay(TimeSpan.Zero).Subscribe(results.Add);
-        await Assert.That(attempts).IsGreaterThanOrEqualTo(Value3);
+        await Assert.That(attempts).IsEqualTo(Value3);
         await Assert.That(results).IsCollectionEqualTo([Value1]);
     }
 
@@ -217,7 +212,7 @@ public async Task WhenThrottleOnSchedulerSourceErrors_ThenForwardsError()
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
-    /// <summary>Verifies that <c>ThrottleDistinct</c> (sync overload, no scheduler) emits distinct values respecting the throttle window.</summary>
+    /// <summary>Verifies the default-scheduler overload forwards source errors.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenThrottleDistinctSyncDefaultScheduler_ThenForwardsSourceError()
@@ -246,7 +241,7 @@ public async Task WhenThrottleDistinctSyncWithScheduler_ThenSuppressesUpstreamDu
         subject.OnNext(Value1);
         subject.OnNext(Value1);
         scheduler.AdvanceBy(AdvancePastWindowTicks);
-        await Assert.That(results.Count).IsLessThanOrEqualTo(1);
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
     }
 
     /// <summary>Verifies that <c>ToReadOnlyBehavior</c> returns a paired observable / observer that
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs
index 22d2541d..8b6f5c6c 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs
@@ -2,22 +2,47 @@
 // ReactiveUI Association Incorporated 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.Linq;
 using System.Reactive.Subjects;
 using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>RunAll</c> backed by <c>RunAllObservable</c> —
-/// empty-list short-circuit, sequential walk through synchronous and asynchronous
-/// sources, error propagation, and disposal mid-walk.</summary>
+/// <summary>Tests sequential source execution, empty input, errors, and disposal during execution.</summary>
 public class RunAllObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
+    /// <summary>Verifies disposal prevents a pending run from reporting completion.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task RunCompletionAfterDisposalIsIgnored()
+    {
+        List<RxVoid> values = [];
+        var completed = false;
+        RunAllObservable.Sink sink = new(Observer.Create<RxVoid>(values.Add, () => completed = true), []);
+        sink.Dispose();
+        sink.CompleteRun();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies repeated run completion emits exactly one value and terminal notification.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task RunCompletionIsDeliveredOnce()
+    {
+        List<RxVoid> values = [];
+        var completed = 0;
+        using RunAllObservable.Sink sink = new(Observer.Create<RxVoid>(values.Add, () => completed++), []);
+        sink.CompleteRun();
+        sink.CompleteRun();
+        await Assert.That(values).IsCollectionEqualTo([RxVoid.Default]);
+        await Assert.That(completed).IsEqualTo(1);
+    }
 
     /// <summary>Verifies that an empty list emits <see cref = "RxVoid"/> and completes immediately.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -75,7 +100,7 @@ public async Task WhenRunAllAsyncSources_ThenWalksSequentially()
         subjectA.OnCompleted();
         await Assert.That(subjectB.HasObservers).IsTrue();
         subjectB.OnCompleted();
-        var done = await completed.Task.WaitAsync(GuardTimeout);
+        var done = await completed.Task;
         await Assert.That(done).IsTrue();
     }
 
@@ -111,16 +136,12 @@ public async Task WhenRunAllDisposedMidWalk_ThenStops()
             () => completed = true);
         sub.Dispose();
 
-        // Second dispose hits the Interlocked.Exchange null-loser branch in Sink.Dispose —
-        // the first call swapped in null and disposed the previous subscription, so the
-        // second call sees null and the `?.Dispose()` no-op fires.
         sub.Dispose();
         subjectA.OnCompleted();
         await Assert.That(completed).IsFalse();
         await Assert.That(subjectB.HasObservers).IsFalse();
     }
 
-    /// <summary>Returns <c>[0, 1, …, count-1]</c> for collection-equality assertions.</summary>
     /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
     /// arriving from a candidate after <c>RunAll</c> has already completed are silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
@@ -144,10 +165,7 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         await Assert.That(caught).IsNull();
     }
 
-    /// <summary>Exercises <c>RunAll.RunNext</c>'s post-loop <c>_done</c> guard — a source
-    /// that synchronously errors during <c>Subscribe</c> sets <c>_done = true</c> inline,
-    /// the <c>while (!_done ...)</c> loop bails, and the post-loop check returns without
-    /// emitting <c>RxVoid.Default</c>.</summary>
+    /// <summary>Verifies synchronous source errors suppress the final value and completion.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenRunAllSourceSyncErrors_ThenPostLoopDoneGuardSuppressesFinalEmit()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs
index 7ff67b30..bbbbc400 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>SampleLatest</c> backed by
-/// <c>SampleLatestObservable&lt;T&gt;</c> — trigger before any source value,
-/// source completion, source error, trigger error, and trigger completion not
-/// terminating downstream.</summary>
+/// <summary>Tests sampling without a source value and source or trigger termination.</summary>
 public class SampleLatestObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs
index 2d033876..478f6ca4 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Terminal-notification coverage for <c>ScanWithInitial</c> — source error, source completion, and post-terminal value ignore.</summary>
+/// <summary>Tests source termination and suppression of subsequent values.</summary>
 public partial class ScanWithInitialTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
index 5d0f1bdb..3b61b004 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
@@ -106,11 +106,12 @@ public async Task OnCompletedDuringEmission_CompletesOnceAndStopsAccumulating()
                    x =>
                    {
                        results.Add(x);
-                       if (results.Count == EmissionsBeforeCompletion)
+                       if (results.Count != EmissionsBeforeCompletion)
                        {
-                           // Re-enter the sink with the terminal notification from inside its own emission.
-                           source.OnCompleted();
+                           return;
                        }
+
+                       source.OnCompleted();
                    },
                    static _ => { },
                    () => completedCount++))
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs
index 26d58d8e..e5b9c0e2 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs
@@ -8,12 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage batch for several small synchronous operators:
-/// <c>DetectStale</c>, <c>BufferUntilIdle</c>, <c>DebounceImmediate</c>,
-/// <c>DebounceUntil</c>, <c>Schedule</c> (value and source overloads),
-/// <c>LatestOrDefault</c>, <c>Pairwise</c>, <c>WaitUntil</c>,
-/// <c>SwitchIfEmpty</c>. Tests focus on the terminal/error/disposal branches
-/// that the existing happy-path tests don't already cover.</summary>
+/// <summary>Tests scheduled value delivery, debounce termination, and disposal.</summary>
 public class ScheduledAndDebounceSyncOperatorTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -170,10 +165,8 @@ public async Task WhenDebounceUntilConditionFalse_ThenDebounced()
         await Assert.That(results).IsCollectionEqualTo([Value1]);
     }
 
-    /// <summary>Verifies that <c>Schedule(this T value, TimeSpan, ISequencer)</c> emits the value after the delay.</summary>
+    /// <summary>Verifies scheduled delivery emits a value without completion.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    /// <remarks>The operator preserves the original <c>Observable.Create</c>-based semantics —
-    /// the scheduled callback emits <c>OnNext</c> only; <c>OnCompleted</c> is not signalled.</remarks>
     [Test]
     public async Task WhenScheduleValueWithDelay_ThenEmitsAfterDelay()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs
index aa225c02..6cbcbb47 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Direct coverage for <c>ScheduledSourceObservable&lt;T&gt;</c>'s
-/// no-op terminal handlers and the <c>EmitState</c> action/transform catch block —
-/// branches the happy-path scheduler tests don't reach.</summary>
+/// <summary>Tests ignored terminal handlers and scheduled action or transform failures.</summary>
 public class ScheduledSourceObservableTests
 {
     /// <summary>Sentinel value used by the emission tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
index e1539579..73733bf3 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
@@ -2,13 +2,13 @@
 // ReactiveUI Association Incorporated 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.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>SelectAsyncConcurrent</c> backed by
-/// <c>SelectAsyncConcurrentObservable&lt;TSource, TResult&gt;</c> — error forwarding,
-/// disposal mid-flight, and deferred completion while in-flight selectors finish.</summary>
+/// <summary>Tests concurrent projection completion, errors, and disposal during projection.</summary>
 public class SelectAsyncConcurrentObservableTests
 {
     /// <summary>Synthetic error message attached to a failing selector.</summary>
@@ -30,12 +30,11 @@ public async Task WhenSelectAsyncConcurrentSelectorThrows_ThenForwardsError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new();
+        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new(SelectorErrorMessage);
-        using var sub = subject.SelectAsyncConcurrent(_ => Task.FromException<int>(expected), MaxConcurrencyTwo)
-            .Subscribe(
-                static _ => { },
-                ex => faulted.TrySetResult(ex));
+        using var sub = subject.SelectAsyncConcurrent(_ => Task.FromException<int>(expected), MaxConcurrencyTwo).Subscribe(
+            static _ => { },
+            ex => faulted.TrySetResult(ex));
         subject.OnNext(TriggerValue);
         var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
@@ -62,31 +61,20 @@ public async Task WhenSelectAsyncConcurrentSourceErrors_ThenForwardsError()
     public async Task WhenSelectAsyncConcurrentDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
     {
         const int TriggerValue = 1;
-        Subject<int> subject = new();
-
-        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> selectorResumed = new();
+        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
         var completed = false;
-        var sub = subject.SelectAsyncConcurrent(
-            async x =>
-            {
-                await gate.Task.ConfigureAwait(false);
-                _ = selectorResumed.TrySetResult(true);
-                return x;
-            },
-            MaxConcurrencyTwo).Subscribe(results.Add, () => completed = true);
-        subject.OnNext(TriggerValue);
-        subject.OnCompleted();
-        sub.Dispose();
-        gate.SetResult(true);
-        await selectorResumed.Task;
+        SelectAsyncConcurrentObservable<int, int>.SelectAsyncConcurrentSink sink = new(Observer.Create<int>(results.Add, () => completed = true), _ => gate.Task, MaxConcurrencyTwo);
+        var processing = sink.OnNextAsync(TriggerValue);
+        sink.Dispose();
+        gate.SetResult(TriggerValue);
+        await processing;
+        sink.OnCompleted();
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
 
-    /// <summary>Verifies that completion arriving while selectors are still in flight is forwarded after all selectors finish.</summary>
+    /// <summary>Verifies completion waits for every active projection.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCompletion()
@@ -94,9 +82,9 @@ public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCom
         const int First = 1;
         const int Second = 2;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new();
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SelectAsyncConcurrent(
             async x =>
             {
@@ -107,16 +95,13 @@ public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCom
         subject.OnNext(First);
         subject.OnNext(Second);
         subject.OnCompleted();
-
-        // Both selectors are parked on the gate, so nothing can have emitted or completed.
         await Assert.That(completed.Task.IsCompleted).IsFalse();
         await Assert.That(results).IsEmpty();
         gate.SetResult(true);
         var done = await completed.Task;
         await Assert.That(done).IsTrue();
 
-        // Downstream OnNext from this operator is serialized inside the sink's lock, so the
-        // list is safely populated by the time completion fires. Order is concurrent so sort.
+        // Delivery is serialized, but concurrent projections may finish in either order.
         int[] sorted = [.. results];
         Array.Sort(sorted);
         await Assert.That(sorted).IsCollectionEqualTo([First, Second]);
@@ -132,8 +117,7 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         List<int> values = [];
         Exception? caught = null;
         var completedCount = 0;
-        using var sub = source.SelectAsyncConcurrent(Task.FromResult, 1)
-            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+        using var sub = source.SelectAsyncConcurrent(Task.FromResult, 1).Subscribe(values.Add, ex => caught = ex, () => completedCount++);
         source.Observer.OnCompleted();
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
index d6b1fa38..513fcf4c 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
@@ -2,13 +2,13 @@
 // ReactiveUI Association Incorporated 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.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>SelectAsyncSequential</c> backed by
-/// <c>SelectAsyncSequentialObservable&lt;TSource, TResult&gt;</c> — error forwarding,
-/// disposal mid-flight, and completion while an in-flight selector is running.</summary>
+/// <summary>Tests sequential projection completion, errors, and disposal during projection.</summary>
 public class SelectAsyncSequentialObservableTests
 {
     /// <summary>Synthetic error message attached to a failing selector.</summary>
@@ -25,12 +25,10 @@ public async Task WhenSelectAsyncSequentialSelectorThrows_ThenForwardsErrorAndSt
         const int First = 1;
         const int Second = 2;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new();
+        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
         InvalidOperationException expected = new(SelectorErrorMessage);
-        using var sub = subject
-            .SelectAsyncSequential(x => x == First ? Task.FromException<int>(expected) : Task.FromResult(x))
-            .Subscribe(results.Add, ex => faulted.TrySetResult(ex));
+        using var sub = subject.SelectAsyncSequential(x => x == First ? Task.FromException<int>(expected) : Task.FromResult(x)).Subscribe(results.Add, ex => faulted.TrySetResult(ex));
         subject.OnNext(First);
         subject.OnNext(Second);
         var caught = await faulted.Task;
@@ -59,24 +57,15 @@ public async Task WhenSelectAsyncSequentialSourceErrors_ThenForwardsError()
     public async Task WhenSelectAsyncSequentialDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
     {
         const int TriggerValue = 1;
-        Subject<int> subject = new();
-
-        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> selectorResumed = new();
+        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
         var completed = false;
-        var sub = subject.SelectAsyncSequential(async x =>
-        {
-            await gate.Task.ConfigureAwait(false);
-            _ = selectorResumed.TrySetResult(true);
-            return x;
-        }).Subscribe(results.Add, () => completed = true);
-        subject.OnNext(TriggerValue);
-        subject.OnCompleted();
-        sub.Dispose();
-        gate.SetResult(true);
-        await selectorResumed.Task;
+        SelectAsyncSequentialObservable<int, int>.SelectAsyncSequentialSink sink = new(Observer.Create<int>(results.Add, () => completed = true), _ => gate.Task);
+        var processing = sink.OnNextAsync(TriggerValue);
+        sink.Dispose();
+        gate.SetResult(TriggerValue);
+        await processing;
+        sink.OnCompleted();
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
@@ -88,9 +77,9 @@ public async Task WhenSelectAsyncSequentialCompletesWhileProcessing_ThenDeferred
     {
         const int Value = 42;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new();
+        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new();
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SelectAsyncSequential(async x =>
         {
             await gate.Task.ConfigureAwait(false);
@@ -98,8 +87,6 @@ public async Task WhenSelectAsyncSequentialCompletesWhileProcessing_ThenDeferred
         }).Subscribe(results.Add, () => completed.TrySetResult(true));
         subject.OnNext(Value);
         subject.OnCompleted();
-
-        // The selector is parked on the gate, so nothing can have emitted or completed.
         await Assert.That(completed.Task.IsCompleted).IsFalse();
         await Assert.That(results).IsEmpty();
         gate.SetResult(true);
@@ -119,8 +106,7 @@ public async Task WhenEventsAfterTerminated_ThenDropped()
         List<int> values = [];
         Exception? caught = null;
         var completedCount = 0;
-        using var sub = source.SelectAsyncSequential(Task.FromResult)
-            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+        using var sub = source.SelectAsyncSequential(Task.FromResult).Subscribe(values.Add, ex => caught = ex, () => completedCount++);
         source.Observer.OnCompleted();
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
index 5f6c67db..ca47b167 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
@@ -2,13 +2,13 @@
 // ReactiveUI Association Incorporated 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.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>SelectLatestAsync</c> backed by
-/// <c>SelectLatestAsyncObservable&lt;TSource, TResult&gt;</c> — error forwarding,
-/// disposal mid-flight, stale-id drop path and completion-after-in-flight.</summary>
+/// <summary>Tests latest projection delivery, errors, and disposal during projection.</summary>
 public class SelectLatestAsyncObservableTests
 {
     /// <summary>Synthetic error message attached to a failing selector.</summary>
@@ -17,9 +17,6 @@ public class SelectLatestAsyncObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Multiplier applied by the gated selector whose result is expected never to be delivered.</summary>
-    private const int SuppressedProjectionMultiplier = 2;
-
     /// <summary>Multiplier applied inside the projection selector.</summary>
     private const int ProjectionMultiplier = 10;
 
@@ -30,7 +27,7 @@ public async Task WhenSelectLatestAsyncSelectorThrows_ThenForwardsError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new();
+        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new(SelectorErrorMessage);
         using var sub = subject.SelectLatestAsync(_ => Task.FromException<int>(expected)).Subscribe(
             static _ => { },
@@ -61,28 +58,42 @@ public async Task WhenSelectLatestAsyncSourceErrors_ThenForwardsError()
     public async Task WhenSelectLatestAsyncDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
     {
         const int TriggerValue = 1;
-        Subject<int> subject = new();
-
-        // The gate completes its continuations inline, so releasing it runs the selector's tail here.
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> selectorResumed = new();
+        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
         var completed = false;
-        var sub = subject.SelectLatestAsync(async x =>
-        {
-            await gate.Task.ConfigureAwait(false);
-            _ = selectorResumed.TrySetResult(true);
-            return x * SuppressedProjectionMultiplier;
-        }).Subscribe(results.Add, () => completed = true);
-        subject.OnNext(TriggerValue);
-        subject.OnCompleted();
-        sub.Dispose();
-        gate.SetResult(true);
-        await selectorResumed.Task;
+        SelectLatestAsyncObservable<int, int>.SelectLatestAsyncSink sink = new(Observer.Create<int>(results.Add, () => completed = true), _ => gate.Task);
+        var processing = sink.OnNextAsync(TriggerValue);
+        sink.Dispose();
+        gate.SetResult(TriggerValue);
+        await processing;
+        sink.OnCompleted();
+        sink.SignalCompleted();
         await Assert.That(results).IsEmpty();
         await Assert.That(completed).IsFalse();
     }
 
+    /// <summary>Verifies source completion waits for the latest projection and is delivered once.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SourceCompletionWaitsForLatestProjection()
+    {
+        const int Value = 1;
+        TaskCompletionSource<int> projection = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<int> values = [];
+        var completions = 0;
+        using SelectLatestAsyncObservable<int, int>.SelectLatestAsyncSink sink = new(
+            Observer.Create<int>(values.Add, () => completions++),
+            _ => projection.Task);
+        var processing = sink.OnNextAsync(Value);
+        sink.OnCompleted();
+        await Assert.That(completions).IsZero();
+        projection.SetResult(Value);
+        await processing;
+        sink.SignalCompleted();
+        await Assert.That(values).IsCollectionEqualTo([Value]);
+        await Assert.That(completions).IsEqualTo(1);
+    }
+
     /// <summary>Verifies that a newer value supersedes a slower in-flight projection, so only the latest result is emitted.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -90,44 +101,29 @@ public async Task WhenSelectLatestAsyncNewerArrives_ThenOlderResultDropped()
     {
         const int Slow = 1;
         const int Fast = 2;
-        Subject<int> subject = new();
-
-        // The gate completes its continuations inline, so releasing it runs the stale projection's tail here.
-        TaskCompletionSource<bool> slowGate = new();
-        TaskCompletionSource<bool> slowResumed = new();
+        TaskCompletionSource<int> slowGate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new();
-        using var sub = subject.SelectLatestAsync(async x =>
-        {
-            if (x == Slow)
-            {
-                await slowGate.Task.ConfigureAwait(false);
-                _ = slowResumed.TrySetResult(true);
-            }
-
-            return x * ProjectionMultiplier;
-        }).Subscribe(results.Add, () => completed.TrySetResult(true));
-        subject.OnNext(Slow);
-        subject.OnNext(Fast);
-
-        // The Fast projection is ungated, so its result is already delivered.
+        var completed = false;
+        using SelectLatestAsyncObservable<int, int>.SelectLatestAsyncSink sink = new(
+            Observer.Create<int>(results.Add, () => completed = true),
+            value => value == Slow ? slowGate.Task : Task.FromResult(value * ProjectionMultiplier));
+        var slow = sink.OnNextAsync(Slow);
+        await sink.OnNextAsync(Fast);
         await Assert.That(results).IsCollectionEqualTo([Fast * ProjectionMultiplier]);
-        slowGate.SetResult(true);
-        await slowResumed.Task;
-        subject.OnCompleted();
-        await completed.Task;
-
-        // Only the latest (Fast) projection's result should appear.
+        slowGate.SetResult(Slow * ProjectionMultiplier);
+        await slow;
+        sink.OnCompleted();
+        await Assert.That(completed).IsTrue();
         await Assert.That(results).IsCollectionEqualTo([Fast * ProjectionMultiplier]);
     }
 
-    /// <summary>Verifies that source completion before any value still completes downstream.</summary>
+    /// <summary>Verifies an empty source completes downstream.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSelectLatestAsyncSourceCompletesWithNoValues_ThenForwardsCompletion()
     {
         Subject<int> subject = new();
-        TaskCompletionSource<bool> completed = new();
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SelectLatestAsync(Task.FromResult).Subscribe(
             static _ => { },
             () => completed.TrySetResult(true));
@@ -146,13 +142,12 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         List<int> values = [];
         Exception? caught = null;
         var completedCount = 0;
-        using var sub = source.SelectLatestAsync(Task.FromResult)
-            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+        using var sub = source.SelectLatestAsync(Task.FromResult).Subscribe(values.Add, ex => caught = ex, () => completedCount++);
         source.Observer.OnCompleted();
         source.Observer.OnNext(1);
         source.Observer.OnError(new InvalidOperationException("late"));
         source.Observer.OnCompleted();
-        await Assert.That(completedCount).IsLessThanOrEqualTo(1);
+        await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs
index 3b46d163..3deef9d8 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>SelectManyThen</c> backed by
-/// <c>SelectManyThenObservable&lt;TSource, TMid, TResult&gt;</c> — two-stage projection,
-/// first/second projection throws, source error/completion, and inner-observable errors.</summary>
+/// <summary>Tests two-stage projection and propagation of source, projection, and inner errors.</summary>
 public class SelectManyThenObservableTests
 {
     /// <summary>Synthetic error messages.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs
index 1f67e9a6..5a57b33a 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for several small synchronous operators — <c>Shuffle</c>, <c>Filter</c> (regex), <c>TrySelect</c>.</summary>
+/// <summary>Tests shuffle, regex filtering, and conditional projection.</summary>
 public partial class SimpleSyncOperatorTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -31,9 +31,6 @@ public partial class SimpleSyncOperatorTests
     /// <summary>Shuffle test sentinel.</summary>
     private const int Shuffle5 = 5;
 
-    /// <summary>Length of the pathological input that drives the regex into catastrophic backtracking.</summary>
-    private const int PathologicalInputLength = 100;
-
     /// <summary>Divisor the <c>TrySelect</c> projection uses to keep even values and drop the odd ones.</summary>
     private const int EvenDivisor = 2;
 
@@ -146,15 +143,15 @@ public async Task WhenFilterNullInput_ThenIgnored()
     [Test]
     public async Task WhenFilterRegexThrows_ThenForwardsError()
     {
-        // A regex with a 1-microsecond timeout against pathological input should throw.
-        var regex = PathologicalCatastrophicBacktrack();
+        RegexMatchTimeoutException expected = new("matching failed");
+        ThrowingRegex regex = new(expected);
         Subject<string> subject = new();
         Exception? caught = null;
         using var sub = subject.Filter(regex).Subscribe(
             static _ => { },
             ex => caught = ex);
-        subject.OnNext($"{new string('a', PathologicalInputLength)}!");
-        await Assert.That(caught).IsNotNull();
+        subject.OnNext(Apple);
+        await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
     /// <summary>Verifies that <c>TrySelect</c> drops null projections and forwards non-nulls.</summary>
@@ -202,10 +199,37 @@ public async Task WhenTrySelectSourceCompletes_ThenForwardsCompletion()
     [GeneratedRegex("^a")]
     private static partial Regex StartsWithA();
 
-    /// <summary>Compiled regex with catastrophic backtracking and a 1-tick timeout —
-    /// guaranteed to throw <see cref = "RegexMatchTimeoutException"/> on pathological input.
-    /// Used to exercise the error-forwarding branch of <c>Filter</c>.</summary>
-    /// <returns>A compile-time generated <see cref = "Regex"/> instance with a 1-tick match timeout.</returns>
-    [GeneratedRegex("(a+)+$", RegexOptions.None, 1)]
-    private static partial Regex PathologicalCatastrophicBacktrack();
+    /// <summary>A regex whose matching engine throws the supplied error.</summary>
+    private sealed class ThrowingRegex : Regex
+    {
+        /// <summary>Initializes a new instance of the <see cref="ThrowingRegex"/> class.</summary>
+        /// <param name="error">The matching error.</param>
+        public ThrowingRegex(Exception error)
+        {
+            factory = new ThrowingRunnerFactory(error);
+            capsize = 1;
+        }
+
+        /// <summary>Creates matching engines that fail with the supplied error.</summary>
+        /// <param name="error">The matching error.</param>
+        private sealed class ThrowingRunnerFactory(Exception error) : RegexRunnerFactory
+        {
+            /// <inheritdoc/>
+            protected override RegexRunner CreateInstance() => new ThrowingRunner(error);
+        }
+
+        /// <summary>Throws when matching begins.</summary>
+        /// <param name="error">The matching error.</param>
+        private sealed class ThrowingRunner(Exception error) : RegexRunner
+        {
+            /// <inheritdoc/>
+            protected override void Go() => throw error;
+
+            /// <inheritdoc/>
+            protected override bool FindFirstChar() => true;
+
+            /// <inheritdoc/>
+            protected override void InitTrackCount() => runtrackcount = 1;
+        }
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs
index be24edc4..261d3972 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs
@@ -6,17 +6,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the action-form <c>Start</c> operator backed by
-/// <c>StartActionObservable</c> — synchronous inline path, scheduler dispatch,
-/// and action-throws forwarding.</summary>
+/// <summary>Tests inline and scheduled actions and exception propagation.</summary>
 public class StartActionObservableTests
 {
     /// <summary>Synthetic error message attached to action failures.</summary>
     private const string ActionFailedMessage = "action failed";
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>Start</c> with a null scheduler runs synchronously and completes.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -39,13 +34,15 @@ public async Task WhenStartActionInline_ThenRunsAndCompletes()
     [Test]
     public async Task WhenStartActionWithScheduler_ThenRunsViaScheduler()
     {
+        VirtualClock scheduler = new();
         TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var ran = false;
 
-        using var sub = ReactiveExtensions.Start(() => ran = true, TaskPoolSequencer.Default)
+        using var sub = ReactiveExtensions.Start(() => ran = true, scheduler)
             .Subscribe(static _ => { }, () => completed.TrySetResult(true));
+        scheduler.Start();
 
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(ran).IsTrue();
     }
 
@@ -68,13 +65,15 @@ public async Task WhenStartActionThrowsInline_ThenForwardsError()
     [Test]
     public async Task WhenStartActionThrowsScheduled_ThenForwardsError()
     {
+        VirtualClock scheduler = new();
         TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new(ActionFailedMessage);
 
-        using var sub = ReactiveExtensions.Start(() => throw expected, TaskPoolSequencer.Default)
+        using var sub = ReactiveExtensions.Start(() => throw expected, scheduler)
             .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+        scheduler.Start();
 
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs
index c717e35f..0d9d4ffc 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the <c>Start(Func{TResult}, ISequencer?)</c> overload
-/// backed by <c>StartFuncObservable&lt;TResult&gt;</c> — paths missed by the happy-path tests
-/// (inline vs scheduler dispatch and function-throws on both paths).</summary>
+/// <summary>Tests inline and scheduled function results and exception propagation.</summary>
 public class StartFuncObservableTests
 {
     /// <summary>Result returned by the Start tests.</summary>
@@ -17,9 +15,6 @@ public class StartFuncObservableTests
     /// <summary>Message attached to a thrown <c>Start</c> function.</summary>
     private const string FunctionFailedMessage = "function failed";
 
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that the inline (null-scheduler) overload runs the function, emits the result and completes.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -40,13 +35,15 @@ public async Task WhenStartFuncInline_ThenEmitsResultAndCompletes()
     [Test]
     public async Task WhenStartFuncOnScheduler_ThenRunsOnSchedulerAndCompletes()
     {
+        VirtualClock scheduler = new();
         List<int> results = [];
         TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        using var sub = ReactiveExtensions.Start(static () => StartResult, Sequencer.Default)
+        using var sub = ReactiveExtensions.Start(static () => StartResult, scheduler)
             .Subscribe(results.Add, () => completed.TrySetResult());
+        scheduler.Start();
 
-        await completed.Task.WaitAsync(GuardTimeout);
+        await completed.Task;
         await Assert.That(results).IsCollectionEqualTo([StartResult]);
     }
 
@@ -69,13 +66,15 @@ public async Task WhenStartFuncThrows_ThenForwardsError()
     [Test]
     public async Task WhenStartFuncOnSchedulerThrows_ThenForwardsError()
     {
+        VirtualClock scheduler = new();
         TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new(FunctionFailedMessage);
 
-        using var sub = ReactiveExtensions.Start((Func<int>)(() => throw expected), Sequencer.Default)
+        using var sub = ReactiveExtensions.Start((Func<int>)(() => throw expected), scheduler)
             .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+        scheduler.Start();
 
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
index 9b269275..9e32be19 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
@@ -3,12 +3,11 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the <c>SubscribeSynchronous</c> / <c>SubscribeAsync</c>
-/// overloads backed by <c>SubscribeAsyncObservable&lt;T&gt;</c> — sequential handler invocation,
-/// handler-throws forwards via onError, completion-while-processing defers, disposal stops queue.</summary>
+/// <summary>Tests sequential handlers, deferred completion, error forwarding, and disposal.</summary>
 public class SubscribeAsyncObservableTests
 {
     /// <summary>Synthetic error message attached to handler failures.</summary>
@@ -26,7 +25,7 @@ public async Task WhenSubscribeAsyncProcessesValues_ThenInOrder()
         const int Second = 2;
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource<bool> completed = new();
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SubscribeSynchronous(
             x =>
             {
@@ -50,7 +49,7 @@ public async Task WhenSubscribeAsyncHandlerThrows_ThenForwardsToOnError()
     {
         const int TriggerValue = 1;
         Subject<int> subject = new();
-        TaskCompletionSource<Exception> faulted = new();
+        TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new(HandlerFailedMessage);
         using var sub =
             subject.SubscribeSynchronous(_ => ValueTask.FromException(expected), ex => faulted.TrySetResult(ex));
@@ -98,8 +97,8 @@ public async Task WhenSubscribeAsyncCompletesWhileProcessing_ThenDeferredComplet
         Subject<int> subject = new();
 
         // The gate completes its continuations inline, so releasing it drains the pump before control returns.
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> completed = new();
+        TaskCompletionSource<bool> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var sub = subject.SubscribeSynchronous(
             async _ => await gate.Task.ConfigureAwait(false),
             () => completed.TrySetResult(true));
@@ -120,20 +119,13 @@ public async Task WhenSubscribeAsyncCompletesWhileProcessingWithoutCallback_Then
     {
         const int Value = 7;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> handled = new();
-        using var sub = subject.SubscribeSynchronous(async value =>
-        {
-            await gate.Task.ConfigureAwait(false);
-            _ = handled.TrySetResult(true);
-        });
-        subject.OnNext(Value);
+        TaskCompletionSource gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using SubscribeAsyncObservable<int> subscription = new(subject, _ => new ValueTask(gate.Task), null, null);
+        var processing = subscription.OnNextAsync(Value);
         subject.OnCompleted();
-
-        // Releasing the gate resumes the handler inline, so the null-completion path runs here.
-        gate.SetResult(true);
-        var done = await handled.Task;
-        await Assert.That(done).IsTrue();
+        gate.SetResult();
+        await processing;
+        await Assert.That(processing.IsCompletedSuccessfully).IsTrue();
     }
 
     /// <summary>Verifies disposal during an in-flight handler suppresses deferred terminal callbacks.</summary>
@@ -143,26 +135,23 @@ public async Task WhenSubscribeAsyncDisposedDuringInFlight_ThenSuppressesComplet
     {
         const int Value = 7;
         Subject<int> subject = new();
-        TaskCompletionSource<bool> gate = new();
-        TaskCompletionSource<bool> handlerStarted = new();
+        TaskCompletionSource gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
         Exception? caught = null;
         var completedCount = 0;
-        var sub = subject.SubscribeSynchronous(
-            async value =>
+        SubscribeAsyncObservable<int> subscription = new(
+            subject,
+            async _ =>
             {
-                _ = handlerStarted.TrySetResult(true);
                 await gate.Task.ConfigureAwait(false);
                 throw new InvalidOperationException(HandlerFailedMessage);
             },
             ex => caught = ex,
             () => completedCount++);
-        subject.OnNext(Value);
-        await handlerStarted.Task;
+        var processing = subscription.OnNextAsync(Value);
         subject.OnCompleted();
-        sub.Dispose();
-
-        // Releasing the gate lets the handler throw inline, so the suppressed terminal paths run here.
-        gate.SetResult(true);
+        subscription.Dispose();
+        gate.SetResult();
+        await processing;
         await Assert.That(caught).IsNull();
         await Assert.That(completedCount).IsEqualTo(0);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs
index c413d994..362cffab 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs
@@ -2,18 +2,11 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Reactive.Subjects;
 using ReactiveUI.Primitives.Disposables;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>
-/// Synchronous test source that hands its observer back to the test so the test can
-/// invoke <c>OnNext</c> / <c>OnError</c> / <c>OnCompleted</c> directly — including
-/// sequences that <see cref="Subject{T}"/> would otherwise block (emit-after-complete,
-/// double-terminal). Subscriptions return a no-op disposable so external dispose does
-/// not detach the observer.
-/// </summary>
+/// <summary>Retains its observer for direct notification after disposal or termination.</summary>
 /// <typeparam name="T">The element type.</typeparam>
 internal sealed class SyncDirectSource<T> : IObservable<T>
 {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs
index 1a087cef..5355e668 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Direct coverage for the trivial <c>OnError</c> forwarders on a cluster of small
-/// synchronous operators. Each method is a one-liner that hands a source error straight to
-/// the downstream observer; the existing happy-path tests never exercised the error branch.</summary>
+/// <summary>Tests error propagation through synchronous operators.</summary>
 public class SyncOperatorErrorForwardingTests
 {
     /// <summary>Synthetic error message used by every forwarder test.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
index 376fd170..76df3e6b 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
@@ -2,12 +2,39 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using ReactiveUI.Primitives.Extensions.Operators;
+
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <c>SynchronizeAsyncObservable</c> — covers the after-terminal guards
-/// on the sink that only fire when the upstream pushes events past its own completion.</summary>
+/// <summary>Tests synchronization acknowledgements and notification handling after termination.</summary>
 public class SynchronizeAsyncObservableTests
 {
+    /// <summary>Verifies disposal completes an acknowledgement published after the disposal step.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task AcknowledgementPublishedAfterDisposalCompletes()
+    {
+        SynchronizeAsyncObservable<int>.SynchronizeAsyncSink.SyncSignal signal = new();
+        TaskCompletionSource<bool> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        signal.Dispose();
+        signal.CompleteIfDisposedRaced(completion);
+        signal.CompleteIfDisposedRaced(completion);
+        await Assert.That(completion.Task.IsCompletedSuccessfully).IsTrue();
+    }
+
+    /// <summary>Verifies a live acknowledgement remains pending until disposal.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task LiveAcknowledgementWaitsForDisposal()
+    {
+        SynchronizeAsyncObservable<int>.SynchronizeAsyncSink.SyncSignal signal = new();
+        var acknowledgement = signal.WaitForDisposeAsync();
+        await Assert.That(acknowledgement.IsCompleted).IsFalse();
+        signal.Dispose();
+        await acknowledgement;
+        await Assert.That(acknowledgement.IsCompletedSuccessfully).IsTrue();
+    }
+
     /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
     /// arriving after the source has already completed are silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs
index ad5e7228..76787e21 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>ThrottleOnScheduler</c>, <c>WaitUntil</c>,
-/// <c>TakeUntilInclusive</c>, and <c>SynchronizeAsync</c> — paths the happy-path
-/// tests do not reach (error propagation, predicate throws, dispose, completion-flush).</summary>
+/// <summary>Tests throttle and wait termination, predicate failures, and disposal.</summary>
 public class ThrottleAndWaitOperatorCoverageTests
 {
     /// <summary>Throttle interval used across the scheduler-driven tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs
index 3745a38a..8606f6ca 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs
@@ -2,12 +2,13 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <c>ThrottleDistinctObservable</c> — the after-terminal guards on the
-/// distinct-throttle sink, exercised via a source that pushes events past its own completion.</summary>
+/// <summary>Tests distinct throttle delivery after termination and disposal.</summary>
 public class ThrottleDistinctObservableTests
 {
     /// <summary>Tick window for advancing past the throttle in settle assertions.</summary>
@@ -16,6 +17,30 @@ public class ThrottleDistinctObservableTests
     /// <summary>Tick window for the throttle itself.</summary>
     private const int ThrottleTicks = 10;
 
+    /// <summary>Verifies a distinct-throttle callback has no effect without a pending value or after disposal.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DistinctThrottleCallbacksRequireAPendingLiveValue()
+    {
+        const int First = 1;
+        const int Disposed = 2;
+        List<int> values = [];
+        VirtualClock scheduler = new();
+        ThrottleDistinctObservable<int>.ThrottleDistinctSink sink = new(
+            Observer.Create<int>(values.Add),
+            TimeSpan.FromTicks(1),
+            scheduler);
+        sink.Emit();
+        await Assert.That(values).IsEmpty();
+        sink.OnNext(First);
+        sink.Emit();
+        sink.Emit();
+        sink.OnNext(Disposed);
+        sink.Dispose();
+        sink.Emit();
+        await Assert.That(values).IsCollectionEqualTo([First]);
+    }
+
     /// <summary>Verifies that an <c>OnNext</c> arriving after completion is silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs
index 764d7069..b63f535b 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>ThrottleFirst</c> backed by
-/// <c>ThrottleFirstObservable&lt;T&gt;</c> — error/completion forwarding and
-/// post-terminal behaviour not exercised by the happy-path window test.</summary>
+/// <summary>Tests throttle termination and suppression of subsequent values.</summary>
 public class ThrottleFirstObservableTests
 {
     /// <summary>Message attached to synthetic source errors.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
index 365bb8fc..4f708c67 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
@@ -2,13 +2,13 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <c>ThrottleObservable</c> — the after-terminal guards on
-/// <c>OnNext</c> / <c>OnError</c> / <c>OnCompleted</c> that are only reachable when
-/// an upstream pushes events past its own completion.</summary>
+/// <summary>Tests throttle delivery after replacement, termination, and disposal.</summary>
 public class ThrottleObservableTests
 {
     /// <summary>Tick window for advancing past the throttle in settle assertions.</summary>
@@ -17,6 +17,32 @@ public class ThrottleObservableTests
     /// <summary>Tick window for the throttle itself.</summary>
     private const int ThrottleTicks = 10;
 
+    /// <summary>Verifies stale, duplicate, and disposed throttle callbacks cannot emit.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ThrottleCallbacksEmitOnlyTheCurrentValueOnce()
+    {
+        const int First = 1;
+        const int Latest = 2;
+        const int Disposed = 3;
+        List<int> values = [];
+        VirtualClock scheduler = new();
+        ThrottleObservable<int>.ThrottleSink sink = new(
+            Observer.Create<int>(values.Add),
+            TimeSpan.FromTicks(1),
+            scheduler);
+        sink.OnNext(First);
+        sink.OnNext(Latest);
+        sink.Emit(First);
+        await Assert.That(values).IsEmpty();
+        sink.Emit(Latest);
+        sink.Emit(Latest);
+        sink.OnNext(Disposed);
+        sink.Dispose();
+        sink.Emit(Disposed);
+        await Assert.That(values).IsCollectionEqualTo([Latest]);
+    }
+
     /// <summary>Verifies that an <c>OnNext</c> arriving after the source has already completed is silently dropped by the throttle sink.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
index 04722e09..cb699f87 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
@@ -8,9 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for <c>ThrottleUntilTrue</c> backed by
-/// <c>ThrottleUntilTrueObservable&lt;T&gt;</c> — predicate-true bypass, predicate-false
-/// throttling, error forwarding, completion forwarding, and dispose-before-fire.</summary>
+/// <summary>Tests predicate bypass, delayed values, termination, and cancellation of pending values.</summary>
 public class ThrottleUntilTrueObservableTests
 {
     /// <summary>Synthetic error message attached to source errors.</summary>
@@ -55,7 +53,7 @@ public async Task WhenThrottleUntilTruePredicateFalse_ThenEmitsAfterWindow()
         await Assert.That(emitted).IsCollectionEqualTo([NonMatchingValue]);
     }
 
-    /// <summary>Verifies that a later throttled value replaces an earlier still-pending one.</summary>
+    /// <summary>Verifies a later throttled value replaces the pending value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenThrottleUntilTrueFastReplacements_ThenLatestWins()
@@ -145,14 +143,15 @@ public async Task WhenEventsAfterCompleted_ThenDropped()
         await Assert.That(caught).IsNull();
     }
 
-    /// <summary>Builds the operator over a clock the test advances, so no emission depends on wall time.</summary>
+    /// <summary>Creates a throttle using the supplied clock and bypass predicate.</summary>
     /// <param name="source">The source sequence.</param>
     /// <param name="scheduler">The virtual clock timing throttled emissions.</param>
     /// <param name="predicate">The bypass predicate.</param>
     /// <returns>The throttled sequence.</returns>
-    private static IObservable<int> Throttled(
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private static ThrottleUntilTrueObservable<int> Throttled(
         IObservable<int> source,
         VirtualClock scheduler,
         Func<int, bool> predicate) =>
-        new ThrottleUntilTrueObservable<int>(source, ThrottleWindow, predicate, scheduler);
+        new(source, ThrottleWindow, predicate, scheduler);
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs
index 3643e01c..552be18b 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs
@@ -31,21 +31,21 @@ public async Task WhenActionAndDisposeBothThrow_ThenPrimaryActionErrorForwardedA
     [Test]
     public async Task WhenSchedulerPathActionThrows_ThenForwardsErrorAndDisposes()
     {
+        VirtualClock scheduler = new();
         CountingDisposable resource = new();
         TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new("scheduler action failed");
 
-        using var sub = resource.Using(_ => throw expected, TaskPoolSequencer.Default)
+        using var sub = resource.Using(_ => throw expected, scheduler)
             .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+        scheduler.Start();
 
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>Disposable that delegates the side-effect of <c>Dispose</c> to a caller-supplied
-    /// <see cref="Action"/>. Used by tests that intentionally exercise the secondary-failure
-    /// swallow branch of <c>UsingActionObservable</c> by passing a throwing hook.</summary>
+    /// <summary>Invokes a supplied disposal action, including actions that throw.</summary>
     private sealed class HookDisposable : IDisposable
     {
         /// <summary>Per-dispose hook invoked from <see cref="Dispose"/>.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs
index 47c5ef6b..74d74e71 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs
@@ -6,20 +6,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the action-form <c>Using</c> operator backed by
-/// <c>UsingActionObservable&lt;T&gt;</c> — happy path, null action, scheduler dispatch,
-/// and action-throws-then-disposes paths.</summary>
+/// <summary>Tests inline and scheduled actions and resource disposal after success or failure.</summary>
 public partial class UsingActionObservableTests
 {
     /// <summary>Synthetic error message attached to action failures.</summary>
     private const string ActionFailedMessage = "action failed";
 
-    /// <summary>How long to spin waiting for the scheduler thread to land the resource dispose before giving up.</summary>
-    private const int DisposeWaitMilliseconds = 5000;
-
-    /// <summary>Guard timeout so a hung rendezvous fails this test rather than stalling the run.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>Using</c> with a null action still emits, completes, and disposes the resource.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -79,24 +71,16 @@ public async Task WhenUsingActionThrows_ThenForwardsErrorAndDisposes()
     [Test]
     public async Task WhenUsingWithScheduler_ThenRunsViaScheduler()
     {
+        VirtualClock scheduler = new();
         TrackedDisposable resource = new();
-        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var actionRan = false;
-
-        using var sub = resource.Using(_ => actionRan = true, TaskPoolSequencer.Default)
-            .Subscribe(static _ => { }, () => completed.TrySetResult(true));
-
-        await completed.Task.WaitAsync(GuardTimeout);
+        var completed = false;
+        using var sub = resource.Using(_ => actionRan = true, scheduler)
+            .Subscribe(static _ => { }, () => completed = true);
+        await Assert.That(actionRan).IsFalse();
+        scheduler.Start();
         await Assert.That(actionRan).IsTrue();
-
-        // OnCompleted is signalled before the resource is disposed on the scheduler
-        // thread, so wait briefly for the dispose to land.
-        var deadline = Environment.TickCount64 + DisposeWaitMilliseconds;
-        while (resource.DisposeCount == 0 && Environment.TickCount64 < deadline)
-        {
-            await Task.Yield();
-        }
-
+        await Assert.That(completed).IsTrue();
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs
index d09cc587..e795b72a 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs
@@ -15,12 +15,6 @@ public class UsingAndSwitchIfEmptyEdgeTests
     /// <summary>Sentinel value the fallback observable would emit if it were subscribed.</summary>
     private const int FallbackSentinel = 99;
 
-    /// <summary>How long the scheduler test spins for the resource dispose to land, in milliseconds.</summary>
-    private const int DisposeWaitMilliseconds = 5000;
-
-    /// <summary>Longest a test waits for an asynchronous signal before failing.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies that <c>Using</c> with a null action still emits RxVoid, completes, and disposes the resource.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -55,23 +49,17 @@ public async Task WhenUsingActionThrows_ThenForwardsErrorAndDisposes()
     [Test]
     public async Task WhenUsingActionWithScheduler_ThenRunsOnScheduler()
     {
+        VirtualClock scheduler = new();
         TrackedDisposable resource = new();
         var ran = false;
-        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = resource.Using(_ => ran = true, Sequencer.Default).Subscribe(
+        var completed = false;
+        using var sub = resource.Using(_ => ran = true, scheduler).Subscribe(
             static _ => { },
-            () => completed.TrySetResult());
-        await completed.Task.WaitAsync(GuardTimeout);
+            () => completed = true);
+        await Assert.That(ran).IsFalse();
+        scheduler.Start();
         await Assert.That(ran).IsTrue();
-
-        // OnCompleted is signalled before the resource is disposed on the scheduler
-        // thread, so spin briefly for the dispose to land.
-        var deadline = Environment.TickCount64 + DisposeWaitMilliseconds;
-        while (resource.DisposeCount == 0 && Environment.TickCount64 < deadline)
-        {
-            await Task.Yield();
-        }
-
+        await Assert.That(completed).IsTrue();
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs
index 820fd2f3..7fdf6dbb 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs
@@ -14,9 +14,6 @@ public class UsingFuncObservableTests
     /// <summary>Sentinel result emitted by the happy-path test.</summary>
     private const int Sentinel = 42;
 
-    /// <summary>Longest a test waits for an asynchronous signal before failing.</summary>
-    private static readonly TimeSpan GuardTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the happy path — the function's result is emitted, completion fires,
     /// and the resource is disposed exactly once.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
@@ -58,15 +55,17 @@ public async Task WhenFunctionAndDisposeBothThrow_ThenPrimaryErrorForwardedAndDi
     [Test]
     public async Task WhenSchedulerPathFunctionThrows_ThenForwardsErrorAndDisposes()
     {
+        VirtualClock scheduler = new();
         CountingDisposable resource = new();
         TaskCompletionSource<Exception> faulted = new(TaskCreationOptions.RunContinuationsAsynchronously);
         InvalidOperationException expected = new("scheduler function failed");
 
         using var sub = resource
-            .Using(new Func<CountingDisposable, int>(_ => throw expected), TaskPoolSequencer.Default)
+            .Using(new Func<CountingDisposable, int>(_ => throw expected), scheduler)
             .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+        scheduler.Start();
 
-        var caught = await faulted.Task.WaitAsync(GuardTimeout);
+        var caught = await faulted.Task;
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
index 561a3fb2..dd7ca734 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Edge-case coverage for the <c>While</c> operator backed by
-/// <c>WhileObservable</c> — inline iteration, scheduler dispatch, predicate-throws,
-/// action-throws, and dispose-during-iteration paths.</summary>
+/// <summary>Tests iteration, scheduling, predicate and action failures, and disposal.</summary>
 public class WhileObservableTests
 {
     /// <summary>Synthetic error message attached to predicate failures.</summary>
@@ -118,18 +116,22 @@ private sealed class ManualSequencer : ISequencer
         public long Timestamp => 0;
 
         /// <inheritdoc/>
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(IWorkItem item) => _pending.Enqueue(item);
 
         /// <inheritdoc/>
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(IWorkItem item, long dueTimestamp) => Schedule(item);
 
         /// <summary>Runs the oldest queued work item, if any.</summary>
         internal void RunNext()
         {
-            if (_pending.Count > 0)
+            if (_pending.Count == 0)
             {
-                _pending.Dequeue().Execute();
+                return;
             }
+
+            _pending.Dequeue().Execute();
         }
 
         /// <summary>Drains the queue, including work items queued by the items it runs.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
index c1c28aea..8c1c19c9 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
@@ -8,7 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
-/// <summary>Ported coverage for the migrated synchronous extension operators using primitives runtime types.</summary>
+/// <summary>Tests synchronous extension operators with primitives runtime types.</summary>
 public sealed class ReactiveExtensionsPortedTests
 {
     /// <summary>Candidate keys probed by the first-match test.</summary>
@@ -244,7 +244,6 @@ public async Task AsyncAndSequentialHelpersEmitExpectedValues()
         using var conSub = source
             .SelectAsyncConcurrent(static x => Task.FromResult(x * ConcurrentMultiplier), MaxConcurrency)
             .Subscribe(concurrent.Add);
-        // Both selectors return an already-completed task, so their projections land inside OnNext.
         source.OnNext(InputValue);
         List<RxVoid> runAll = [];
         using var runAllSub = new[] { Observable.Return(RxVoid.Default), Observable.Return(RxVoid.Default) }.RunAll()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs
index 6cc6e73b..c54045cd 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs
@@ -86,9 +86,7 @@ public async Task WhenSelectManyThen_ThenChainsTwoProjections()
         const int ExpectedChained = 11;
         List<int> results = [];
 
-        // Single source emission keeps the test deterministic — the operator's downstream
-        // completes once the inner-inner observable completes, so a multi-emission source
-        // would race against the early-completion semantic.
+        // The inner sequence completes the result after this emission.
         using var subscription = Observable.Return(1)
             .SelectManyThen(
                 static x => Observable.Return(x * SampleValue10),
@@ -117,7 +115,7 @@ public async Task WhenRunAll_ThenEmitsSingleUnitAfterAllComplete()
             results.Add,
             () => completed.TrySetResult());
 
-        await completed.Task.WaitAsync(WaitTimeout);
+        await completed.Task;
         await Assert.That(results).Count().IsEqualTo(1);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
index 722bd928..aba9ea10 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
@@ -22,16 +22,13 @@ public partial class ReactiveExtensionsTests
     /// <summary>Value at which the <c>TakeUntil</c>/<c>WaitUntil</c> predicates trip.</summary>
     private const int PredicateThreshold = 5;
 
-    /// <summary>Hoisted source array used by tests (was inline literal).</summary>
+    /// <summary>Source values for string filtering tests.</summary>
     private static readonly string[] SequenceTest123HelloTest456World = ["test123", "hello", "test456", "world"];
 
     /// <summary>Expected sequence [1, 2, 3, 4, 5] for collection equality assertions.</summary>
     private static readonly int[] ExpectedSequence12345 = [1, 2, 3, 4, 5];
 
-    /// <summary>Longest a test waits for an asynchronous signal before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Inactivity window long enough that a buffer can only be flushed by completion, never by a timeout.</summary>
+    /// <summary>The inactivity interval used with the virtual clock.</summary>
     private static readonly TimeSpan InactivityWindow = TimeSpan.FromSeconds(5);
 
     /// <summary>Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.</summary>
@@ -39,9 +36,7 @@ public partial class ReactiveExtensionsTests
     [Test]
     public async Task SyncronizeAsync_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. The six handlers can run concurrently, so the counters use Interlocked;
-        // awaiting WhenAll is what establishes that every handler ran, because each one bumps
-        // itterations in its finally before its task completes.
+        // Each handler completes after updating the shared counters.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
@@ -112,10 +107,10 @@ public async Task Filter_WithRegex_FiltersStrings()
         await Assert.That(results).IsCollectionEqualTo(["test123", "test456"]);
     }
 
-    /// <summary>Tests Shuffle randomizes array.</summary>
+    /// <summary>Verifies Shuffle preserves every input element.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task Shuffle_RandomizesArray()
+    public async Task Shuffle_PreservesInputElements()
     {
         const int SampleSize = 100;
         var original = Enumerable.Range(1, SampleSize).ToArray();
@@ -408,8 +403,7 @@ public async Task ReplayLastOnSubscribe_ReplaysLastValueToNewSubscribers()
         List<int> results2 = [];
         using var sub2 = replayed.Subscribe(results2.Add);
 
-        // Each subscriber gets its own replay hub seeded with the initial value, so a late subscriber
-        // observes that initial value rather than values delivered to earlier subscribers.
+        // Each subscriber receives its own replay hub and initial value.
         await Assert.That(results2).IsCollectionEqualTo([SampleValue99]);
         subject.OnNext(SampleValue2);
         using (Assert.Multiple())
@@ -616,7 +610,7 @@ public async Task WhenRetryWithBackoffTwoArgOverload_ThenRetriesUntilSuccess()
             return EmptyDisposable.Instance;
         });
         const int MaxRetries = 3;
-        using var sub = source.RetryWithBackoff(MaxRetries, TimeSpan.FromMilliseconds(1))
+        using var sub = source.RetryWithBackoff(MaxRetries, TimeSpan.Zero)
             .Subscribe(values.Add, () => done.TrySetResult(values));
         var captured = await done.Task;
         await Assert.That(captured).IsCollectionEqualTo([SuccessAttempt]);
@@ -631,12 +625,13 @@ public void WhenReplayLastOnSubscribeSourceNull_ThenThrows() =>
     /// <summary>Verifies the two-argument <c>BufferUntilInactive</c> overload flushes a buffer on completion using the default scheduler.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenBufferUntilInactiveTwoArgOverload_ThenFlushesBufferOnCompletion()
+    public async Task WhenBufferUntilInactiveSourceCompletes_ThenFlushesBuffer()
     {
         Subject<int> subject = new();
         List<IList<int>> results = [];
         TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var sub = subject.BufferUntilInactive(InactivityWindow)
+        VirtualClock scheduler = new();
+        using var sub = subject.BufferUntilInactive(InactivityWindow, scheduler)
             .Subscribe(results.Add, () => completed.TrySetResult());
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
@@ -777,11 +772,7 @@ public string TestProperty
         } = string.Empty;
     }
 
-    /// <summary>INPC owner whose property type lets us pass a non-member expression body
-    /// (e.g. a literal arithmetic expression) into <c>ToPropertyObservable</c> so the
-    /// <c>as MemberExpression ?? throw</c> guard fires. The <c>PropertyChanged</c> event is
-    /// required by the interface but never raised — the guard short-circuits before
-    /// subscription wiring runs.</summary>
+    /// <summary>Provides a notification owner for rejecting non-member property expressions.</summary>
     private sealed class ToPropertyNonMemberOwner : INotifyPropertyChanged
     {
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs
index 77a3913c..8e7f96df 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs
@@ -3,18 +3,15 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Linq;
-using ReactiveUI.Primitives.Async.Tests;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Operators;
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
 /// <summary>Tests for ReactiveExtensionsTests.</summary>
 public partial class ReactiveExtensionsTests
 {
-    /// <summary>Longest a retry test waits for the final error to propagate after the retries are exhausted.</summary>
-    private static readonly TimeSpan ErrorPropagationTimeout = TimeSpan.FromSeconds(2);
-
     /// <summary>Tests OnErrorRetry without parameters.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
@@ -54,32 +51,38 @@ public async Task RetryWithBackoff_RespectsMaxDelay()
     {
         const int SuccessAttempt = 5;
         const int MaxRetries = 10;
-        const int InitialDelayMilliseconds = 10;
+        const long InitialDelayTicks = 10;
         const double BackoffFactor = 2.0;
-        const int MaxDelayMilliseconds = 50;
+        const long MaxDelayTicks = 50;
+        const long SecondDelayTicks = 20;
+        const long ThirdDelayTicks = 40;
+        VirtualClock scheduler = new();
         var attempts = 0;
-        var source = Observable.Create<int>(observer =>
+        var source = Observable.Defer(() =>
         {
             attempts++;
-            if (attempts < SuccessAttempt)
-            {
-                observer.OnError(new InvalidOperationException());
-            }
-            else
-            {
-                observer.OnNext(SampleValue42);
-                observer.OnCompleted();
-            }
-
-            return EmptyDisposable.Instance;
+            return attempts < SuccessAttempt
+                ? Observable.Throw<int>(new InvalidOperationException())
+                : Observable.Return(SampleValue42);
         });
-        var result = source.RetryWithBackoff(
+        List<int> results = [];
+        using var subscription = source.RetryWithBackoff(
             MaxRetries,
-            TimeSpan.FromMilliseconds(InitialDelayMilliseconds),
+            TimeSpan.FromTicks(InitialDelayTicks),
             BackoffFactor,
-            TimeSpan.FromMilliseconds(MaxDelayMilliseconds),
-            null).Wait();
-        await Assert.That(result).IsEqualTo(SampleValue42);
+            TimeSpan.FromTicks(MaxDelayTicks),
+            scheduler).Subscribe(results.Add);
+        long[] expectedDelays = [InitialDelayTicks, SecondDelayTicks, ThirdDelayTicks, MaxDelayTicks];
+        foreach (var delay in expectedDelays)
+        {
+            var before = attempts;
+            scheduler.AdvanceBy(delay - 1);
+            await Assert.That(attempts).IsEqualTo(before);
+            scheduler.AdvanceBy(1);
+            await Assert.That(attempts).IsEqualTo(before + 1);
+        }
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
     }
 
     /// <summary>Tests OnErrorRetry with error action and retry count.</summary>
@@ -87,6 +90,7 @@ public async Task RetryWithBackoff_RespectsMaxDelay()
     [Test]
     public async Task OnErrorRetry_WithErrorActionAndRetryCount_RetriesLimitedTimes()
     {
+        VirtualClock scheduler = new();
         const int RetryCount = 3;
         const int ExpectedAttempts = RetryCount + 1;
         var attempts = 0;
@@ -102,6 +106,7 @@ public async Task OnErrorRetry_WithErrorActionAndRetryCount_RetriesLimitedTimes(
             .Subscribe(
                 static _ => { },
                 ex => caughtException = ex);
+        scheduler.Start();
         using (Assert.Multiple())
         {
             // retryCount = retries after the initial attempt; total subscriptions = 1 + retryCount.
@@ -117,34 +122,33 @@ public async Task OnErrorRetry_WithDelay_DelaysRetries()
     {
         const int SuccessAttempt = 3;
         const int RetryCount = 5;
-        const int DelayMilliseconds = 50;
+        const long DelayTicks = 50;
+        VirtualClock scheduler = new();
         var attempts = 0;
-        var source = Observable.Create<int>(observer =>
+        var source = Observable.Defer(() =>
         {
             attempts++;
-            if (attempts < SuccessAttempt)
-            {
-                observer.OnError(new InvalidOperationException());
-            }
-            else
-            {
-                observer.OnNext(SampleValue42);
-                observer.OnCompleted();
-            }
-
-            return EmptyDisposable.Instance;
+            return attempts < SuccessAttempt
+                ? Observable.Throw<int>(new InvalidOperationException())
+                : Observable.Return(SampleValue42);
         });
-        var startTimestamp = TimeProvider.System.GetTimestamp();
-        var result = source.OnErrorRetry<int, InvalidOperationException>(
-            static ex => { },
+        List<int> results = [];
+        using var subscription = source.OnErrorRetry<int, InvalidOperationException>(
+            static _ => { },
             RetryCount,
-            TimeSpan.FromMilliseconds(DelayMilliseconds)).Wait();
-        var elapsed = TimeProvider.System.GetElapsedTime(startTimestamp);
-        using (Assert.Multiple())
-        {
-            await Assert.That(result).IsEqualTo(SampleValue42);
-            await Assert.That(elapsed.TotalMilliseconds).IsGreaterThanOrEqualTo(MinimumExpectedMilliseconds);
-        }
+            TimeSpan.FromTicks(DelayTicks),
+            scheduler).Subscribe(results.Add);
+
+        scheduler.AdvanceBy(DelayTicks - 1);
+        await Assert.That(attempts).IsEqualTo(1);
+        await Assert.That(results).IsEmpty();
+        scheduler.AdvanceBy(1);
+        await Assert.That(attempts).IsEqualTo(SampleValue2);
+        scheduler.AdvanceBy(DelayTicks - 1);
+        await Assert.That(results).IsEmpty();
+        scheduler.AdvanceBy(1);
+        await Assert.That(attempts).IsEqualTo(SuccessAttempt);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
     }
 
     /// <summary>Tests OnErrorRetry with delay and no error action.</summary>
@@ -191,6 +195,7 @@ public async Task OnErrorRetry_WithDelayAndErrorAction_RetriesWithDelay()
     [Test]
     public async Task OnErrorRetry_WithRetryCount_LimitsRetries()
     {
+        VirtualClock scheduler = new();
         const int RetryCount = 2;
         const int ExpectedErrorCallbacks = RetryCount + 1;
         var attemptCount = 0;
@@ -205,13 +210,12 @@ public async Task OnErrorRetry_WithRetryCount_LimitsRetries()
         _ = source.OnErrorRetry<int, InvalidOperationException>(ex => errorsCaught++, RetryCount).Subscribe(
             static _ => { },
             ex => finalError = true);
-        var finalErrorReceived =
-            await AsyncTestHelpers.WaitForConditionAsync(() => finalError, ErrorPropagationTimeout);
+        scheduler.Start();
         using (Assert.Multiple())
         {
             // OnError callback fires for every failure (including the final propagated one):
             // 1 initial attempt + retryCount retries = retryCount + 1 callbacks.
-            await Assert.That(finalErrorReceived).IsTrue();
+            await Assert.That(finalError).IsTrue();
             await Assert.That(errorsCaught).IsEqualTo(ExpectedErrorCallbacks);
             await Assert.That(finalError).IsTrue();
         }
@@ -258,6 +262,7 @@ public async Task OnErrorRetry_WithRetryCountAndDelay_LimitsRetriesWithDelay()
     [Test]
     public async Task OnErrorRetry_WithRetryCountDelayAndScheduler_RetriesCorrectly()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 2;
         const int DelayMilliseconds = 10;
         var attemptCount = 0;
@@ -284,6 +289,7 @@ public async Task OnErrorRetry_WithRetryCountDelayAndScheduler_RetriesCorrectly(
             RetryCount,
             TimeSpan.FromMilliseconds(DelayMilliseconds),
             Sequencer.Immediate).Subscribe(r => result = r);
+        scheduler.Start();
         using (Assert.Multiple())
         {
             await Assert.That(errorsCaught).IsEqualTo(1);
@@ -328,6 +334,7 @@ public async Task WhenOnErrorRetryWithActionOnly_ThenRetriesImmediately()
     [Test]
     public async Task WhenOnErrorRetryWithDelay_ThenRetriesAfterDelay()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 2;
         const int DelayMilliseconds = 10;
         var attempts = 0;
@@ -346,9 +353,14 @@ public async Task WhenOnErrorRetryWithDelay_ThenRetriesAfterDelay()
 
             return EmptyDisposable.Instance;
         });
-        var result = source.OnErrorRetry<int, InvalidOperationException>(
+        var result = 0;
+        using var subscription = source.OnErrorRetry<int, InvalidOperationException>(
             static ex => { },
-            TimeSpan.FromMilliseconds(DelayMilliseconds)).Wait();
+            int.MaxValue,
+            TimeSpan.FromMilliseconds(DelayMilliseconds),
+            scheduler)
+            .Subscribe(value => result = value);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
@@ -357,6 +369,7 @@ public async Task WhenOnErrorRetryWithDelay_ThenRetriesAfterDelay()
     [Test]
     public async Task WhenRetryWithBackoffExceedsMaxRetries_ThenRethrows()
     {
+        VirtualClock scheduler = new();
         var source = Observable.Throw<int>(new InvalidOperationException("fail"));
         Exception? caughtError = null;
         const int MaxRetries = 2;
@@ -366,9 +379,10 @@ public async Task WhenRetryWithBackoffExceedsMaxRetries_ThenRethrows()
             TimeSpan.FromMilliseconds(1),
             BackoffFactor,
             null,
-            Sequencer.Immediate).Subscribe(
+            scheduler).Subscribe(
             static _ => { },
             ex => caughtError = ex);
+        scheduler.Start();
         await Assert.That(caughtError).IsNotNull();
     }
 
@@ -377,6 +391,7 @@ public async Task WhenRetryWithBackoffExceedsMaxRetries_ThenRethrows()
     [Test]
     public async Task WhenRetryWithBackoffDelayExceedsMax_ThenCapsDelay()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 4;
         const int MaxRetries = 5;
         const int InitialDelayMilliseconds = 5;
@@ -398,12 +413,14 @@ public async Task WhenRetryWithBackoffDelayExceedsMax_ThenCapsDelay()
 
             return EmptyDisposable.Instance;
         });
-        var result = source.RetryWithBackoff(
+        var result = 0;
+        using var subscription = source.RetryWithBackoff(
             MaxRetries,
             TimeSpan.FromMilliseconds(InitialDelayMilliseconds),
             BackoffFactor,
             TimeSpan.FromMilliseconds(MaxDelayMilliseconds),
-            Sequencer.Immediate).Wait();
+            scheduler).Subscribe(value => result = value);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
@@ -412,6 +429,7 @@ public async Task WhenRetryWithBackoffDelayExceedsMax_ThenCapsDelay()
     [Test]
     public async Task WhenRetryWithDelay_ThenRetriesWithCustomDelay()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 3;
         const int MaxRetries = 5;
         var attempts = 0;
@@ -430,7 +448,9 @@ public async Task WhenRetryWithDelay_ThenRetriesWithCustomDelay()
 
             return EmptyDisposable.Instance;
         });
-        var result = source.RetryWithDelay(MaxRetries, static attempt => TimeSpan.FromMilliseconds(1)).Wait();
+        var result = 0;
+        using var subscription = new RetryWithDelayObservable<int>(source, MaxRetries, static attempt => TimeSpan.FromMilliseconds(1), scheduler).Subscribe(value => result = value);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
@@ -441,23 +461,24 @@ public async Task WhenRetryForeverWithDelay_ThenRetriesIndefinitely()
     {
         const int SuccessAttempt = 4;
         var attempts = 0;
-        var source = Observable.Create<int>(observer =>
+        VirtualClock scheduler = new();
+        var delay = TimeSpan.FromTicks(1);
+        var source = Observable.Defer(() =>
         {
             attempts++;
-            if (attempts < SuccessAttempt)
-            {
-                observer.OnError(new InvalidOperationException());
-            }
-            else
-            {
-                observer.OnNext(SampleValue42);
-                observer.OnCompleted();
-            }
-
-            return EmptyDisposable.Instance;
+            return attempts < SuccessAttempt
+                ? Observable.Throw<int>(new InvalidOperationException())
+                : Observable.Return(SampleValue42);
         });
-        var result = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(1)).Wait();
-        await Assert.That(result).IsEqualTo(SampleValue42);
+        List<int> results = [];
+        using var sub = new RetryWithDelayObservable<int>(source, int.MaxValue, _ => delay, scheduler)
+            .Subscribe(results.Add);
+        await Assert.That(attempts).IsEqualTo(1);
+        scheduler.AdvanceBy(delay.Ticks);
+        await Assert.That(attempts).IsEqualTo(SampleValue2);
+        scheduler.Start();
+        await Assert.That(attempts).IsEqualTo(SuccessAttempt);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
     }
 
     /// <summary>Tests RetryWithFixedDelay retries with constant delay between retries.</summary>
@@ -465,6 +486,7 @@ public async Task WhenRetryForeverWithDelay_ThenRetriesIndefinitely()
     [Test]
     public async Task WhenRetryWithFixedDelay_ThenRetriesWithConstantDelay()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 3;
         const int MaxRetries = 5;
         var attempts = 0;
@@ -483,7 +505,9 @@ public async Task WhenRetryWithFixedDelay_ThenRetriesWithConstantDelay()
 
             return EmptyDisposable.Instance;
         });
-        var result = source.RetryWithFixedDelay(MaxRetries, TimeSpan.FromMilliseconds(1)).Wait();
+        var result = 0;
+        using var subscription = new RetryWithBackoffObservable<int>(source, new(MaxRetries, TimeSpan.FromMilliseconds(1), 1.0, null, scheduler, null)).Subscribe(value => result = value);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
@@ -526,6 +550,7 @@ public async Task WhenRetryWithBackoffInnerRetry_ThenRetriesAndCapsDelay()
     [Test]
     public async Task WhenOnErrorRetryNegativeDelay_ThenUsesZeroDelay()
     {
+        VirtualClock scheduler = new();
         const int SuccessAttempt = 3;
         var attempt = 0;
         var source = Observable.Defer(() =>
@@ -542,14 +567,16 @@ public async Task WhenOnErrorRetryNegativeDelay_ThenUsesZeroDelay()
         _ = source.OnErrorRetry<int, InvalidOperationException>(
             static _ => { },
             RetryCount,
-            TimeSpan.FromTicks(-1)).Subscribe(
+            TimeSpan.FromTicks(-1),
+            scheduler).Subscribe(
             v =>
             {
                 results.Add(v);
                 _ = received.TrySetResult();
             },
             ex => error = ex);
-        await received.Task.WaitAsync(WaitTimeout);
+        scheduler.Start();
+        await received.Task;
         await Assert.That(results).Contains(SampleValue42);
     }
 
@@ -558,6 +585,7 @@ public async Task WhenOnErrorRetryNegativeDelay_ThenUsesZeroDelay()
     [Test]
     public async Task WhenOnErrorRetryExceedsRetryCount_ThenRethrows()
     {
+        VirtualClock scheduler = new();
         var source = Observable.Throw<int>(new InvalidOperationException("fail"));
         Exception? caught = null;
         TaskCompletionSource errorReceived = new(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -565,14 +593,16 @@ public async Task WhenOnErrorRetryExceedsRetryCount_ThenRethrows()
         _ = source.OnErrorRetry<int, InvalidOperationException>(
             static _ => { },
             RetryCount,
-            TimeSpan.Zero).Subscribe(
+            TimeSpan.Zero,
+            scheduler).Subscribe(
             static _ => { },
             ex =>
             {
                 caught = ex;
                 _ = errorReceived.TrySetResult();
             });
-        await errorReceived.Task.WaitAsync(WaitTimeout);
+        scheduler.Start();
+        await errorReceived.Task;
         await Assert.That(caught).IsNotNull();
         await Assert.That(caught).IsTypeOf<InvalidOperationException>();
     }
@@ -675,6 +705,7 @@ public async Task WhenRetryWithBackoffDelayExceedsMaxDelay_ThenCappedAtMaxDelay(
     [Test]
     public async Task WhenRetryWithBackoffComputedDelayExceedsMaxDelay_ThenCappedToMaxDelay()
     {
+        VirtualClock scheduler = new();
         const int FailingAttempts = 2;
         const int MaxRetries = 5;
         const double BackoffFactor = 1000.0;
@@ -697,15 +728,14 @@ public async Task WhenRetryWithBackoffComputedDelayExceedsMaxDelay_ThenCappedToM
 
             return EmptyDisposable.Instance;
         });
-
-        // initialDelay=1ms, backoffFactor=1000 => computed delay = 1000ms >> maxDelay=2ms
-        // This ensures the cap path at line 1240 is hit
-        var result = source.RetryWithBackoff(
+        var result = 0;
+        using var subscription = source.RetryWithBackoff(
             MaxRetries,
             TimeSpan.FromMilliseconds(1),
             BackoffFactor,
             TimeSpan.FromMilliseconds(MaxDelayMilliseconds),
-            Sequencer.Immediate).Wait();
+            scheduler).Subscribe(value => result = value);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue42);
         await Assert.That(attemptCount).IsEqualTo(SampleValue3);
     }
@@ -772,19 +802,17 @@ public async Task WhenRetryWithBackoff_GivenLargeBackoffFactor_ThenDelayIsCapped
     [Test]
     public async Task WhenRetryWithDelayExhaustsRetries_ThenRethrowsOriginalException()
     {
-        // Given — source always fails
+        VirtualClock scheduler = new();
         const int MaxRetries = 2;
         var source = Observable.Throw<int>(new InvalidOperationException("permanent"));
         TaskCompletionSource<Exception> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         // When
-        using var sub = source.RetryWithDelay(MaxRetries, static _ => TimeSpan.FromMilliseconds(1)).Subscribe(
+        using var sub = new RetryWithDelayObservable<int>(source, MaxRetries, static _ => TimeSpan.FromMilliseconds(1), scheduler).Subscribe(
             static _ => { },
             ex => completion.TrySetResult(ex));
+        scheduler.Start();
 
-        // Await the error propagation directly rather than polling a flag against a wall-clock
-        // deadline — the retries run on the default (thread-pool) scheduler, so a fixed budget is
-        // racy under CI load.
         var caught = await completion.Task;
 
         // Then
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
index 028728a6..e08c8430 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Extensions.Tests;
 /// <summary>Tests for ReactiveExtensions around scheduling.</summary>
 public partial class ReactiveExtensionsTests
 {
-    /// <summary>Delay used by the schedule tests that run on the immediate/real-time sequencer.</summary>
+    /// <summary>The delay advanced by the scheduling tests.</summary>
     private const int ShortScheduleDelayMilliseconds = 10;
 
     /// <summary>Tests DetectStale marks stream as stale.</summary>
@@ -237,9 +237,11 @@ public async Task Using_WithFunction_TransformsValue()
     [Test]
     public async Task Schedule_WithTimeSpanAndAction_ExecutesAction()
     {
+        VirtualClock scheduler = new();
         var executed = false;
         const int Value = 42;
-        _ = Value.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), Sequencer.Immediate, v => executed = true).Subscribe();
+        _ = Value.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), scheduler, v => executed = true).Subscribe();
+        scheduler.Start();
         await Assert.That(executed).IsTrue();
     }
 
@@ -274,10 +276,12 @@ public async Task Schedule_WithObservableDateTimeOffsetAndAction_DelaysAndExecut
     [Test]
     public async Task Schedule_WithObservableTimeSpanAndAction_ExecutesAction()
     {
+        VirtualClock scheduler = new();
         var executed = false;
         Subject<int> subject = new();
-        _ = subject.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), Sequencer.Immediate, v => executed = true).Subscribe();
+        _ = subject.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), scheduler, v => executed = true).Subscribe();
         subject.OnNext(SampleValue42);
+        scheduler.Start();
         await Assert.That(executed).IsTrue();
     }
 
@@ -286,12 +290,14 @@ public async Task Schedule_WithObservableTimeSpanAndAction_ExecutesAction()
     [Test]
     public async Task Schedule_WithDateTimeOffsetAndAction_ExecutesAction()
     {
+        VirtualClock scheduler = new();
         var executed = false;
         const int Value = 42;
         _ = Value.Schedule(
-            TimeProvider.System.GetLocalNow().AddMilliseconds(SampleValue10),
-            Sequencer.Immediate,
+            scheduler.Now.AddMilliseconds(SampleValue10),
+            scheduler,
             v => executed = true).Subscribe();
+        scheduler.Start();
         await Assert.That(executed).IsTrue();
     }
 
@@ -300,13 +306,15 @@ public async Task Schedule_WithDateTimeOffsetAndAction_ExecutesAction()
     [Test]
     public async Task Schedule_WithObservableDateTimeOffsetAndAction_ExecutesAction()
     {
+        VirtualClock scheduler = new();
         var executed = false;
         Subject<int> subject = new();
         _ = subject.Schedule(
-            TimeProvider.System.GetLocalNow().AddMilliseconds(SampleValue10),
-            Sequencer.Immediate,
+            scheduler.Now.AddMilliseconds(SampleValue10),
+            scheduler,
             v => executed = true).Subscribe();
         subject.OnNext(SampleValue42);
+        scheduler.Start();
         await Assert.That(executed).IsTrue();
     }
 
@@ -338,10 +346,12 @@ public async Task Schedule_WithObservableAndFunction_TransformsValue()
     [Test]
     public async Task Schedule_WithTimeSpanAndFunction_TransformsValue()
     {
+        VirtualClock scheduler = new();
         const int Value = 42;
         var result = 0;
-        _ = Value.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), Sequencer.Immediate, static v => v * SampleValue2)
+        _ = Value.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), scheduler, static v => v * SampleValue2)
             .Subscribe(r => result = r);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue84);
     }
 
@@ -350,11 +360,13 @@ public async Task Schedule_WithTimeSpanAndFunction_TransformsValue()
     [Test]
     public async Task Schedule_WithObservableTimeSpanAndFunction_TransformsValue()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         var result = 0;
-        _ = subject.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), Sequencer.Immediate, static v => v * SampleValue2)
+        _ = subject.Schedule(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), scheduler, static v => v * SampleValue2)
             .Subscribe(r => result = r);
         subject.OnNext(SampleValue42);
+        scheduler.Start();
         await Assert.That(result).IsEqualTo(SampleValue84);
     }
 
@@ -459,23 +471,20 @@ public async Task ObserveOnIf_WithReactiveConditionAndSingleScheduler_ObservesOn
         await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
     }
 
-    /// <summary>Tests SyncTimer without scheduler uses default scheduler and produces ticks.</summary>
+    /// <summary>Verifies the initial tick is due immediately and the next tick waits for one period.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenSyncTimerCalledWithoutScheduler_ThenProducesTicks()
+    public async Task WhenSyncTimerClockAdvances_ThenProducesTicks()
     {
-        const int TickPeriodMilliseconds = 50;
+        VirtualClock scheduler = new();
+        var period = TimeSpan.FromTicks(SchedulerWindowTicks);
         List<DateTime> results = [];
-        TaskCompletionSource firstTick = new();
-        using var sub = ReactiveExtensions.SyncTimer(TimeSpan.FromMilliseconds(TickPeriodMilliseconds))
-            .Take(SampleValue2)
-            .Subscribe(tick =>
-            {
-                results.Add(tick);
-                _ = firstTick.TrySetResult();
-            });
-        await firstTick.Task;
-        await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
+        using var sub = ReactiveExtensions.SyncTimer(period, scheduler).Take(SampleValue2).Subscribe(results.Add);
+        await Assert.That(results).IsEmpty();
+        scheduler.AdvanceBy(period.Ticks - 1);
+        await Assert.That(results).Count().IsEqualTo(1);
+        scheduler.AdvanceBy(1);
+        await Assert.That(results).Count().IsEqualTo(SampleValue2);
     }
 
     /// <summary>Tests Start with null scheduler executes the action directly.</summary>
@@ -501,19 +510,15 @@ public async Task WhenStartFuncWithNullScheduler_ThenReturnsResult()
         await Assert.That(result).IsEqualTo(SampleValue42);
     }
 
-    /// <summary>Tests ScheduleSafe with a TimeSpan and a null scheduler takes the inline blocking path.</summary>
+    /// <summary>Verifies a zero delay and null scheduler execute inline.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenScheduleSafeWithTimeSpanAndNullScheduler_ThenSleepsAndExecutes()
+    public async Task WhenScheduleSafeWithZeroDelayAndNullScheduler_ThenExecutes()
     {
         var executed = false;
         const ISequencer? Scheduler = null;
-        var disposable = Scheduler.ScheduleSafe(TimeSpan.FromMilliseconds(ShortScheduleDelayMilliseconds), () => executed = true);
-        using (Assert.Multiple())
-        {
-            await Assert.That(executed).IsTrue();
-            await Assert.That(disposable).IsNotNull();
-        }
+        using var disposable = Scheduler.ScheduleSafe(TimeSpan.Zero, () => executed = true);
+        await Assert.That(executed).IsTrue();
     }
 
     /// <summary>Tests Using with Action invokes the action and disposes the resource.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
index 31d41428..d604fcf3 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
@@ -2,6 +2,9 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Extensions.Operators;
+
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
 /// <summary>Tests for ReactiveExtensionsTests.</summary>
@@ -69,22 +72,25 @@ public async Task WhenSelectAsyncSequential_ThenProcessesInOrder()
     [Test]
     public async Task WhenSelectLatestAsync_ThenEmitsLatestResult()
     {
-        var source = ExpectedSequence123.ToObservable();
         List<int> results = [];
-        TaskCompletionSource<bool> tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        _ = source.SelectLatestAsync(static async x =>
-        {
-            await Task.Yield();
-            return x * SampleValue2;
-        }).Subscribe(
-            results.Add,
-            () => tcs.TrySetResult(true));
-
-        await tcs.Task;
-
-        // Switch means only the latest survives; with sources 1,2,3 and selector x*2, expect [6].
-        await Assert.That(results).IsNotEmpty();
+        TaskCompletionSource<int> first = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<int> second = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<int> latest = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        Task<int>[] projections = [first.Task, second.Task, latest.Task];
+        using SelectLatestAsyncObservable<int, int>.SelectLatestAsyncSink sink = new(
+            Observer.Create<int>(results.Add),
+            value => projections[value - 1]);
+
+        var firstOperation = sink.OnNextAsync(1);
+        var secondOperation = sink.OnNextAsync(SampleValue2);
+        var latestOperation = sink.OnNextAsync(SampleValue3);
+        latest.SetResult(SampleValue6);
+        await latestOperation;
+        first.SetResult(SampleValue2);
+        second.SetResult(SampleValue4);
+        await Task.WhenAll(firstOperation, secondOperation);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue6]);
     }
 
     /// <summary>Tests SelectAsyncConcurrent processes tasks concurrently up to max concurrency.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
index 43b6f892..a85ef72c 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
@@ -17,13 +17,11 @@ public partial class ReactiveExtensionsTests
     [Test]
     public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. SubscribeSynchronous queues each OnNext and drains the queue one handler at
-        // a time; each handler resumes on a pool thread, so the counters use Interlocked. The
-        // alternating +1 / -1 handlers cancel out once all six have run.
+        // Each handler completes after updating the shared counters.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
-        TaskCompletionSource allHandled = new();
+        TaskCompletionSource allHandled = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var disposable = subject.SubscribeSynchronous(async x =>
         {
             await Task.Yield();
@@ -47,10 +45,7 @@ public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
     [Test]
     public async Task SynchronizeSynchronous_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. SynchronizeSynchronous dispatches each OnNext through an independent
-        // Continuation so the six HandleAsync invocations can run concurrently — the int
-        // read-modify-write therefore needs Interlocked. The test asserts pair-wise
-        // (+1, -1) sums to zero after WhenAll completes.
+        // Each handler completes after updating the shared counters.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
@@ -92,13 +87,11 @@ async Task HandleAsync((bool Value, IDisposable Sync) x)
     [Test]
     public async Task SubscribeAsync_RunsWithAsyncTasksInSubscriptions()
     {
-        // Given, When. SubscribeAsync queues each OnNext and drains the queue one handler at a
-        // time; each handler resumes on a pool thread, so the counters use Interlocked. The
-        // alternating +1 / -1 handlers cancel out once all six have run.
+        // Each handler completes after updating the shared counters.
         var result = 0;
         var itterations = 0;
         Subject<bool> subject = new();
-        TaskCompletionSource allHandled = new();
+        TaskCompletionSource allHandled = new(TaskCreationOptions.RunContinuationsAsynchronously);
         using var disposable = subject.SubscribeAsync(async x =>
         {
             await Task.Yield();
@@ -125,40 +118,33 @@ public async Task WithLimitedConcurrency_LimitsConcurrentTasks()
         const int MaxConcurrency = 3;
         var inFlight = 0;
         var maxConcurrent = 0;
-        Queue<TaskCompletionSource<int>> pulled = new();
+        var pulled = System.Threading.Channels.Channel.CreateUnbounded<TaskCompletionSource<int>>();
         List<int> results = [];
-        var completed = false;
-
-        // Each task only finishes when the test completes its gate, so the pull count the limiter
-        // holds open is observable exactly rather than sampled while real tasks overlap.
+        TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         IEnumerable<Task<int>> CreateTasks()
         {
             for (var i = 1; i <= SampleValue10; i++)
             {
-                TaskCompletionSource<int> gate = new();
-                pulled.Enqueue(gate);
-                inFlight++;
-                maxConcurrent = Math.Max(maxConcurrent, inFlight);
+                TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
+                var current = Interlocked.Increment(ref inFlight);
+                maxConcurrent = Math.Max(maxConcurrent, current);
+                _ = pulled.Writer.TryWrite(gate);
                 yield return gate.Task;
             }
         }
 
         using var sub = CreateTasks().WithLimitedConcurrency(MaxConcurrency)
-            .Subscribe(results.Add, () => completed = true);
-        var next = 0;
-        while (pulled.Count > 0)
+            .Subscribe(results.Add, completed.SetResult);
+        for (var next = 1; next <= SampleValue10; next++)
         {
-            var gate = pulled.Dequeue();
-            inFlight--;
-            gate.SetResult(++next);
+            var gate = await pulled.Reader.ReadAsync();
+            _ = Interlocked.Decrement(ref inFlight);
+            gate.SetResult(next);
         }
 
-        using (Assert.Multiple())
-        {
-            await Assert.That(results).Count().IsEqualTo(SampleValue10);
-            await Assert.That(maxConcurrent).IsLessThanOrEqualTo(MaxConcurrency);
-            await Assert.That(completed).IsTrue();
-        }
+        await completed.Task;
+        await Assert.That(results).Count().IsEqualTo(SampleValue10);
+        await Assert.That(maxConcurrent).IsEqualTo(MaxConcurrency);
     }
 
     /// <summary>Verifies an empty limited-concurrency task sequence completes immediately.</summary>
@@ -207,16 +193,15 @@ IEnumerable<Task<int>> FaultingTasks()
     [Test]
     public async Task WithLimitedConcurrency_DisposeBeforeTaskContinuation_DropsWork()
     {
-        // The limiter attaches its continuation with ExecuteSynchronously, so SetResult runs the
-        // dropped-work path inline before it returns.
-        TaskCompletionSource<int> task = new();
+        ConcurrencyLimiter<int> limiter = new([], 1);
         List<int> values = [];
         Exception? caught = null;
         var completed = false;
-        var sub = new[] { task.Task }.WithLimitedConcurrency(1)
-            .Subscribe(values.Add, ex => caught = ex, () => completed = true);
-        sub.Dispose();
-        task.SetResult(SampleValue10);
+        ConcurrencyLimiter<int>.Subscription subscription = new(
+            limiter,
+            Observer.Create<int>(values.Add, ex => caught = ex, () => completed = true));
+        subscription.Dispose();
+        limiter.ProcessTaskCompletion(subscription, Task.FromResult(SampleValue10));
         await Assert.That(values).IsEmpty();
         await Assert.That(caught).IsNull();
         await Assert.That(completed).IsFalse();
@@ -311,7 +296,9 @@ public async Task SubscribeAsync_WithOnNextAndOnError_HandlesError()
             observer.OnError(new InvalidOperationException());
             return EmptyDisposable.Instance;
         });
-        using var sub = source.SubscribeAsync(async x => results.Add(x), ex =>
+        using var sub = source.SubscribeAsync(
+            async x => results.Add(x),
+            ex =>
         {
             caughtException = ex;
             _ = errorSource.TrySetResult(true);
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
index 4d38931a..1bc8fba4 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
@@ -11,13 +11,13 @@ namespace ReactiveUI.Primitives.Extensions.Tests;
 /// <summary>Tests for ReactiveExtensionsTests.</summary>
 public partial class ReactiveExtensionsTests
 {
-    /// <summary>Throttle window in virtual ticks used by the real-time-free throttle tests.</summary>
+    /// <summary>The throttle window in virtual ticks.</summary>
     private const int ThrottleWindowTicks = 100;
 
-    /// <summary>Window used by the throttle tests that run on the default sequencer and await their emission.</summary>
-    private static readonly TimeSpan DefaultSequencerWindow = TimeSpan.FromMilliseconds(200);
+    /// <summary>The interval used to verify distinct-value throttling.</summary>
+    private static readonly TimeSpan DistinctThrottleWindow = TimeSpan.FromMilliseconds(200);
 
-    /// <summary>Debounce window used by the default-sequencer <c>DebounceUntil</c> test.</summary>
+    /// <summary>The debounce interval.</summary>
     private static readonly TimeSpan DebounceWindow = TimeSpan.FromMilliseconds(500);
 
     /// <summary>Tests DebounceImmediate emits first immediately.</summary>
@@ -62,8 +62,8 @@ public async Task DropIfBusy_DropsWhenBusy()
     {
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource<object> release = new();
-        TaskCompletionSource processed = new();
+        TaskCompletionSource<object> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource processed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         _ = subject.DropIfBusy(async x =>
         {
             await release.Task.ConfigureAwait(false);
@@ -226,24 +226,20 @@ public async Task WhenThrottleUntilTruePredicateFalse_ThenAppliesThrottle()
         await Assert.That(results).Contains(1);
     }
 
-    /// <summary>Tests ThrottleDistinct without scheduler parameter.</summary>
+    /// <summary>Verifies the throttle window emits the latest distinct value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenThrottleDistinctWithoutScheduler_ThenThrottlesAndDeduplicates()
+    public async Task WhenThrottleDistinctWindowEnds_ThenEmitsLatestDistinctValue()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         List<int> results = [];
-        TaskCompletionSource emitted = new();
-        using var sub = subject.ThrottleDistinct(DefaultSequencerWindow).Subscribe(value =>
-        {
-            results.Add(value);
-            _ = value == SampleValue2 && emitted.TrySetResult();
-        });
+        using var sub = subject.ThrottleDistinct(DistinctThrottleWindow, scheduler).Subscribe(results.Add);
         subject.OnNext(1);
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
-        await emitted.Task;
-        await Assert.That(results).Contains(SampleValue2);
+        scheduler.AdvanceBy(DistinctThrottleWindow.Ticks);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
     }
 
     /// <summary>Tests DebounceUntil with scheduler delays non-matching values and passes matching immediately.</summary>
@@ -263,19 +259,20 @@ public async Task WhenDebounceUntilWithScheduler_ThenUsesScheduler()
         await Assert.That(results).Contains(SampleValue3);
     }
 
-    /// <summary>Tests DebounceImmediate with null scheduler uses Default scheduler.</summary>
+    /// <summary>Verifies the first value is immediate and the trailing value waits for the debounce window.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenDebounceImmediateNullScheduler_ThenUsesDefault()
+    public async Task WhenDebounceImmediateWithScheduler_ThenEmitsTrailingValue()
     {
+        VirtualClock scheduler = new();
         Subject<int> subject = new();
         List<int> results = [];
-        using var sub = subject.DebounceImmediate(PolledThrottleWindow).Subscribe(results.Add);
+        using var sub = subject.DebounceImmediate(DebounceWindow, scheduler).Subscribe(results.Add);
         subject.OnNext(1);
         subject.OnNext(SampleValue2);
-        await AsyncTestHelpers.WaitForConditionAsync(() => results.Count >= 2, LongWaitTimeout);
-        await Assert.That(results).Contains(1);
-        await Assert.That(results).Contains(SampleValue2);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+        scheduler.AdvanceBy(DebounceWindow.Ticks);
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
     }
 
     /// <summary>Tests DebounceUntil without scheduler emits immediately when condition true.</summary>
@@ -294,7 +291,7 @@ public async Task WhenDebounceUntilWithoutScheduler_ThenEmitsImmediatelyWhenCond
 
         // Even values should emit immediately (condition true)
         subject.OnNext(SampleValue2);
-        await received.Task.WaitAsync(WaitTimeout);
+        await received.Task;
         await Assert.That(results).Contains(SampleValue2);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs
index 5f10f670..f2402d35 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs
@@ -58,9 +58,6 @@ public partial class ReactiveExtensionsTests
     /// <summary>Sample integer value (99) used by multiple tests.</summary>
     private const int SampleValue99 = 99;
 
-    /// <summary>Minimum-elapsed-time guard in milliseconds for timing assertions.</summary>
-    private const int MinimumExpectedMilliseconds = 90;
-
     /// <summary>Throttle/debounce wait window in milliseconds.</summary>
     private const int ThrottleWaitMilliseconds = 150;
 
@@ -76,20 +73,12 @@ public partial class ReactiveExtensionsTests
     /// <summary>One tick past the scheduler window, used to advance virtual time.</summary>
     private const int SchedulerAdvancePastWindowTicks = 101;
 
-    /// <summary>Short real-time delay in milliseconds.</summary>
+    /// <summary>Short delay supplied to virtual schedulers, in milliseconds.</summary>
     private const int ShortDelayMilliseconds = 500;
 
-    /// <summary>Long real-time delay in milliseconds.</summary>
+    /// <summary>Long delay supplied to virtual schedulers, in milliseconds.</summary>
     private const int LongDelayMilliseconds = 1_000;
 
     /// <summary>Expected sequence [1, 2, 3] for collection equality assertions.</summary>
     private static readonly int[] ExpectedSequence123 = [1, 2, 3];
-
-#if NET9_0_OR_GREATER
-    /// <summary>Lock used to synchronize observer callbacks during concurrency tests.</summary>
-    private readonly Lock _gate = new();
-#else
-    /// <summary>Lock used to synchronize observer callbacks during concurrency tests.</summary>
-    private readonly object _gate = new();
-#endif
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj
index 84af6a33..a4eca593 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj
@@ -12,10 +12,6 @@
     <PackageReference Include="Microsoft.Reactive.Testing" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs" />
-  </ItemGroup>
-
   <ItemGroup>
     <Using Include="System" />
     <Using Include="System.Collections.Generic" />
diff --git a/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
index 488b28df..e89e69ff 100644
--- a/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
@@ -104,7 +104,7 @@ public async Task ImmediateBurstExecutesInOrder()
             _ = scheduler.Schedule(() => values.Add(captured));
         }
 
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
     /// <summary>Fake MAUI dispatcher that runs marshalled work synchronously and records how it was dispatched.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
index 6985f799..d92168d1 100644
--- a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
@@ -17,9 +17,6 @@ public sealed class MauiDispatcherSequencerTests
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
-    /// <summary>Due time far enough out that the delay reaching the dispatcher is positive whatever the call costs.</summary>
-    private static readonly TimeSpan FutureDueTime = TimeSpan.FromHours(1);
-
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -68,8 +65,7 @@ public async Task DelayedScheduleUsesDispatchDelayed()
         MauiDispatcherSequencer sequencer = new(dispatcher);
         var executed = false;
 
-        // The relative overload converts the due time against the sequencer's own clock, so the test needs none.
-        _ = sequencer.Schedule(FutureDueTime, () => executed = true);
+        sequencer.Schedule(new DelegateWorkItem(() => executed = true), long.MaxValue);
 
         await Assert.That(executed).IsTrue();
         await Assert.That(dispatcher.DispatchDelayedCount).IsEqualTo(1);
@@ -109,7 +105,7 @@ public async Task ImmediateBurstExecutesInOrder()
             sequencer.Schedule(new DelegateWorkItem(() => values.Add(captured)));
         }
 
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
     /// <summary>Verifies the sequencer surfaces the shared dispatch clock through both clock properties.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Incremental.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Incremental.cs
index 1ee3bc75..859f3775 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Incremental.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Incremental.cs
@@ -10,12 +10,6 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Tests;
 
 /// <summary>Verifies the generator's pipeline caches, so an unrelated edit costs nothing to recompute.</summary>
-/// <remarks>
-/// Correct output alone does not prove a generator is incremental: a pipeline that reruns everything on every
-/// keystroke produces exactly the same files. What proves it is the driver's own record of why each step ran, which
-/// is what these tests read. They are the guard against a model quietly regaining a symbol, a syntax node, or the
-/// compilation, any of which makes every step compare unequal and every file regenerate on every keystroke.
-/// </remarks>
 public sealed partial class EventGeneratorTests
 {
     /// <summary>Consumer source that exercises both the instance and the static request routes at once.</summary>
@@ -79,12 +73,7 @@ public static class Unrelated
         GeneratorStepNames.StaticNamespaces,
     ];
 
-    /// <summary>The steps that must not recompute at all when an unrelated file is edited.</summary>
-    /// <remarks>
-    /// These are the two that run the semantic model, and they are the expensive half of the generator. Accepting
-    /// <c>Unchanged</c> here would let a regression through: a transform that re-runs and happens to produce an
-    /// equal value still paid for every symbol walk, which is the cost this pipeline exists to avoid.
-    /// </remarks>
+    /// <summary>Asserts that semantic extraction steps reuse their cached results.</summary>
     private static readonly string[] SemanticStepNames =
     [
         GeneratorStepNames.InstanceTargets,
@@ -116,8 +105,7 @@ public async Task EventGeneratorCachesEveryPipelineStepWhenNothingChanges()
         GeneratorDriver driver = CreateTrackingDriver();
         driver = driver.RunGenerators(compilation);
 
-        // A clone is a different compilation object holding the same trees, so every step is asked again and
-        // every step has to answer that its value is unchanged.
+        // A cloned compilation preserves its syntax trees and model values.
         driver = driver.RunGenerators(compilation.Clone());
         var reasons = CollectTrackedStepReasons(driver.GetRunResult());
 
@@ -156,14 +144,8 @@ await Assert.That(semantic.FindAll(
             static reason => reason.Reason != IncrementalStepRunReason.Cached)).IsEmpty();
     }
 
-    /// <summary>Verifies the generator emits no post-initialization output, which would defeat all caching.</summary>
+    /// <summary>Verifies activation source does not invalidate cached semantic extraction.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
-    /// <remarks>
-    /// Post-initialization source is added to the compilation the pipeline runs against, so producing any at all -
-    /// even one file nothing refers to - makes that compilation new on every run and discards every semantic result
-    /// cached against the previous one. Measured at roughly a hundredfold on an unchanged re-run, so this is worth
-    /// a test of its own: the activation API has to arrive as an ordinary source output instead.
-    /// </remarks>
     [Test]
     [RequiresAssemblyFiles]
     public async Task EventGeneratorEmitsNoPostInitializationOutput()
@@ -181,10 +163,6 @@ [new EventGenerator().AsSourceGenerator()],
 
     /// <summary>Verifies re-running against the very same compilation recomputes nothing at all.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
-    /// <remarks>
-    /// The strongest statement the pipeline can make, and the one that only holds while no post-initialization
-    /// output exists: handed back the identical compilation, every semantic transform is skipped outright.
-    /// </remarks>
     [Test]
     [RequiresAssemblyFiles]
     public async Task EventGeneratorRecomputesNothingForTheSameCompilation()
@@ -240,8 +218,7 @@ public async Task EventGeneratorRecomputesOnlyTheStepsAnEventChangeAffects()
         await Assert.That(reasons.Exists(static reason =>
             reason.StepName == GeneratorStepNames.InstanceTargets && !IsCached(reason.Reason))).IsTrue();
 
-        // Its signature did not move, so the shared overload file must not be rebuilt, and neither the static
-        // request nor the resolved provider has anything to do with an instance event being added.
+        // Only this host's wrapper depends on the added event.
         await Assert.That(reasons.FindAll(static reason =>
                 reason.StepName != GeneratorStepNames.InstanceTargets && !IsCached(reason.Reason)))
             .IsEmpty();
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Nullability.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Nullability.cs
index 0b95e7cf..ba68280e 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Nullability.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.Nullability.cs
@@ -10,11 +10,6 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Tests;
 
 /// <summary>Verifies generated handlers match the nullability of the delegates they are assigned to.</summary>
-/// <remarks>
-/// A handler whose parameter nullability differs from its delegate's is assignable but warns (CS8622), and a
-/// consumer building warnings-as-errors cannot use the generated wrapper at all. The annotations are therefore part
-/// of the contract - but only where the consumer's language version can express them, which is what these pin down.
-/// </remarks>
 public sealed partial class EventGeneratorTests
 {
     /// <summary>The nullable directive a generated file opens with when the consumer's language allows it.</summary>
@@ -26,11 +21,7 @@ public sealed partial class EventGeneratorTests
     /// <summary>The same handler with the annotation dropped, as an older language version requires.</summary>
     private const string ObliviousSenderHandler = "void Handler(object sender, global::System.EventArgs e)";
 
-    /// <summary>Consumer source valid on every language version the generator supports.</summary>
-    /// <remarks>
-    /// Requests both an instance wrapper and a static one, so every generated file the language gate touches - the
-    /// wrapper, the shared overloads, and the namespace's static class - is exercised at both language versions.
-    /// </remarks>
+    /// <summary>Checks nullability output for instance wrappers, activation overloads, and static event classes.</summary>
     private const string ConventionalEventSource = """
         using System;
         using ReactiveUI.Primitives.ObservableEvents;
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.StaticRequests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.StaticRequests.cs
index 7b39a6fd..be4bb3bc 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.StaticRequests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.StaticRequests.cs
@@ -8,11 +8,6 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Tests;
 
 /// <summary>Verifies every spelling of the static request attribute is recognised.</summary>
-/// <remarks>
-/// The attribute is matched on how it is written rather than on the symbol it binds to, because the type it names
-/// is this generator's own output and output is invisible to the pipeline that produced it. That puts the burden of
-/// understanding C#'s naming forms on this generator, so each one a consumer may reasonably write is pinned here.
-/// </remarks>
 public sealed partial class EventGeneratorTests
 {
     /// <summary>The host every spelling in these tests points at.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
index df33e3ef..89d95732 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
@@ -39,7 +39,7 @@ public sealed partial class EventGeneratorTests
     /// <summary>The number of deliberately unsupported events in the combined signature test.</summary>
     private const int UnsupportedEventCount = 4;
 
-    /// <summary>The number of distinct wrappers expected from the sanitization-collision regression.</summary>
+    /// <summary>The distinct wrappers required when sanitized identifiers collide.</summary>
     private const int SanitizationCollisionWrapperCount = 2;
 
     /// <summary>Source that exercises a conventional instance event.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
index c04ec97c..e79f6de2 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
@@ -26,11 +26,9 @@ public async Task RunDisposesTheStartedWorkWhenCancellationClaimsTheItemDuringIt
     {
         BooleanDisposable started = new();
         ProbeWorkItem? item = null;
-        item = new(Scheduler.Default, ProbeState, (_, _) =>
+        item = new(Scheduler.Immediate, ProbeState, (_, _) =>
         {
-            // Reproduce the interleaving the guard exists for: a concurrent cancel has claimed the single
-            // dispose transition, but the run's compare-exchange has already published the started work, so
-            // the run itself is what tears the work down.
+            // Cancellation claims disposal before Run publishes its started work.
             _ = item!.ClaimCancellation();
             return started;
         });
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
index e472d2b4..6b02aa07 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
@@ -5,8 +5,7 @@
 using System.Reactive;
 using System.Reactive.Disposables;
 
-// Imported so the DisposeWith tests below are compiled with System.Reactive's own fluent disposal helpers in
-// scope - that is the call-site shape the ContainerDisposable overload exists to keep unambiguous.
+// Import both fluent disposal APIs to check overload resolution.
 using System.Reactive.Disposables.Fluent;
 using System.Reactive.Linq;
 using ReactiveUI.Primitives.Advanced;
@@ -74,8 +73,7 @@ public async Task DisposeWithContainerReturnsConcreteDisposableAndTracksIt()
         await Assert.That(result).IsSameReferenceAs(disposable);
         await Assert.That(disposables.Contains(disposable)).IsTrue();
 
-        // Resolving to this overload rather than System.Reactive's is what keeps the registration on the
-        // container itself instead of the composite it would have been converted into.
+        // Register the item on the container, not its implicit composite.
         await Assert.That(((CompositeDisposable)disposables).Count).IsEqualTo(0);
 
         disposables.Dispose();
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
index de212932..a3705caf 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
@@ -7,12 +7,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>
-/// Exercises every member of the scheduling seam directly, rather than through an operator that happens to use one
-/// of them. This part deliberately does not import <c>System.Reactive.Concurrency</c>: the <c>Scheduler</c> class in
-/// that namespace carries extension methods with the same signatures, and importing it would make every call below
-/// ambiguous. The scheduler types are therefore spelled out in full.
-/// </summary>
+/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
 public partial class SequencerSchedulingExtensionsTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -111,10 +106,7 @@ private sealed class CountingWorkItem : IWorkItem
         public void Execute() => ExecuteCount++;
     }
 
-    /// <summary>
-    /// Counts how often the scheduler ran a plain action. Holding the count here lets the action overloads be
-    /// handed <see cref="Record"/> as a method group, so the callback closes over nothing.
-    /// </summary>
+    /// <summary>Counts action invocations through a method-group callback.</summary>
     private sealed class RunCounter
     {
         /// <summary>Gets the number of times the scheduler ran the action.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
index 763765f9..67215fb5 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Reactive.Concurrency;
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
@@ -31,10 +32,10 @@ public sealed class WasmSchedulerTests
     /// <summary>A positive due time or period, so a null action is the only invalid argument under test.</summary>
     private static readonly TimeSpan ValidInterval = TimeSpan.FromMilliseconds(100);
 
-    /// <summary>A due time no test waits out, so the only run a delayed item sees is the one the test drives.</summary>
+    /// <summary>Due time for manually dispatched callbacks.</summary>
     private static readonly TimeSpan UnreachableDueTime = TimeSpan.FromHours(1);
 
-    /// <summary>A period no test waits out, so the only tick a periodic item sees is the one the test drives.</summary>
+    /// <summary>Period for manually dispatched callbacks.</summary>
     private static readonly TimeSpan UnreachablePeriod = TimeSpan.FromHours(1);
 
     /// <summary>Verifies the shared instance is a singleton.</summary>
@@ -48,7 +49,8 @@ public async Task DefaultReturnsSingleton() =>
     [Test]
     public async Task ScheduleRejectsNullAction()
     {
-        var scheduler = WasmScheduler.Default;
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
 
         await Assert.That(() => scheduler.Schedule(0, null!)).ThrowsExactly<ArgumentNullException>();
         await Assert.That(() => scheduler.Schedule(0, ValidInterval, null!))
@@ -71,14 +73,17 @@ await Assert
     [Test]
     public async Task ImmediateScheduleExecutes()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         TaskCompletionSource<int> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        _ = WasmScheduler.Default.Schedule(StatePayload, (scheduler, state) =>
+        _ = scheduler.Schedule(StatePayload, (scheduler, state) =>
         {
             _ = scheduler;
             _ = executed.TrySetResult(state);
             return Disposable.Empty;
         });
+        timeProvider.FireAll();
 
         await Assert.That(await executed.Task).IsEqualTo(StatePayload);
     }
@@ -88,12 +93,14 @@ public async Task ImmediateScheduleExecutes()
     [Test]
     public async Task ImmediateBurstExecutesInOrder()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         TaskCompletionSource<bool> done = new(TaskCreationOptions.RunContinuationsAsynchronously);
         List<int> values = [];
 
         foreach (var value in ExpectedBurst)
         {
-            _ = WasmScheduler.Default.Schedule(value, (scheduler, state) =>
+            _ = scheduler.Schedule(value, (scheduler, state) =>
             {
                 _ = scheduler;
                 values.Add(state);
@@ -106,8 +113,10 @@ public async Task ImmediateBurstExecutesInOrder()
             });
         }
 
+        timeProvider.FireAll();
+
         _ = await done.Task;
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
     /// <summary>Verifies an item disposed while it waits in the ready queue is skipped while later work still runs.</summary>
@@ -145,19 +154,22 @@ public async Task DisposedImmediateItemIsSkipped()
     [Test]
     public async Task DelayedScheduleExecutes()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         TaskCompletionSource<bool> delayed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         TaskCompletionSource<bool> immediate = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        _ = WasmScheduler.Default.Schedule(0, DelayedDueTime, (_, _) =>
+        _ = scheduler.Schedule(0, DelayedDueTime, (_, _) =>
         {
             _ = delayed.TrySetResult(true);
             return Disposable.Empty;
         });
-        _ = WasmScheduler.Default.Schedule(0, TimeSpan.Zero, (_, _) =>
+        _ = scheduler.Schedule(0, TimeSpan.Zero, (_, _) =>
         {
             _ = immediate.TrySetResult(true);
             return Disposable.Empty;
         });
+        timeProvider.FireAll();
 
         await Assert.That(await delayed.Task).IsTrue();
         await Assert.That(await immediate.Task).IsTrue();
@@ -168,8 +180,10 @@ public async Task DelayedScheduleExecutes()
     [Test]
     public async Task DisposedDelayedItemDoesNotRun()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         var ran = false;
-        var subscription = (WasmScheduler.StatefulWorkItem<int>)WasmScheduler.Default.Schedule(
+        var subscription = (WasmScheduler.StatefulWorkItem<int>)scheduler.Schedule(
             0,
             UnreachableDueTime,
             (_, _) =>
@@ -192,8 +206,10 @@ public async Task DisposedDelayedItemDoesNotRun()
     [Test]
     public async Task SchedulePeriodicTicksAndStopsOnDispose()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         var count = 0;
-        var subscription = (WasmScheduler.PeriodicWorkItem<int>)WasmScheduler.Default.SchedulePeriodic(
+        var subscription = (WasmScheduler.PeriodicWorkItem<int>)scheduler.SchedulePeriodic(
             0,
             UnreachablePeriod,
             state =>
@@ -216,18 +232,22 @@ public async Task SchedulePeriodicTicksAndStopsOnDispose()
         await Assert.That(count).IsEqualTo(PeriodicTickCount);
     }
 
-    /// <summary>Verifies a zero period is clamped instead of rejected and still ticks.</summary>
+    /// <summary>Verifies a zero period is clamped and dispatches ticks.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task SchedulePeriodicClampsZeroPeriod()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         TaskCompletionSource<bool> ticked = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        var subscription = WasmScheduler.Default.SchedulePeriodic(0, TimeSpan.Zero, state =>
+        var subscription = scheduler.SchedulePeriodic(0, TimeSpan.Zero, state =>
         {
             _ = ticked.TrySetResult(true);
             return state;
         });
+        await Assert.That(timeProvider.LastPeriod).IsEqualTo(TimeSpan.FromMilliseconds(1));
+        timeProvider.FireAll();
 
         await Assert.That(await ticked.Task).IsTrue();
         subscription.Dispose();
@@ -250,8 +270,10 @@ public async Task DisposeReleasesDrainTimerAndIsIdempotent()
     [Test]
     public async Task DisposedDelayedItemDisposeIsIdempotent()
     {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
         var subscription =
-            WasmScheduler.Default.Schedule(0, UnreachableDueTime, static (_, _) => Disposable.Empty);
+            scheduler.Schedule(0, UnreachableDueTime, static (_, _) => Disposable.Empty);
 
         subscription.Dispose();
 
@@ -263,7 +285,9 @@ public async Task DisposedDelayedItemDisposeIsIdempotent()
     [Test]
     public async Task DisposedPeriodicItemDisposeIsIdempotent()
     {
-        var subscription = WasmScheduler.Default.SchedulePeriodic(0, UnreachablePeriod, static state => state);
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
+        var subscription = scheduler.SchedulePeriodic(0, UnreachablePeriod, static state => state);
 
         subscription.Dispose();
 
@@ -278,9 +302,7 @@ public async Task SelfCancellingImmediateActionDisposesReturnedDisposable()
         using var scheduler = CreateIsolatedScheduler();
         BooleanDisposable returned = new();
 
-        // Build the item and publish the handle it cancels through before anything can run it. Scheduling normally
-        // arms the drain inside Schedule and only then returns the handle, so the action is free to run first and
-        // find nothing to cancel; enqueueing by hand is the same path with that window closed.
+        // Publish the cancellation handle before running the queued action.
         WasmScheduler.StatefulWorkItem<int>? subscription = null;
         WasmScheduler.StatefulWorkItem<int> item = new(
             scheduler,
@@ -326,11 +348,7 @@ public async Task SchedulePeriodicWithNullActionThrows() => await Assert
         .That(static () => WasmScheduler.Default.SchedulePeriodic(0, ValidInterval, null!))
         .Throws<ArgumentNullException>();
 
-    /// <summary>
-    /// Verifies a disposed scheduler rejects new work rather than queueing work it can never drain. The drain timer
-    /// is released on disposal, so an accepted item would sit in the ready queue forever behind a latch the failed
-    /// timer post left set. Every scheduling overload fails fast instead, and none of the actions run.
-    /// </summary>
+    /// <summary>Verifies every scheduling overload rejects work after disposal.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduleAfterDisposeThrowsObjectDisposedException()
@@ -390,11 +408,7 @@ public async Task DisposeCancelsWorkTheInFlightDrainHasNotReachedYet()
         await Assert.That(queued.Dispose).ThrowsNothing();
     }
 
-    /// <summary>
-    /// Verifies a one-shot timer handed to a work item that was already cancelled is released instead of left armed.
-    /// A delayed schedule builds the item first and attaches its timer afterwards, so a dispose landing in that window
-    /// must not strand a timer that would still fire against an item nobody can cancel any more.
-    /// </summary>
+    /// <summary>Verifies a timer attached after cancellation is disposed immediately.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task AttachTimerReleasesATimerGivenToAnAlreadyCancelledItem()
@@ -410,10 +424,8 @@ public async Task AttachTimerReleasesATimerGivenToAnAlreadyCancelledItem()
                 return Disposable.Empty;
             });
 
-        // Cancel before the delayed schedule reaches its AttachTimer call.
         item.Dispose();
 
-        // Stands in for the one-shot timer, recording the release the item owes it.
         BooleanDisposable timer = new();
         item.AttachTimer(timer);
 
@@ -421,11 +433,7 @@ public async Task AttachTimerReleasesATimerGivenToAnAlreadyCancelledItem()
         await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies a periodic tick that loses the race to disposal drops the tick instead of running the action. A timer
-    /// callback the runtime had already dispatched when <see cref="IDisposable.Dispose"/> won still lands, and must
-    /// find the item cancelled rather than mutate state the disposal has already torn down.
-    /// </summary>
+    /// <summary>Verifies a dispatched periodic callback observes disposal before invoking the action.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task PeriodicTickThatLosesTheRaceToDisposeDoesNotRunTheAction()
@@ -438,21 +446,17 @@ public async Task PeriodicTickThatLosesTheRaceToDisposeDoesNotRunTheAction()
             {
                 ticks++;
                 return state;
-            });
+            },
+            new ManualTimeProvider());
 
         item.Dispose();
 
-        // The period never elapses on its own, so this is the tick a callback already in flight would have delivered.
         item.Tick();
 
         await Assert.That(ticks).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies an enqueue that loses the race to disposal releases the item it just queued. The scheduler's disposed
-    /// check happens before the item joins the ready queue, so a disposal that drains the queue in between would
-    /// otherwise strand the item behind a drain timer that can never fire again.
-    /// </summary>
+    /// <summary>Verifies disposal between the initial check and enqueue cancels the queued item.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task EnqueueThatLosesTheRaceToDisposeReleasesTheItemItQueued()
@@ -507,10 +511,136 @@ public async Task DrainDispatchesEveryQueuedItemExactlyOnce()
         await Assert.That(Array.FindIndex(dispatches, static count => count != 1)).IsEqualTo(NoMatch);
     }
 
-    /// <summary>
-    /// Creates a scheduler that owns its own drain timer and ready queue, so a test can dispose it without
-    /// disturbing the shared singleton every other test schedules through.
-    /// </summary>
+    /// <summary>Verifies a drain claim rejects stale snapshots and preserves the current claimant.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DrainClaimsRejectStaleStateSnapshots()
+    {
+        const int Idle = 0;
+        const int Running = 1;
+        const int Pending = 2;
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
+        var runs = 0;
+        scheduler.QueueReady(new WasmScheduler.StatefulWorkItem<int>(scheduler, 0, (_, _) =>
+        {
+            runs++;
+            return Disposable.Empty;
+        }));
+
+        await Assert.That(scheduler.TryPostDrain(Running)).IsFalse();
+        await Assert.That(scheduler.TryPostDrain(Idle)).IsTrue();
+        await Assert.That(scheduler.TryPostDrain(Idle)).IsFalse();
+        await Assert.That(scheduler.TryPostDrain(Running)).IsTrue();
+        await Assert.That(scheduler.TryPostDrain(Running)).IsFalse();
+        await Assert.That(scheduler.TryPostDrain(Pending)).IsTrue();
+        timeProvider.FireAll();
+        await Assert.That(runs).IsEqualTo(1);
+        await Assert.That(scheduler.TryPostDrain(Idle)).IsTrue();
+    }
+
+    /// <summary>Verifies work published without a drain request is picked up by the finishing drain.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task FinishingDrainSchedulesWorkPublishedDuringItsBatch()
+    {
+        const int First = 1;
+        const int Second = 2;
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
+        List<int> values = [];
+        _ = scheduler.Schedule(First, (_, value) =>
+        {
+            values.Add(value);
+            scheduler.QueueReady(new WasmScheduler.StatefulWorkItem<int>(scheduler, Second, (_, next) =>
+            {
+                values.Add(next);
+                return Disposable.Empty;
+            }));
+            return Disposable.Empty;
+        });
+
+        timeProvider.FireAll();
+        await Assert.That(values).IsEquivalentTo([First], EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
+        timeProvider.FireAll();
+        await Assert.That(values).IsEquivalentTo([First, Second], EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
+    }
+
+    /// <summary>Creates a scheduler with manually dispatched timers.</summary>
     /// <returns>The isolated scheduler.</returns>
-    private static WasmScheduler CreateIsolatedScheduler() => new();
+    private static WasmScheduler CreateIsolatedScheduler() => new(new ManualTimeProvider());
+
+    /// <summary>Stores timer callbacks until the test dispatches them.</summary>
+    private sealed class ManualTimeProvider : TimeProvider
+    {
+        /// <summary>The timers owned by this provider.</summary>
+        private readonly List<ManualTimer> _timers = [];
+
+        /// <summary>Gets the most recently requested timer period.</summary>
+        public TimeSpan LastPeriod => _timers[^1].Period;
+
+        /// <inheritdoc/>
+        public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
+        {
+            ManualTimer timer = new(callback, state);
+            _ = timer.Change(dueTime, period);
+            _timers.Add(timer);
+            return timer;
+        }
+
+        /// <summary>Invokes each armed timer once.</summary>
+        public void FireAll()
+        {
+            foreach (var timer in _timers.ToArray())
+            {
+                timer.Fire();
+            }
+        }
+
+        /// <summary>A timer whose callback is dispatched explicitly.</summary>
+        /// <param name="callback">The timer callback.</param>
+        /// <param name="state">The callback state.</param>
+        private sealed class ManualTimer(TimerCallback callback, object? state) : ITimer
+        {
+            /// <summary>The next due time.</summary>
+            private TimeSpan _dueTime;
+
+            /// <summary>Whether the timer has been disposed.</summary>
+            private bool _disposed;
+
+            /// <summary>Gets the repeating period.</summary>
+            public TimeSpan Period { get; private set; }
+
+            /// <inheritdoc/>
+            public bool Change(TimeSpan dueTime, TimeSpan period)
+            {
+                _dueTime = dueTime;
+                Period = period;
+                return !_disposed;
+            }
+
+            /// <summary>Invokes the callback if the timer is armed.</summary>
+            public void Fire()
+            {
+                if (_disposed || _dueTime == Timeout.InfiniteTimeSpan)
+                {
+                    return;
+                }
+
+                _dueTime = Period;
+                callback(state);
+            }
+
+            /// <inheritdoc/>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Dispose() => _disposed = true;
+
+            /// <inheritdoc/>
+            public ValueTask DisposeAsync()
+            {
+                Dispose();
+                return default;
+            }
+        }
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/AsyncEnumerableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/AsyncEnumerableSignalTests.cs
index c109e3ff..cf8de3d3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/AsyncEnumerableSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/AsyncEnumerableSignalTests.cs
@@ -14,82 +14,55 @@ public sealed class AsyncEnumerableSignalTests
     private static readonly int[] SourceValues = [1, 2, 3];
 
     /// <summary>Verifies a value buffered while disposal tears down the observer is not delivered.</summary>
-    /// <param name="token">The test cancellation token.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    [Timeout(30_000)]
-    public async Task DisposeDuringMoveNextSuppressesBufferedOnNext(CancellationToken token)
+    public async Task DisposeDuringMoveNextSuppressesBufferedOnNext()
     {
         GatedAsyncEnumerable source = new();
-        AsyncEnumerableSignal<int> signal = new(source, CancellationToken.None);
         RecordingWitness<int> observer = new();
-
-        var subscription = signal.Subscribe(observer);
-
-        // Wait until the pump is parked inside MoveNextAsync with a value ready to emit.
-        await source.MoveNextEntered.Task.WaitAsync(token);
-
-        // Dispose mid-flight, then let the buffered MoveNextAsync complete with a value.
+        AsyncEnumerableSignal<int>.Subscription subscription = new(observer, source, CancellationToken.None);
+        var pump = subscription.PumpAsync();
+        await source.MoveNextEntered.Task;
         subscription.Dispose();
         source.ReleaseMoveNext(true);
-
-        // Wait for the pump to drain so any (incorrect) emission would already have happened.
-        await source.Disposed.Task.WaitAsync(token);
+        await pump;
 
         await Assert.That(observer.Values).IsEmpty();
         await Assert.That(observer.Completed).IsEqualTo(0);
         await Assert.That(observer.Errors).IsEmpty();
     }
 
-    /// <summary>Verifies the enumerator is disposed exactly once when disposal races the pump.</summary>
-    /// <param name="token">The test cancellation token.</param>
+    /// <summary>Disposal before the last move completes releases the enumerator once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    [Timeout(30_000)]
-    public async Task DisposeAfterCompletionDisposesEnumeratorExactlyOnce(CancellationToken token)
+    public async Task DisposeBeforeCompletionDisposesEnumeratorExactlyOnce()
     {
         GatedAsyncEnumerable source = new();
-        AsyncEnumerableSignal<int> signal = new(source, CancellationToken.None);
         RecordingWitness<int> observer = new();
-
-        var subscription = signal.Subscribe(observer);
-
-        await source.MoveNextEntered.Task.WaitAsync(token);
-
-        // Dispose while parked, then end the sequence; both disposal and the pump's finally run.
+        AsyncEnumerableSignal<int>.Subscription subscription = new(observer, source, CancellationToken.None);
+        var pump = subscription.PumpAsync();
+        await source.MoveNextEntered.Task;
         subscription.Dispose();
         source.ReleaseMoveNext(false);
-
-        await source.Disposed.Task.WaitAsync(token);
-
-        // Dispose again to confirm the idempotent disposer never reaches the enumerator twice.
+        await pump;
         subscription.Dispose();
 
         await Assert.That(source.DisposeCount).IsEqualTo(1);
     }
 
     /// <summary>Verifies disposal disposes a non-cooperative enumerator without waiting on its <c>MoveNextAsync</c>.</summary>
-    /// <param name="token">The test cancellation token.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    [Timeout(30_000)]
-    public async Task DisposeDisposesNonCooperativeEnumeratorWithoutHanging(CancellationToken token)
+    public async Task DisposeDisposesNonCooperativeEnumeratorWithoutWaitingForMoveNext()
     {
         NeverCompletingAsyncEnumerable source = new();
-        AsyncEnumerableSignal<int> signal = new(source, CancellationToken.None);
         RecordingWitness<int> observer = new();
-
-        var subscription = signal.Subscribe(observer);
-
-        // Wait until the pump is parked inside the MoveNextAsync that never completes.
-        await source.MoveNextEntered.Task.WaitAsync(token);
-
-        // Disposal must dispose the enumerator promptly even though MoveNextAsync ignores cancellation.
+        AsyncEnumerableSignal<int>.Subscription subscription = new(observer, source, CancellationToken.None);
+        var pump = subscription.PumpAsync();
+        await source.MoveNextEntered.Task;
         subscription.Dispose();
-
-        await source.Disposed.Task.WaitAsync(token);
-
-        // Dispose again to confirm the second call never reaches the enumerator.
+        await source.Disposed.Task;
+        await pump;
         subscription.Dispose();
 
         await Assert.That(source.DisposeCount).IsEqualTo(1);
@@ -99,18 +72,16 @@ public async Task DisposeDisposesNonCooperativeEnumeratorWithoutHanging(Cancella
     }
 
     /// <summary>Verifies a normally completing sequence delivers all values then completes.</summary>
-    /// <param name="token">The test cancellation token.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    [Timeout(30_000)]
-    public async Task CompletesNormallyAndDeliversAllValues(CancellationToken token)
+    public async Task CompletesNormallyAndDeliversAllValues()
     {
         AsyncEnumerableSignal<int> signal = new(new CountingAsyncEnumerable(SourceValues), CancellationToken.None);
         RecordingWitness<int> observer = new();
 
         _ = signal.Subscribe(observer);
 
-        await observer.CompletedSignal.Task.WaitAsync(token);
+        await observer.CompletedSignal.Task;
 
         await Assert.That(observer.Values.SequenceEqual(SourceValues)).IsTrue();
         await Assert.That(observer.Completed).IsEqualTo(1);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
index 41fb4d65..9a108b57 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
@@ -13,15 +13,12 @@ public class AsyncSignalTests
     /// <summary>Defines the integer value observed by asynchronous tests.</summary>
     private const int ExpectedValue = 42;
 
-    /// <summary>The first value emitted before completion in churn coverage.</summary>
+    /// <summary>The first value emitted before completion.</summary>
     private const int FirstEmittedValue = 5;
 
     /// <summary>A value emitted after completion that must be ignored.</summary>
     private const int IgnoredAfterCompletion = 6;
 
-    /// <summary>Defines the maximum time to wait for cross-thread test work.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>The values expected after the first emission.</summary>
     private static readonly int[] FirstEmittedValues = [FirstEmittedValue];
 
@@ -43,7 +40,8 @@ public void OnError_ArgumentChecking() =>
     public async Task Await_Blocking()
     {
         AsyncSignal<int> s = new();
-        await GetResult_BlockingImpl(s.GetAwaiter());
+        await GetResult_BlockingImpl(s);
+        await Assert.That(s.GetAwaiter()).IsSameReferenceAs(s);
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
@@ -53,7 +51,8 @@ public async Task Await_Blocking()
     public async Task Await_Throw()
     {
         AsyncSignal<int> s = new();
-        await GetResult_Blocking_ThrowImpl(s.GetAwaiter());
+        await GetResult_Blocking_ThrowImpl(s);
+        await Assert.That(s.GetAwaiter()).IsSameReferenceAs(s);
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
@@ -90,25 +89,25 @@ public async Task GetResult_Blocking_Throw()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GetResult_Context()
-    {
-        AsyncSignal<int> x = new();
-        MyContext ctx = new();
-        using ManualResetEventSlim registered = new();
-        using ManualResetEventSlim completed = new();
-        Thread registrationThread = new(() =>
+{
+        AsyncSignal<int> signal = new();
+        MyContext context = new();
+        var completed = false;
+        var previous = SynchronizationContext.Current;
+        try
         {
-            SynchronizationContext.SetSynchronizationContext(ctx);
-            var a = x.GetAwaiter();
-            a.OnCompleted(() => completed.Set());
-            registered.Set();
-        });
-        registrationThread.Start();
-        await Assert.That(registered.Wait(WaitTimeout)).IsTrue();
-        await Assert.That(registrationThread.Join(WaitTimeout)).IsTrue();
-        x.OnNext(ExpectedValue);
-        x.OnCompleted();
-        await Assert.That(completed.Wait(WaitTimeout)).IsTrue();
-        await Assert.That(ctx.Ran).IsTrue();
+            SynchronizationContext.SetSynchronizationContext(context);
+            signal.GetAwaiter().OnCompleted(() => completed = true);
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(previous);
+        }
+
+        signal.OnNext(ExpectedValue);
+        signal.OnCompleted();
+        await Assert.That(completed).IsTrue();
+        await Assert.That(context.Ran).IsTrue();
     }
 
     /// <summary>Determines whether this instance has observers.</summary>
@@ -284,79 +283,42 @@ public async Task AsyncSignalSubscriberChurnLateTerminalsAndDisposalCoverBranche
         await Assert.That(completionFaults).IsEqualTo(1);
     }
 
-    /// <summary>Gets the result blocking implementation.</summary>
-    /// <param name = "s">The s.</param>
+    /// <summary>A pending wait observes completion and returns its last value.</summary>
+    /// <param name="s">The pending signal.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task GetResult_BlockingImpl(IAwaitSignal<int> s)
+    private static async Task GetResult_BlockingImpl(AsyncSignal<int> s)
     {
         await Assert.That(s.IsCompleted).IsFalse();
-        using ManualResetEventSlim release = new();
-        using ManualResetEventSlim started = new();
-        Thread producer = new(() =>
+        var waits = 0;
+        s.WaitIfPending(signal =>
         {
-            if (!release.Wait(WaitTimeout))
-            {
-                return;
-            }
-
-            s.OnNext(ExpectedValue);
-            s.OnCompleted();
+            waits++;
+            signal.OnNext(ExpectedValue);
+            signal.OnCompleted();
         });
-        var y = 0;
-        Thread consumer = new(() =>
-        {
-            started.Set();
-            y = s.GetResult();
-        });
-        producer.Start();
-        consumer.Start();
-        await Assert.That(started.Wait(WaitTimeout)).IsTrue();
-        release.Set();
-        await Assert.That(consumer.Join(WaitTimeout)).IsTrue();
-        await Assert.That(producer.Join(WaitTimeout)).IsTrue();
-        await Assert.That(y).IsEqualTo(ExpectedValue);
+        s.WaitIfPending(_ => waits++);
+        await Assert.That(waits).IsEqualTo(1);
+        await Assert.That(s.GetResult()).IsEqualTo(ExpectedValue);
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
-    /// <summary>Gets the result blocking throw implementation.</summary>
-    /// <param name = "s">The s.</param>
+    /// <summary>A pending wait observes failure and rethrows the same error.</summary>
+    /// <param name="s">The pending signal.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task GetResult_Blocking_ThrowImpl(IAwaitSignal<int> s)
+    private static async Task GetResult_Blocking_ThrowImpl(AsyncSignal<int> s)
     {
         await Assert.That(s.IsCompleted).IsFalse();
-        using ManualResetEventSlim release = new();
-        using ManualResetEventSlim started = new();
         InvalidOperationException expectedException = new();
-        Thread producer = new(() =>
-        {
-            if (!release.Wait(WaitTimeout))
-            {
-                return;
-            }
-
-            s.OnError(expectedException);
-        });
-        Exception? caughtException = null;
-        Thread consumer = new(() =>
+        var waits = 0;
+        s.WaitIfPending(signal =>
         {
-            started.Set();
-            try
-            {
-                _ = s.GetResult();
-            }
-            catch (Exception exception)
-            {
-                caughtException = exception;
-            }
+            waits++;
+            signal.OnError(expectedException);
         });
-        producer.Start();
-        consumer.Start();
-        await Assert.That(started.Wait(WaitTimeout)).IsTrue();
-        release.Set();
-        await Assert.That(consumer.Join(WaitTimeout)).IsTrue();
-        await Assert.That(producer.Join(WaitTimeout)).IsTrue();
-        await Assert.That(caughtException).IsNotNull();
-        await Assert.That(caughtException!).IsSameReferenceAs(expectedException);
+        s.WaitIfPending(_ => waits++);
+        await Assert.That(waits).IsEqualTo(1);
+        var caughtException = Assert.Throws<InvalidOperationException>(() => s.GetResult());
+        await Assert.That(caughtException).IsSameReferenceAs(expectedException);
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
similarity index 89%
rename from src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs
rename to src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
index 138147b1..dcf4edd8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
@@ -8,7 +8,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for the behavior signal type.</summary>
-public class BehaviourSignalTests
+public class BehaviorSignalTests
 {
     /// <summary>Initial value used by behavior signal value tests.</summary>
     private const int InitialValue = 42;
@@ -234,40 +234,23 @@ public async Task Value_ThrowsOnDispose()
         await Assert.That(s.TryGetValue(out _)).IsFalse();
     }
 
-    /// <summary>
-    /// A new subscriber that races a live <see cref="BehaviorSignal{T}.OnNext"/> must never observe a newer
-    /// value before the initial value it was promised; the values it receives stay monotonically ordered.
-    /// </summary>
+    /// <summary>Reentrant emission follows the initial value promised to a new subscriber.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task Subscribe_RacingOnNext_NeverDeliversNewerValueBeforeInitial()
+    public async Task Subscribe_ReentrantOnNext_FollowsTheInitialValue()
     {
-        const int subscribeAttempts = 50_000;
-
-        BehaviorSignal<int> signal = new(0);
-        using CancellationTokenSource stop = new();
-        var firstFailure = default(OrderingWitness<int>.OutOfOrderDelivery);
-
-        var producer = Task.Run(() =>
+        using BehaviorSignal<int> signal = new(0);
+        List<int> values = [];
+        using var subscription = signal.Subscribe(value =>
         {
-            var value = 0;
-            while (!stop.IsCancellationRequested)
+            values.Add(value);
+            if (value != 0)
             {
-                value++;
-                signal.OnNext(value);
+                return;
             }
-        });
 
-        for (var attempt = 0; attempt < subscribeAttempts && firstFailure is null; attempt++)
-        {
-            OrderingWitness<int> witness = new();
-            signal.Subscribe(witness).Dispose();
-            firstFailure = witness.OutOfOrder;
-        }
-
-        await stop.CancelAsync();
-        await producer;
-
-        await Assert.That(firstFailure).IsNull();
+            signal.OnNext(1);
+        });
+        await Assert.That(values.SequenceEqual([0, 1])).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
index dc290599..e236e3d2 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
@@ -282,12 +282,7 @@ public void NullArgumentsThrow()
             new Signal<string?>().SwitchSelect(static _ => Signal.None<int>()).Subscribe((IObserver<int>)null!));
     }
 
-    /// <summary>
-    /// An observable whose subscription deliberately ignores disposal, retaining its observer so a test
-    /// can keep pushing notifications after the operator has switched away from it or disposed it. A
-    /// well-behaved source unsubscribes on either event; this misbehaving source is what the operator's
-    /// race guards exist to defend against.
-    /// </summary>
+    /// <summary>Retains its observer after disposal and permits further notifications.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class ManualObservable<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
index 5d99dca6..4f78e7ef 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
@@ -83,24 +83,15 @@ public async Task ConfigureAwaitPreservesTheOutcomeOfEveryExecutionShape()
     /// <returns>A task that completes when the continuation assertions finish.</returns>
     [Test]
     public async Task TheAwaiterResumesAContinuationScheduledThroughOnCompleted()
-    {
-        using ManualResetEventSlim release = new(false);
-        using CommandSignal<int> command = new(async token =>
-        {
-            await Task.Run(() => release.Wait(token), token);
-            return CommandResult;
-        });
-
+{
+        TaskCompletionSource<int> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using CommandSignal<int> command = new(release.Task.WaitAsync);
         var awaiter = command.ExecuteAsync().GetAwaiter();
         TaskCompletionSource resumed = new(TaskCreationOptions.RunContinuationsAsynchronously);
         awaiter.OnCompleted(() => resumed.SetResult());
-
         await Assert.That(awaiter.IsCompleted).IsFalse();
-
-        release.Set();
+        release.SetResult(CommandResult);
         await resumed.Task;
-
-        await Assert.That(awaiter.IsCompleted).IsTrue();
         await Assert.That(awaiter.GetResult()).IsEqualTo(CommandResult);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.Results.cs b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.Results.cs
new file mode 100644
index 00000000..90793f60
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.Results.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests result observer updates against explicit current and stale snapshots.</summary>
+public sealed partial class CommandSignalTests
+{
+    /// <summary>Stale additions leave the published observer set unchanged.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ResultAdditionsRetryStaleSnapshots()
+    {
+        RecordingWitness<int> first = new();
+        RecordingWitness<int> second = new();
+        RecordingWitness<int> third = new();
+        object? storage = null;
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, null, first)).IsTrue();
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, null, second)).IsFalse();
+        await Assert.That(storage).IsSameReferenceAs(first);
+
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, first, second)).IsTrue();
+        var pair = storage;
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, first, third)).IsFalse();
+        await Assert.That(storage).IsSameReferenceAs(pair);
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, pair, third)).IsTrue();
+        await Assert.That(((IObserver<int>[])storage!).SequenceEqual([first, second, third])).IsTrue();
+        await Assert.That(CommandSignal<int>.TryAddResult(ref storage, pair, first)).IsFalse();
+    }
+
+    /// <summary>Removal retries changed snapshots and preserves absent observers without an update.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ResultRemovalsDistinguishStaleAndAbsentObservers()
+    {
+        RecordingWitness<int> first = new();
+        RecordingWitness<int> second = new();
+        RecordingWitness<int> third = new();
+        RecordingWitness<int> absent = new();
+        IObserver<int>[] original = [first, second];
+        IObserver<int>[] current = [first, second, third];
+        object? storage = current;
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, original, first)).IsFalse();
+        await Assert.That(storage).IsSameReferenceAs(current);
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, current, absent)).IsTrue();
+        await Assert.That(storage).IsSameReferenceAs(current);
+
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, current, first)).IsTrue();
+        await Assert.That(((IObserver<int>[])storage!).SequenceEqual([second, third])).IsTrue();
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, storage, second)).IsTrue();
+        await Assert.That(storage).IsSameReferenceAs(third);
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, storage, third)).IsTrue();
+        await Assert.That(storage).IsNull();
+        await Assert.That(CommandSignal<int>.TryRemoveResult(ref storage, null, absent)).IsTrue();
+        await Assert.That(storage).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
index 7c90a60d..b2bb0e42 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
@@ -8,7 +8,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Verifies <see cref="CommandSignal{TResult}"/> result, failure, running-state, and disposal contracts.</summary>
-public sealed class CommandSignalTests
+public sealed partial class CommandSignalTests
 {
     /// <summary>Initial behavior state value used by command tests.</summary>
     private const int InitialStateValue = 10;
@@ -19,9 +19,6 @@ public sealed class CommandSignalTests
     /// <summary>Successful command result.</summary>
     private const int CommandResult = 42;
 
-    /// <summary>Number of tasks that race for the lazily allocated stream in the contention test.</summary>
-    private const int ContendingTasks = 2;
-
     /// <summary>Number of results the longest-lived result subscriber receives in the fan-out test.</summary>
     private const int ThreeResults = 3;
 
@@ -117,42 +114,20 @@ public async Task CommandSignalCoversSyncFaultAndDisposalBranches()
         await Assert.That(disposed).IsNotNull();
     }
 
-    /// <summary>
-    /// Reproduces the lazy-init race for <see cref="CommandSignal{TResult}.IsRunning"/>: the state
-    /// stream is requested for the first time while an execution is finishing. If the getter
-    /// snapshots a <see langword="true"/> flag and installs the stream after the matching
-    /// completion lowered it, the stream must still settle at <see langword="false"/> rather than
-    /// latching permanently true with no in-flight execution to correct it.
-    /// </summary>
-    /// <returns>A task that completes when every interleaving has settled at false.</returns>
+    /// <summary>Installing a stale running snapshot reconciles it with the completed execution.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task IsRunningNeverLatchesTrueWhenFirstObservedDuringCompletion()
-    {
-        const int iterations = 20_000;
-
-        for (var iteration = 0; iteration < iterations; iteration++)
-        {
-            CommandSignal<int> command = new(static () => CommandResult);
-            using ManualResetEventSlim ready = new(false);
-
-            // Race the first observation of the lazily allocated stream against the execution that
-            // raises and immediately lowers the running flag.
-            var reader = Task.Run(() =>
-            {
-                ready.Wait();
-                return command.IsRunning;
-            });
-
-            ready.Set();
-            _ = command.ExecuteAsync();
-            var stream = await reader;
-
-            // No execution is in flight once ExecuteAsync returns for the synchronous path, so a
-            // stuck-true stream would have no future event to correct it. TryGetValue reads under
-            // the state lock, giving a synchronized view of the settled value.
-            _ = stream.TryGetValue(out var latched);
-            await Assert.That(latched).IsFalse();
-        }
+    public async Task InstallingAStaleRunningSnapshotReconcilesCompletion()
+{
+        TaskCompletionSource<int> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using CommandSignal<int> command = new(release.Task.WaitAsync);
+        var execution = command.ExecuteAsync();
+        StateSignal<bool> candidate = new(true);
+        release.SetResult(CommandResult);
+        _ = await execution;
+        var installed = command.InstallRunningState(candidate);
+        await Assert.That(installed).IsSameReferenceAs(candidate);
+        await Assert.That(installed.Value).IsFalse();
     }
 
     /// <summary>
@@ -217,34 +192,18 @@ public async Task IsRunningReportsFalseWhenObservedOnlyAfterExecution()
     /// <returns>A task that completes when the mid-flight assertions finish.</returns>
     [Test]
     public async Task IsRunningObservedMidFlightSettlesFalseAfterCompletion()
-    {
-        using ManualResetEventSlim release = new(false);
-        using ManualResetEventSlim entered = new(false);
-        CommandSignal<int> command = new(async token =>
-        {
-            entered.Set();
-            await Task.Run(() => release.Wait(token), token);
-            return CommandResult;
-        });
-
+{
+        TaskCompletionSource<int> release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using CommandSignal<int> command = new(release.Task.WaitAsync);
         var execution = command.ExecuteAsync();
-        entered.Wait();
-
-        // The first observation happens while the command is genuinely running.
         var stream = command.IsRunning;
         await Assert.That(stream.Value).IsTrue();
-
-        release.Set();
+        release.SetResult(CommandResult);
         _ = await execution;
-
         await Assert.That(stream.Value).IsFalse();
     }
 
-    /// <summary>
-    /// Results fan out to every active subscriber, and unsubscribing removes that subscriber and nobody else.
-    /// This walks the observer set through all three of its shapes — one observer, a pair, a longer array — and
-    /// back down again, because each shape has its own add and remove path.
-    /// </summary>
+    /// <summary>Results reach each active subscriber as subscriptions are added and removed.</summary>
     /// <returns>A task that completes when the fan-out assertions finish.</returns>
     [Test]
     public async Task ResultsFanOutToEverySubscriberAndStopAtUnsubscribe()
@@ -365,66 +324,37 @@ public async Task FaultsAllocateLazilyAndDisposalReleasesTheGateSubscription()
         await Assert.That(running.IsDisposed).IsTrue();
     }
 
-    /// <summary>
-    /// Forces concurrent first observations of the lazily allocated fault stream so the install CAS has a loser,
-    /// exercising the dispose-and-return-installed branch. All racers must observe the same instance.
-    /// </summary>
-    /// <returns>A task that completes when the concurrent fault-stream assertions finish.</returns>
+    /// <summary>Competing fault-stream candidates return the installed stream and dispose the unused candidate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task ConcurrentFirstObservationsShareASingleFaultStream()
-    {
-        const int iterations = 5_000;
-
-        for (var iteration = 0; iteration < iterations; iteration++)
-        {
-            CommandSignal<int> command = new(static () => CommandResult);
-            using Barrier barrier = new(ContendingTasks);
-
-            var left = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                return command.Faults;
-            });
-            var right = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                return command.Faults;
-            });
-
-            var streams = await Task.WhenAll(left, right);
-            await Assert.That(streams[0]).IsSameReferenceAs(streams[1]);
-        }
+    public async Task CompetingFaultStreamCandidatesShareTheInstalledStream()
+{
+        using CommandSignal<int> command = new(static () => CommandResult);
+        Signal<Exception> first = new();
+        Signal<Exception> second = new();
+        var winner = command.InstallFaultsSignal(first);
+        var loser = command.InstallFaultsSignal(second);
+        await Assert.That(winner).IsSameReferenceAs(first);
+        await Assert.That(loser).IsSameReferenceAs(first);
+        await Assert.That(command.Faults).IsSameReferenceAs(first);
+        await Assert.That(first.IsDisposed).IsFalse();
+        await Assert.That(second.IsDisposed).IsTrue();
     }
 
-    /// <summary>
-    /// Forces concurrent first observations of the lazily allocated stream so the install CAS has a
-    /// loser, exercising the dispose-and-return-installed branch. All racers must observe the same
-    /// instance.
-    /// </summary>
-    /// <returns>A task that completes when the concurrent-install assertions finish.</returns>
+    /// <summary>Competing running-stream candidates return the installed stream and dispose the unused candidate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task ConcurrentFirstObservationsShareASingleStream()
-    {
-        const int iterations = 5_000;
-
-        for (var iteration = 0; iteration < iterations; iteration++)
-        {
-            CommandSignal<int> command = new(static () => CommandResult);
-            using Barrier barrier = new(ContendingTasks);
-
-            var left = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                return command.IsRunning;
-            });
-            var right = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                return command.IsRunning;
-            });
-
-            var streams = await Task.WhenAll(left, right);
-            await Assert.That(streams[0]).IsSameReferenceAs(streams[1]);
-        }
+    public async Task CompetingRunningStreamCandidatesShareTheInstalledStream()
+{
+        using CommandSignal<int> command = new(static () => CommandResult);
+        StateSignal<bool> first = new(false);
+        StateSignal<bool> second = new(false);
+        var winner = command.InstallRunningState(first);
+        var loser = command.InstallRunningState(second);
+        await Assert.That(winner).IsSameReferenceAs(first);
+        await Assert.That(loser).IsSameReferenceAs(first);
+        await Assert.That(command.IsRunning).IsSameReferenceAs(first);
+        await Assert.That(first.IsDisposed).IsFalse();
+        await Assert.That(second.IsDisposed).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
index e7e5b0db..f1b9aa55 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/AwaitableWitness.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// An observer that records every callback and hands out tasks that complete when a callback arrives, so a test
-/// awaits the notification it is asserting on instead of giving a clock a budget to produce it.
-/// </summary>
+/// <summary>Records callbacks and completes a task for each notification.</summary>
 /// <typeparam name="T">The type of the observed values.</typeparam>
 internal sealed class AwaitableWitness<T> : IObserver<T>
 {
@@ -45,24 +42,6 @@ internal sealed class AwaitableWitness<T> : IObserver<T>
     /// <summary>Gets the number of completion callbacks observed.</summary>
     internal int Completions { get; private set; }
 
-    /// <summary>Gets a task that completes once the observed value count reaches a threshold.</summary>
-    /// <param name="count">The value count to wait for.</param>
-    /// <returns>A task that completes when at least <paramref name="count"/> values have been observed.</returns>
-    internal Task ValueCountReaching(int count)
-    {
-        var waiter = _valueWaiters.GetOrAdd(
-            count,
-            static _ => new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously));
-
-        // Re-check after registering: a value that arrived in between would otherwise never signal this waiter.
-        if (_values.Count >= count)
-        {
-            _ = waiter.TrySetResult();
-        }
-
-        return waiter.Task;
-    }
-
     /// <inheritdoc/>
     public void OnCompleted()
     {
@@ -90,4 +69,22 @@ public void OnNext(T value)
             }
         }
     }
+
+    /// <summary>Gets a task that completes once the observed value count reaches a threshold.</summary>
+    /// <param name="count">The value count to wait for.</param>
+    /// <returns>A task that completes when at least <paramref name="count"/> values have been observed.</returns>
+    internal Task ValueCountReaching(int count)
+    {
+        var waiter = _valueWaiters.GetOrAdd(
+            count,
+            static _ => new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously));
+
+        // Re-check after registering: a value that arrived in between would otherwise never signal this waiter.
+        if (_values.Count >= count)
+        {
+            _ = waiter.TrySetResult();
+        }
+
+        return waiter.Task;
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs
index e92862e3..1ee5903b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/CancellationTokenExtensions.cs
@@ -7,21 +7,19 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Awaitable adapters over a <see cref="CancellationToken"/>.</summary>
 internal static class CancellationTokenExtensions
 {
-    /// <summary>
-    /// Returns a task that stays pending until the token is cancelled and then throws
-    /// <see cref="OperationCanceledException"/>. It models work that only ever ends by cancellation, so a test can
-    /// hold a factory open for as long as it needs to without handing a deadline to a clock.
-    /// </summary>
-    /// <param name="token">The token whose cancellation ends the wait.</param>
-    /// <returns>A task that transitions to cancelled when <paramref name="token"/> is cancelled.</returns>
-    internal static async Task WhenCanceled(this CancellationToken token)
+    /// <summary>Provides cancellation completion for a token.</summary>
+    /// <param name="token">The token to observe.</param>
+    extension(CancellationToken token)
     {
-        // No RunContinuationsAsynchronously: the awaiting body resumes inside Cancel, so the cancellation path
-        // has run by the time the caller's Cancel call returns.
-        TaskCompletionSource completion = new();
-        using var registration = token.Register(
-            static state => ((TaskCompletionSource)state!).TrySetCanceled(),
-            completion);
-        await completion.Task.ConfigureAwait(false);
+        /// <summary>Completes with cancellation when the token is canceled.</summary>
+        /// <returns>The cancellation task.</returns>
+        internal async Task WhenCanceled()
+        {
+            TaskCompletionSource completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            await using var registration = token.UnsafeRegister(
+                static state => _ = ((TaskCompletionSource)state!).TrySetCanceled(),
+                completion);
+            await completion.Task.ConfigureAwait(false);
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
index 5d8af9d0..a3be5b8d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
@@ -7,17 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// A sequencer that runs the first work item inline, before <c>Schedule</c> returns, and queues every item
-/// scheduled after that. It models a sequencer that dispatches on the calling thread when it already owns that
-/// thread but defers re-entrant work, which is the interleaving under which an operator that assigns its timer
-/// handle after scheduling cancels the successor timer its own callback just armed.
-/// <para>
-/// The clock is virtual and only moves when a test calls <see cref="Advance"/>, and queued work only runs when a
-/// test calls <see cref="RunPending"/>. Nothing here reads the wall clock, sleeps, or starts a real timer, so the
-/// tests built on it are decided entirely by the order of their own calls.
-/// </para>
-/// </summary>
+/// <summary>Runs the first item inline and queues subsequent work. Clock advancement and queue draining are explicit.</summary>
 /// <param name="advanceBeforeFirst">The amount the clock moves forward before the first item runs.</param>
 [System.Diagnostics.DebuggerDisplay("FirstInlineSequencer: Now = {Now}, Started = {_started}, Pending = {_pending.Count}")]
 public sealed class FirstInlineSequencer(TimeSpan advanceBeforeFirst) : ISequencer
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
index 9b74e10e..390da735 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// A sequencer that queues scheduled work instead of running it, so a test can decide exactly when a timer
-/// fires. <see cref="RunStaleTick"/> re-runs the most recently fired work item, modelling a timer that fires a
-/// second time after the operator has already consumed the value it was scheduled for.
-/// </summary>
+/// <summary>Queues work for explicit execution and permits replaying the last callback.</summary>
 internal sealed class ManualSequencer : ISequencer
 {
     /// <summary>The work items scheduled and not yet run.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualTaskScheduler.cs
new file mode 100644
index 00000000..dd24eff4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualTaskScheduler.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Runs queued tasks only when explicitly drained.</summary>
+internal sealed class ManualTaskScheduler : TaskScheduler
+{
+    /// <summary>Tasks awaiting execution.</summary>
+    private readonly Queue<Task> _tasks = new();
+
+    /// <summary>Runs every queued task.</summary>
+    internal void RunPending()
+    {
+        while (_tasks.TryDequeue(out var task))
+        {
+            _ = TryExecuteTask(task);
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override IEnumerable<Task> GetScheduledTasks() => _tasks.ToArray();
+
+    /// <inheritdoc/>
+    protected override void QueueTask(Task task) => _tasks.Enqueue(task);
+
+    /// <inheritdoc/>
+    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualThreadPool.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualThreadPool.cs
new file mode 100644
index 00000000..cac69951
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualThreadPool.cs
@@ -0,0 +1,49 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Drives a thread-pool sequencer through explicit queue and clock transitions.</summary>
+internal sealed class ManualThreadPool : IDisposable
+{
+    /// <summary>Pending immediate callbacks.</summary>
+    private readonly Queue<Action> _ready = new();
+
+    /// <summary>Initializes a new instance of the <see cref="ManualThreadPool"/> class.</summary>
+    internal ManualThreadPool() =>
+        Sequencer = new(() => Timestamp, (callback, state) => _ready.Enqueue(() => callback(state)), Delays.Add);
+
+    /// <summary>Gets the sequencer under test.</summary>
+    internal ThreadPoolSequencer Sequencer { get; }
+
+    /// <summary>Gets or sets the current monotonic clock reading.</summary>
+    internal long Timestamp { get; set; }
+
+    /// <summary>Gets the timer changes requested by the sequencer.</summary>
+    internal List<TimeSpan> Delays { get; } = [];
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Dispose() => Sequencer.Dispose();
+
+    /// <summary>Executes all immediate callbacks.</summary>
+    internal void RunReady()
+    {
+        while (_ready.TryDequeue(out var callback))
+        {
+            callback();
+        }
+    }
+
+    /// <summary>Runs the timer callback at an explicit clock reading.</summary>
+    /// <param name="timestamp">The clock reading for the callback.</param>
+    internal void RunDue(long timestamp)
+    {
+        Timestamp = timestamp;
+        Sequencer.RunDue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/OrderingWitness.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/OrderingWitness.cs
index a3ffb4cc..c113e7fa 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/OrderingWitness.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/OrderingWitness.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// An observer that watches a monotonically increasing stream and flags the first delivery that breaks the
-/// ordering contract: a value that is not strictly greater than the one before it. A repeat of the previous
-/// value (a duplicate) or a smaller value (a reorder) both trip the flag.
-/// </summary>
+/// <summary>Records the first value that is not strictly greater than its predecessor.</summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 internal sealed class OrderingWitness<T> : IObserver<T>
     where T : IComparable<T>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/TaskNotificationObserver.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/TaskNotificationObserver.cs
new file mode 100644
index 00000000..ad2c125a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/TaskNotificationObserver.cs
@@ -0,0 +1,41 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Tests;
+
+/// <summary>Records notifications and signals terminal delivery.</summary>
+internal sealed class TaskNotificationObserver : IObserver<int>
+{
+    /// <summary>Gets the received values.</summary>
+    public List<int> Values { get; } = [];
+
+    /// <summary>Gets the received failure.</summary>
+    public Exception? Error { get; private set; }
+
+    /// <summary>Gets the number of completion notifications.</summary>
+    public int Completions { get; private set; }
+
+    /// <summary>Gets the terminal delivery signal.</summary>
+    public TaskCompletionSource Terminal { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void OnNext(int value) => Values.Add(value);
+
+    /// <inheritdoc/>
+    public void OnError(Exception error)
+    {
+        Error = error;
+        _ = Terminal.TrySetResult();
+    }
+
+    /// <inheritdoc/>
+    public void OnCompleted()
+    {
+        Completions++;
+        _ = Terminal.TrySetResult();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/TestPolling.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/TestPolling.cs
deleted file mode 100644
index 7430d027..00000000
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/TestPolling.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-namespace ReactiveUI.Primitives.Tests;
-
-/// <summary>Shared polling helpers for asynchronous coverage branches.</summary>
-internal static class TestPolling
-{
-    /// <summary>The delay in milliseconds between condition polls.</summary>
-    private const int PollDelayMilliseconds = 10;
-
-    /// <summary>Polls a condition until it succeeds or the timeout elapses.</summary>
-    /// <param name="condition">The condition to evaluate on each poll.</param>
-    /// <param name="timeout">The maximum time to wait for the condition.</param>
-    /// <returns>A task that completes when the condition is satisfied.</returns>
-    /// <exception cref="TimeoutException"><paramref name="condition"/> did not succeed before <paramref name="timeout"/> elapsed.</exception>
-    internal static async Task SpinUntil(Func<bool> condition, TimeSpan timeout)
-    {
-        var attempts = (int)(timeout.TotalMilliseconds / PollDelayMilliseconds);
-        for (var attempt = 0; attempt < attempts; attempt++)
-        {
-            if (condition())
-            {
-                return;
-            }
-
-            await Task.Delay(PollDelayMilliseconds).ConfigureAwait(false);
-        }
-
-        throw new TimeoutException("Timed out waiting for asynchronous coverage branch.");
-    }
-}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ConcurencyTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ConcurencyTests.cs
deleted file mode 100644
index e426d9da..00000000
--- a/src/tests/ReactiveUI.Primitives.Tests/ConcurencyTests.cs
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated 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;
-using ReactiveUI.Primitives.Concurrency;
-using ReactiveUI.Primitives.Disposables;
-
-namespace ReactiveUI.Primitives.Tests;
-
-/// <summary>Tests task-pool sequencer behavior.</summary>
-public class ConcurencyTests
-{
-    /// <summary>Defines the maximum time to wait for scheduled work in tests.</summary>
-    private static readonly TimeSpan ScheduleTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Defines the maximum tolerated difference between sequencer and system time.</summary>
-    private static readonly TimeSpan ClockTolerance = TimeSpan.FromSeconds(1);
-
-    /// <summary>Defines the short due time used by delayed scheduling tests.</summary>
-    private static readonly TimeSpan ShortDueTime = TimeSpan.FromMilliseconds(10);
-
-    /// <summary>Defines the due time used by cancellation tests.</summary>
-    private static readonly TimeSpan CancelDueTime = TimeSpan.FromMilliseconds(200);
-
-    /// <summary>Defines the observation window used after canceling scheduled work.</summary>
-    private static readonly TimeSpan CancelObservationWindow = TimeSpan.FromMilliseconds(400);
-
-    /// <summary>Verifies that scheduling state returns a disposable.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TestCreate()
-    {
-        var disposable = TaskPoolSequencer.Instance.Schedule(0, static (_, _) => EmptyDisposable.Instance);
-        await Assert.That(disposable).IsNotNull();
-        disposable.Dispose();
-    }
-
-    /// <summary>Verifies that the task-pool sequencer reports current UTC time.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolNow()
-    {
-        var delta = TaskPoolSequencer.Instance.Now - TimeProvider.System.GetUtcNow();
-        await Assert.That(delta.Duration() < ClockTolerance).IsTrue();
-    }
-
-    /// <summary>Verifies that immediate work is scheduled asynchronously.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolScheduleAction()
-    {
-        var nt = TaskPoolSequencer.Instance;
-        var probe = new InlineExecutionProbe();
-        using var scheduled = nt.Schedule(probe, static p => p.RecordExecution());
-        probe.MarkSchedulingFinished();
-        var ranInline = await probe.Completed.Task.WaitAsync(ScheduleTimeout);
-        await Assert.That(ranInline).IsFalse();
-    }
-
-    /// <summary>Verifies that work due immediately is scheduled asynchronously.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolScheduleActionDueNow()
-    {
-        var nt = TaskPoolSequencer.Instance;
-        var probe = new InlineExecutionProbe();
-        using var scheduled = nt.Schedule(probe, TimeSpan.Zero, static p => p.RecordExecution());
-        probe.MarkSchedulingFinished();
-        var ranInline = await probe.Completed.Task.WaitAsync(ScheduleTimeout);
-        await Assert.That(ranInline).IsFalse();
-    }
-
-    /// <summary>Verifies that delayed work is scheduled asynchronously.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolScheduleActionDue()
-    {
-        var nt = TaskPoolSequencer.Instance;
-        var probe = new InlineExecutionProbe();
-        using var scheduled = nt.Schedule(probe, ShortDueTime, static p => p.RecordExecution());
-        probe.MarkSchedulingFinished();
-        var ranInline = await probe.Completed.Task.WaitAsync(ScheduleTimeout);
-        await Assert.That(ranInline).IsFalse();
-    }
-
-    /// <summary>Verifies that canceled delayed work does not run.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolScheduleActionCancel()
-    {
-        var nt = TaskPoolSequencer.Instance;
-        var probe = new CancellationProbe();
-        var scheduled = nt.Schedule(probe, CancelDueTime, static p => p.RecordExecution());
-        scheduled.Dispose();
-        var delay = Task.Delay(CancelObservationWindow);
-        var observed = await Task.WhenAny(probe.Completed.Task, delay);
-        await Assert.That(observed).IsSameReferenceAs(delay);
-        await Assert.That(probe.RunCount).IsEqualTo(0);
-    }
-
-    /// <summary>Verifies that delays larger than <see cref = "int.MaxValue"/> milliseconds are accepted.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TaskPoolDelayLargerThanIntMaxValue()
-    {
-        var dueTime = TimeSpan.FromMilliseconds((double)int.MaxValue + 1);
-        using var scheduled = TaskPoolSequencer.Instance.Schedule(dueTime, static () => { });
-        await Assert.That(scheduled).IsNotNull();
-    }
-
-    /// <summary>Records whether a scheduled callback ran on the scheduling thread before scheduling returned.</summary>
-    private sealed class InlineExecutionProbe
-    {
-        /// <summary>The thread the scheduling call was made on.</summary>
-        private readonly int _schedulingThreadId = Environment.CurrentManagedThreadId;
-
-        /// <summary>Non-zero while the scheduling call has not yet returned.</summary>
-        private int _scheduling = 1;
-
-        /// <summary>Gets the source completed with whether the callback observed an inline execution.</summary>
-        public TaskCompletionSource<bool> Completed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <summary>Signals that the scheduling call has returned, so any later callback cannot have run inline.</summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MarkSchedulingFinished() => Volatile.Write(ref _scheduling, 0);
-
-        /// <summary>Completes <see cref = "Completed"/> with whether this callback ran inline on the scheduling thread.</summary>
-        public void RecordExecution() => _ = Completed.TrySetResult(
-            Environment.CurrentManagedThreadId == _schedulingThreadId
-            && Volatile.Read(ref _scheduling) != 0);
-    }
-
-    /// <summary>Records whether a scheduled callback ran at all, so a cancellation can be shown to have suppressed it.</summary>
-    private sealed class CancellationProbe
-    {
-        /// <summary>How many times the scheduled callback has run.</summary>
-        private int _runCount;
-
-        /// <summary>Gets the source completed when the scheduled callback runs.</summary>
-        public TaskCompletionSource<int> Completed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <summary>Gets the number of times the scheduled callback ran.</summary>
-        public int RunCount => Volatile.Read(ref _runCount);
-
-        /// <summary>Records that the scheduled callback ran.</summary>
-        public void RecordExecution()
-        {
-            Volatile.Write(ref _runCount, 1);
-            _ = Completed.TrySetResult(1);
-        }
-    }
-}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
index 6be8a4bd..c18c71fd 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
@@ -29,9 +29,6 @@ public sealed class ConnectableSignalTests
     /// <summary>Second value observed through replay.</summary>
     private const int SecondReplayValue = 5;
 
-    /// <summary>A replay window wide enough that no value expires while a test runs.</summary>
-    private const int ReplayWindowSeconds = 30;
-
     /// <summary>Expected values for the first shared subscription.</summary>
     private static readonly int[] ExpectedFirstSharedValues = [FirstSharedValue];
 
@@ -106,7 +103,7 @@ public async Task ConnectableAliasesValidateAndConnectAtThreshold()
         _ = Assert.Throws<ArgumentNullException>(static () => ConnectableSignalExtensions.AutoShare<int>(null!));
         _ = Assert.Throws<ArgumentNullException>(static () => ConnectableSignalExtensions.AutoConnect<int>(null!));
         _ = Assert.Throws<ArgumentOutOfRangeException>(() => cold.ShareLive().AutoConnect(-1));
-        var replayed = cold.Replay(1, TimeSpan.FromSeconds(1));
+        var replayed = cold.Replay(1, TimeSpan.MaxValue);
         using var connection = replayed.Connect();
         source.OnNext(FirstReplayValue);
         List<int> replayValues = [];
@@ -155,13 +152,13 @@ public async Task UnboundedReplayLiveReplaysEveryValueToALateSubscriber()
         await Assert.That(late.SequenceEqual(ExpectedReplayValues)).IsTrue();
     }
 
-    /// <summary>A windowed replay hub still honours its buffer-size bound.</summary>
+    /// <summary>A replay hub with expiration disabled honours its buffer-size bound.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task WindowedReplayLiveHonoursItsBufferSizeBound()
+    public async Task ReplayLiveWithExpirationDisabledHonoursItsBufferSizeBound()
     {
         Signal<int> source = new();
-        var replayed = source.ReplayLive(1, TimeSpan.FromSeconds(ReplayWindowSeconds));
+        var replayed = source.ReplayLive(1, TimeSpan.MaxValue);
 
         using var connection = replayed.Connect();
         source.OnNext(FirstReplayValue);
@@ -170,7 +167,6 @@ public async Task WindowedReplayLiveHonoursItsBufferSizeBound()
         List<int> late = [];
         using var subscription = replayed.Subscribe(late.Add);
 
-        // The window is wide enough to keep both values, so only the buffer size may trim the replay.
         await Assert.That(late.SequenceEqual(ExpectedReplayValues[1..])).IsTrue();
     }
 
@@ -385,45 +381,29 @@ public async Task AutoShareConnectFailureUnwindsRefcount()
         await Assert.That(values.SequenceEqual(ExpectedFirstSharedValues)).IsTrue();
     }
 
-    /// <summary>Verifies AutoShare maintains a single connection under concurrent subscribe and dispose churn.</summary>
+    /// <summary>Overlapping subscriptions share one source connection until the last subscriber leaves.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task AutoShareKeepsSingleConnectionUnderConcurrentChurn()
-    {
-        const int Workers = 8;
-        const int IterationsPerWorker = 200;
+    public async Task AutoShareKeepsOneConnectionAcrossOverlappingSubscriptions()
+{
         var peakConnections = 0;
         var liveConnections = 0;
         var cold = Signal.Create<int>(observer =>
         {
-            var live = Interlocked.Increment(ref liveConnections);
-            var peak = Volatile.Read(ref peakConnections);
-            while (live > peak && Interlocked.CompareExchange(ref peakConnections, live, peak) != peak)
-            {
-                peak = Volatile.Read(ref peakConnections);
-            }
-
+            liveConnections++;
+            peakConnections = Math.Max(peakConnections, liveConnections);
             observer.OnNext(FirstSharedValue);
-            return new ActionDisposable(() => Interlocked.Decrement(ref liveConnections));
+            return new ActionDisposable(() => liveConnections--);
         });
-
         var shared = cold.Share().AutoShare();
-
-        var workers = new Task[Workers];
-        for (var worker = 0; worker < Workers; worker++)
-        {
-            workers[worker] = Task.Run(() =>
-            {
-                for (var iteration = 0; iteration < IterationsPerWorker; iteration++)
-                {
-                    shared.Subscribe(static _ => { }).Dispose();
-                }
-            });
-        }
-
-        await Task.WhenAll(workers);
-
-        // Refcount churn must never run two upstream connections at once and must release the last one.
+        var first = shared.Subscribe(static _ => { });
+        var second = shared.Subscribe(static _ => { });
+        first.Dispose();
+        await Assert.That(liveConnections).IsEqualTo(1);
+        var third = shared.Subscribe(static _ => { });
+        second.Dispose();
+        await Assert.That(liveConnections).IsEqualTo(1);
+        third.Dispose();
         await Assert.That(peakConnections).IsEqualTo(1);
         await Assert.That(liveConnections).IsEqualTo(0);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerBaseTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
similarity index 87%
rename from src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerBaseTests.cs
rename to src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
index a4910fb2..79e72b09 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
@@ -10,7 +10,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for the shared UI dispatch sequencer base.</summary>
-public sealed class DispatchSequencerBaseTests
+public sealed class DispatchSequencerStateTests
 {
     /// <summary>Expected post count after reentrant scheduling.</summary>
     private const int ExpectedReentrantPostCount = 2;
@@ -51,24 +51,10 @@ public sealed class DispatchSequencerBaseTests
     /// <summary>The single value recorded when only the live half of a pair of work items runs.</summary>
     private static readonly int[] ExpectedLiveOnly = [OuterDrainValue];
 
-    /// <summary>How far ahead delayed work is scheduled.</summary>
-    private static readonly TimeSpan DelayedDueTime = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>
-    /// A due time far enough out that no scheduling pause between capturing the timestamp and reading the
-    /// remaining delay can elapse it. Asserting a still-pending delay against a short due time races the wall
-    /// clock: a loaded runner can spend longer than the due time inside the preceding assertion, leaving nothing
-    /// to wait for and clamping the result to zero.
-    /// </summary>
-    private static readonly TimeSpan UnreachableDueTime = TimeSpan.FromHours(1);
-
-    /// <summary>How long a test watches for delayed work that must never reach the dispatcher.</summary>
-    private static readonly TimeSpan CancelObservationWindow = TimeSpan.FromMilliseconds(400);
-
     /// <summary>Verifies a burst posts one dispatcher drain and preserves FIFO order.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DispatchSequencerBaseCoalescesBurstIntoOneDrain()
+    public async Task CoalescesBurstIntoOneDrain()
     {
         var sequencer = TestDispatchSequencer.Create();
         List<int> values = [];
@@ -84,7 +70,7 @@ public async Task DispatchSequencerBaseCoalescesBurstIntoOneDrain()
     /// <summary>Verifies cancelled queued work is skipped when the drain runs.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DispatchSequencerBaseSkipsCancelledQueuedWork()
+    public async Task SkipsCancelledQueuedWork()
     {
         var sequencer = TestDispatchSequencer.Create();
         List<int> values = [];
@@ -98,7 +84,7 @@ public async Task DispatchSequencerBaseSkipsCancelledQueuedWork()
     /// <summary>Verifies work scheduled from inside a drain runs in the next drain.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task DispatchSequencerBaseDefersReentrantWorkToNextDrain()
+    public async Task DefersReentrantWorkToNextDrain()
     {
         var sequencer = TestDispatchSequencer.Create();
         List<int> values = [];
@@ -142,12 +128,45 @@ public async Task RunIfActiveRunsLiveWorkAndSkipsCancelledWork()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayUntilClampsElapsedDueTimestampsToZero()
+{
+        await Assert.That(DispatchSequencerState.DelayUntil(0)).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(Sequencer.TimeUntil(ElapsedTimestampOffset, ElapsedTimestampOffset)).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(Sequencer.TimeUntil(0, ElapsedTimestampOffset)).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(Sequencer.TimeUntil(ElapsedTimestampOffset, 0)).IsGreaterThan(TimeSpan.Zero);
+    }
+
+    /// <summary>Active delayed work returns to its owning dispatch queue.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task MarshalOnDueQueuesActiveWorkOnItsOwner()
     {
-        var now = DispatchSequencerState.Timestamp;
+        var sequencer = TestDispatchSequencer.Create();
+        List<int> values = [];
+        RecordingWorkItem item = new(values, OuterDrainValue);
+        DispatchSequencerState.MarshalOnDueWorkItem marshal = new(sequencer, item);
+        marshal.Execute();
+        await Assert.That(values.Count).IsEqualTo(0);
+        sequencer.RunNextDrain();
+        await Assert.That(values.SequenceEqual([OuterDrainValue])).IsTrue();
+    }
 
-        await Assert.That(DispatchSequencerState.DelayUntil(now - ElapsedTimestampOffset)).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(DispatchSequencerState.DelayUntil(Sequencer.AddTimestamp(now, UnreachableDueTime)) > TimeSpan.Zero)
-            .IsTrue();
+    /// <summary>The fallback timer marshals delayed work through the owning dispatch queue.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task FallbackTimerMarshalsDelayedWorkToItsOwner()
+    {
+        ManualSequencer timer = new();
+        var sequencer = TestDispatchSequencer.Create(timer);
+        List<int> values = [];
+        RecordingWorkItem item = new(values, OuterDrainValue);
+        sequencer.Schedule(item, long.MaxValue);
+        await Assert.That(values.Count).IsEqualTo(0);
+        await Assert.That(sequencer.PostCount).IsEqualTo(0);
+        timer.RunPending();
+        await Assert.That(values.Count).IsEqualTo(0);
+        await Assert.That(sequencer.PostCount).IsEqualTo(1);
+        sequencer.RunNextDrain();
+        await Assert.That(values.SequenceEqual([OuterDrainValue])).IsTrue();
     }
 
     /// <summary>Verifies a platform delayed-scheduling override receives delayed work instead of the shared timer.</summary>
@@ -158,7 +177,7 @@ public async Task DelayedWorkUsesThePlatformOverrideWhenOneIsSupplied()
         var sequencer = ConfigurableDispatchSequencer.CreateWithDelayedOverride();
         List<int> values = [];
         RecordingWorkItem item = new(values, OuterDrainValue);
-        var dueTimestamp = Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime);
+        const long dueTimestamp = long.MaxValue;
 
         sequencer.Schedule(item, dueTimestamp);
 
@@ -173,16 +192,13 @@ public async Task DelayedWorkUsesThePlatformOverrideWhenOneIsSupplied()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayedWorkCancelledBeforeItIsDueNeverReachesTheDispatcher()
-    {
+{
         var sequencer = ConfigurableDispatchSequencer.Create();
         List<int> values = [];
         RecordingWorkItem item = new(values, OuterDrainValue);
-
-        sequencer.Schedule(item, Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime));
+        DispatchSequencerState.MarshalOnDueWorkItem marshal = new(sequencer, item);
         item.Dispose();
-
-        await Task.Delay(CancelObservationWindow);
-
+        marshal.Execute();
         await Assert.That(sequencer.PostCount).IsEqualTo(0);
         await Assert.That(values.Count).IsEqualTo(0);
     }
@@ -280,11 +296,14 @@ private TestDispatchSequencer()
 
         /// <summary>Creates a sequencer whose dispatch state is wired only after construction has finished,
         /// so the engine never sees a half-built owner.</summary>
+        /// <param name="sharedTimer">The optional fallback delay sequencer.</param>
         /// <returns>The wired sequencer.</returns>
-        public static TestDispatchSequencer Create()
+        public static TestDispatchSequencer Create(ISequencer? sharedTimer = null)
         {
             TestDispatchSequencer sequencer = new();
-            sequencer._state = new(sequencer, sequencer.Post, sequencer.RunDrain);
+            sequencer._state = sharedTimer is null
+                ? new(sequencer, sequencer.Post, sequencer.RunDrain)
+                : new(sequencer, sequencer.Post, sequencer.RunDrain, null, sharedTimer);
             return sequencer;
         }
 
@@ -337,10 +356,7 @@ private sealed class RecordingWorkItem(List<int> values, int value) : IWorkItem,
         public void Execute() => _values.Add(_value);
     }
 
-    /// <summary>
-    /// Dispatch sequencer whose post can be made to reject a drain or throw, and which can capture delayed work
-    /// through a platform override instead of falling back to the shared thread-pool timer.
-    /// </summary>
+    /// <summary>Captures delayed work and supports accepted, rejected, or throwing drain posts.</summary>
     private sealed class ConfigurableDispatchSequencer : ISequencer
     {
         /// <summary>Posted drains awaiting a run.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
index e5e3a4f4..b879f1b3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
@@ -34,7 +34,7 @@ public class DisposableTests
     /// <summary>The number of disposables added to the multiple-disposable group.</summary>
     private const int Twenty = 20;
 
-    /// <summary>Calendar year used by value-type timestamp coverage.</summary>
+    /// <summary>Calendar year used by timestamp values.</summary>
     private const int CalendarYear = 2024;
 
     /// <summary>The disposal count produced when a slot disposes twice.</summary>
@@ -175,7 +175,7 @@ public async Task LowLevelDisposablesCollectionsAndSchedulersCoverDeterministicE
         _ = Assert.Throws<ArgumentNullException>(() => current.Schedule((Action)null!));
         _ = Assert.Throws<ArgumentNullException>(() => current.Schedule(One, TimeSpan.Zero, null!));
         List<int> scheduled = [];
-        current.Schedule(One, TimeSpan.FromMilliseconds(1), (_, state) =>
+        current.Schedule(One, TimeSpan.Zero, (_, state) =>
         {
             scheduled.Add(state);
             return EmptyDisposable.Instance;
@@ -368,7 +368,7 @@ private static async Task InvokeInternalHandleMembers(Exception exception)
         _ = Assert.Throws<InvalidOperationException>(() => Handle<int, int, int>.Throw(exception, 1, Two, Three));
     }
 
-    /// <summary>Exposes the protected dispose path for coverage.</summary>
+    /// <summary>Exposes disposal without managed-resource cleanup.</summary>
     private sealed class ExposedSingleDisposable : SingleDisposable
     {
         /// <summary>Initializes a new instance of the <see cref="ExposedSingleDisposable"/> class.</summary>
@@ -383,7 +383,7 @@ public ExposedSingleDisposable(IDisposable disposable)
         public void DisposeFalse() => Dispose(false);
     }
 
-    /// <summary>Exposes the protected dispose path for coverage.</summary>
+    /// <summary>Exposes disposal without managed-resource cleanup.</summary>
     private sealed class ExposedSingleReplaceableDisposable : SingleReplaceableDisposable
     {
         /// <summary>Initializes a new instance of the <see cref="ExposedSingleReplaceableDisposable"/> class.</summary>
@@ -398,7 +398,7 @@ public ExposedSingleReplaceableDisposable(IDisposable disposable)
         public void DisposeFalse() => Dispose(false);
     }
 
-    /// <summary>Exposes the protected dispose path for coverage.</summary>
+    /// <summary>Exposes disposal without managed-resource cleanup.</summary>
     private sealed class ExposedMultipleDisposable : MultipleDisposable
     {
         /// <summary>Initializes a new instance of the <see cref="ExposedMultipleDisposable"/> class.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
index 67b023c5..bcf39bb5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
@@ -3,21 +3,12 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Signals;
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for the recurring <c>Every</c> timer on the current-thread sequencer, whose trampoline runs the
-/// ticks on the subscribing thread and therefore has to hand the subscription back before it starts ticking.
-/// Every bounding operator layered over it — <c>Take</c>, <c>TakeWhile</c>, <c>TakeUntil</c>, <c>Any</c>,
-/// <c>All</c>, <c>Contains</c>, <c>IsEmpty</c>, <c>Expire</c> — has to enter the trampoline itself, so that the
-/// source only queues its first tick and the sink owns the upstream handle in time to dispose it when the bound
-/// is reached. An operator that skips that step drains the trampoline from inside the source's own subscribe
-/// call and never learns its bound was hit, livelocking the subscribing thread.
-/// </summary>
+/// <summary>Tests recurring ticks and bounded subscriptions on the current-thread sequencer.</summary>
 public sealed class EverySignalTests
 {
     /// <summary>The number of ticks the bounded subscriptions ask for.</summary>
@@ -32,29 +23,10 @@ public sealed class EverySignalTests
     /// <summary>The period between ticks.</summary>
     private static readonly TimeSpan TickPeriod = TimeSpan.FromMilliseconds(10);
 
-    /// <summary>
-    /// A tick period an order of magnitude longer than <see cref="ExpiryPeriod"/>, so the inactivity timeout always
-    /// fires first, yet short enough that the trampoline's wait for the tick that never arrives stays inside
-    /// <see cref="LivelockTimeout"/>.
-    /// </summary>
-    private static readonly TimeSpan QuietTickPeriod = TimeSpan.FromSeconds(1);
-
     /// <summary>The inactivity window <c>Expire</c> allows before it times the sequence out.</summary>
     private static readonly TimeSpan ExpiryPeriod = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>
-    /// The time a subscribing thread is given to return before it is declared livelocked. A livelocked trampoline
-    /// never returns, so the window costs nothing to widen and is deliberately far longer than any of these
-    /// subscriptions needs: it only has to outlast a runner busy enough to stall a thread that is merely slow.
-    /// </summary>
-    private static readonly TimeSpan LivelockTimeout = TimeSpan.FromSeconds(30);
-
-    /// <summary>
-    /// Verifies the recurring schedule survives a sequencer that runs the first tick before its own
-    /// <c>Schedule</c> returns. That tick arms the next one, and the handle the outer call goes on to return
-    /// must not replace - and so cancel - the successor the tick just armed, which would stop the interval
-    /// after a single value.
-    /// </summary>
+    /// <summary>An inline first tick retains the successor it schedules before the initial scheduling call returns.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EveryRetainsTheTickArmedByAnInlineFirstTick()
@@ -77,15 +49,9 @@ public async Task EveryOnTheCurrentThreadSequencerStopsWhenTakeReachesItsCount()
     {
         List<long> ticks = [];
         var completions = 0;
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            using var subscription = Signal.Every(TickPeriod, Sequencer.CurrentThread)
-                .Take(RequestedTicks)
-                .Subscribe(ticks.Add, static _ => { }, () => completions++);
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+        using var subscription = Signal.Every(TimeSpan.Zero, Sequencer.CurrentThread)
+            .Take(RequestedTicks)
+            .Subscribe(ticks.Add, static _ => { }, () => completions++);
         await Assert.That(ticks.SequenceEqual(ExpectedTicks)).IsTrue();
         await Assert.That(completions).IsEqualTo(1);
     }
@@ -96,17 +62,10 @@ public async Task EveryOnTheCurrentThreadSequencerStopsWhenTakeReachesItsCount()
     public async Task EveryOnTheCurrentThreadSequencerTicksOnTheSubscribingThread()
     {
         List<int> tickThreadIds = [];
-        var subscriberThreadId = 0;
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            subscriberThreadId = Environment.CurrentManagedThreadId;
-            using var subscription = Signal.Every(TickPeriod, Sequencer.CurrentThread)
-                .Take(RequestedTicks)
-                .Subscribe(_ => tickThreadIds.Add(Environment.CurrentManagedThreadId));
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+        var subscriberThreadId = Environment.CurrentManagedThreadId;
+        using var subscription = Signal.Every(TimeSpan.Zero, Sequencer.CurrentThread)
+            .Take(RequestedTicks)
+            .Subscribe(_ => tickThreadIds.Add(Environment.CurrentManagedThreadId));
         await Assert.That(tickThreadIds.Count).IsEqualTo(RequestedTicks);
         await Assert.That(tickThreadIds.TrueForAll(id => id == subscriberThreadId)).IsTrue();
     }
@@ -119,24 +78,17 @@ public async Task EveryOnTheCurrentThreadSequencerStopsWhenTakeWhileRejectsATick
         List<long> ticks = [];
         List<int> tickThreadIds = [];
         var completions = 0;
-        var subscriberThreadId = 0;
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            subscriberThreadId = Environment.CurrentManagedThreadId;
-            using var subscription = Signal.Every(TickPeriod, Sequencer.CurrentThread)
-                .TakeWhile(static tick => tick < RequestedTicks)
-                .Subscribe(
-                    tick =>
-                    {
-                        ticks.Add(tick);
-                        tickThreadIds.Add(Environment.CurrentManagedThreadId);
-                    },
-                    static _ => { },
-                    () => completions++);
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+        var subscriberThreadId = Environment.CurrentManagedThreadId;
+        using var subscription = Signal.Every(TimeSpan.Zero, Sequencer.CurrentThread)
+            .TakeWhile(static tick => tick < RequestedTicks)
+            .Subscribe(
+                tick =>
+                {
+                    ticks.Add(tick);
+                    tickThreadIds.Add(Environment.CurrentManagedThreadId);
+                },
+                static _ => { },
+                () => completions++);
         await Assert.That(ticks.SequenceEqual(ExpectedTicks)).IsTrue();
         await Assert.That(completions).IsEqualTo(1);
         await Assert.That(tickThreadIds.TrueForAll(id => id == subscriberThreadId)).IsTrue();
@@ -152,29 +104,23 @@ public async Task EveryOnTheCurrentThreadSequencerStopsWhenTakeUntilIsNotified()
         var completions = 0;
         var subscriberThreadId = 0;
         using CancellationTokenSource stop = new();
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            subscriberThreadId = Environment.CurrentManagedThreadId;
-            using var subscription = Signal.Every(TickPeriod, Sequencer.CurrentThread)
-                .TakeUntil(stop.Token)
-                .Subscribe(
-                    tick =>
+        subscriberThreadId = Environment.CurrentManagedThreadId;
+        using var subscription = Signal.Every(TimeSpan.Zero, Sequencer.CurrentThread)
+            .TakeUntil(stop.Token)
+            .Subscribe(
+                tick =>
+                {
+                    ticks.Add(tick);
+                    tickThreadIds.Add(Environment.CurrentManagedThreadId);
+                    if (ticks.Count != RequestedTicks)
                     {
-                        ticks.Add(tick);
-                        tickThreadIds.Add(Environment.CurrentManagedThreadId);
-                        if (ticks.Count != RequestedTicks)
-                        {
-                            return;
-                        }
+                        return;
+                    }
 
-                        stop.Cancel();
-                    },
-                    static _ => { },
-                    () => completions++);
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+                    stop.Cancel();
+                },
+                static _ => { },
+                () => completions++);
         await Assert.That(ticks.SequenceEqual(ExpectedTicks)).IsTrue();
         await Assert.That(completions).IsEqualTo(1);
         await Assert.That(tickThreadIds.TrueForAll(id => id == subscriberThreadId)).IsTrue();
@@ -225,36 +171,23 @@ public Task EveryOnTheCurrentThreadSequencerStopsWhenIsEmptySeesItsFirstTick() =
             static source => source.IsEmpty(),
             expectedResult: false);
 
-    /// <summary>
-    /// Verifies <c>Expire</c> times a silent current-thread source out instead of livelocking on it. The tick period
-    /// is far longer than the expiry window, so the inactivity timeout is guaranteed to fire before the first tick.
-    /// </summary>
+    /// <summary>Advancing to the expiry boundary terminates the source before its first scheduled tick.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task EveryOnTheCurrentThreadSequencerExpiresWhenNoTickArrivesInTime()
-    {
+    public async Task EveryExpiresBeforeTheFirstVirtualTick()
+{
+        VirtualClock clock = new();
         var ticks = 0;
         Exception? failure = null;
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            using var subscription = Signal.Every(QuietTickPeriod, Sequencer.CurrentThread)
-                .Expire(ExpiryPeriod)
-                .Subscribe(
-                    _ => ticks++,
-                    error => failure = error,
-                    static () => { });
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+        using var subscription = Signal.Every(ExpiryPeriod + ExpiryPeriod, clock)
+            .Expire(ExpiryPeriod, clock)
+            .Subscribe(_ => ticks++, error => failure = error, static () => { });
+        clock.AdvanceBy(ExpiryPeriod);
         await Assert.That(ticks).IsEqualTo(0);
         await Assert.That(failure).IsTypeOf<TimeoutException>();
     }
 
-    /// <summary>
-    /// Asserts a boolean bounding operator terminates the current-thread ticks at the first tick that satisfies it,
-    /// and that it hands its single result back on the subscribing thread the trampoline ticks on.
-    /// </summary>
+    /// <summary>Checks the bounding result and completion on the subscribing thread.</summary>
     /// <param name="bound">Applies the bounding operator to the current-thread tick source.</param>
     /// <param name="expectedResult">The value the bounded sequence must emit before it completes.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
@@ -265,105 +198,18 @@ private static async Task AssertBoundedByFirstMatchingTick(
         List<bool> results = [];
         List<int> resultThreadIds = [];
         var completions = 0;
-        var subscriberThreadId = 0;
-
-        var subscriber = RunOnDedicatedThread(() =>
-        {
-            subscriberThreadId = Environment.CurrentManagedThreadId;
-            using var subscription = bound(Signal.Every(TickPeriod, Sequencer.CurrentThread))
-                .Subscribe(
-                    result =>
-                    {
-                        results.Add(result);
-                        resultThreadIds.Add(Environment.CurrentManagedThreadId);
-                    },
-                    static _ => { },
-                    () => completions++);
-        });
-
-        await Assert.That(CompletedWithinTimeout(subscriber)).IsTrue();
+        var subscriberThreadId = Environment.CurrentManagedThreadId;
+        using var subscription = bound(Signal.Every(TimeSpan.Zero, Sequencer.CurrentThread))
+            .Subscribe(
+                result =>
+                {
+                    results.Add(result);
+                    resultThreadIds.Add(Environment.CurrentManagedThreadId);
+                },
+                static _ => { },
+                () => completions++);
         await Assert.That(results).IsEquivalentTo([expectedResult], EqualityComparer<bool>.Default);
         await Assert.That(completions).IsEqualTo(1);
         await Assert.That(resultThreadIds.TrueForAll(id => id == subscriberThreadId)).IsTrue();
     }
-
-    /// <summary>Runs the subscription body on its own background thread so a livelock cannot hang the test host.</summary>
-    /// <param name="body">The subscription body to run.</param>
-    /// <returns>The subscribing thread, already running the body.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static SubscribingThread RunOnDedicatedThread(Action body) => SubscribingThread.Start(body);
-
-    /// <summary>Waits for the subscribing thread to finish within the livelock timeout.</summary>
-    /// <param name="subscriber">The subscribing thread to wait on.</param>
-    /// <returns><see langword="true"/> when the subscribing thread finished in time.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static bool CompletedWithinTimeout(SubscribingThread subscriber) =>
-        subscriber.ReturnedWithin(LivelockTimeout);
-
-    /// <summary>The thread a subscription body runs on, and whatever that body threw.</summary>
-    /// <remarks>
-    /// The livelock guard waits on the thread itself rather than on a task the thread completes. Completing a task
-    /// only queues its continuation to the thread pool, so the guard would be racing two pool-scheduled
-    /// continuations: on a runner whose pool is saturated the subscribing thread's continuation can be dequeued
-    /// after the guard's window has already closed, reporting a livelock in a trampoline that in truth returned in
-    /// milliseconds. <see cref="Thread.Join(TimeSpan)"/> is an OS-level wait no amount of pool pressure can starve,
-    /// so it observes the subscribing thread returning rather than the pool getting round to saying that it did.
-    /// A thread that is genuinely livelocked never returns, so the guard still trips on it.
-    /// </remarks>
-    private sealed class SubscribingThread
-    {
-        /// <summary>The subscription body to run.</summary>
-        private readonly Action _body;
-
-        /// <summary>The background thread the body runs on.</summary>
-        private readonly Thread _thread;
-
-        /// <summary>The exception the body threw, if any.</summary>
-        private ExceptionDispatchInfo? _failure;
-
-        /// <summary>Initializes a new instance of the <see cref="SubscribingThread"/> class.</summary>
-        /// <param name="body">The subscription body to run.</param>
-        private SubscribingThread(Action body)
-        {
-            _body = body;
-            _thread = new(Run) { IsBackground = true, };
-        }
-
-        /// <summary>Starts a subscription body on a background thread of its own.</summary>
-        /// <param name="body">The subscription body to run.</param>
-        /// <returns>The running subscribing thread.</returns>
-        internal static SubscribingThread Start(Action body)
-        {
-            SubscribingThread subscriber = new(body);
-            subscriber._thread.Start();
-            return subscriber;
-        }
-
-        /// <summary>Waits for the thread to return, rethrowing whatever the subscription body threw.</summary>
-        /// <param name="timeout">How long the thread is given to return before it is declared livelocked.</param>
-        /// <returns><see langword="true"/> when the thread returned within <paramref name="timeout"/>.</returns>
-        internal bool ReturnedWithin(TimeSpan timeout)
-        {
-            if (!_thread.Join(timeout))
-            {
-                return false;
-            }
-
-            _failure?.Throw();
-            return true;
-        }
-
-        /// <summary>Runs the subscription body, capturing a failure so it can be rethrown with its original stack.</summary>
-        private void Run()
-        {
-            try
-            {
-                _body();
-            }
-            catch (Exception error)
-            {
-                _failure = ExceptionDispatchInfo.Capture(error);
-            }
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
index 27488f5b..d0edd33e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
@@ -115,13 +115,7 @@ public async Task NoTimeoutFiresAfterError()
         await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies a value that arrives after the inactivity window closed expires the sequence even though the armed
-    /// timeout has not been dispatched yet. The timeout runs on the sequencer, and a thread-pool sequencer whose pool
-    /// is saturated can dispatch it arbitrarily late while a source ticking on its own thread keeps producing. The
-    /// window is a property of the clock, not of whether the timer callback has been given a thread, so a value that
-    /// missed it must not reach the observer.
-    /// </summary>
+    /// <summary>A value after the inactivity deadline expires the sequence even when the timeout callback remains queued.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ValueArrivingAfterTheWindowClosedExpiresWhileTheTimeoutIsStillUndispatched()
@@ -141,10 +135,7 @@ public async Task ValueArrivingAfterTheWindowClosedExpiresWhileTheTimeoutIsStill
         await Assert.That(errors.SequenceEqual([nameof(TimeoutException)])).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies the deadline check does not expire a value that is still inside its window. This is the guard against
-    /// the previous test's fix over-firing: an undispatched timeout must not turn an on-time value into a timeout.
-    /// </summary>
+    /// <summary>A value inside the inactivity window is forwarded while its timeout callback remains queued.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ValueArrivingInsideTheWindowIsForwardedWhileTheTimeoutIsStillUndispatched()
@@ -180,11 +171,7 @@ public async Task TimeoutDoesNotEnterObserverWhileOnNextIsInFlight()
         await Assert.That(observer.Values).IsEqualTo(One);
     }
 
-    /// <summary>
-    /// A sequencer that accepts scheduled work and never dispatches it, modelling a thread-pool sequencer whose pool
-    /// is saturated: the timer becomes due on the clock, but no thread is free to run the callback. Its clock is
-    /// driven by the test.
-    /// </summary>
+    /// <summary>Tracks virtual time and accepts work without dispatching it.</summary>
     /// <param name="start">The instant the clock starts at.</param>
     private sealed class UndispatchedSequencer(DateTimeOffset start) : ISequencer
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
new file mode 100644
index 00000000..f1d3ab39
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
@@ -0,0 +1,79 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies observer failures during task result delivery.</summary>
+public class FromAsyncTaskObservationTests
+{
+    /// <summary>The task result passed to the observer.</summary>
+    private const int ResultValue = 7;
+
+    /// <summary>A throwing value callback receives no additional terminal notification.</summary>
+    /// <param name="dispose">Whether the observer disposes its lifetime before throwing.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task ThrowingValueCallbackSuppressesTerminalNotification(bool dispose)
+    {
+        using AsyncSubscriptionLifetime lifetime = new();
+        FailingObserver observer = new(lifetime, dispose);
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, CancellationToken.None);
+        FromAsyncTaskObservation<int> observation = new(observer, lifetime, cancellation, null);
+        observation.Observe(Task.FromResult(ResultValue));
+        await Assert.That(observer.Values).IsEqualTo(1);
+        await Assert.That(observer.Errors).IsEqualTo(0);
+        await Assert.That(observer.Completions).IsEqualTo(0);
+        await Assert.That(lifetime.IsCompleted).IsTrue();
+    }
+
+    /// <summary>An uncancelable external token permits synchronous factory execution.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task UncancelableTokenRunsFactory()
+    {
+        TaskNotificationObserver observer = new();
+        using var subscription = Signal.FromAsync(static _ => Task.FromResult(ResultValue), CancellationToken.None).Subscribe(observer);
+        await Assert.That(observer.Values.SequenceEqual([ResultValue])).IsTrue();
+        await Assert.That(observer.Completions).IsEqualTo(1);
+        await Assert.That(observer.Error).IsNull();
+    }
+
+    /// <summary>Throws after recording a value and optionally disposing its lifetime.</summary>
+    /// <param name="lifetime">The subscription lifetime.</param>
+    /// <param name="dispose">Whether to dispose before throwing.</param>
+    private sealed class FailingObserver(AsyncSubscriptionLifetime lifetime, bool dispose) : IObserver<int>
+    {
+        /// <summary>Gets the number of value callbacks.</summary>
+        public int Values { get; private set; }
+
+        /// <summary>Gets the number of error callbacks.</summary>
+        public int Errors { get; private set; }
+
+        /// <summary>Gets the number of completion callbacks.</summary>
+        public int Completions { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(int value)
+        {
+            Values++;
+            if (dispose)
+            {
+                lifetime.Dispose();
+            }
+
+            throw new InvalidOperationException("observer failure");
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => Errors++;
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completions++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
index 62fb7687..eddcd39f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
@@ -22,28 +22,16 @@ public sealed class LoopSignalTests
     /// <summary>The values a three-repetition loop must observe.</summary>
     private static readonly int[] ExpectedValues = [RepeatedValue, RepeatedValue, RepeatedValue];
 
-    /// <summary>How long the bounded loop is given to finish before it is declared livelocked.</summary>
-    private static readonly TimeSpan CompletionTimeout = TimeSpan.FromSeconds(30);
-
     /// <summary>Verifies a loop bounded by <c>Take</c> repeats the value exactly the requested number of times and stops.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task LoopBoundedByTakeRepeatsTheValueAndStops()
-    {
+{
         List<int> values = [];
         var completions = 0;
-
-        // The loop runs its ticks on the subscribing thread's trampoline, so subscribe on a dedicated thread:
-        // a bounded loop returns in milliseconds, but a regression that livelocked it would otherwise hang the run.
-        var worker = Task.Run(() =>
-        {
-            using var subscription = Signal.Loop(RepeatedValue)
-                .Take(RequestedRepetitions)
-                .Subscribe(values.Add, static _ => { }, () => completions++);
-        });
-
-        await Assert.That(await Task.WhenAny(worker, Task.Delay(CompletionTimeout)) == worker).IsTrue();
-        await worker;
+        using var subscription = Signal.Loop(RepeatedValue)
+            .Take(RequestedRepetitions)
+            .Subscribe(values.Add, static _ => { }, () => completions++);
         await Assert.That(values.SequenceEqual(ExpectedValues)).IsTrue();
         await Assert.That(completions).IsEqualTo(1);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/MergeCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/MergeCoordinatorTests.cs
new file mode 100644
index 00000000..6e756326
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/MergeCoordinatorTests.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests merge completion tracking across inner sources.</summary>
+public sealed class MergeCoordinatorTests
+{
+    /// <summary>Repeated completion cannot consume another inner source's active count.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task RepeatedInnerCompletionKeepsTheSiblingActive()
+    {
+        IObserver<int>? left = null;
+        IObserver<int>? right = null;
+        RecordingWitness<int> downstream = new();
+        ScriptedObservable<int> leftSource = new(observer => left = observer);
+        ScriptedObservable<int> rightSource = new(observer => right = observer);
+
+        using var subscription = new MergeCoordinator<int>(downstream).Run([leftSource, rightSource]);
+
+        left!.OnCompleted();
+        left.OnCompleted();
+        await Assert.That(downstream.Completed).IsEqualTo(0);
+
+        right!.OnCompleted();
+        await Assert.That(downstream.Completed).IsEqualTo(1);
+        await Assert.That(right).IsNotNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
index 0b304818..4fd86be2 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
@@ -9,7 +9,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Focused coverage for the Rx-style on-error resume sequence coordinator.</summary>
+/// <summary>Tests continuation after source errors.</summary>
 public sealed class OnErrorResumeNextSignalTests
 {
     /// <summary>The integer constant one.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
index 0ea73d93..1e680f78 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
@@ -30,36 +30,21 @@ public sealed class PrioritySemaphoreSignalTests
     /// <summary>The number of values expected after the first drain.</summary>
     private const int FirstDrainCount = 2;
 
-    /// <summary>The number of worker tasks used to stress concurrent signaling.</summary>
-    private const int StressWorkers = 4;
+    /// <summary>The number of reentrant operation groups.</summary>
+    private const int OperationGroups = 4;
 
-    /// <summary>The number of operations each stress worker performs.</summary>
-    private const int StressIterations = 4;
+    /// <summary>The number of release and production pairs per group.</summary>
+    private const int OperationsPerGroup = 4;
 
-    /// <summary>The number of seeded values for the concurrent drain scenario.</summary>
+    /// <summary>The number of values queued before draining.</summary>
     private const int SeededValueCount = 12;
 
-    /// <summary>The initial semaphore capacity used in the concurrent drain scenario.</summary>
+    /// <summary>The initial capacity used to drain queued values.</summary>
     private const int InitialDrainCapacity = 3;
 
     /// <summary>The amount added during alternating capacity updates.</summary>
     private const int CapacityJitter = 2;
 
-    /// <summary>The number of polling loops while waiting for signal drain.</summary>
-    private const int PollIterations = 500;
-
-    /// <summary>The wait duration for each drain polling loop.</summary>
-    private const int PollDelayMilliseconds = 1;
-
-    /// <summary>Task-group offsets for the concurrent operations phase.</summary>
-    private const int OnNextTaskOffsetMultiplier = 2;
-
-    /// <summary>The number of worker groups (release, capacity, and OnNext) started for each stress worker.</summary>
-    private const int StressWorkerGroups = 3;
-
-    /// <summary>The wait duration for terminal serialization probes.</summary>
-    private static readonly TimeSpan TerminalProbeTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Constructor and observer validation follow the inner signal contract.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -203,135 +188,115 @@ public async Task ScheduledInnerSignalDeliversThroughSequencerAndDisposes()
         await Assert.That(observer.Values.SequenceEqual([FourthValue])).IsTrue();
     }
 
-    /// <summary>Concurrent release and production drain work without concurrent downstream <see langword="OnNext"/> calls.</summary>
+    /// <summary>Reentrant release and production preserve serialized value delivery.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ConcurrentOperationsDoNotNotifyObserverConcurrently()
-    {
-        using var signal = new PrioritySemaphoreSignal<int>(InitialDrainCapacity);
-        var observer = new ConcurrencyProbe();
-        var subscription = signal.Subscribe(observer);
-        for (var i = 0; i < SeededValueCount; i++)
-        {
-            signal.OnNext(i);
-        }
-
-        var go = new ManualResetEventSlim();
-        var tasks = new Task[StressWorkers * StressWorkerGroups];
+    public async Task ReentrantOperationsDoNotOverlapValueDelivery()
+{
+        using var signal = new PrioritySemaphoreSignal<int>(0);
+        var inside = false;
+        var overlap = false;
+        var count = 0;
         var next = 0;
-        for (var t = 0; t < StressWorkers; t++)
-        {
-            tasks[t] = Task.Run(() =>
-            {
-                go.Wait();
-                for (var i = 0; i < StressIterations; i++)
-                {
-                    signal.Release();
-                    signal.OnNext(Interlocked.Increment(ref next));
-                }
-            });
-        }
-
-        for (var t = 0; t < StressWorkers; t++)
+        using var subscription = signal.Subscribe(_ =>
         {
-            tasks[StressWorkers + t] = Task.Run(() =>
+            overlap |= inside;
+            inside = true;
+            count++;
+            if (count == 1)
             {
-                go.Wait();
-                for (var i = 0; i < StressIterations; i++)
+                for (var group = 0; group < OperationGroups; group++)
                 {
-                    signal.MaximumCount = InitialDrainCapacity + (i % CapacityJitter);
+                    for (var iteration = 0; iteration < OperationsPerGroup; iteration++)
+                    {
+                        signal.Release();
+                        next++;
+                        signal.OnNext(next);
+                        signal.MaximumCount = InitialDrainCapacity + (iteration % CapacityJitter);
+                        next++;
+                        signal.OnNext(InitialDrainCapacity + next);
+                    }
                 }
-            });
-        }
+            }
 
-        for (var t = 0; t < StressWorkers; t++)
+            inside = false;
+        });
+        for (var value = 0; value < SeededValueCount; value++)
         {
-            tasks[(StressWorkers * OnNextTaskOffsetMultiplier) + t] = Task.Run(() =>
-            {
-                go.Wait();
-                for (var i = 0; i < StressIterations; i++)
-                {
-                    signal.OnNext(InitialDrainCapacity + Interlocked.Increment(ref next));
-                }
-            });
+            signal.OnNext(value);
         }
 
-        go.Set();
-        await Task.WhenAll(tasks);
-
+        signal.MaximumCount = InitialDrainCapacity;
         signal.MaximumCount = int.MaxValue;
-
-        const int ExpectedValues = SeededValueCount + (StressWorkers * StressIterations * 2);
-        for (var i = 0; i < PollIterations && observer.OnNextCount < ExpectedValues; i++)
-        {
-            await Task.Delay(PollDelayMilliseconds);
-        }
-
-        await Assert.That(observer.OverlapDetected).IsFalse();
-        await Assert.That(observer.OnNextCount).IsEqualTo(ExpectedValues);
-
-        subscription.Dispose();
+        const int ExpectedValues = SeededValueCount + (OperationGroups * OperationsPerGroup * 2);
+        await Assert.That(overlap).IsFalse();
+        await Assert.That(count).IsEqualTo(ExpectedValues);
     }
 
-    /// <summary>Terminal completion notifications remain serialized with value delivery under concurrent drain.</summary>
+    /// <summary>Reentrant completion waits until value delivery returns.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ConcurrentCompletionDoesNotOverlapObserverOnNext()
-    {
+    public async Task ReentrantCompletionWaitsForValueDelivery()
+{
         using var signal = new PrioritySemaphoreSignal<int>(0);
-        using var releaseOnNext = new ManualResetEventSlim();
-        using var observer = new TerminalOverlapProbe(releaseOnNext);
-        using var subscription = signal.Subscribe(observer);
-
+        List<int> values = [];
+        var inside = false;
+        var overlap = false;
+        var completed = 0;
+        using var subscription = signal.Subscribe(
+            value =>
+        {
+            inside = true;
+            values.Add(value);
+            signal.OnCompleted();
+            inside = false;
+        },
+            static _ => { },
+            () =>
+        {
+            overlap |= inside;
+            completed++;
+        });
         signal.OnNext(ThirdValue);
         signal.OnNext(FirstValue);
         signal.OnNext(SecondValue);
-
-        // Drive the drain on a dedicated thread so the probe can block it without starving the
-        // thread pool; the started gate is observed synchronously to keep the race deterministic.
-        var drainThread = StartThread(() => signal.MaximumCount = 1);
-        await Assert.That(observer.WaitForOnNextStarted(TerminalProbeTimeout)).IsTrue();
-
-        var completionThread = StartThread(signal.OnCompleted);
-
-        releaseOnNext.Set();
-        drainThread.Join();
-        completionThread.Join();
-
-        await Assert.That(observer.Completed).IsEqualTo(1);
-        await Assert.That(observer.Values.SequenceEqual([FirstValue, SecondValue, ThirdValue])).IsTrue();
-        await Assert.That(observer.OverlapDetected).IsFalse();
+        signal.MaximumCount = 1;
+        await Assert.That(completed).IsEqualTo(1);
+        await Assert.That(values.SequenceEqual([FirstValue, SecondValue, ThirdValue])).IsTrue();
+        await Assert.That(overlap).IsFalse();
     }
 
-    /// <summary>Terminal error notifications remain serialized with value delivery under concurrent drain.</summary>
+    /// <summary>Reentrant errors wait until value delivery returns.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ConcurrentErrorDoesNotOverlapObserverOnNext()
-    {
+    public async Task ReentrantErrorWaitsForValueDelivery()
+{
         using var signal = new PrioritySemaphoreSignal<int>(0);
-        using var releaseOnNext = new ManualResetEventSlim();
-        using var observer = new TerminalOverlapProbe(releaseOnNext);
-        using var subscription = signal.Subscribe(observer);
-        var expected = new InvalidOperationException("expected");
-
+        List<int> values = [];
+        var inside = false;
+        var overlap = false;
+        InvalidOperationException expected = new("expected");
+        Exception? observed = null;
+        using var subscription = signal.Subscribe(
+            value =>
+        {
+            inside = true;
+            values.Add(value);
+            signal.OnError(expected);
+            inside = false;
+        },
+            error =>
+        {
+            overlap |= inside;
+            observed = error;
+        });
         signal.OnNext(ThirdValue);
         signal.OnNext(FirstValue);
         signal.OnNext(SecondValue);
-
-        // Drive the drain on a dedicated thread so the probe can block it without starving the
-        // thread pool; the started gate is observed synchronously to keep the race deterministic.
-        var drainThread = StartThread(() => signal.MaximumCount = 1);
-        await Assert.That(observer.WaitForOnNextStarted(TerminalProbeTimeout)).IsTrue();
-
-        var errorThread = StartThread(() => signal.OnError(expected));
-
-        releaseOnNext.Set();
-        drainThread.Join();
-        errorThread.Join();
-
-        await Assert.That(observer.Errors[0]).IsSameReferenceAs(expected);
-        await Assert.That(observer.Values.Length).IsEqualTo(1);
-        await Assert.That(observer.OverlapDetected).IsFalse();
+        signal.MaximumCount = 1;
+        await Assert.That(observed).IsSameReferenceAs(expected);
+        await Assert.That(values.SequenceEqual([FirstValue])).IsTrue();
+        await Assert.That(overlap).IsFalse();
     }
 
     /// <summary>A terminal notification arriving after the signal is already terminal is ignored.</summary>
@@ -381,16 +346,6 @@ public async Task DrainReleasesOwnershipWhenDeliveryThrows()
         await Assert.That(deliveries).IsEqualTo(FirstDrainCount);
     }
 
-    /// <summary>Starts a background thread running the supplied action.</summary>
-    /// <param name="action">The work to run.</param>
-    /// <returns>The started thread.</returns>
-    private static Thread StartThread(Action action)
-    {
-        var thread = new Thread(() => action()) { IsBackground = true };
-        thread.Start();
-        return thread;
-    }
-
     /// <summary>Test sequencer that queues scheduled work until drained explicitly.</summary>
     private sealed class QueuedSequencer : ISequencer
     {
@@ -512,170 +467,4 @@ public void OnNext(T value)
             }
         }
     }
-
-    /// <summary>Observer used to detect concurrent <see cref="IObserver{T}.OnCompleted"/> and <see cref="IObserver{T}.OnError"/> overlap.</summary>
-    private sealed class TerminalOverlapProbe : IObserver<int>, IDisposable
-    {
-        /// <summary>Gate to hold the first value until assertions can observe interleaving.</summary>
-        private readonly ManualResetEventSlim _releaseOnNext;
-
-        /// <summary>Guards internal state.</summary>
-        private readonly Lock _gate = new();
-
-        /// <summary>Captured errors.</summary>
-        private readonly List<Exception> _errors = [];
-
-        /// <summary>Captured values.</summary>
-        private readonly List<int> _values = [];
-
-        /// <summary>Signals that one <see cref="OnNext"/> value started delivering.</summary>
-        private readonly ManualResetEventSlim _onNextStarted = new();
-
-        /// <summary>Whether the observer is currently inside <see cref="OnNext"/>.</summary>
-        private int _insideOnNext;
-
-        /// <summary>Whether a terminal notification was observed while a value was being delivered.</summary>
-        private int _overlapDetected;
-
-        /// <summary>Whether a value was emitted.</summary>
-        private int _onNextCount;
-
-        /// <summary>Completed notification count.</summary>
-        private int _completed;
-
-        /// <summary>Initializes a new instance of the <see cref="TerminalOverlapProbe"/> class.</summary>
-        /// <param name="releaseOnNext">Gate used by tests to hold <see cref="OnNext"/> in-flight.</param>
-        public TerminalOverlapProbe(ManualResetEventSlim releaseOnNext) => _releaseOnNext = releaseOnNext;
-
-        /// <summary>Gets whether overlapping terminal and value notifications were observed.</summary>
-        public bool OverlapDetected => Volatile.Read(ref _overlapDetected) != 0;
-
-        /// <summary>Gets the number of delivered values.</summary>
-        public int[] Values
-        {
-            get
-            {
-                lock (_gate)
-                {
-                    return [.. _values];
-                }
-            }
-        }
-
-        /// <summary>Gets the number of completed notifications.</summary>
-        public int Completed => Volatile.Read(ref _completed);
-
-        /// <summary>Gets the errors delivered to this observer.</summary>
-        public Exception[] Errors
-        {
-            get
-            {
-                lock (_gate)
-                {
-                    return [.. _errors];
-                }
-            }
-        }
-
-        /// <summary>Blocks until <see cref="OnNext"/> has started delivering at least one value.</summary>
-        /// <param name="timeout">The maximum time to wait.</param>
-        /// <returns><see langword="true"/> when delivery started within the timeout.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool WaitForOnNextStarted(TimeSpan timeout) => _onNextStarted.Wait(timeout);
-
-        /// <inheritdoc />
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Dispose() => _onNextStarted.Dispose();
-
-        /// <inheritdoc />
-        public void OnNext(int value)
-        {
-            if (Interlocked.Exchange(ref _insideOnNext, 1) != 0)
-            {
-                _ = Interlocked.Exchange(ref _overlapDetected, 1);
-            }
-
-            lock (_gate)
-            {
-                _onNextCount++;
-                _values.Add(value);
-            }
-
-            _onNextStarted.Set();
-            _releaseOnNext.Wait();
-            _ = Interlocked.Exchange(ref _insideOnNext, 0);
-        }
-
-        /// <inheritdoc />
-        public void OnCompleted()
-        {
-            if (Volatile.Read(ref _insideOnNext) != 0)
-            {
-                _ = Interlocked.Exchange(ref _overlapDetected, 1);
-            }
-
-            _ = Interlocked.Increment(ref _completed);
-        }
-
-        /// <inheritdoc />
-        public void OnError(Exception error)
-        {
-            if (Volatile.Read(ref _insideOnNext) != 0)
-            {
-                _ = Interlocked.Exchange(ref _overlapDetected, 1);
-            }
-
-            lock (_gate)
-            {
-                _errors.Add(error);
-            }
-        }
-    }
-
-    /// <summary>Observer used to detect overlapping <see cref="IObserver{T}.OnNext"/> notifications.</summary>
-    private sealed class ConcurrencyProbe : IObserver<int>
-    {
-        /// <summary>The spin delay used to amplify overlap detection.</summary>
-        private const int ProbeSpinWaitIterations = 1000;
-
-        /// <summary>Non-zero while a notification is in-flight.</summary>
-        private int _inside;
-
-        /// <summary>Whether two notifications overlapped.</summary>
-        private int _overlapDetected;
-
-        /// <summary>Count of delivered notifications.</summary>
-        private int _onNextCount;
-
-        /// <summary>Gets whether overlapping notifications were observed.</summary>
-        public bool OverlapDetected => Volatile.Read(ref _overlapDetected) != 0;
-
-        /// <summary>Gets the number of delivered notifications.</summary>
-        public int OnNextCount => Volatile.Read(ref _onNextCount);
-
-        /// <summary>Records a single notification value, pausing briefly to amplify overlap races.</summary>
-        /// <param name="value">The observed value.</param>
-        public void OnNext(int value)
-        {
-            if (Interlocked.Exchange(ref _inside, 1) != 0)
-            {
-                _ = Interlocked.Exchange(ref _overlapDetected, 1);
-            }
-
-            _ = Interlocked.Increment(ref _onNextCount);
-            Thread.SpinWait(ProbeSpinWaitIterations);
-            _ = Interlocked.Exchange(ref _inside, 0);
-        }
-
-        /// <summary>Implements the generic observer interface for value-only checks.</summary>
-        public void OnCompleted()
-        {
-        }
-
-        /// <summary>Implements the generic observer interface for value-only checks.</summary>
-        /// <param name="error">The observed error.</param>
-        public void OnError(Exception error)
-        {
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj b/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
index f6dcc9c5..272083b3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
@@ -18,10 +18,6 @@
     <PackageReference Include="Microsoft.Reactive.Testing"/>
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs"/>
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj"/>
     <ProjectReference Include="..\..\ReactiveUI.Primitives.Async\ReactiveUI.Primitives.Async.csproj"/>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
index 9efa4da1..55688d60 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
@@ -121,7 +121,7 @@ public async Task HasObservers()
         await HasObserversImpl(new());
         await HasObserversImpl(new(1));
         await HasObserversImpl(new(Three));
-        await HasObserversImpl(new(TimeSpan.FromSeconds(1)));
+        await HasObserversImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Determines whether [has observers dispose1].</summary>
@@ -132,7 +132,7 @@ public async Task HasObservers_Dispose1()
         await HasObservers_Dispose1Impl(new());
         await HasObservers_Dispose1Impl(new(1));
         await HasObservers_Dispose1Impl(new(Three));
-        await HasObservers_Dispose1Impl(new(TimeSpan.FromSeconds(1)));
+        await HasObservers_Dispose1Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Determines whether [has observers dispose2].</summary>
@@ -143,7 +143,7 @@ public async Task HasObservers_Dispose2()
         await HasObservers_Dispose2Impl(new());
         await HasObservers_Dispose2Impl(new(1));
         await HasObservers_Dispose2Impl(new(Three));
-        await HasObservers_Dispose2Impl(new(TimeSpan.FromSeconds(1)));
+        await HasObservers_Dispose2Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Determines whether [has observers dispose3].</summary>
@@ -154,7 +154,7 @@ public async Task HasObservers_Dispose3()
         await HasObservers_Dispose3Impl(new());
         await HasObservers_Dispose3Impl(new(1));
         await HasObservers_Dispose3Impl(new(Three));
-        await HasObservers_Dispose3Impl(new(TimeSpan.FromSeconds(1)));
+        await HasObservers_Dispose3Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Determines whether [has observers on completed].</summary>
@@ -165,7 +165,7 @@ public async Task HasObservers_OnCompleted()
         await HasObservers_OnCompletedImpl(new());
         await HasObservers_OnCompletedImpl(new(1));
         await HasObservers_OnCompletedImpl(new(Three));
-        await HasObservers_OnCompletedImpl(new(TimeSpan.FromSeconds(1)));
+        await HasObservers_OnCompletedImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Determines whether [has observers on error].</summary>
@@ -176,7 +176,7 @@ public async Task HasObservers_OnError()
         await HasObservers_OnErrorImpl(new());
         await HasObservers_OnErrorImpl(new(1));
         await HasObservers_OnErrorImpl(new(Three));
-        await HasObservers_OnErrorImpl(new(TimeSpan.FromSeconds(1)));
+        await HasObservers_OnErrorImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
     /// <summary>Called when [error argument checking].</summary>
@@ -215,16 +215,13 @@ public async Task SubjectsReplayBehaviorStateAndConnectableAliasesCoverLateTermi
         await Assert.That(state.ParamName).IsEqualTo("selector");
     }
 
-    /// <summary>
-    /// A new subscriber that races a live <see cref="ReplaySignal{T}.OnNext"/> must receive each value exactly
-    /// once: the replayed buffer must not duplicate or reorder a value that is also delivered live.
-    /// </summary>
+    /// <summary>Replay and live delivery hold one shared gate and deliver each value once in order.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task Subscribe_RacingOnNext_DeliversEachValueOnce()
+    public async Task SubscribeAndOnNextHoldTheSharedDeliveryGate()
     {
-        await RaceSubscribeAgainstProducer(static () => new(1));
-        await RaceSubscribeAgainstProducer(static () => new(Three));
+        await AssertReplayAndLiveDeliveryHoldTheGate(static () => new(1));
+        await AssertReplayAndLiveDeliveryHoldTheGate(static () => new(Three));
     }
 
     /// <summary>Asserts a behavior signal keeps its first terminal notification and replays it to late subscribers.</summary>
@@ -306,41 +303,28 @@ private static async Task AssertWindowedReplayDropsValuesOlderThanTheWindow()
         await Assert.That(windowedLate.Values.SequenceEqual(expectedWindowedLate)).IsTrue();
     }
 
-    /// <summary>
-    /// Continuously emits increasing values from one thread while another thread repeatedly subscribes and
-    /// disposes, asserting that no subscriber ever receives a value out of order or twice.
-    /// </summary>
+    /// <summary>Checks gate ownership and ordered handover from replay to live delivery.</summary>
     /// <param name = "factory">Factory used to create the replay signal under test.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task RaceSubscribeAgainstProducer(Func<ReplaySignal<int>> factory)
+    private static async Task AssertReplayAndLiveDeliveryHoldTheGate(Func<ReplaySignal<int>> factory)
     {
-        const int subscribeAttempts = 50_000;
-
         using var signal = factory();
-        using CancellationTokenSource stop = new();
-        var firstFailure = default(OrderingWitness<int>.OutOfOrderDelivery);
-
-        var producer = Task.Run(() =>
+        List<int> values = [];
+        var ownsGate = true;
+        signal.OnNext(1);
+        using var subscription = signal.Subscribe(value =>
         {
-            var value = 0;
-            while (!stop.IsCancellationRequested)
-            {
-                value++;
-                signal.OnNext(value);
-            }
+            values.Add(value);
+#if NET9_0_OR_GREATER
+            ownsGate &= signal.Gate.IsHeldByCurrentThread;
+#else
+            ownsGate &= Monitor.IsEntered(signal.Gate);
+#endif
         });
-
-        for (var attempt = 0; attempt < subscribeAttempts && firstFailure is null; attempt++)
-        {
-            OrderingWitness<int> witness = new();
-            signal.Subscribe(witness).Dispose();
-            firstFailure = witness.OutOfOrder;
-        }
-
-        await stop.CancelAsync();
-        await producer;
-
-        await Assert.That(firstFailure).IsNull();
+        signal.OnNext(Two);
+        signal.OnNext(Three);
+        await Assert.That(ownsGate).IsTrue();
+        await Assert.That(values.SequenceEqual([1, Two, Three])).IsTrue();
     }
 
     /// <summary>Creates a replay signal and disposes it immediately.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs
index 681a5409..b60729f5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs
@@ -311,7 +311,6 @@ public async Task DynamicDataRxConvenienceAliasesCoverPublicEntryPoints()
         _ = Signal.FromEnumerable([Task.FromResult(One), Task.FromResult(Two)]).Concat().Subscribe(aliasValues.Add);
         _ = ((IEnumerable<IObservable<int>>)[Signal.Return(One), Signal.Return(Two)]).Merge()
             .Subscribe(aliasValues.Add);
-        await Task.Yield();
 
         await Assert.That(aliasValues.SequenceEqual([One, Two, Three, One, Two, Three, One, Three, One, Two, One, Two]))
             .IsTrue();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
index dfb010d0..d4c5c63a 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
@@ -514,10 +514,7 @@ private static List<int> Collect(IObservable<int> source)
     private static IObservable<IObservable<int>> RangeInners() =>
         Signal.FromEnumerable([Signal.Sequence(One, Two), Signal.Sequence(Three, Two)]);
 
-    /// <summary>
-    /// Drives a stateful sink through a value, a terminal completion, and then further notifications, reporting
-    /// whether the post-terminal notifications were dropped (exactly one completion, no leaked error).
-    /// </summary>
+    /// <summary>Checks that a stateful sink drops every notification after its first completion.</summary>
     /// <param name = "op">The stateful operator under test.</param>
     /// <returns><see langword="true"/> when notifications after the terminal were dropped.</returns>
     private static bool RunStopGuards(Func<IObservable<int>, IObservable<int>> op)
@@ -623,10 +620,7 @@ public CombineLatestSources() =>
         public Signal<int> Sixteenth { get; } = new();
     }
 
-    /// <summary>
-    /// An observable whose subscription retains its observer and ignores disposal, letting a test push raw
-    /// notifications (including ones after a terminal notification) to exercise a sink's terminal guards.
-    /// </summary>
+    /// <summary>Retains its observer after disposal so tests can deliver post-terminal notifications.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class ManualSource<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
new file mode 100644
index 00000000..4139c9af
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies scheduler selection by time-operator aliases.</summary>
+public partial class RxNamesTests
+{
+    /// <summary>Verifies absolute-time overloads use the default scheduler when no scheduler is supplied.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task AbsoluteTimeOperatorsUseDefaultScheduler()
+    {
+        var dueTime = DateTimeOffset.UnixEpoch;
+        AwaitableWitness<int> delayedScalar = new();
+        AwaitableWitness<int> delayedRange = new();
+        AwaitableWitness<int> delayedSubscriptionScalar = new();
+        AwaitableWitness<int> delayedSubscriptionRange = new();
+        AwaitableWitness<int> delayedExplicitRange = new();
+        AwaitableWitness<int> delayedSubscriptionExplicitRange = new();
+        AwaitableWitness<int> timeout = new();
+        AwaitableWitness<int> explicitTimeout = new();
+        const ISequencer? defaultScheduler = null;
+
+        using var delayScalarSubscription = Signal.Emit(One)
+            .Delay(dueTime)
+            .Subscribe(delayedScalar);
+        using var delayRangeSubscription = Signal.Sequence(Two, Two)
+            .Delay(dueTime)
+            .Subscribe(delayedRange);
+        using var delayExplicitRangeSubscription = Signal.Sequence(Two, Two)
+            .Delay(dueTime, defaultScheduler)
+            .Subscribe(delayedExplicitRange);
+        using var subscriptionScalarSubscription = Signal.Emit(One)
+            .DelaySubscription(dueTime)
+            .Subscribe(delayedSubscriptionScalar);
+        using var subscriptionRangeSubscription = Signal.Sequence(Two, Two)
+            .DelaySubscription(dueTime)
+            .Subscribe(delayedSubscriptionRange);
+        using var subscriptionExplicitRangeSubscription = Signal.Sequence(Two, Two)
+            .DelaySubscription(dueTime, defaultScheduler)
+            .Subscribe(delayedSubscriptionExplicitRange);
+        using var timeoutSubscription = Signal.Silent<int>()
+            .Timeout(dueTime)
+            .Subscribe(timeout);
+        using var explicitTimeoutSubscription = Signal.Silent<int>()
+            .Timeout(dueTime, defaultScheduler)
+            .Subscribe(explicitTimeout);
+
+        await delayedScalar.ValueCountReaching(One);
+        await delayedRange.ValueCountReaching(Two);
+        await delayedExplicitRange.ValueCountReaching(Two);
+        await delayedSubscriptionScalar.ValueCountReaching(One);
+        await delayedSubscriptionRange.ValueCountReaching(Two);
+        await delayedSubscriptionExplicitRange.ValueCountReaching(Two);
+        var timedOut = await timeout.FirstError;
+        var explicitlyTimedOut = await explicitTimeout.FirstError;
+
+        await Assert.That(delayedScalar.Values.SequenceEqual([One])).IsTrue();
+        await Assert.That(delayedRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedSubscriptionScalar.Values.SequenceEqual([One])).IsTrue();
+        await Assert.That(delayedSubscriptionRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(delayedSubscriptionExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
+        await Assert.That(timedOut).IsTypeOf<TimeoutException>();
+        await Assert.That(explicitlyTimedOut).IsTypeOf<TimeoutException>();
+    }
+
+    /// <summary>Time aliases construct signals when no sequencer is supplied.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task TimeOperatorsAcceptDefaultSequencer()
+    {
+        await Assert.That(Signal.Sequence(One, Three).Delay(TimeSpan.FromTicks(DueTicks))).IsNotNull();
+        await Assert.That(Signal.FromEnumerable(_oneToThree).Timeout(TimeSpan.FromTicks(DueTicks))).IsNotNull();
+        await Assert.That(Signal.FromEnumerable(_oneToThree).Sample(TimeSpan.FromTicks(DueTicks))).IsNotNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
index 6c479ba2..ec4fa688 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
@@ -11,11 +11,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Data-driven parity tests proving each System.Reactive/LINQ name builds a behaviorally identical sink to its
-/// Primitives-named counterpart. Each operator pair is one data-source row consumed by a single test body, so the
-/// behavior is asserted once and checked for both names (and for identity between them).
-/// </summary>
+/// <summary>Verifies Rx and LINQ aliases preserve their corresponding signal operator behavior.</summary>
 public partial class RxNamesTests
 {
     /// <summary>The multiplier/state used by projection cases.</summary>
@@ -60,9 +56,6 @@ public partial class RxNamesTests
     /// <summary>The amount the virtual clock is advanced, comfortably past <see cref = "DueTicks"/>.</summary>
     private const long AdvanceTicks = 5;
 
-    /// <summary>How far in the past the absolute due time of the default-scheduler operators is placed.</summary>
-    private const int ElapsedDueSeconds = 2;
-
     /// <summary>Source values 1..5.</summary>
     private static readonly int[] _oneToFive = [1, 2, 3, 4, 5];
 
@@ -434,66 +427,6 @@ await Assert
                 .IsRequiredSubscribeOnCurrentThread()).IsFalse();
     }
 
-    /// <summary>Verifies absolute-time overloads use the default scheduler when no scheduler is supplied.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task AbsoluteTimeOperatorsUseDefaultScheduler()
-    {
-        var dueTime = ThreadPoolSequencer.Instance.Now.AddSeconds(-ElapsedDueSeconds);
-        AwaitableWitness<int> delayedScalar = new();
-        AwaitableWitness<int> delayedRange = new();
-        AwaitableWitness<int> delayedSubscriptionScalar = new();
-        AwaitableWitness<int> delayedSubscriptionRange = new();
-        AwaitableWitness<int> delayedExplicitRange = new();
-        AwaitableWitness<int> delayedSubscriptionExplicitRange = new();
-        AwaitableWitness<int> timeout = new();
-        AwaitableWitness<int> explicitTimeout = new();
-        const ISequencer? defaultScheduler = null;
-
-        using var delayScalarSubscription = Signal.Emit(One)
-            .Delay(dueTime)
-            .Subscribe(delayedScalar);
-        using var delayRangeSubscription = Signal.Sequence(Two, Two)
-            .Delay(dueTime)
-            .Subscribe(delayedRange);
-        using var delayExplicitRangeSubscription = Signal.Sequence(Two, Two)
-            .Delay(dueTime, defaultScheduler)
-            .Subscribe(delayedExplicitRange);
-        using var subscriptionScalarSubscription = Signal.Emit(One)
-            .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionScalar);
-        using var subscriptionRangeSubscription = Signal.Sequence(Two, Two)
-            .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionRange);
-        using var subscriptionExplicitRangeSubscription = Signal.Sequence(Two, Two)
-            .DelaySubscription(dueTime, defaultScheduler)
-            .Subscribe(delayedSubscriptionExplicitRange);
-        using var timeoutSubscription = Signal.Silent<int>()
-            .Timeout(dueTime)
-            .Subscribe(timeout);
-        using var explicitTimeoutSubscription = Signal.Silent<int>()
-            .Timeout(dueTime, defaultScheduler)
-            .Subscribe(explicitTimeout);
-
-        await delayedScalar.ValueCountReaching(One);
-        await delayedRange.ValueCountReaching(Two);
-        await delayedExplicitRange.ValueCountReaching(Two);
-        await delayedSubscriptionScalar.ValueCountReaching(One);
-        await delayedSubscriptionRange.ValueCountReaching(Two);
-        await delayedSubscriptionExplicitRange.ValueCountReaching(Two);
-        var timedOut = await timeout.FirstError;
-        var explicitlyTimedOut = await explicitTimeout.FirstError;
-
-        await Assert.That(delayedScalar.Values.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionScalar.Values.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedSubscriptionRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(timedOut).IsTypeOf<TimeoutException>();
-        await Assert.That(explicitlyTimedOut).IsTypeOf<TimeoutException>();
-    }
-
     /// <summary>Verifies the binary <c>Concat</c>/<c>Chain</c> overload concatenates two sequences identically.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -837,18 +770,6 @@ public async Task RxNamesRangeFastPathsMatchCounterparts()
     public async Task RetryMirrorsSourceWhenNoError() =>
         await Assert.That(Collect(Signal.FromEnumerable(_oneToThree).Retry(Two)).SequenceEqual(_oneToThree)).IsTrue();
 
-    /// <summary>Exercises the default-sequencer (no-scheduler) overloads of the time operators.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task TimeOperatorsAcceptDefaultSequencer()
-    {
-        Signal.Sequence(One, Three).Delay(TimeSpan.FromTicks(DueTicks)).Subscribe(static _ => { }).Dispose();
-        Signal.FromEnumerable(_oneToThree).Timeout(TimeSpan.FromSeconds(AdvanceTicks)).Subscribe(static _ => { })
-            .Dispose();
-        Signal.FromEnumerable(_oneToThree).Sample(TimeSpan.FromTicks(DueTicks)).Subscribe(static _ => { }).Dispose();
-        await Task.CompletedTask.ConfigureAwait(false);
-    }
-
     /// <summary>Verifies the stateful sinks drop notifications that arrive after a terminal notification.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
index 61e5557e..652a9bea 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
@@ -7,12 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the three wrappers <see cref="Witness.Safe{T}(IObserver{T})"/> can hand back: the delegate
-/// witness made safe in place, the cancel-owning safe wrapper, and the cancel-free safe wrapper. All three
-/// promise the same thing — one terminal signal reaches the wrapped observer, nothing reaches it afterwards,
-/// and a throwing value callback stops the witness for good.
-/// </summary>
+/// <summary>Tests that safe witnesses stop after one terminal signal or a throwing value callback.</summary>
 public class SafeWitnessTests
 {
     /// <summary>The first value pushed at a witness.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
index 0833eddd..f869ddd0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
@@ -24,14 +24,11 @@ public sealed class ScheduledSignalTests
     /// <summary>The fourth emitted value.</summary>
     private const int FourthValue = 4;
 
-    /// <summary>The final emitted value used by stress tests.</summary>
+    /// <summary>The value delivered after the final subscription is disposed.</summary>
     private const int FinalValue = 999;
 
-    /// <summary>The number of concurrent workers used by stress tests.</summary>
-    private const int WorkerCount = 8;
-
-    /// <summary>The number of subscribe/dispose iterations each stress worker runs.</summary>
-    private const int WorkerIterations = 64;
+    /// <summary>The number of overlapping subscriptions.</summary>
+    private const int SubscriptionCount = 8;
 
     /// <summary>The expected terminal exception message.</summary>
     private const string TerminalThrowMessage = "terminal";
@@ -198,37 +195,30 @@ public async Task SubscribeRestoresDefaultObserverWhenTerminalReplayThrows()
         await Assert.That(lateObserver.Completed).IsEqualTo(1);
     }
 
-    /// <summary>Concurrent subscribe and dispose operations do not prevent default-observer restoration.</summary>
+    /// <summary>Disposing the final explicit subscription restores the default observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ConcurrentSubscribeDisposeRestoresDefaultObserver()
+    public async Task DisposingOverlappingSubscriptionsRestoresDefaultObserver()
     {
         var defaultObserver = new RecordingObserver<int>();
         using var signal = new ScheduledSignal<int>(Sequencer.Immediate, defaultObserver);
-        var tasks = Enumerable.Range(0, WorkerCount)
-            .Select(worker => Task.Run(() => SubscribeAndDispose(signal, worker)))
-            .ToArray();
+        var subscriptions = new IDisposable[SubscriptionCount];
+        for (var index = 0; index < subscriptions.Length; index++)
+        {
+            subscriptions[index] = signal.Subscribe(new RecordingObserver<int>());
+        }
 
-        await Task.WhenAll(tasks);
+        for (var index = 0; index < subscriptions.Length; index++)
+        {
+            signal.OnNext(FirstValue);
+            subscriptions[index].Dispose();
+        }
 
         signal.OnNext(FinalValue);
-
-        await Assert.That(defaultObserver.Values.Contains(FinalValue)).IsTrue();
+        await Assert.That(defaultObserver.Values.SequenceEqual([FinalValue])).IsTrue();
         await Assert.That(signal.IsDisposed).IsFalse();
     }
 
-    /// <summary>Subscribes and disposes observers repeatedly.</summary>
-    /// <param name="signal">The scheduled signal under test.</param>
-    /// <param name="worker">The worker identifier.</param>
-    private static void SubscribeAndDispose(ScheduledSignal<int> signal, int worker)
-    {
-        for (var i = 0; i < WorkerIterations; i++)
-        {
-            using var subscription = signal.Subscribe(new RecordingObserver<int>());
-            signal.OnNext((worker * WorkerIterations) + i);
-        }
-    }
-
     /// <summary>Test sequencer that queues scheduled work until drained explicitly.</summary>
     private sealed class QueuedSequencer : ISequencer
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
new file mode 100644
index 00000000..ddfbb345
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests cancellation across queued, waiting, and completed work states.</summary>
+public partial class SequencerTests
+{
+    /// <summary>A canceled trampoline item is skipped before waiting or after its wait returns.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CurrentThreadTrampolineChecksCancellationAroundTheWait()
+    {
+        SequencerQueue<long> queue = new();
+        var runs = 0;
+        ScheduledItem<long> canceled = new(0, Comparer<long>.Default, _ =>
+        {
+            runs++;
+            return EmptyDisposable.Instance;
+        });
+        ScheduledItem<long> waiting = new(Stopwatch.Frequency, Comparer<long>.Default, _ =>
+        {
+            runs++;
+            return EmptyDisposable.Instance;
+        });
+        canceled.Cancel();
+        queue.Enqueue(canceled);
+        queue.Enqueue(waiting);
+        List<TimeSpan> waits = [];
+        CurrentThreadSequencer.Trampoline.Run(queue, static () => 0, delay =>
+        {
+            waits.Add(delay);
+            waiting.Cancel();
+        });
+        await Assert.That(waits.SequenceEqual([TimeSpan.FromSeconds(1)])).IsTrue();
+        await Assert.That(runs).IsEqualTo(0);
+        await Assert.That(queue.Count).IsEqualTo(0);
+    }
+
+    /// <summary>Only positive remaining delays invoke the wait operation.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CurrentThreadWaitsOnlyForPositiveDelays()
+    {
+        List<TimeSpan> waits = [];
+        CurrentThreadSequencer.WaitIfNeeded(TimeSpan.Zero, waits.Add);
+        CurrentThreadSequencer.WaitIfNeeded(TimeSpan.FromTicks(-1), waits.Add);
+        CurrentThreadSequencer.WaitIfNeeded(TimeSpan.FromTicks(1), waits.Add);
+        await Assert.That(waits.SequenceEqual([TimeSpan.FromTicks(1)])).IsTrue();
+
+        var runs = 0;
+        CurrentThreadSequencer.ActionWorkItem item = new(() => runs++);
+        item.Dispose();
+        item.Execute();
+        await Assert.That(runs).IsEqualTo(0);
+        await Assert.That(item.IsDisposed).IsTrue();
+    }
+
+    /// <summary>Canceled immediate and delayed work never executes when the manual pool drains.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ThreadPoolDropsCanceledWorkFromBothQueues()
+    {
+        using ManualThreadPool pool = new();
+        CancellableWorkItem immediate = new();
+        CancellableWorkItem delayed = new();
+        pool.Sequencer.Schedule(immediate);
+        pool.Sequencer.Schedule(delayed, One);
+        immediate.Dispose();
+        delayed.Dispose();
+        pool.RunReady();
+        pool.RunDue(One);
+        await Assert.That(immediate.ExecuteCount).IsEqualTo(0);
+        await Assert.That(delayed.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>A task canceled after dispatch is skipped when its task scheduler runs it.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolSkipsWorkCanceledAfterDispatch()
+    {
+        ManualTaskScheduler scheduler = new();
+        TaskPoolSequencer sequencer = new(new(scheduler));
+        CancellableWorkItem item = new();
+        sequencer.Schedule(item);
+        item.Dispose();
+        scheduler.RunPending();
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>Cancellation after result publication releases the owned resource exactly once.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ThreadPoolFinalCancellationCleanupDoesNotReleaseTheResultTwice()
+    {
+        using ManualThreadPool pool = new();
+        var releases = 0;
+        ThreadPoolSequencer.ScheduledWorkItem<int> item = new(
+            pool.Sequencer,
+            0,
+            (_, _) => new ActionDisposable(() => releases++));
+        item.Execute();
+        item.Dispose();
+        item.ReleaseCanceledResult();
+        await Assert.That(releases).IsEqualTo(1);
+        await Assert.That(item.IsDisposed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
index e1676ff6..f3c9b7a0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
@@ -8,27 +8,12 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the sequencers that hand work to a pool or a dispatcher: how a faulting work item is routed, how the
-/// shared delay timer is armed and released, and how delayed work is marshalled back onto its own thread.
-/// </summary>
+/// <summary>Tests delayed dispatch, cancellation, and failure routing through pool and context sequencers.</summary>
 public partial class SequencerTests
 {
     /// <summary>Message carried by the work item that faults on purpose.</summary>
     private const string FaultMessage = "scheduled work failed";
 
-    /// <summary>How far ahead delayed work is scheduled, so the sequencer's delay timer really has to arm.</summary>
-    private static readonly TimeSpan DelayedDueTime = TimeSpan.FromMilliseconds(20);
-
-    /// <summary>How far ahead work that is cancelled before it becomes due is scheduled.</summary>
-    private static readonly TimeSpan CancelledDueTime = TimeSpan.FromMilliseconds(100);
-
-    /// <summary>How long a test watches for work that must never run.</summary>
-    private static readonly TimeSpan CancelObservationWindow = TimeSpan.FromMilliseconds(400);
-
-    /// <summary>How long a test lets a drain finish disarming before it releases the sequencer's timer.</summary>
-    private static readonly TimeSpan DrainSettleWindow = TimeSpan.FromMilliseconds(100);
-
     /// <summary>Verifies a faulting work item is handed to the sequencer's unhandled-exception handler.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -67,63 +52,68 @@ public async Task TaskPoolSequencerRethrowsWorkItemFailuresWithoutAHandler()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThreadPoolSequencerRunsDelayedWorkAndDrainsItsQueue()
-    {
-        using var sequencer = CreateIsolatedThreadPoolSequencer();
-        TaskCompletionSource ran = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        sequencer.Schedule(
-            new CallbackWorkItem(() => ran.TrySetResult()),
-            Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime));
-
-        await ran.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
-        await Assert.That(ran.Task.IsCompletedSuccessfully).IsTrue();
+{
+        using ManualThreadPool pool = new();
+        CancellableWorkItem first = new();
+        CancellableWorkItem second = new();
+        pool.Sequencer.Schedule(first, One);
+        pool.Sequencer.Schedule(second, Two);
+        pool.RunDue(0);
+        await Assert.That(first.ExecuteCount).IsEqualTo(0);
+        pool.RunDue(One);
+        await Assert.That(first.ExecuteCount).IsEqualTo(1);
+        await Assert.That(second.ExecuteCount).IsEqualTo(0);
+        pool.RunDue(Two);
+        await Assert.That(second.ExecuteCount).IsEqualTo(1);
+        await Assert.That(pool.Delays[^1]).IsEqualTo(Timeout.InfiniteTimeSpan);
+    }
 
-        // Let the drain finish disarming the timer before this scope releases it.
-        await Task.Delay(DrainSettleWindow);
+    /// <summary>Elapsed and current timestamps queue immediate work without arming a timer.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task ThreadPoolSequencerRoutesElapsedTimestampsToItsImmediateQueue()
+    {
+        using ManualThreadPool pool = new() { Timestamp = Two };
+        CancellableWorkItem elapsed = new();
+        CancellableWorkItem current = new();
+        pool.Sequencer.Schedule(elapsed, One);
+        pool.Sequencer.Schedule(current, Two);
+        await Assert.That(elapsed.ExecuteCount).IsEqualTo(0);
+        await Assert.That(current.ExecuteCount).IsEqualTo(0);
+        await Assert.That(pool.Delays).IsEmpty();
+        pool.RunReady();
+        await Assert.That(elapsed.ExecuteCount).IsEqualTo(1);
+        await Assert.That(current.ExecuteCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// Verifies a disposed thread-pool sequencer rejects new work rather than accepting work it can never run: the
-    /// delay timer is gone, so an accepted delayed item would sit in the queue forever, and an accepted immediate
-    /// item would run on a sequencer its owner has already torn down. Both overloads fail fast instead.
-    /// </summary>
+    /// <summary>A disposed thread-pool sequencer rejects immediate and delayed work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThreadPoolSequencerRejectsWorkScheduledAfterDispose()
-    {
-        var sequencer = CreateIsolatedThreadPoolSequencer();
+{
+        using ManualThreadPool pool = new();
         CancellableWorkItem immediate = new();
         CancellableWorkItem delayed = new();
-
-        sequencer.Dispose();
-
-        await Assert.That(() => sequencer.Schedule(immediate)).ThrowsExactly<ObjectDisposedException>();
-        await Assert
-            .That(() => sequencer.Schedule(delayed, Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime)))
-            .ThrowsExactly<ObjectDisposedException>();
-
-        await Task.Delay(CancelObservationWindow);
+        pool.Sequencer.Dispose();
+        await Assert.That(() => pool.Sequencer.Schedule(immediate)).ThrowsExactly<ObjectDisposedException>();
+        await Assert.That(() => pool.Sequencer.Schedule(delayed, One)).ThrowsExactly<ObjectDisposedException>();
+        pool.RunReady();
+        pool.RunDue(One);
         await Assert.That(immediate.ExecuteCount).IsEqualTo(0);
         await Assert.That(delayed.ExecuteCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies disposing a thread-pool sequencer releases the delayed work still queued behind its timer: the
-    /// pending item is cancelled, not stranded in the queue of a sequencer that can no longer arm a timer for it.
-    /// </summary>
+    /// <summary>Disposal cancels queued delayed work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThreadPoolSequencerDisposeCancelsQueuedDelayedWork()
-    {
-        var sequencer = CreateIsolatedThreadPoolSequencer();
+{
+        using ManualThreadPool pool = new();
         CancellableWorkItem pending = new();
-
-        sequencer.Schedule(pending, Sequencer.AddTimestamp(sequencer.Timestamp, CancelledDueTime));
-        sequencer.Dispose();
-
+        pool.Sequencer.Schedule(pending, One);
+        pool.Sequencer.Dispose();
+        pool.RunDue(One);
         await Assert.That(pending.IsDisposed).IsTrue();
-
-        await Task.Delay(CancelObservationWindow);
         await Assert.That(pending.ExecuteCount).IsEqualTo(0);
     }
 
@@ -143,20 +133,43 @@ public async Task SynchronizationContextSequencerSkipsCancelledPostedWork()
         await Assert.That(item.ExecuteCount).IsEqualTo(0);
     }
 
-    /// <summary>Verifies delayed work is marshalled back through the synchronization context once it is due.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>The current-context factory captures the active context and rejects an absent context.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task SynchronizationContextSequencerPostsDelayedWorkOnceItIsDue()
+    public async Task SynchronizationContextSequencerCapturesTheCurrentContext()
     {
+        var previous = SynchronizationContext.Current;
         RecordingSynchronizationContext context = new();
-        SynchronizationContextSequencer sequencer = new(context);
-        TaskCompletionSource ran = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        CancellableWorkItem item = new();
+        try
+        {
+            SynchronizationContext.SetSynchronizationContext(context);
+            SynchronizationContextSequencer.Current.Schedule(item);
+            SynchronizationContext.SetSynchronizationContext(null);
+            _ = Assert.Throws<InvalidOperationException>(static () => _ = SynchronizationContextSequencer.Current);
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(previous);
+        }
 
-        sequencer.Schedule(
-            new CallbackWorkItem(() => ran.TrySetResult()),
-            Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime));
+        await Assert.That(context.PostCount).IsEqualTo(1);
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
 
-        await ran.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+    /// <summary>Verifies delayed work is marshalled back through the synchronization context once it is due.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task SynchronizationContextSequencerPostsDelayedWorkOnceItIsDue()
+{
+        RecordingSynchronizationContext context = new();
+        ManualSequencer delays = new();
+        SynchronizationContextSequencer sequencer = new(context, delays);
+        CancellableWorkItem item = new();
+        sequencer.Schedule(item, long.MaxValue);
+        await Assert.That(context.PostCount).IsEqualTo(0);
+        delays.RunPending();
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
         await Assert.That(context.PostCount).IsEqualTo(1);
     }
 
@@ -164,90 +177,51 @@ public async Task SynchronizationContextSequencerPostsDelayedWorkOnceItIsDue()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SynchronizationContextSequencerDropsDelayedWorkCancelledBeforeItIsDue()
-    {
+{
         RecordingSynchronizationContext context = new();
-        SynchronizationContextSequencer sequencer = new(context);
+        ManualSequencer delays = new();
+        SynchronizationContextSequencer sequencer = new(context, delays);
         CancellableWorkItem item = new();
-
-        sequencer.Schedule(item, Sequencer.AddTimestamp(sequencer.Timestamp, CancelledDueTime));
+        sequencer.Schedule(item, long.MaxValue);
         item.Dispose();
-
-        await Task.Delay(CancelObservationWindow);
-
+        delays.RunPending();
         await Assert.That(item.ExecuteCount).IsEqualTo(0);
         await Assert.That(context.PostCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies disposing a thread-pool sequencer twice releases its queued work exactly once and leaves the sequencer
-    /// closed. The second disposal must be a no-op rather than a second release of work the first disposal already
-    /// cancelled and handed back to its owner.
-    /// </summary>
+    /// <summary>Repeated disposal releases queued work once and keeps the sequencer closed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThreadPoolSequencerDisposeIsIdempotent()
-    {
-        var sequencer = CreateIsolatedThreadPoolSequencer();
+{
+        using ManualThreadPool pool = new();
         DisposeCountingWorkItem pending = new();
-
-        sequencer.Schedule(pending, Sequencer.AddTimestamp(sequencer.Timestamp, CancelledDueTime));
-
-        sequencer.Dispose();
+        pool.Sequencer.Schedule(pending, One);
+        pool.Sequencer.Dispose();
         await Assert.That(pending.DisposeCount).IsEqualTo(1);
-
-        await Assert.That(sequencer.Dispose).ThrowsNothing();
-
-        // The queued item was released once, and the sequencer is still closed rather than reopened by the second call.
+        await Assert.That(pool.Sequencer.Dispose).ThrowsNothing();
         await Assert.That(pending.DisposeCount).IsEqualTo(1);
-        await Assert.That(() => sequencer.Schedule(new CancellableWorkItem()))
+        await Assert.That(() => pool.Sequencer.Schedule(new CancellableWorkItem()))
             .ThrowsExactly<ObjectDisposedException>();
     }
 
-    /// <summary>
-    /// Verifies a drain still unwinding when the sequencer is disposed does not re-arm the timer disposal has already
-    /// released. The drain runs its items outside the gate, so disposal can land mid-drain; when the drain takes the
-    /// gate again it must observe the disposal and stop rather than arm a timer that no longer exists.
-    /// </summary>
+    /// <summary>Disposal during a drain cancels pending work and prevents timer rearming.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThreadPoolSequencerDisposeDuringADrainStopsTheDrainRearmingTheTimer()
-    {
-        var sequencer = CreateIsolatedThreadPoolSequencer();
-        TaskCompletionSource draining = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using ManualResetEventSlim release = new(false);
-
-        // Park the drain inside a due item, so the disposal below provably lands while RunDue is mid-loop.
-        sequencer.Schedule(
-            new CallbackWorkItem(() =>
-            {
-                _ = draining.TrySetResult();
-                _ = release.Wait(TimeSpan.FromSeconds(TimeoutSeconds));
-            }),
-            Sequencer.AddTimestamp(sequencer.Timestamp, DelayedDueTime));
-
-        await draining.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
-
+{
+        using ManualThreadPool pool = new();
         CancellableWorkItem queued = new();
-        sequencer.Schedule(queued, Sequencer.AddTimestamp(sequencer.Timestamp, CancelledDueTime));
-
-        sequencer.Dispose();
-
-        // Let the parked drain resume: it must unwind quietly instead of arming the timer disposal released.
-        release.Set();
-        await Task.Delay(CancelObservationWindow);
-
+        pool.Sequencer.Schedule(new CallbackWorkItem(pool.Sequencer.Dispose), One);
+        pool.Sequencer.Schedule(queued, Two);
+        var changes = pool.Delays.Count;
+        pool.RunDue(One);
         await Assert.That(queued.IsDisposed).IsTrue();
         await Assert.That(queued.ExecuteCount).IsEqualTo(0);
-        await Assert.That(sequencer.Dispose).ThrowsNothing();
+        await Assert.That(pool.Delays.Count).IsEqualTo(changes);
+        await Assert.That(pool.Sequencer.Dispose).ThrowsNothing();
     }
 
-    /// <summary>
-    /// Creates a thread-pool sequencer that owns its own delay queue and timer, so a test can dispose it without
-    /// disturbing the shared singleton every other test schedules through.
-    /// </summary>
-    /// <returns>The isolated sequencer.</returns>
-    private static ThreadPoolSequencer CreateIsolatedThreadPoolSequencer() => new();
-
     /// <summary>Work item that counts how many times a sequencer released it.</summary>
     private sealed class DisposeCountingWorkItem : IWorkItem, IsDisposed
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
index 2766d016..b73c09bd 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
@@ -147,10 +147,7 @@ public async Task VirtualTimeSequencerExposesItsStopwatchProvider()
         await Assert.That(stopwatch.Elapsed).IsEqualTo(TimeSpan.FromTicks(VirtualDelay));
     }
 
-    /// <summary>
-    /// Creates a virtual-time sequencer whose clock is a raw tick count. Unlike <see cref="VirtualClock"/> it does not
-    /// normalize a negative relative time away, so the sequencer's own arithmetic delegates and guards are exercised.
-    /// </summary>
+    /// <summary>Creates a virtual sequencer that preserves signed relative tick counts.</summary>
     /// <returns>The sequencer.</returns>
     private static VirtualTimeSequencer<long, long> CreateTickSequencer() =>
         new(
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
index 52fc9694..b55075fa 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
@@ -16,9 +16,6 @@ public partial class SequencerTests
     /// <summary>A monotonic timestamp delta used to drive the delay conversions.</summary>
     private const long DueTimestamp = 1000;
 
-    /// <summary>How many times a test replays the cancel-versus-start race before checking nothing leaked.</summary>
-    private const int StartCancelRaceAttempts = 2000;
-
     /// <summary>Verifies a monotonic delta that has already elapsed converts to no delay at all.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -138,22 +135,19 @@ public async Task ScheduledWorkItemDoesNotRunAfterCancellation()
     /// <summary>Verifies queueing a thread-pool work item hands it to the pool for execution.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ScheduledWorkItemQueueRunsOnTheThreadPool()
-    {
-        TaskCompletionSource ran = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        ThreadPoolSequencer.ScheduledWorkItem<int> item = new(
-            ThreadPoolSequencer.Instance,
-            One,
-            (_, _) =>
-            {
-                _ = ran.TrySetResult();
-                return EmptyDisposable.Instance;
-            });
-
+    public async Task ScheduledWorkItemQueuesItsExecutionCallback()
+{
+        using ManualThreadPool pool = new();
+        var ran = false;
+        ThreadPoolSequencer.ScheduledWorkItem<int> item = new(pool.Sequencer, One, (_, _) =>
+        {
+            ran = true;
+            return EmptyDisposable.Instance;
+        });
         item.Queue();
-
-        await ran.Task.WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
-        await Assert.That(ran.Task.IsCompletedSuccessfully).IsTrue();
+        await Assert.That(ran).IsFalse();
+        pool.RunReady();
+        await Assert.That(ran).IsTrue();
     }
 
     /// <summary>Verifies the stateful scheduling overloads that take a due time run their callbacks.</summary>
@@ -173,11 +167,7 @@ public async Task ScheduleActionDueTimeOverloadsRunTheirCallbacks()
         await Assert.That(values.SequenceEqual(ExpectedOneTwo)).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies the delayed work item the sequencer's heap stores is a value with identity semantics: two entries are
-    /// equal only when they carry the very same work item and the same due timestamp. The heap dedupes and reorders
-    /// entries, so two distinct items that merely look alike must never compare equal, and the hash must agree.
-    /// </summary>
+    /// <summary>Timed work item equality and hashing use work item identity and due timestamp.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TimedWorkItemComparesByWorkItemIdentityAndDueTimestamp()
@@ -203,48 +193,22 @@ public async Task TimedWorkItemComparesByWorkItemIdentityAndDueTimestamp()
         await Assert.That(item.Equals(new object())).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies a cancellation that lands while the action is starting still releases whatever the action returned.
-    /// The work item claims cancellation and the action's result in two separate steps, so a dispose that slips
-    /// between them would otherwise leave the returned disposable owned by nobody and never torn down.
-    /// </summary>
+    /// <summary>Cancellation during invocation disposes the action's returned resource exactly once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ScheduledWorkItemReleasesItsActionResultWhenCancellationRacesTheStart()
+    public async Task ScheduledWorkItemReleasesItsActionResultWhenCanceledDuringInvocation()
     {
-        var created = 0;
         var disposed = 0;
-
-        for (var attempt = 0; attempt < StartCancelRaceAttempts; attempt++)
+        ThreadPoolSequencer.ScheduledWorkItem<int>? item = null;
+        item = new(ThreadPoolSequencer.Instance, One, (_, _) =>
         {
-            using ManualResetEventSlim actionReturning = new(false);
-            ThreadPoolSequencer.ScheduledWorkItem<int> item = new(
-                ThreadPoolSequencer.Instance,
-                One,
-                (_, _) =>
-                {
-                    // Let the canceller run at the moment the action hands its result back.
-                    actionReturning.Set();
-                    _ = Interlocked.Increment(ref created);
-                    return new ActionDisposable(() => Interlocked.Increment(ref disposed));
-                });
-
-            var canceller = Task.Run(() =>
-            {
-                _ = actionReturning.Wait(TimeSpan.FromSeconds(TimeoutSeconds));
-                item.Dispose();
-            });
-
-            item.Execute();
-            await canceller;
-
-            // Whichever side won, the item is cancelled, so the action's result must not survive it.
-            item.Dispose();
-        }
-
-        // Every disposable the action handed back was released: none was stranded by the cancel-versus-start race.
-        await Assert.That(Volatile.Read(ref disposed)).IsEqualTo(Volatile.Read(ref created));
-        await Assert.That(Volatile.Read(ref created)).IsEqualTo(StartCancelRaceAttempts);
+            item!.Dispose();
+            return new ActionDisposable(() => disposed++);
+        });
+        item.Execute();
+        item.Dispose();
+        await Assert.That(item.IsDisposed).IsTrue();
+        await Assert.That(disposed).IsEqualTo(1);
     }
 
     /// <summary>Work item that counts executions and can be cancelled before a sequencer reaches it.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
index 706815bf..fafe8ba7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Core;
@@ -34,9 +33,6 @@ public partial class SequencerTests
     /// <summary>A reusable negative value.</summary>
     private const int NegativeOne = -1;
 
-    /// <summary>Timeout used when waiting for background scheduled work.</summary>
-    private const int TimeoutSeconds = 10;
-
     /// <summary>Reused first-error message.</summary>
     private const string FirstMessage = "first";
 
@@ -55,12 +51,6 @@ public partial class SequencerTests
     /// <summary>Deterministic absolute due time for scheduler overload tests.</summary>
     private static readonly DateTimeOffset AbsoluteDueTime = DateTimeOffset.UnixEpoch;
 
-    /// <summary>How far ahead of now the immediate sequencer's absolute-due-time test schedules its work.</summary>
-    private static readonly TimeSpan AbsoluteDueOffset = TimeSpan.FromMilliseconds(30);
-
-    /// <summary>The shortest wait that still proves the immediate sequencer honoured the absolute due time.</summary>
-    private static readonly TimeSpan MinimumAbsoluteWait = TimeSpan.FromMilliseconds(20);
-
     /// <summary>Expected values produced by simple scheduling extension overloads.</summary>
     private static readonly int[] ScheduleExpected = [One, Two, Three, Four];
 
@@ -110,11 +100,18 @@ public async Task CurrentThreadSequencerSkipsNestedWorkCancelledBeforeTheTrampol
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ImmediateSequencerHonorsAbsoluteDueTime()
-    {
-        var start = Stopwatch.GetTimestamp();
-        _ = Sequencer.Immediate.Schedule(Sequencer.Immediate.Now + AbsoluteDueOffset, static () => { });
-        var elapsed = Stopwatch.GetElapsedTime(start);
-        await Assert.That(elapsed >= MinimumAbsoluteWait).IsTrue();
+{
+        var dueTime = TimeSpan.FromTicks(One);
+        List<string> events = [];
+        CallbackWorkItem item = new(() => events.Add("execute"));
+        TimeSpan? waited = null;
+        ImmediateSequencer.RunScheduled(item, dueTime, delay =>
+        {
+            waited = delay;
+            events.Add("wait");
+        });
+        await Assert.That(waited).IsEqualTo(dueTime);
+        await Assert.That(events.SequenceEqual(["wait", "execute"])).IsTrue();
     }
 
     /// <summary>Verifies virtual-clock work runs only after the clock reaches the due time.</summary>
@@ -456,52 +453,21 @@ public async Task ScheduledItemNonGenericComparisonOrdersByDueTime()
         _ = Assert.Throws<ArgumentException>(() => ((IComparable)early).CompareTo("not-scheduled"));
     }
 
-    /// <summary>
-    /// Cancelling a scheduled item that is already running must not leak the resource the invocation produced.
-    /// The two operations race by nature, so this drives every interleaving and asserts the invariant that
-    /// holds across all of them: once both have finished, the invocation's resource is disposed.
-    /// </summary>
+    /// <summary>Cancellation during invocation releases the resource produced by the running action.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduledItemCancelledDuringInvocationNeverLeaksTheInvocationResource()
     {
-        const int Iterations = 20_000;
-
-        for (var iteration = 0; iteration < Iterations; iteration++)
+        RecordingDisposable resource = new();
+        ScheduledItem<int>? item = null;
+        item = ScheduledProbe.Create(One, () =>
         {
-            RecordingDisposable resource = new();
-            var invoked = false;
-            var item = ScheduledProbe.Create(
-                One,
-                () =>
-                {
-                    invoked = true;
-                    return resource;
-                });
-
-            using Barrier barrier = new(Two);
-            var invoking = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                item.Invoke();
-            });
-            var cancelling = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                item.Cancel();
-            });
-
-            await Task.WhenAll(invoking, cancelling);
-
-            await Assert.That(item.IsDisposed).IsTrue();
-
-            // Either the cancellation beat the invocation entirely (no resource was ever created), or the
-            // invocation produced one — and in that case it must not have outlived the cancellation. The
-            // count is not pinned to exactly one: on the interleaving where the invocation installs the
-            // resource between the cancellation's two writes, both paths dispose it, and IDisposable.Dispose
-            // is required to tolerate that.
-            await Assert.That(!invoked || resource.DisposeCount >= 1).IsTrue();
-        }
+            item!.Cancel();
+            return resource;
+        });
+        item.Invoke();
+        await Assert.That(item.IsDisposed).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
     /// <summary>Asserts the immediate sequencer validates its callbacks and runs each scheduling overload in order.</summary>
@@ -521,7 +487,7 @@ private static async Task AssertImmediateSequencerValidatesAndRunsScheduledWork(
             immediateValues.Add(state);
             return EmptyDisposable.Instance;
         }).Dispose();
-        Sequencer.Immediate.Schedule(Three, Sequencer.Immediate.Now.AddTicks(NegativeOne), (_, state) =>
+        Sequencer.Immediate.Schedule(Three, DateTimeOffset.UnixEpoch, (_, state) =>
         {
             immediateValues.Add(state);
             return EmptyDisposable.Instance;
@@ -532,26 +498,29 @@ private static async Task AssertImmediateSequencerValidatesAndRunsScheduledWork(
     /// <summary>Asserts the task-pool and thread-pool sequencers validate their callbacks and run scheduled work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task AssertPoolSequencersValidateAndRunScheduledWork()
-    {
-        _ = Assert.Throws<ArgumentNullException>(static () => TaskPoolSequencer.Instance.Schedule(One, null!));
-        _ = Assert.Throws<ArgumentNullException>(static () => TaskPoolSequencer.Instance.Schedule(One, TimeSpan.Zero, null!));
-        TaskCompletionSource taskPoolCompletion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var taskPoolSubscription = TaskPoolSequencer.Instance.Schedule(Seven, (_, _) =>
+{
+        InlineTaskScheduler scheduler = new();
+        TaskPoolSequencer taskPool = new(new(scheduler));
+        using ManualThreadPool pool = new();
+        await Assert.That(() => taskPool.Schedule(One, null!)).Throws<ArgumentNullException>();
+        await Assert.That(() => taskPool.Schedule(One, TimeSpan.Zero, null!)).Throws<ArgumentNullException>();
+        var taskValue = 0;
+        using var taskSubscription = taskPool.Schedule(Seven, (_, value) =>
         {
-            taskPoolCompletion.SetResult();
+            taskValue = value;
             return EmptyDisposable.Instance;
         });
-        await WaitForAsync(taskPoolCompletion.Task);
-        TaskCompletionSource threadPoolCompletion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        using var threadPoolSubscription = ThreadPoolSequencer.Instance.Schedule(Eight, TimeSpan.Zero, (_, _) =>
+        await Assert.That(taskValue).IsEqualTo(Seven);
+        var threadValue = 0;
+        using var threadSubscription = pool.Sequencer.Schedule(Eight, TimeSpan.Zero, (_, value) =>
         {
-            threadPoolCompletion.SetResult();
+            threadValue = value;
             return EmptyDisposable.Instance;
         });
-        await WaitForAsync(threadPoolCompletion.Task);
-        _ = Assert.Throws<ArgumentNullException>(static () => ThreadPoolSequencer.Instance.Schedule(One, null!));
-        _ = Assert.Throws<ArgumentNullException>(static () =>
-            ThreadPoolSequencer.Instance.Schedule(One, TimeSpan.Zero, null!));
+        pool.RunReady();
+        await Assert.That(threadValue).IsEqualTo(Eight);
+        await Assert.That(() => pool.Sequencer.Schedule(One, null!)).Throws<ArgumentNullException>();
+        await Assert.That(() => pool.Sequencer.Schedule(One, TimeSpan.Zero, null!)).Throws<ArgumentNullException>();
     }
 
     /// <summary>Asserts the synchronization-context sequencer validates its context and callbacks and runs scheduled work.</summary>
@@ -580,8 +549,7 @@ private static async Task AssertSynchronizationContextSequencerValidatesAndRunsS
                 SetCompletion(delayedSynchronizationCompletion, state);
                 return EmptyDisposable.Instance;
             });
-        var delayedValue = await delayedSynchronizationCompletion.Task
-            .WaitAsync(TimeSpan.FromSeconds(TimeoutSeconds));
+        var delayedValue = await delayedSynchronizationCompletion.Task;
         var synchronizedValues = synchronizationValues.Append(delayedValue);
         await Assert.That(synchronizedValues.SequenceEqual(ExpectedOneTwo)).IsTrue();
     }
@@ -623,22 +591,6 @@ private static async Task AssertVirtualClockStartsAtItsInitialTime()
         await Assert.That(initialClock.Now).IsEqualTo(DateTimeOffset.UnixEpoch);
     }
 
-    /// <summary>Waits for a task with a bounded timeout.</summary>
-    /// <param name="task">The task to wait for.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    /// <exception cref="TimeoutException"><paramref name="task"/> did not complete within the bounded timeout.</exception>
-    private static async Task WaitForAsync(Task task)
-    {
-        var timeout = Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds));
-        var completed = await Task.WhenAny(task, timeout).ConfigureAwait(false);
-        if (completed == timeout)
-        {
-            throw new TimeoutException("Timed out waiting for scheduled work.");
-        }
-
-        await task.ConfigureAwait(false);
-    }
-
     /// <summary>Creates an invalid sequencer queue.</summary>
     private static void CreateInvalidSequencerQueue()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
index 08acddf4..4f51298d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
@@ -31,12 +31,6 @@ public class SignalCreateTests
     /// <summary>Expected values for create-with-state tests.</summary>
     private static readonly int[] CreateWithStateExpected = [Third];
 
-    /// <summary>A delay long enough that the subscription is always disposed before it elapses.</summary>
-    private static readonly TimeSpan NeverElapsingDelay = TimeSpan.FromSeconds(30);
-
-    /// <summary>How long the test waits for the cancellation callback before failing.</summary>
-    private static readonly TimeSpan CancellationTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Creates the argument checking.</summary>
     [Test]
     public void Create_ArgumentChecking()
@@ -251,7 +245,6 @@ public async Task AsyncCreateFactoriesAssignDisposablesAndForwardFailures()
         });
 
         var subscription = created.Subscribe(values.Add);
-        await Task.Yield();
         subscription.Dispose();
 
         await Assert.That(values.SequenceEqual([CreatedValue])).IsTrue();
@@ -261,16 +254,16 @@ public async Task AsyncCreateFactoriesAssignDisposablesAndForwardFailures()
         InvalidOperationException expected = new("async-create");
         _ = Signal.Create<int>((_, _) => Task.FromException<IDisposable>(expected))
             .Subscribe(static _ => { }, error => observed = error);
-        await Task.Yield();
 
         await Assert.That(observed).IsSameReferenceAs(expected);
 
         TaskCompletionSource canceled = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
         var cancellable = Signal.Create<int>(async (_, cancellationToken) =>
         {
             try
             {
-                await Task.Delay(NeverElapsingDelay, cancellationToken).ConfigureAwait(false);
+                await release.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -283,11 +276,10 @@ public async Task AsyncCreateFactoriesAssignDisposablesAndForwardFailures()
 
         var cancellableSubscription = cancellable.Subscribe(static _ => { });
         cancellableSubscription.Dispose();
-        await canceled.Task.WaitAsync(CancellationTimeout).ConfigureAwait(false);
+        await canceled.Task.ConfigureAwait(false);
 
         var nullDisposable = Signal.Create<int>(static (_, _) => Task.FromResult<IDisposable>(null!));
         var nullSubscription = nullDisposable.Subscribe(static _ => { });
-        await Task.Yield();
         nullSubscription.Dispose();
 
         _ = Assert.Throws<ArgumentNullException>(static () =>
@@ -304,7 +296,6 @@ public async Task AsyncDeferFactoriesEmitFailAndHonorCancellation()
         List<int> values = [];
         _ = Signal.Defer(static () => Task.FromResult(Signal.Emit(CreatedValue))).Subscribe(values.Add);
         _ = Signal.Defer(static _ => Task.FromResult(Signal.Emit(First))).Subscribe(values.Add);
-        await Task.Yield();
 
         await Assert.That(values.SequenceEqual([CreatedValue, First])).IsTrue();
 
@@ -312,19 +303,23 @@ public async Task AsyncDeferFactoriesEmitFailAndHonorCancellation()
         InvalidOperationException expected = new("defer");
         _ = Signal.Defer(() => Task.FromException<IObservable<int>>(expected))
             .Subscribe(static _ => { }, error => observed = error);
-        await Task.Yield();
 
         await Assert.That(observed).IsSameReferenceAs(expected);
 
-        TaskCompletionSource<IObservable<int>> delayedFactory = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        List<int> canceledValues = [];
-        var deferred = Signal.Defer(_ => delayedFactory.Task);
-        var subscription = deferred.Subscribe(canceledValues.Add);
-        subscription.Dispose();
-        delayedFactory.SetResult(Signal.Emit(Fourth));
-        await Task.Yield();
+        RecordingWitness<int> canceled = new();
+        AsyncSubscriptionLifetime lifetime = new();
+        using CreateWitness<int> witness = new(canceled);
+        witness.SetCancel(lifetime);
+        await AsyncDeferSignal<int>.RunAsyncFactory(
+            _ =>
+            {
+                lifetime.Dispose();
+                return Task.FromResult(Signal.Emit(Fourth));
+            },
+            witness,
+            lifetime);
 
-        await Assert.That(canceledValues.Count).IsEqualTo(0);
+        await Assert.That(canceled.Values.Count).IsEqualTo(0);
 
         _ = Assert.Throws<ArgumentNullException>(static () => Signal.Defer((Func<Task<IObservable<int>>>)null!));
         _ = Assert.Throws<ArgumentNullException>(static () =>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs
index eced4803..ffe45348 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs
@@ -12,9 +12,6 @@ public sealed class SignalDeferTests
     /// <summary>Message carried by the failure a deferred source raises when an observer subscribes to it.</summary>
     private const string SubscribeFailureMessage = "defer-subscribe";
 
-    /// <summary>Longest a test waits for the deferred subscription to report back.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies deferred sources and blocking enumeration surface success, factory failure, and source failure paths.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -47,11 +44,7 @@ await Assert.That(Signal.FromEnumerable([First, Second]).ToEnumerable().Sequence
         _ = Assert.Throws<ArgumentNullException>(static () => ((IObservable<int>)null!).ToEnumerable());
     }
 
-    /// <summary>
-    /// Verifies an asynchronously deferred source whose subscription throws surfaces that failure to the observer.
-    /// The factory succeeded, so the failure arrives on the subscribe step rather than the await, and it must still
-    /// reach the observer instead of faulting the fire-and-forget task that drives the deferred subscription.
-    /// </summary>
+    /// <summary>A subscription failure in an asynchronously produced source reaches the observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DeferAsyncSurfacesAFailureRaisedWhenSubscribingToTheProducedSource()
@@ -70,7 +63,7 @@ public async Task DeferAsyncSurfacesAFailureRaisedWhenSubscribingToTheProducedSo
                     _ = observed.TrySetResult();
                 });
 
-        await Assert.That(observed.Task.WaitAsync(WaitTimeout)).ThrowsNothing();
+        await Assert.That(observed.Task).ThrowsNothing();
         await Assert.That(observedError!).IsSameReferenceAs(subscribeError);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
index 7190e35c..b6978cfa 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Completes branch and contract coverage for factory, task, and terminal-task behavior.</summary>
+/// <summary>Tests factories, task observation, and terminal task results.</summary>
 public partial class SignalFactoriesTests
 {
     /// <summary>Expected use-factory errors.</summary>
@@ -24,7 +24,7 @@ public partial class SignalFactoriesTests
     private static readonly int[] ExpectedSingleAsyncValue = [1];
 
     /// <summary>Exercises task, async-enumerable, and terminal task branches.</summary>
-    /// <returns>A task that completes when asynchronous coverage has run.</returns>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task FactoriesTasksAndTerminalTasksCoverCancellationFaultAndEmptyBranches()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
index 3a596db4..dd44f4e3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
@@ -285,11 +285,9 @@ public async Task RetryResubscribesUntilSuccess()
     }
 
     /// <summary>Verifies async enumerable subscriptions cancel and dispose the enumerator.</summary>
-    /// <param name="testToken">The test cancellation token.</param>
     /// <returns>A task that completes when the asynchronous assertions have run.</returns>
     [Test]
-    [Timeout(30_000)]
-    public async Task AsyncEnumerableFactoryCancelsEnumeratorOnDispose(CancellationToken testToken)
+    public async Task AsyncEnumerableFactoryCancelsEnumeratorOnDispose()
     {
         var disposed = false;
         List<int> values = [];
@@ -311,7 +309,7 @@ async IAsyncEnumerable<int> Values([EnumeratorCancellation] CancellationToken to
             }
         }
 
-        var subscription = Signal.FromAsyncEnumerable(Values(testToken), testToken).Subscribe(
+        var subscription = Signal.FromAsyncEnumerable(Values()).Subscribe(
             value =>
             {
                 values.Add(value);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
index 2c768ce3..8387f54f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the factory overloads that name no sequencer and therefore run on the default one, together with
-/// the degenerate inputs those factories have to fold away: an empty range and an uncancellable token.
-/// </summary>
+/// <summary>Verifies factory defaults, cancellation, and scheduled notifications.</summary>
 public partial class SignalFactoriesTests
 {
     /// <summary>The timeout used by the expiry factory test.</summary>
@@ -49,15 +46,17 @@ public async Task FromEnumerableHonorsACancellableTokenAndIgnoresAnUncancellable
         await Assert.That(plainValues.SequenceEqual([One, Two, Three])).IsTrue();
     }
 
-    /// <summary>Verifies the sequencer-free expiry factory fails a sequence that never terminates.</summary>
+    /// <summary>Running the scheduled expiry fails a silent source.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ExpireWithoutASequencerFailsASilentSequence()
-    {
-        AwaitableWitness<int> witness = new();
-        using var subscription = Signal.Expire(Signal.Silent<int>(), ShortExpiry).Subscribe(witness);
-        var error = await witness.FirstError;
-        await Assert.That(error).IsTypeOf<TimeoutException>();
+    public async Task ExpireFailsASilentSequenceWhenTheDelayRuns()
+{
+        ManualSequencer sequencer = new();
+        RecordingWitness<int> witness = new();
+        using var subscription = Signal.Expire(Signal.Silent<int>(), ShortExpiry, sequencer).Subscribe(witness);
+        await Assert.That(witness.Errors.Count).IsEqualTo(0);
+        sequencer.RunPending();
+        await Assert.That(witness.Errors[0]).IsTypeOf<TimeoutException>();
         await Assert.That(witness.Errors.Count).IsEqualTo(1);
     }
 
@@ -83,18 +82,16 @@ public async Task StartWithoutASequencerRunsTheWorkOnTheDefaultSequencer()
         await Assert.That(actionWitness.Values[0]).IsEqualTo(RxVoid.Default);
     }
 
-    /// <summary>Verifies the sequencer-free <c>Every</c> factory ticks on the default sequencer.</summary>
+    /// <summary>Each scheduled callback emits the next tick.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task EveryWithoutASequencerTicksOnTheDefaultSequencer()
-    {
-        AwaitableWitness<long> witness = new();
-        using (Signal.Every(ShortExpiry).Subscribe(witness))
-        {
-            await witness.ValueCountReaching(Two);
-        }
-
-        var ticks = witness.Values;
-        await Assert.That(ticks[1]).IsGreaterThan(ticks[0]);
+    public async Task EveryTicksWhenTheSequencerRuns()
+{
+        ManualSequencer sequencer = new();
+        RecordingWitness<long> witness = new();
+        using var subscription = Signal.Every(ShortExpiry, sequencer).Subscribe(witness);
+        sequencer.RunPending();
+        sequencer.RunPending();
+        await Assert.That(witness.Values.SequenceEqual([0L, 1L])).IsTrue();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
index 7380390c..dac4e5f5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
@@ -8,11 +8,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies how the <see cref="Signal"/> run-once, sequence, loop, and timer factories dispatch through an
-/// explicit sequencer: the work is deferred until the sequencer runs it, a current-thread sequencer routes the
-/// subscription through the trampoline, and an external cancellation token is only wired up when it can be cancelled.
-/// </summary>
+/// <summary>Tests factory dispatch, recurring ticks, and cancellation through explicit sequencers.</summary>
 public partial class SignalFactoriesTests
 {
     /// <summary>The number of values taken from the infinite loop signal before it is torn down.</summary>
@@ -21,11 +17,7 @@ public partial class SignalFactoriesTests
     /// <summary>The tick used as both the due time and the period of the virtual timers.</summary>
     private static readonly TimeSpan SingleTick = TimeSpan.FromTicks(1);
 
-    /// <summary>
-    /// Verifies a periodic timer keeps ticking under a sequencer that runs the first tick before its own
-    /// <c>Schedule</c> returns. The tick arms the next one, and the handle the outer call goes on to return must
-    /// not replace - and so cancel - that successor, which would leave the timer emitting a single value.
-    /// </summary>
+    /// <summary>An inline first tick retains the successor it schedules before the initial scheduling call returns.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TimerRetainsThePeriodicTickArmedByAnInlineFirstTick()
@@ -182,8 +174,7 @@ await Assert.That(((IRequireCurrentThread<int>)Signal.Loop(Seven)).IsRequiredSub
 
         RecordingWitness<int> witness = new();
 
-        // Loop drives itself through the current-thread trampoline, so the subscription has to be taken while the
-        // trampoline is already running; otherwise the handle that stops the recursion is never handed back.
+        // Subscribe inside the trampoline so Take receives its cancellation handle before emission starts.
         _ = Sequencer.CurrentThread.Schedule(() =>
             Signal.Loop(Seven).Take(LoopTakeCount).Subscribe(witness));
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
index 86d01d7e..762810ef 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
@@ -40,9 +40,6 @@ public partial class SignalFactoriesTests
     /// <summary>The integer constant ninety-nine.</summary>
     private const int NinetyNine = 99;
 
-    /// <summary>The timeout in seconds used when waiting for asynchronous branches.</summary>
-    private const int TimeoutSeconds = 2;
-
     /// <summary>The long constant zero.</summary>
     private const long ZeroLong = 0L;
 
@@ -271,19 +268,13 @@ public async Task FromAsyncCancellableFactoryDisposalCancelsSubscriptionToken()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromAsyncCancellableFactoryDisposalSuppressesIgnoredCancellationResult()
-    {
-        TaskCompletionSource subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<int> complete = new(TaskCreationOptions.RunContinuationsAsynchronously);
+{
+        AsyncSubscriptionLifetime lifetime = new();
         AwaitableWitness<int> observer = new();
-        var subscription = Signal.FromAsync(token =>
-        {
-            subscribed.SetResult();
-            return complete.Task;
-        }).Subscribe(observer);
-        await subscribed.Task;
-        subscription.Dispose();
-        complete.SetResult(NinetyNine);
-        await Task.Yield();
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, CancellationToken.None);
+        FromAsyncTaskObservation<int> observation = new(observer, lifetime, cancellation, null);
+        lifetime.Dispose();
+        observation.Observe(Task.FromResult(NinetyNine));
         await Assert.That(observer.Values.Count).IsEqualTo(0);
         await Assert.That(observer.Errors.Count).IsEqualTo(0);
         await Assert.That(observer.Completions).IsEqualTo(0);
@@ -318,24 +309,16 @@ public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserve
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserverErrorWhenTaskIgnoresToken()
-    {
+{
         using CancellationTokenSource external = new();
-        TaskCompletionSource subscribed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<int> complete = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        using AsyncSubscriptionLifetime lifetime = new();
         AwaitableWitness<int> observer = new();
-        using var subscription = Signal.FromAsync(
-            token =>
-            {
-                subscribed.SetResult();
-                return complete.Task;
-            },
-            external.Token).Subscribe(observer);
-        await subscribed.Task;
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, external.Token);
+        FromAsyncTaskObservation<int> observation = new(observer, lifetime, cancellation, null);
+        await Assert.That(cancellation.Start()).IsTrue();
         await external.CancelAsync();
-        var error = await observer.FirstError;
-        complete.SetResult(NinetyNine);
-        await Task.Yield();
-        await Assert.That(error).IsTypeOf<TaskCanceledException>();
+        observation.Observe(Task.FromResult(NinetyNine));
+        await Assert.That(observer.Errors[0]).IsTypeOf<TaskCanceledException>();
         await Assert.That(observer.Errors.Count).IsEqualTo(One);
         await Assert.That(observer.Values.Count).IsEqualTo(0);
         await Assert.That(observer.Completions).IsEqualTo(0);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
deleted file mode 100644
index 2a6e8383..00000000
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
+++ /dev/null
@@ -1,1218 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-using System.Collections.Concurrent;
-using System.Runtime.CompilerServices;
-using ReactiveUI.Primitives.Advanced;
-using ReactiveUI.Primitives.Concurrency;
-using ReactiveUI.Primitives.Signals;
-
-namespace ReactiveUI.Primitives.Tests;
-
-/// <summary>Tests for creating signals from tasks.</summary>
-public class SignalFromTaskTest
-{
-    /// <summary>The value emitted by the simple from-task result test.</summary>
-    private const int EmittedValue = 2;
-
-    /// <summary>The value produced by the successful pending task.</summary>
-    private const int SuccessValue = 7;
-
-    /// <summary>The value produced by the disposed pending subscription.</summary>
-    private const int DisposedValue = 99;
-
-    /// <summary>
-    /// Maximum wait for cancellation callbacks that are intentionally driven by timers. The callbacks fire on pool
-    /// threads, so on a saturated runner they can arrive far later than on an idle box; a cancellation that never
-    /// fires the callbacks never signals, so this window only has to outlast a slow runner and costs nothing when
-    /// the callbacks arrive promptly.
-    /// </summary>
-    private const int CancellationCallbackTimeoutMilliseconds = 30_000;
-
-    /// <summary>Message carried by a failure an observer raises from inside a notification.</summary>
-    private const string ObserverFailureMessage = "observer failed";
-
-    /// <summary>Delay used before checking that a task has started.</summary>
-    private const int InitialDelayMilliseconds = 500;
-
-    /// <summary>
-    /// Time spent performing synchronous cancellation cleanup work. Kept short so the
-    /// blocking <see cref = "Thread.Sleep(int)"/> does not occupy a thread-pool thread long
-    /// enough to delay the timer-driven cancellation callbacks the tests wait on (which
-    /// previously tipped the loaded CI runners over <see cref = "CancellationCallbackTimeoutMilliseconds"/>).
-    /// </summary>
-    private const int CleanupWorkMilliseconds = 250;
-
-    /// <summary>Delay used to wait for cancellation cleanup to finish.</summary>
-    private const int CancellationWaitDelayMilliseconds = 6000;
-
-    /// <summary>Delay used by the command body.</summary>
-    private const int CommandDelayMilliseconds = 10_000;
-
-    /// <summary>Exception message used by user exception tests.</summary>
-    private const string BreakExecutionMessage = "break execution";
-
-    /// <summary>Status text recorded when a command starts.</summary>
-    private const string StartedCommand = "started command";
-
-    /// <summary>Status text recorded when cancellation cleanup starts.</summary>
-    private const string StartingCancellingCommand = "starting cancelling command";
-
-    /// <summary>Status text recorded when cancellation cleanup finishes.</summary>
-    private const string FinishedCancellingCommand = "finished cancelling command";
-
-    /// <summary>Status text recorded when the command completes normally.</summary>
-    private const string FinishedCommandNormally = "finished command Normally";
-
-    /// <summary>Status text recorded by the exception handler.</summary>
-    private const string ExceptionShouldBeHere = "Exception Should Be here";
-
-    /// <summary>Status text recorded by the finalizer callback.</summary>
-    private const string ShouldAlwaysComeHere = "Should always come here.";
-
-    /// <summary>How long a poll waits for an observed notification before failing.</summary>
-    private static readonly TimeSpan PollTimeout = TimeSpan.FromSeconds(2);
-
-    /// <summary>Covers from-task cancellation callback argument validation.</summary>
-    [Test]
-    public void FromTaskValidatesCancellationCallback()
-    {
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(1), Sequencer.Immediate);
-        try
-        {
-            _ = Assert.Throws<ArgumentNullException>(() => taskSignal.GetOperationCanceled(null!));
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>Covers from-task result emission and completion.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task FromTaskEmitsResult()
-    {
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(EmittedValue), Sequencer.Immediate);
-        try
-        {
-            List<int> taskValues = [];
-            var taskCompleted = 0;
-            _ = taskSignal.Subscribe(taskValues.Add, static error => throw error, () => taskCompleted++);
-            await Assert.That(taskValues.SequenceEqual([EmittedValue])).IsTrue();
-            await Assert.That(taskCompleted).IsEqualTo(1);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>Covers non-completed task factory continuations for success, fault, cancellation, and disposed subscriptions.</summary>
-    /// <returns>A task that completes when all continuations have been observed.</returns>
-    [Test]
-    public async Task TaskFactoryContinuationsCoverPendingTaskBranches()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        void AddValue(int value) => values.Enqueue(value);
-        void AddError(Exception error) => errors.Enqueue(error.GetType().Name);
-
-        bool ObservedPendingBranches()
-        {
-            var observedValues = values.ToArray();
-            var observedErrors = errors.ToArray();
-            return Array.IndexOf(observedValues, SuccessValue) >= 0
-                   && Array.IndexOf(observedErrors, nameof(InvalidOperationException)) >= 0
-                   && Array.IndexOf(observedErrors, nameof(TaskCanceledException)) >= 0;
-        }
-
-        TaskCompletionSource<int> success = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<int> fault = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<int> canceled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource<int> disposed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var disposedSubscription = Signal.FromTask(disposed.Task).Subscribe(_ => AddValue(DisposedValue), AddError);
-        disposedSubscription.Dispose();
-        _ = Signal.FromTask(success.Task).Subscribe(AddValue, AddError);
-        _ = Signal.FromTask(fault.Task).Subscribe(AddValue, AddError);
-        _ = Signal.FromTask(canceled.Task).Subscribe(AddValue, AddError);
-        success.SetResult(SuccessValue);
-        fault.SetException(new InvalidOperationException("pending-fault"));
-        canceled.SetCanceled(new(true));
-        disposed.SetResult(DisposedValue);
-        await TestPolling.SpinUntil(ObservedPendingBranches, PollTimeout).ConfigureAwait(false);
-        var finalValues = values.ToArray();
-        var finalErrors = errors.ToArray();
-        await Assert.That(finalValues.Length).IsEqualTo(1);
-        await Assert.That(finalValues[0]).IsEqualTo(SuccessValue);
-        await Assert.That(finalErrors).Contains(nameof(InvalidOperationException));
-        await Assert.That(finalErrors).Contains(nameof(TaskCanceledException));
-    }
-
-    /// <summary>A synchronously completed task emits its result and completes through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateSynchronousSuccessEmitsResultAndCompletes()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var completed = 0;
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(
-                values.Enqueue,
-                error => errors.Enqueue(error.GetType().Name),
-                () => Interlocked.Increment(ref completed));
-            await Assert.That(values.SequenceEqual([SuccessValue])).IsTrue();
-            await Assert.That(errors).IsEmpty();
-            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(1);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A synchronously canceled task errors with a cancellation through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateSynchronousCanceledTaskErrors()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var taskSignal = Signal.FromTask(static _ => Task.FromCanceled<int>(new(true)), Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(OperationCanceledException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A synchronously faulted task forwards the exception through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateSynchronousFaultedTaskForwardsError()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var taskSignal =
-            Signal.FromTask(
-                static _ => Task.FromException<int>(new InvalidOperationException(BreakExecutionMessage)),
-                Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A throwing task factory forwards the exception through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateFactoryThrowForwardsError()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var taskSignal = Signal.FromTask<int>(
-            static _ => throw new InvalidOperationException(BreakExecutionMessage),
-            Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A throwing task factory forwards the exception through the scheduled path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ScheduledFactoryThrowForwardsError()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var taskSignal = Signal.FromTask<int>(static _ => throw new InvalidOperationException(BreakExecutionMessage));
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            await TestPolling.SpinUntil(() => !errors.IsEmpty, PollTimeout).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A synchronously completed task emits its result through the scheduled synchronous fast path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ScheduledSynchronousSuccessEmitsResultAndCompletes()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var completed = 0;
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.CurrentThread);
-        try
-        {
-            _ = taskSignal.Subscribe(
-                values.Enqueue,
-                error => errors.Enqueue(error.GetType().Name),
-                () => Interlocked.Increment(ref completed));
-            await TestPolling.SpinUntil(() => Volatile.Read(ref completed) == 1, PollTimeout)
-                .ConfigureAwait(false);
-            await Assert.That(values.SequenceEqual([SuccessValue])).IsTrue();
-            await Assert.That(errors).IsEmpty();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A synchronously canceled task errors through the scheduled synchronous fast path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ScheduledSynchronousCanceledTaskErrors()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var taskSignal = Signal.FromTask(static _ => Task.FromCanceled<int>(new(true)), Sequencer.CurrentThread);
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            await TestPolling.SpinUntil(() => !errors.IsEmpty, PollTimeout).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(OperationCanceledException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>Disposing a subscription whose cancellation source was already disposed swallows the resulting error.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task DisposeAfterCancellationSourceDisposedSwallowsObjectDisposedException()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var cts = new CancellationTokenSource();
-        var taskSignal = Signal.FromTask(_ => gate.Task, Sequencer.Immediate, cts);
-        try
-        {
-            var subscription =
-                taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-
-            // Dispose the cancellation source out from under the subscription, then dispose the
-            // subscription. The disposer wins the gate and calls Cancel on the disposed source,
-            // which must swallow the ObjectDisposedException.
-            cts.Dispose();
-            subscription.Dispose();
-
-            gate.SetResult(SuccessValue);
-            await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors).IsEmpty();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A pending task that faults after subscription forwards the exception via the continuation through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediatePendingTaskFaultForwardsErrorViaContinuation()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => gate.Task, Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
-            gate.SetException(new InvalidOperationException(BreakExecutionMessage));
-            await TestPolling.SpinUntil(() => !errors.IsEmpty, PollTimeout).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>A pending task that completes after subscription emits the result via the continuation through the immediate path.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediatePendingTaskSuccessEmitsResultViaContinuation()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var completed = 0;
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => gate.Task, Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(
-                values.Enqueue,
-                error => errors.Enqueue(error.GetType().Name),
-                () => Interlocked.Increment(ref completed));
-            gate.SetResult(SuccessValue);
-            await TestPolling.SpinUntil(() => Volatile.Read(ref completed) == 1, PollTimeout)
-                .ConfigureAwait(false);
-            await Assert.That(values.SequenceEqual([SuccessValue])).IsTrue();
-            await Assert.That(errors).IsEmpty();
-            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(1);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>Disposing the immediate subscription before the awaited task completes suppresses the terminal notification.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task DisposeBeforeImmediateTaskCompletionSuppressesTerminalNotification()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var completed = 0;
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => gate.Task, Sequencer.Immediate);
-        try
-        {
-            var subscription = taskSignal.Subscribe(
-                values.Enqueue,
-                error => errors.Enqueue(error.GetType().Name),
-                () => Interlocked.Increment(ref completed));
-
-            // Dispose while the awaited task is still pending, then release the continuation.
-            subscription.Dispose();
-            gate.SetResult(SuccessValue);
-
-            // Give the continuation ample time to run; it must observe the dispose and stay silent.
-            await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors).IsEmpty();
-            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(0);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>Disposing the scheduled subscription before the awaited task completes suppresses the terminal notification.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task DisposeBeforeScheduledTaskCompletionSuppressesTerminalNotification()
-    {
-        ConcurrentQueue<int> values = new();
-        ConcurrentQueue<string> errors = new();
-        var completed = 0;
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => gate.Task);
-        try
-        {
-            var subscription = taskSignal.Subscribe(
-                values.Enqueue,
-                error => errors.Enqueue(error.GetType().Name),
-                () => Interlocked.Increment(ref completed));
-
-            // Dispose while the awaited task is still pending, then release the continuation.
-            subscription.Dispose();
-            gate.SetResult(SuccessValue);
-
-            // Give the continuation ample time to run; it must observe the dispose and stay silent.
-            await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(false);
-            await Assert.That(values).IsEmpty();
-            await Assert.That(errors).IsEmpty();
-            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(0);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>The non-generic RxVoid factory honors the scheduler overload and emits a completion.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task RxVoidFactoryWithSchedulerEmitsCompletion()
-    {
-        var completed = 0;
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(RxVoid.Default), Sequencer.Immediate);
-        try
-        {
-            _ = taskSignal.Subscribe(static _ => { }, static error => throw error, () => Interlocked.Increment(ref completed));
-            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(1);
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>The immediate signal reports cancellation and disposal state and fires the cancellation callback once disposed.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateSignalReportsStateAndFiresCancellationCallbackOnDispose()
-    {
-        TaskCompletionSource<int> gate = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => gate.Task, Sequencer.Immediate);
-        var canceledRaised = 0;
-        await Assert.That(taskSignal.IsCancellationRequested).IsFalse();
-        await Assert.That(taskSignal.IsDisposed).IsFalse();
-        taskSignal.GetOperationCanceled(Witness.Create<Exception>(_ => Interlocked.Increment(ref canceledRaised)));
-
-        ((IDisposable)taskSignal).Dispose();
-
-        await Assert.That(taskSignal.IsDisposed).IsTrue();
-        await Assert.That(taskSignal.IsCancellationRequested).IsTrue();
-        await TestPolling.SpinUntil(() => Volatile.Read(ref canceledRaised) == 1, PollTimeout)
-            .ConfigureAwait(false);
-        await Assert.That(Volatile.Read(ref canceledRaised)).IsEqualTo(1);
-
-        // A second dispose is a no-op (covers the already-disposed early return).
-        ((IDisposable)taskSignal).Dispose();
-        await Assert.That(taskSignal.IsDisposed).IsTrue();
-    }
-
-    /// <summary>Subscribing to a disposed immediate signal throws.</summary>
-    [Test]
-    public void ImmediateSignalSubscribeAfterDisposeThrows()
-    {
-        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.Immediate);
-        ((IDisposable)taskSignal).Dispose();
-        _ = Assert.Throws<ObjectDisposedException>(() => taskSignal.Subscribe(static _ => { }));
-    }
-
-    /// <summary>
-    /// Signals from task handles user exceptions. The command body is released by a gate rather than a timer, so the
-    /// subscription is only torn down once the failure has already travelled the whole chain; a dispose that lands
-    /// after the terminal must leave the cancellation path untouched.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTaskHandlesUserExceptions()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource executionStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource releaseExecution = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = executionStarted.TrySetResult();
-            await releaseExecution.Task.WaitAsync(cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            throw new InvalidOperationException(BreakExecutionMessage);
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        var subscription = fixture.Subscribe(_ => result = true);
-        await executionStarted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        _ = releaseExecution.TrySetResult();
-        await finallyCompleted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        subscription.Dispose();
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ExceptionShouldBeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task handles cancellation.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTaskHandlesCancellation()
-    {
-        StatusTrail statusTrail = new();
-        var position = 0;
-        var fixture = Signal.FromTask(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            await Task.Delay(CommandDelayMilliseconds, cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() => RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere));
-        var result = false;
-        var subscription = fixture.Subscribe(_ => result = true);
-        await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(true);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        subscription.Dispose();
-        await Task.Delay(CancellationWaitDelayMilliseconds).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task handles token cancellation.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTaskHandlesTokenCancellation()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource<CancellationTokenSource> cancellationReady =
-            new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource cleanupCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = cancellationReady.TrySetResult(cts);
-            await Task.Delay(Timeout.InfiniteTimeSpan, cts.Token).HandleCancellation(() =>
-            {
-                RecordCancellationCleanup(statusTrail, ref position);
-                _ = cleanupCompleted.TrySetResult();
-            }).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        using var subscription = fixture.Subscribe(_ => result = true);
-        var cancellationSource = await cancellationReady.Task.ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        await cancellationSource.CancelAsync().ConfigureAwait(false);
-        await WaitForCancellationCallbacks(cleanupCompleted.Task, finallyCompleted.Task).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task handles cancellation in base.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTaskHandlesCancellationInBase()
-    {
-        StatusTrail statusTrail = new();
-        var position = 0;
-        var fixture = Signal.FromTask(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            await Task.Delay(CommandDelayMilliseconds, cts.Token).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() => RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere));
-        var subscription = fixture.Subscribe();
-        await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(true);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        subscription.Dispose();
-        await Task.Delay(CancellationWaitDelayMilliseconds).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(statusTrail.LastMessage).IsEqualTo(ShouldAlwaysComeHere);
-    }
-
-    /// <summary>
-    /// Signals from task handles completion. The command body is released by a gate rather than a timer, so the
-    /// assertions run once the terminal cleanup has actually happened instead of once a wall-clock window is judged
-    /// long enough for it.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTaskHandlesCompletion()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource executionStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource releaseExecution = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = executionStarted.TrySetResult();
-            await releaseExecution.Task.WaitAsync(cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        using var subscription = fixture.Subscribe(_ => result = true);
-        await executionStarted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        _ = releaseExecution.TrySetResult();
-        await finallyCompleted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCommandNormally);
-        await Assert.That(statusTrail.LastMessage).IsEqualTo(ShouldAlwaysComeHere);
-        await Assert.That(result).IsTrue();
-    }
-
-    /// <summary>Signals from task t handles user exceptions.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTask_T_HandlesUserExceptions()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource executionStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource releaseExecution = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask<RxVoid>(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = executionStarted.TrySetResult();
-            await releaseExecution.Task.WaitAsync(cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            throw new InvalidOperationException(BreakExecutionMessage);
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        using var subscription = fixture.Subscribe(_ => result = true);
-        await executionStarted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        _ = releaseExecution.TrySetResult();
-        await finallyCompleted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ExceptionShouldBeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task t handles cancellation.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTask_T_HandlesCancellation()
-    {
-        StatusTrail statusTrail = new();
-        var position = 0;
-        var fixture = Signal.FromTask<RxVoid>(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            await Task.Delay(CommandDelayMilliseconds, cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() => RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere));
-        var result = false;
-        var subscription = fixture.Subscribe(_ => result = true);
-        await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(true);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        subscription.Dispose();
-        await Task.Delay(CancellationWaitDelayMilliseconds).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task t handles token cancellation.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTask_T_HandlesTokenCancellation()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource<CancellationTokenSource> cancellationReady =
-            new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource cleanupCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask<RxVoid>(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = cancellationReady.TrySetResult(cts);
-            await Task.Delay(Timeout.InfiniteTimeSpan, cts.Token).HandleCancellation(() =>
-            {
-                RecordCancellationCleanup(statusTrail, ref position);
-                _ = cleanupCompleted.TrySetResult();
-            }).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        using var subscription = fixture.Subscribe(_ => result = true);
-        var cancellationSource = await cancellationReady.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        await cancellationSource.CancelAsync().ConfigureAwait(false);
-        await WaitForCancellationCallbacks(cleanupCompleted.Task, finallyCompleted.Task).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(ShouldAlwaysComeHere);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(result).IsFalse();
-    }
-
-    /// <summary>Signals from task t handles cancellation in base.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTask_T_HandlesCancellationInBase()
-    {
-        StatusTrail statusTrail = new();
-        var position = 0;
-        var fixture = Signal.FromTask<RxVoid>(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            await Task.Delay(CommandDelayMilliseconds, cts.Token).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() => RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere));
-        var subscription = fixture.Subscribe();
-        await Task.Delay(InitialDelayMilliseconds).ConfigureAwait(true);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        subscription.Dispose();
-        await Task.Delay(CancellationWaitDelayMilliseconds).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCommandNormally);
-        await Assert.That(statusTrail.LastMessage).IsEqualTo(ShouldAlwaysComeHere);
-    }
-
-    /// <summary>
-    /// Signals from task t handles completion. Like its non-generic counterpart the command body is released by a
-    /// gate rather than a timer, so the assertions run once the terminal cleanup has actually happened.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task SignalFromTask_T_HandlesCompletion()
-    {
-        StatusTrail statusTrail = new();
-        TaskCompletionSource executionStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource releaseExecution = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        TaskCompletionSource finallyCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var position = 0;
-        var fixture = Signal.FromTask<RxVoid>(async cts =>
-        {
-            RecordStatus(statusTrail, ref position, StartedCommand);
-            _ = executionStarted.TrySetResult();
-            await releaseExecution.Task.WaitAsync(cts.Token)
-                .HandleCancellation(() => RecordCancellationCleanup(statusTrail, ref position)).ConfigureAwait(true);
-            if (!cts.IsCancellationRequested)
-            {
-                RecordStatus(statusTrail, ref position, FinishedCommandNormally);
-            }
-
-            return RxVoid.Default;
-        }).Recover<RxVoid, Exception>(ex =>
-        {
-            RecordStatus(statusTrail, ref position, ExceptionShouldBeHere);
-            return Signal.Fail<RxVoid>(ex);
-        }).OnCleanup(() =>
-        {
-            RecordStatus(statusTrail, ref position, ShouldAlwaysComeHere);
-            _ = finallyCompleted.TrySetResult();
-        });
-        var result = false;
-        using var subscription = fixture.Subscribe(_ => result = true);
-        await executionStarted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).Contains(StartedCommand);
-        _ = releaseExecution.TrySetResult();
-        await finallyCompleted.Task.WaitAsync(PollTimeout).ConfigureAwait(false);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(StartingCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).DoesNotContain(FinishedCancellingCommand);
-        await Assert.That(StatusMessages(statusTrail)).Contains(FinishedCommandNormally);
-        await Assert.That(statusTrail.LastMessage).IsEqualTo(ShouldAlwaysComeHere);
-        await Assert.That(result).IsTrue();
-    }
-
-    /// <summary>
-    /// Verifies the immediate task signal exposes itself as its own source and owns a cancellation source, and
-    /// that a task whose token was cancelled before it produced its result errors instead of emitting it.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
-    [Test]
-    public async Task ImmediateTaskSignalErrorsWhenTheTokenIsCancelledBeforeTheResultArrives()
-    {
-        TaskCompletionSource<int> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var taskSignal = Signal.FromTask(_ => completion.Task, Sequencer.Immediate);
-        try
-        {
-            await Assert.That(taskSignal.CancellationTokenSource).IsNotNull();
-            await Assert.That(ReferenceEquals(taskSignal.Source, taskSignal)).IsTrue();
-            ConcurrentQueue<int> values = new();
-            ConcurrentQueue<Exception> errors = new();
-            _ = taskSignal.Subscribe(values.Enqueue, errors.Enqueue, static () => { });
-            await taskSignal.CancellationTokenSource!.CancelAsync();
-            completion.SetResult(SuccessValue);
-            await TestPolling.SpinUntil(() => !errors.IsEmpty, PollTimeout).ConfigureAwait(false);
-            await Assert.That(errors.Count).IsEqualTo(1);
-            _ = errors.TryPeek(out var error);
-            await Assert.That(error!).IsTypeOf<OperationCanceledException>();
-            await Assert.That(values).IsEmpty();
-        }
-        finally
-        {
-            (taskSignal as IDisposable)?.Dispose();
-        }
-    }
-
-    /// <summary>
-    /// Verifies a task that faults after its subscription was disposed notifies nobody. The task continuation still
-    /// runs, and it must find the subscription already stopped rather than push a terminal at an observer that has
-    /// unsubscribed.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous operation.</returns>
-    [Test]
-    public async Task FromTaskDropsAFaultRaisedAfterTheSubscriptionWasDisposed()
-    {
-        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        RecordingObserver observer = new();
-
-        var subscription = Signal.FromTask(pending.Task).Subscribe(observer);
-        subscription.Dispose();
-
-        pending.SetException(new InvalidOperationException(ObserverFailureMessage));
-
-        // The continuation runs on the thread pool; give it room to reach the stopped subscription.
-        await Task.Delay(PollTimeout);
-
-        await Assert.That(observer.ErrorCount).IsEqualTo(0);
-        await Assert.That(observer.NextCount).IsEqualTo(0);
-        await Assert.That(observer.CompletedCount).IsEqualTo(0);
-    }
-
-    /// <summary>
-    /// Verifies an observer that throws out of its own <see cref = "IObserver{T}.OnNext"/> does not get a second
-    /// terminal. The task's terminal was already claimed before the value was pushed, so the observer's failure is
-    /// swallowed rather than turned into an <see cref = "IObserver{T}.OnError"/> the observer never expected.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous operation.</returns>
-    [Test]
-    public async Task FromAsyncSwallowsAFailureTheObserverRaisedFromOnNext()
-    {
-        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        ThrowingObserver observer = new(new InvalidOperationException(ObserverFailureMessage));
-
-        using var subscription = Signal.FromAsync(_ => pending.Task).Subscribe(observer);
-        pending.SetResult(SuccessValue);
-
-        await Assert.That(observer.Observed.Task.WaitAsync(PollTimeout)).ThrowsNothing();
-        await Task.Delay(PollTimeout);
-
-        await Assert.That(observer.NextCount).IsEqualTo(1);
-        await Assert.That(observer.ErrorCount).IsEqualTo(0);
-        await Assert.That(observer.CompletedCount).IsEqualTo(0);
-    }
-
-    /// <summary>
-    /// Verifies an observer that disposes its own subscription and then throws is met with silence. Disposal owns that
-    /// cancellation path, so the failure must not be reported back down a subscription the observer has just torn down.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous operation.</returns>
-    [Test]
-    public async Task FromAsyncStaysSilentWhenTheObserverDisposesItselfAndThenThrows()
-    {
-        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        SelfDisposingThrowingObserver observer = new(new InvalidOperationException(ObserverFailureMessage));
-
-        observer.Subscription = Signal.FromAsync(_ => pending.Task).Subscribe(observer);
-        pending.SetResult(SuccessValue);
-
-        await Assert.That(observer.Observed.Task.WaitAsync(PollTimeout)).ThrowsNothing();
-        await Task.Delay(PollTimeout);
-
-        await Assert.That(observer.NextCount).IsEqualTo(1);
-        await Assert.That(observer.ErrorCount).IsEqualTo(0);
-        await Assert.That(observer.CompletedCount).IsEqualTo(0);
-    }
-
-    /// <summary>
-    /// Verifies the external-cancellation overload still runs the factory when the caller passes a token that can never
-    /// be cancelled. There is nothing to register against, so the subscription must start rather than register a
-    /// callback on a token that will never fire.
-    /// </summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous operation.</returns>
-    [Test]
-    public async Task FromAsyncWithAnUncancellableTokenStillRunsTheFactory()
-    {
-        RecordingObserver observer = new();
-
-        using var subscription = Signal
-            .FromAsync(static _ => Task.FromResult(SuccessValue), CancellationToken.None)
-            .Subscribe(observer);
-
-        await Assert.That(observer.NextCount).IsEqualTo(1);
-        await Assert.That(observer.LastValue).IsEqualTo(SuccessValue);
-        await Assert.That(observer.CompletedCount).IsEqualTo(1);
-        await Assert.That(observer.ErrorCount).IsEqualTo(0);
-    }
-
-    /// <summary>Gets the recorded status messages.</summary>
-    /// <param name = "statusTrail">The status trail.</param>
-    /// <returns>The recorded messages.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string[] StatusMessages(StatusTrail statusTrail) => statusTrail.Messages();
-
-    /// <summary>Awaits both timer-driven cancellation callbacks, or fails once the generous window closes.</summary>
-    /// <param name = "cleanupCompleted">Completes when the cancellation cleanup callback has run.</param>
-    /// <param name = "finallyCompleted">Completes when the terminal cleanup callback has run.</param>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous operation.</returns>
-    /// <exception cref = "TimeoutException">Neither callback had run once the generous wait window closed.</exception>
-    /// <remarks>
-    /// The callbacks are driven by timers and run on pool threads, so the wait must stay asynchronous: blocking a pool
-    /// thread would starve the very chain it is waiting on. It also must not decide the outcome from which continuation
-    /// the pool dequeues first — <c>Task.WhenAny</c> reports whichever continuation ran first, not whichever task
-    /// completed first, so on a saturated runner the timeout can be reported as the winner even though the callbacks
-    /// already fired. This awaits the race for liveness but then decides from the callback tasks' own completion state,
-    /// which <see cref = "TaskCompletionSource.TrySetResult"/> flips synchronously and no pool pressure can misreport.
-    /// A cancellation that never fires the callbacks never completes, so the generous window still fails on a real hang.
-    /// </remarks>
-    private static async Task WaitForCancellationCallbacks(Task cleanupCompleted, Task finallyCompleted)
-    {
-        var callbacks = Task.WhenAll(cleanupCompleted, finallyCompleted);
-        _ = await Task.WhenAny(callbacks, Task.Delay(CancellationCallbackTimeoutMilliseconds)).ConfigureAwait(false);
-        if (!cleanupCompleted.IsCompleted || !finallyCompleted.IsCompleted)
-        {
-            throw new TimeoutException(
-                $"Timed out after {CancellationCallbackTimeoutMilliseconds}ms waiting for cancellation callbacks.");
-        }
-
-        await callbacks.ConfigureAwait(false);
-    }
-
-    /// <summary>Records a status message.</summary>
-    /// <param name = "statusTrail">The status trail.</param>
-    /// <param name = "position">The current status position.</param>
-    /// <param name = "message">The message to record.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void RecordStatus(StatusTrail statusTrail, ref int position, string message) =>
-        statusTrail.Add(ref position, message);
-
-    /// <summary>Records synchronous cancellation cleanup.</summary>
-    /// <param name = "statusTrail">The status trail.</param>
-    /// <param name = "position">The current status position.</param>
-    private static void RecordCancellationCleanup(StatusTrail statusTrail, ref int position)
-    {
-        RecordStatus(statusTrail, ref position, StartingCancellingCommand);
-        Thread.Sleep(CleanupWorkMilliseconds);
-        RecordStatus(statusTrail, ref position, FinishedCancellingCommand);
-    }
-
-    /// <summary>Observer that counts the notifications it received.</summary>
-    private class RecordingObserver : IObserver<int>
-    {
-        /// <summary>Gets the number of values received.</summary>
-        public int NextCount { get; private set; }
-
-        /// <summary>Gets the number of failures received.</summary>
-        public int ErrorCount { get; private set; }
-
-        /// <summary>Gets the number of completions received.</summary>
-        public int CompletedCount { get; private set; }
-
-        /// <summary>Gets the most recently received value.</summary>
-        public int LastValue { get; private set; }
-
-        /// <inheritdoc/>
-        public virtual void OnNext(int value)
-        {
-            NextCount++;
-            LastValue = value;
-        }
-
-        /// <inheritdoc/>
-        public void OnError(Exception error) => ErrorCount++;
-
-        /// <inheritdoc/>
-        public void OnCompleted() => CompletedCount++;
-    }
-
-    /// <summary>Observer that throws out of <see cref = "IObserver{T}.OnNext"/> after recording the value.</summary>
-    /// <param name = "failure">The failure the observer raises.</param>
-    private class ThrowingObserver(Exception failure) : RecordingObserver
-    {
-        /// <summary>The failure raised from the value notification.</summary>
-        private readonly Exception _failure = failure;
-
-        /// <summary>Gets a task that completes once the observer has seen its value.</summary>
-        public TaskCompletionSource Observed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        /// <inheritdoc/>
-        public override void OnNext(int value)
-        {
-            base.OnNext(value);
-            _ = Observed.TrySetResult();
-            throw _failure;
-        }
-    }
-
-    /// <summary>Observer that tears its own subscription down before it throws.</summary>
-    /// <param name = "failure">The failure the observer raises.</param>
-    private sealed class SelfDisposingThrowingObserver(Exception failure) : ThrowingObserver(failure)
-    {
-        /// <summary>Gets or sets the subscription the observer disposes from inside its value notification.</summary>
-        public IDisposable? Subscription { get; set; }
-
-        /// <inheritdoc/>
-        public override void OnNext(int value)
-        {
-            Subscription?.Dispose();
-            base.OnNext(value);
-        }
-    }
-
-    /// <summary>Thread-safe status trail used by async cancellation tests.</summary>
-    private sealed class StatusTrail
-    {
-        /// <summary>Synchronizes access to the recorded statuses.</summary>
-        private readonly Lock _gate = new();
-
-        /// <summary>Stores the recorded status positions and messages.</summary>
-        private readonly List<(int Position, string Message)> _items = [];
-
-        /// <summary>Gets the last recorded status message.</summary>
-        public string LastMessage
-        {
-            get
-            {
-                lock (_gate)
-                {
-                    return _items[^1].Message;
-                }
-            }
-        }
-
-        /// <summary>Adds a status message.</summary>
-        /// <param name = "position">The current status position.</param>
-        /// <param name = "message">The message.</param>
-        public void Add(ref int position, string message)
-        {
-            lock (_gate)
-            {
-                _items.Add((position, message));
-                position++;
-            }
-        }
-
-        /// <summary>Creates a snapshot of the recorded messages.</summary>
-        /// <returns>The message snapshot.</returns>
-        public string[] Messages()
-        {
-            lock (_gate)
-            {
-                var messages = new string[_items.Count];
-                for (var i = 0; i < messages.Length; i++)
-                {
-                    messages[i] = _items[i].Message;
-                }
-
-                return messages;
-            }
-        }
-    }
-}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
index bbf58491..0819b57c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
@@ -19,12 +19,7 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The late terminal error message.</summary>
     private const string LateErrorMessage = "late";
 
-    /// <summary>
-    /// Map and Keep are pass-through wrappers: neither adds a thread affinity of its own, so each must report
-    /// exactly the current-thread requirement of the source it wraps. Reporting <see langword="true"/> for a
-    /// free-threaded source would needlessly pin subscription; reporting <see langword="false"/> for a pinned
-    /// one would subscribe on the wrong thread.
-    /// </summary>
+    /// <summary>Map and Keep preserve their source's current-thread subscription requirement.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task MapAndKeepSignalsInheritTheCurrentThreadRequirementOfTheirSource()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
index d52ee57b..a51573d0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
@@ -10,7 +10,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Completes branch and contract coverage for primitive signal operators and aliases.</summary>
+/// <summary>Tests signal operators and their aliases.</summary>
 public partial class SignalOperatorMixinsTests
 {
     /// <summary>The integer constant eight.</summary>
@@ -25,7 +25,7 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The integer constant twenty-one.</summary>
     private const int TwentyOne = 21;
 
-    /// <summary>The integer constant forty-two used by behavior coverage.</summary>
+    /// <summary>The integer constant forty-two.</summary>
     private const int BehaviorFortyTwo = 42;
 
     /// <summary>Expected operator values.</summary>
@@ -100,7 +100,7 @@ public partial class SignalOperatorMixinsTests
     /// <summary>Expected timestamp values.</summary>
     private static readonly int[] ExpectedTimestampValues = [Eight, Nine];
 
-    /// <summary>Validates null guard coverage across public factories, operators, and observers.</summary>
+    /// <summary>Factories, operators, and observers reject null arguments.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task NullGuardsCoverPublicFactoryOperatorAndObserverContracts()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
index 19125952..76e58c6a 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
@@ -2,9 +2,7 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
-using System.Threading;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Signals;
 
@@ -13,12 +11,6 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies delayed signal operator behavior.</summary>
 public partial class SignalOperatorMixinsTests
 {
-    /// <summary>Observation window used to verify disposal waits for in-flight delivery.</summary>
-    private const int DisposeObservationMilliseconds = 200;
-
-    /// <summary>Generous bound for the in-flight delivery to begin, tolerant of a saturated thread pool.</summary>
-    private const int InflightDeliveryTimeoutSeconds = 30;
-
     /// <summary>Verifies shift uses one ordered drain for a burst of delayed notifications.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -47,11 +39,7 @@ public async Task ShiftUsesSingleSerializedDrainForQueuedNotifications()
         await Assert.That(sequencer.ScheduledCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies the drain timer a tick reschedules for itself survives the scheduling call that ran that tick.
-    /// A sequencer may run the drain before <c>Schedule</c> returns; the tick then finds the queued value is not
-    /// due yet and arms the next drain, and that successor must not be cancelled when the outer call returns.
-    /// </summary>
+    /// <summary>An inline drain retains the successor it schedules before the initial scheduling call returns.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ShiftRetainsTheDrainTimerArmedByAnInlineTick()
@@ -74,63 +62,35 @@ public async Task ShiftRetainsTheDrainTimerArmedByAnInlineTick()
     /// <summary>Verifies that dispose waits for in-flight delivery and blocks queued notifications.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task ShiftDisposeWaitsForInflightDeliveryAndDisallowsFurtherDelivery()
-    {
-        var dueTime = TimeSpan.FromMilliseconds(One);
-
-        // Drain on dedicated threads so a saturated thread pool cannot stall the
-        // blocking in-flight delivery this test relies on; only the brief timer
-        // callback stays on the pool.
-        TaskPoolSequencer sequencer = new(new(
-            CancellationToken.None,
-            TaskCreationOptions.LongRunning,
-            TaskContinuationOptions.None,
-            TaskScheduler.Default));
+    public async Task ShiftDisposalClaimDuringDeliverySuppressesQueuedNotifications()
+{
+        var dueTime = TimeSpan.FromTicks(One);
+        RecordingSequencer sequencer = new(DateTimeOffset.UnixEpoch);
         Signal<int> source = new();
-        using ManualResetEventSlim onNextEntered = new(false);
-        using ManualResetEventSlim onNextRelease = new(false);
-        ConcurrentQueue<int> values = [];
+        List<int> values = [];
         var completed = 0;
-        var delivered = 0;
-
-        using var subscription = source
-            .Shift(dueTime, sequencer)
-            .Subscribe(
-                value =>
-                {
-                    if (Interlocked.Increment(ref delivered) == 1)
-                    {
-                        onNextEntered.Set();
-                    }
-
-                    onNextRelease.Wait();
-                    values.Enqueue(value);
-                },
-                static _ => { },
-                () => Interlocked.Increment(ref completed));
-
+        var claimed = false;
+        LinqExtensions.ShiftCoordinator<int>? coordinator = null;
+        var observer = new DelegateWitness<int>(
+            value =>
+        {
+            values.Add(value);
+            claimed = coordinator!.TryBeginDispose();
+        },
+            static _ => { },
+            () => completed++);
+        coordinator = new(source, dueTime, sequencer, observer);
+        using var subscription = coordinator.Run();
         source.OnNext(One);
         source.OnNext(Two);
         source.OnCompleted();
-
-        await Assert.That(onNextEntered.Wait(TimeSpan.FromSeconds(InflightDeliveryTimeoutSeconds))).IsTrue();
-
-        var disposeTask = Task.Factory.StartNew(
-            subscription.Dispose,
-            CancellationToken.None,
-            TaskCreationOptions.LongRunning,
-            TaskScheduler.Default);
-        var disposeObservation = Task.Delay(TimeSpan.FromMilliseconds(DisposeObservationMilliseconds));
-        var disposeCompleted = await Task.WhenAny(disposeTask, disposeObservation) == disposeTask;
-
-        await Assert.That(disposeCompleted).IsFalse();
-
-        onNextRelease.Set();
-        await disposeTask;
-
-        await Assert.That(values.ToArray().SequenceEqual([One])).IsTrue();
-
-        await Assert.That(Volatile.Read(ref completed)).IsEqualTo(0);
+        sequencer.AdvanceBy(dueTime);
+        sequencer.RunNext();
+        coordinator.ReleaseSubscriptions();
+        await Assert.That(claimed).IsTrue();
+        await Assert.That(coordinator.TryBeginDispose()).IsFalse();
+        await Assert.That(values.SequenceEqual([One])).IsTrue();
+        await Assert.That(completed).IsEqualTo(0);
     }
 
     /// <summary>Verifies a delayed error is forwarded after the queued values that precede it.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
index c523fbfd..48005413 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
@@ -6,13 +6,12 @@
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
-using ReactiveUI.Primitives.Core;
 using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.Signals;
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Verifies deterministic operator, factory, coordinator, and timing branch coverage.</summary>
+/// <summary>Tests operator and coordinator notification ordering.</summary>
 public partial class SignalOperatorMixinsTests
 {
     /// <summary>The integer constant ten.</summary>
@@ -36,18 +35,12 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The integer constant thirty-two.</summary>
     private const int ThirtyTwo = 32;
 
-    /// <summary>Iterations used to stress the work item invoke/dispose race.</summary>
-    private const int RaceIterations = 256;
-
     /// <summary>The long constant two.</summary>
     private const long TwoLong = 2L;
 
     /// <summary>The long constant three.</summary>
     private const long ThreeLong = 3L;
 
-    /// <summary>The number of threads that rendezvous before the disposal race starts.</summary>
-    private const int RacingThreadCount = 2;
-
     /// <summary>A fixed deterministic timestamp used in place of the current time.</summary>
     private static readonly DateTimeOffset FixedTimestamp = new(2024, 1, 1, 0, 0, 0, TimeSpan.Zero);
 
@@ -473,7 +466,7 @@ private static async Task VerifyAsyncEnumerableShiftAndExpireAsync()
             asyncValues.Add,
             ex => asyncCompleted.TrySetException(ex),
             () => asyncCompleted.TrySetResult(null));
-        await asyncCompleted.Task.WaitAsync(TimeSpan.FromSeconds(Five)).ConfigureAwait(false);
+        await asyncCompleted.Task.ConfigureAwait(false);
         int[] expectedAsyncValues = [0, One, Two];
         await Assert.That(asyncValues.SequenceEqual(expectedAsyncValues)).IsTrue();
         var exact = await Signal.FromAsyncEnumerable(AsyncValues(Sixteen)).CollectArrayAsync().ConfigureAwait(false);
@@ -690,10 +683,7 @@ private static async Task VerifySwitchDefersCompletionUntilTheCurrentInnerFinish
         await Assert.That(staleCompleted.Completed).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// Verifies an inner error makes the coordinator terminal even though the outer source is still live, so a
-    /// later switch, a later outer error, and a later outer completion are all gated.
-    /// </summary>
+    /// <summary>Checks that an inner error suppresses later outer values and terminal notifications.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifySwitchGatesEveryNotificationAfterAnInnerError()
     {
@@ -837,303 +827,6 @@ private static async Task VerifyCalmAppendAndForkJoinBranches()
         await Assert.That(forkRightFirst.Completed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the timestamp operator immediate and clock-backed branches.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task VerifyTimestampBranches()
-    {
-        RecordingWitness<Moment<int>> immediateMoments = new();
-        Signal.Sequence(One, Three).Timestamp(Sequencer.Immediate).Subscribe(immediateMoments).Dispose();
-        IEnumerable<int> expectedImmediateMoments = [One, Two, Three];
-        int[] immediateMomentValues =
-            [immediateMoments.Values[0].Value, immediateMoments.Values[1].Value, immediateMoments.Values[Two].Value];
-        await Assert.That(immediateMomentValues.SequenceEqual(expectedImmediateMoments)).IsTrue();
-        await Assert.That(immediateMoments.Completed).IsEqualTo(1);
-        List<Moment<int>> clockMoments = [];
-        var clockMomentCompleted = 0;
-        _ = Signal.Sequence(Four, Two).Timestamp(new VirtualClock(DateTimeOffset.UnixEpoch))
-            .Subscribe(clockMoments.Add, static ex => throw ex, () => clockMomentCompleted++);
-        IEnumerable<int> expectedClockMoments = [Four, Five];
-        int[] clockMomentValues = [clockMoments[0].Value, clockMoments[1].Value];
-        await Assert.That(clockMomentValues.SequenceEqual(expectedClockMoments)).IsTrue();
-        await Assert.That(clockMomentCompleted).IsEqualTo(1);
-        List<Moment<int>> immediateMomentActions = [];
-        var immediateMomentCompleted = 0;
-        var immediateTimestampSignal =
-            (IInlineSignal<Moment<int>>)Signal.Sequence(Two, Two).Timestamp(Sequencer.Immediate);
-        immediateTimestampSignal.Subscribe(immediateMomentActions.Add, static ex => throw ex, () => immediateMomentCompleted++)
-            .Dispose();
-        IEnumerable<int> expectedImmediateMomentActions = [Two, Three];
-        int[] immediateMomentActionValues = [immediateMomentActions[0].Value, immediateMomentActions[1].Value];
-        await Assert.That(immediateMomentActionValues.SequenceEqual(expectedImmediateMomentActions)).IsTrue();
-        await Assert.That(immediateMomentCompleted).IsEqualTo(1);
-        RecordingWitness<Moment<int>> clockMomentObserver = new();
-        var clockTimestampSignal =
-            (IInlineSignal<Moment<int>>)Signal.Sequence(Two, Two).Timestamp(new VirtualClock(DateTimeOffset.UnixEpoch));
-        clockTimestampSignal.Subscribe(clockMomentObserver).Dispose();
-        IEnumerable<int> expectedClockMomentObserver = [Two, Three];
-        int[] clockMomentObserverValues = [clockMomentObserver.Values[0].Value, clockMomentObserver.Values[1].Value];
-        await Assert.That(clockMomentObserverValues.SequenceEqual(expectedClockMomentObserver)).IsTrue();
-        await Assert.That(clockMomentObserver.Completed).IsEqualTo(1);
-        _ = Assert.Throws<ArgumentNullException>(() =>
-            immediateTimestampSignal.Subscribe((IObserver<Moment<int>>)null!));
-        _ = Assert.Throws<ArgumentNullException>(() =>
-            immediateTimestampSignal.Subscribe((Action<Moment<int>>)null!, static _ => { }, static () => { }));
-    }
-
-    /// <summary>Verifies the time-interval operator immediate and clock-backed branches.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task VerifyTimeIntervalBranches()
-    {
-        RecordingWitness<TimeInterval<int>> immediateIntervals = new();
-        Signal.Sequence(One, Three).TimeInterval(Sequencer.Immediate).Subscribe(immediateIntervals).Dispose();
-        IEnumerable<int> expectedImmediateIntervals = [One, Two, Three];
-        int[] immediateIntervalValues =
-        [
-            immediateIntervals.Values[0].Value, immediateIntervals.Values[1].Value, immediateIntervals.Values[Two].Value
-        ];
-        await Assert.That(immediateIntervalValues.SequenceEqual(expectedImmediateIntervals)).IsTrue();
-        await Assert.That(immediateIntervals.Values[0].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(immediateIntervals.Values[1].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(immediateIntervals.Values[Two].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(immediateIntervals.Completed).IsEqualTo(1);
-        List<TimeInterval<int>> clockIntervals = [];
-        var clockIntervalCompleted = 0;
-        _ = Signal.Sequence(Four, Three).TimeInterval(new VirtualClock(DateTimeOffset.UnixEpoch))
-            .Subscribe(clockIntervals.Add, static ex => throw ex, () => clockIntervalCompleted++);
-        IEnumerable<int> expectedClockIntervals = [Four, Five, Six];
-        int[] clockIntervalValues = [clockIntervals[0].Value, clockIntervals[1].Value, clockIntervals[Two].Value];
-        await Assert.That(clockIntervalValues.SequenceEqual(expectedClockIntervals)).IsTrue();
-        await Assert.That(clockIntervals[0].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervals[1].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervals[Two].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervalCompleted).IsEqualTo(1);
-        List<TimeInterval<int>> immediateIntervalActions = [];
-        var immediateIntervalCompleted = 0;
-        var immediateIntervalSignal =
-            (IInlineSignal<TimeInterval<int>>)Signal.Sequence(Two, Two).TimeInterval(Sequencer.Immediate);
-        immediateIntervalSignal
-            .Subscribe(immediateIntervalActions.Add, static ex => throw ex, () => immediateIntervalCompleted++)
-            .Dispose();
-        IEnumerable<int> expectedImmediateIntervalActions = [Two, Three];
-        int[] immediateIntervalActionValues = [immediateIntervalActions[0].Value, immediateIntervalActions[1].Value];
-        await Assert.That(immediateIntervalActionValues.SequenceEqual(expectedImmediateIntervalActions)).IsTrue();
-        await Assert.That(immediateIntervalCompleted).IsEqualTo(1);
-        RecordingWitness<TimeInterval<int>> clockIntervalObserver = new();
-        var clockIntervalSignal =
-            (IInlineSignal<TimeInterval<int>>)Signal.Sequence(Two, Three)
-                .TimeInterval(new VirtualClock(DateTimeOffset.UnixEpoch));
-        clockIntervalSignal.Subscribe(clockIntervalObserver).Dispose();
-        IEnumerable<int> expectedClockIntervalObserver = [Two, Three, Four];
-        int[] clockIntervalObserverValues =
-        [
-            clockIntervalObserver.Values[0].Value, clockIntervalObserver.Values[1].Value,
-            clockIntervalObserver.Values[Two].Value
-        ];
-        await Assert.That(clockIntervalObserverValues.SequenceEqual(expectedClockIntervalObserver)).IsTrue();
-        await Assert.That(clockIntervalObserver.Values[0].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervalObserver.Values[1].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervalObserver.Values[Two].Interval).IsEqualTo(TimeSpan.Zero);
-        await Assert.That(clockIntervalObserver.Completed).IsEqualTo(1);
-        _ = Assert.Throws<ArgumentNullException>(() =>
-            immediateIntervalSignal.Subscribe((IObserver<TimeInterval<int>>)null!));
-        _ = Assert.Throws<ArgumentNullException>(() =>
-            immediateIntervalSignal.Subscribe((Action<TimeInterval<int>>)null!, static _ => { }, static () => { }));
-    }
-
-    /// <summary>Verifies delay-start signal branches, the sequencer work item, and queue guard clauses.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task VerifyDelayStartAndWorkItemBranches()
-    {
-        RecordingWitness<int> shiftedObserver = new();
-        Signal.Sequence(One, Two).DelayStart(TimeSpan.Zero, Sequencer.Immediate).Subscribe(shiftedObserver).Dispose();
-        int[] expectedShiftedObserver = [One, Two];
-        await Assert.That(shiftedObserver.Values.SequenceEqual(expectedShiftedObserver)).IsTrue();
-        await Assert.That(shiftedObserver.Completed).IsEqualTo(1);
-        List<int> shiftedActions = [];
-        var shiftedActionCompleted = 0;
-        _ = Signal.Sequence(Three, Two).DelayStart(TimeSpan.Zero, Sequencer.Immediate)
-            .Subscribe(shiftedActions.Add, static ex => throw ex, () => shiftedActionCompleted++);
-        int[] expectedShiftedActions = [Three, Four];
-        await Assert.That(shiftedActions.SequenceEqual(expectedShiftedActions)).IsTrue();
-        await Assert.That(shiftedActionCompleted).IsEqualTo(1);
-        var currentThreadShift =
-            (IRequireCurrentThread<int>)Signal.Sequence(One, One).DelayStart(TimeSpan.Zero, Sequencer.CurrentThread);
-        await Assert.That(currentThreadShift.IsRequiredSubscribeOnCurrentThread()).IsTrue();
-        var inlineShift = (IInlineSignal<int>)Signal.Sequence(One, One).DelayStart(TimeSpan.Zero, Sequencer.Immediate);
-        _ = Assert.Throws<ArgumentNullException>(static () => Signal.Sequence(One, One)
-            .DelayStart(TimeSpan.Zero, Sequencer.Immediate)
-            .Subscribe((IObserver<int>)null!));
-        _ = Assert.Throws<ArgumentNullException>(() => inlineShift.Subscribe((Action<int>)null!, static _ => { }, static () => { }));
-        _ = Assert.Throws<ArgumentNullException>(() => inlineShift.Subscribe(static _ => { }, static _ => { }, null!));
-        List<int> helperValues = [];
-        SequencerWorkItem<ISequencer, int> helper = new(Sequencer.Immediate, One, (_, state) =>
-        {
-            helperValues.Add(state);
-            return new ActionDisposable(static () => { });
-        });
-        helper.Invoke();
-        helper.Dispose();
-        helper.Invoke();
-        int[] expectedHelperValues = [One];
-        await Assert.That(helperValues.SequenceEqual(expectedHelperValues)).IsTrue();
-        await VerifySequencerWorkItemDisposalBranches();
-        var unusedScheduled =
-            ScheduledItem.Create(Sequencer.Immediate, "unused", static (_, _) => EmptyDisposable.Instance, One);
-        await Assert.That(new SequencerQueue<int>().Remove(unusedScheduled)).IsFalse();
-        _ = Assert.Throws<ArgumentOutOfRangeException>(CreatePriorityQueueWithInvalidCapacity);
-        PriorityQueue<int> shrink = new(ThirtyTwo);
-        for (var i = 0; i < ThirtyTwo; i++)
-        {
-            shrink.Enqueue(i);
-        }
-
-        for (var i = 0; i < TwentySix; i++)
-        {
-            await Assert.That(shrink.Dequeue()).IsEqualTo(i);
-        }
-    }
-
-    /// <summary>Verifies the sequencer work item disposes the action's disposable across invoke and dispose orderings.</summary>
-    /// <returns>A task representing the asynchronous verification.</returns>
-    private static async Task VerifySequencerWorkItemDisposalBranches()
-    {
-        // Invoke then dispose: the published disposable is released by Dispose exactly once,
-        // and a redundant second Dispose is a no-op.
-        var invokeThenDisposeReleased = 0;
-        SequencerWorkItem<ISequencer, int> invokeThenDispose = new(Sequencer.Immediate, One, (_, _) =>
-            new ActionDisposable(() => Interlocked.Increment(ref invokeThenDisposeReleased)));
-        invokeThenDispose.Invoke();
-        invokeThenDispose.Dispose();
-        invokeThenDispose.Dispose();
-        await Assert.That(invokeThenDisposeReleased).IsEqualTo(1);
-
-        // A null action result is coalesced to an empty disposable and never throws.
-        var nullActionRan = false;
-        SequencerWorkItem<ISequencer, int> nullAction = new(Sequencer.Immediate, One, (_, _) =>
-        {
-            nullActionRan = true;
-            return null!;
-        });
-        nullAction.Invoke();
-        nullAction.Dispose();
-        await Assert.That(nullActionRan).IsTrue();
-
-        await VerifySequencerWorkItemPublishBranches();
-        await VerifySequencerWorkItemDisposeRaceInvariant();
-    }
-
-    /// <summary>Verifies both compare-exchange outcomes of <c>SequencerWorkItem.Publish</c>.</summary>
-    /// <returns>A task representing the asynchronous verification.</returns>
-    private static async Task VerifySequencerWorkItemPublishBranches()
-    {
-        // Publish wins the empty slot: the disposable is stored and left alive for Dispose.
-        var stored = 0;
-        ActionDisposable storedDisposable = new(() => Interlocked.Increment(ref stored));
-        IDisposable? winSlot = null;
-        SequencerWorkItemDisposal.Publish(ref winSlot, storedDisposable);
-        await Assert.That(ReferenceEquals(winSlot, storedDisposable)).IsTrue();
-        await Assert.That(stored).IsEqualTo(0);
-
-        // Publish loses to disposal (slot already claimed): the disposable is released immediately.
-        var loserDisposed = 0;
-        ActionDisposable loser = new(() => Interlocked.Increment(ref loserDisposed));
-        IDisposable? loseSlot = EmptyDisposable.Instance;
-        SequencerWorkItemDisposal.Publish(ref loseSlot, loser);
-        await Assert.That(loserDisposed).IsEqualTo(1);
-        await Assert.That(ReferenceEquals(loseSlot, EmptyDisposable.Instance)).IsTrue();
-    }
-
-    /// <summary>Verifies the action's disposable is released exactly once when invoke and dispose race.</summary>
-    /// <returns>A task representing the asynchronous verification.</returns>
-    private static async Task VerifySequencerWorkItemDisposeRaceInvariant()
-    {
-        for (var iteration = 0; iteration < RaceIterations; iteration++)
-        {
-            var created = 0;
-            var disposed = 0;
-            SequencerWorkItem<ISequencer, int> item = new(Sequencer.Immediate, One, (_, _) =>
-            {
-                _ = Interlocked.Increment(ref created);
-                return new ActionDisposable(() => Interlocked.Increment(ref disposed));
-            });
-
-            using Barrier barrier = new(RacingThreadCount);
-            var invoke = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                item.Invoke();
-            });
-            var dispose = Task.Run(() =>
-            {
-                barrier.SignalAndWait();
-                item.Dispose();
-            });
-            await Task.WhenAll(invoke, dispose);
-
-            // Whenever the action produced a disposable it is released once; otherwise nothing leaks.
-            await Assert.That(disposed).IsEqualTo(created);
-            await Assert.That(created <= 1).IsTrue();
-        }
-    }
-
-    /// <summary>Verifies the thread pool absolute scheduling and scheduled work item disposal branches.</summary>
-    /// <returns>A task representing the asynchronous verification.</returns>
-    private static async Task VerifyThreadPoolWorkItemBranchesAsync()
-    {
-        TaskCompletionSource<int> absoluteRan = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var absolute = ThreadPoolSequencer.Instance.Schedule(Five, FixedTimestamp, (_, state) =>
-        {
-            if (!absoluteRan.TrySetResult(state))
-            {
-                throw new InvalidOperationException("Thread pool completion was already set.");
-            }
-
-            return EmptyDisposable.Instance;
-        });
-        await Assert.That(await absoluteRan.Task.WaitAsync(TimeSpan.FromSeconds(Five)).ConfigureAwait(false))
-            .IsEqualTo(Five);
-        absolute.Dispose();
-        absolute.Dispose();
-        var delayedDisposed = CreateThreadPoolWorkItem(One, static (_, _) => EmptyDisposable.Instance);
-        delayedDisposed.Dispose();
-        QueueThreadPoolWorkItem(delayedDisposed, TimeSpan.FromMilliseconds(Ten));
-        var skipped = false;
-        var skippedItem = CreateThreadPoolWorkItem(Two, (_, _) =>
-        {
-            skipped = true;
-            return EmptyDisposable.Instance;
-        });
-        skippedItem.Dispose();
-        InvokeThreadPoolWorkItem(skippedItem);
-        await Assert.That(skipped).IsFalse();
-        var disposedReturned = 0;
-        object?[] holder = [null];
-        var selfDisposing = CreateThreadPoolWorkItem(holder, (_, state) =>
-        {
-            ((IDisposable)state[0]!).Dispose();
-            return new ActionDisposable(() => disposedReturned++);
-        });
-        holder[0] = selfDisposing;
-        InvokeThreadPoolWorkItem(selfDisposing);
-        await Assert.That(disposedReturned).IsEqualTo(1);
-    }
-
-    /// <summary>Creates a thread pool scheduled work item for the given state and action.</summary>
-    /// <typeparam name="TState">The type of the work item state.</typeparam>
-    /// <param name="state">The state passed to the scheduled action.</param>
-    /// <param name="action">The action invoked when the work item runs.</param>
-    /// <returns>A new scheduled work item.</returns>
-    private static ThreadPoolSequencer.ScheduledWorkItem<TState> CreateThreadPoolWorkItem<TState>(
-        TState state,
-        Func<ISequencer, TState, IDisposable> action) => new(ThreadPoolSequencer.Instance, state, action);
-
-    /// <summary>Creates a priority queue with an invalid capacity.</summary>
-    private static void CreatePriorityQueueWithInvalidCapacity()
-    {
-        PriorityQueue<int> invalid = new(-1);
-        GC.KeepAlive(invalid);
-    }
-
     /// <summary>Executes the supplied thread pool scheduled work item.</summary>
     /// <typeparam name="TState">The type of the work item state.</typeparam>
     /// <param name="item">The work item to execute.</param>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
index ed4269cf..a7d3f97d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
@@ -7,15 +7,10 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the operator coordinators hold the Rx grammar even when a source breaks it: a notification that
-/// arrives after the sequence has terminated, or after the subscription was disposed, is dropped rather than
-/// forwarded. Sources here are scripted so that disposing the subscription does not unhook them, which is what
-/// lets the test deliver the illegal notifications the guards exist for.
-/// </summary>
+/// <summary>Tests that operator coordinators drop notifications after termination or disposal.</summary>
 public partial class SignalOperatorMixinsTests
 {
-    /// <summary>The quiet period used by the timer-driven guard tests.</summary>
+    /// <summary>The virtual quiet period used by guard tests.</summary>
     private static readonly TimeSpan GuardPeriod = TimeSpan.FromMilliseconds(50);
 
     /// <summary>Verifies <c>Pair</c> drops values that arrive after the paired sequence has completed.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
new file mode 100644
index 00000000..be543818
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
@@ -0,0 +1,281 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Core;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests scheduled delivery and virtual-time operator behavior.</summary>
+public partial class SignalOperatorMixinsTests
+{
+    /// <summary>Verifies the timestamp operator immediate and clock-backed branches.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task VerifyTimestampBranches()
+    {
+        RecordingWitness<Moment<int>> immediateMoments = new();
+        Signal.Sequence(One, Three).Timestamp(Sequencer.Immediate).Subscribe(immediateMoments).Dispose();
+        IEnumerable<int> expectedImmediateMoments = [One, Two, Three];
+        int[] immediateMomentValues =
+            [immediateMoments.Values[0].Value, immediateMoments.Values[1].Value, immediateMoments.Values[Two].Value];
+        await Assert.That(immediateMomentValues.SequenceEqual(expectedImmediateMoments)).IsTrue();
+        await Assert.That(immediateMoments.Completed).IsEqualTo(1);
+        List<Moment<int>> clockMoments = [];
+        var clockMomentCompleted = 0;
+        _ = Signal.Sequence(Four, Two).Timestamp(new VirtualClock(DateTimeOffset.UnixEpoch))
+            .Subscribe(clockMoments.Add, static ex => throw ex, () => clockMomentCompleted++);
+        IEnumerable<int> expectedClockMoments = [Four, Five];
+        int[] clockMomentValues = [clockMoments[0].Value, clockMoments[1].Value];
+        await Assert.That(clockMomentValues.SequenceEqual(expectedClockMoments)).IsTrue();
+        await Assert.That(clockMomentCompleted).IsEqualTo(1);
+        List<Moment<int>> immediateMomentActions = [];
+        var immediateMomentCompleted = 0;
+        var immediateTimestampSignal =
+            (IInlineSignal<Moment<int>>)Signal.Sequence(Two, Two).Timestamp(Sequencer.Immediate);
+        immediateTimestampSignal.Subscribe(immediateMomentActions.Add, static ex => throw ex, () => immediateMomentCompleted++)
+            .Dispose();
+        IEnumerable<int> expectedImmediateMomentActions = [Two, Three];
+        int[] immediateMomentActionValues = [immediateMomentActions[0].Value, immediateMomentActions[1].Value];
+        await Assert.That(immediateMomentActionValues.SequenceEqual(expectedImmediateMomentActions)).IsTrue();
+        await Assert.That(immediateMomentCompleted).IsEqualTo(1);
+        RecordingWitness<Moment<int>> clockMomentObserver = new();
+        var clockTimestampSignal =
+            (IInlineSignal<Moment<int>>)Signal.Sequence(Two, Two).Timestamp(new VirtualClock(DateTimeOffset.UnixEpoch));
+        clockTimestampSignal.Subscribe(clockMomentObserver).Dispose();
+        IEnumerable<int> expectedClockMomentObserver = [Two, Three];
+        int[] clockMomentObserverValues = [clockMomentObserver.Values[0].Value, clockMomentObserver.Values[1].Value];
+        await Assert.That(clockMomentObserverValues.SequenceEqual(expectedClockMomentObserver)).IsTrue();
+        await Assert.That(clockMomentObserver.Completed).IsEqualTo(1);
+        _ = Assert.Throws<ArgumentNullException>(() =>
+            immediateTimestampSignal.Subscribe((IObserver<Moment<int>>)null!));
+        _ = Assert.Throws<ArgumentNullException>(() =>
+            immediateTimestampSignal.Subscribe((Action<Moment<int>>)null!, static _ => { }, static () => { }));
+    }
+
+    /// <summary>Verifies the time-interval operator immediate and clock-backed branches.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task VerifyTimeIntervalBranches()
+    {
+        RecordingWitness<TimeInterval<int>> immediateIntervals = new();
+        Signal.Sequence(One, Three).TimeInterval(Sequencer.Immediate).Subscribe(immediateIntervals).Dispose();
+        IEnumerable<int> expectedImmediateIntervals = [One, Two, Three];
+        int[] immediateIntervalValues =
+        [
+            immediateIntervals.Values[0].Value, immediateIntervals.Values[1].Value, immediateIntervals.Values[Two].Value
+        ];
+        await Assert.That(immediateIntervalValues.SequenceEqual(expectedImmediateIntervals)).IsTrue();
+        await Assert.That(immediateIntervals.Values[0].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(immediateIntervals.Values[1].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(immediateIntervals.Values[Two].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(immediateIntervals.Completed).IsEqualTo(1);
+        List<TimeInterval<int>> clockIntervals = [];
+        var clockIntervalCompleted = 0;
+        _ = Signal.Sequence(Four, Three).TimeInterval(new VirtualClock(DateTimeOffset.UnixEpoch))
+            .Subscribe(clockIntervals.Add, static ex => throw ex, () => clockIntervalCompleted++);
+        IEnumerable<int> expectedClockIntervals = [Four, Five, Six];
+        int[] clockIntervalValues = [clockIntervals[0].Value, clockIntervals[1].Value, clockIntervals[Two].Value];
+        await Assert.That(clockIntervalValues.SequenceEqual(expectedClockIntervals)).IsTrue();
+        await Assert.That(clockIntervals[0].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervals[1].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervals[Two].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervalCompleted).IsEqualTo(1);
+        List<TimeInterval<int>> immediateIntervalActions = [];
+        var immediateIntervalCompleted = 0;
+        var immediateIntervalSignal =
+            (IInlineSignal<TimeInterval<int>>)Signal.Sequence(Two, Two).TimeInterval(Sequencer.Immediate);
+        immediateIntervalSignal
+            .Subscribe(immediateIntervalActions.Add, static ex => throw ex, () => immediateIntervalCompleted++)
+            .Dispose();
+        IEnumerable<int> expectedImmediateIntervalActions = [Two, Three];
+        int[] immediateIntervalActionValues = [immediateIntervalActions[0].Value, immediateIntervalActions[1].Value];
+        await Assert.That(immediateIntervalActionValues.SequenceEqual(expectedImmediateIntervalActions)).IsTrue();
+        await Assert.That(immediateIntervalCompleted).IsEqualTo(1);
+        RecordingWitness<TimeInterval<int>> clockIntervalObserver = new();
+        var clockIntervalSignal =
+            (IInlineSignal<TimeInterval<int>>)Signal.Sequence(Two, Three)
+                .TimeInterval(new VirtualClock(DateTimeOffset.UnixEpoch));
+        clockIntervalSignal.Subscribe(clockIntervalObserver).Dispose();
+        IEnumerable<int> expectedClockIntervalObserver = [Two, Three, Four];
+        int[] clockIntervalObserverValues =
+        [
+            clockIntervalObserver.Values[0].Value, clockIntervalObserver.Values[1].Value,
+            clockIntervalObserver.Values[Two].Value
+        ];
+        await Assert.That(clockIntervalObserverValues.SequenceEqual(expectedClockIntervalObserver)).IsTrue();
+        await Assert.That(clockIntervalObserver.Values[0].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervalObserver.Values[1].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervalObserver.Values[Two].Interval).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(clockIntervalObserver.Completed).IsEqualTo(1);
+        _ = Assert.Throws<ArgumentNullException>(() =>
+            immediateIntervalSignal.Subscribe((IObserver<TimeInterval<int>>)null!));
+        _ = Assert.Throws<ArgumentNullException>(() =>
+            immediateIntervalSignal.Subscribe((Action<TimeInterval<int>>)null!, static _ => { }, static () => { }));
+    }
+
+    /// <summary>Verifies delay-start signal branches, the sequencer work item, and queue guard clauses.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task VerifyDelayStartAndWorkItemBranches()
+    {
+        RecordingWitness<int> shiftedObserver = new();
+        Signal.Sequence(One, Two).DelayStart(TimeSpan.Zero, Sequencer.Immediate).Subscribe(shiftedObserver).Dispose();
+        int[] expectedShiftedObserver = [One, Two];
+        await Assert.That(shiftedObserver.Values.SequenceEqual(expectedShiftedObserver)).IsTrue();
+        await Assert.That(shiftedObserver.Completed).IsEqualTo(1);
+        List<int> shiftedActions = [];
+        var shiftedActionCompleted = 0;
+        _ = Signal.Sequence(Three, Two).DelayStart(TimeSpan.Zero, Sequencer.Immediate)
+            .Subscribe(shiftedActions.Add, static ex => throw ex, () => shiftedActionCompleted++);
+        int[] expectedShiftedActions = [Three, Four];
+        await Assert.That(shiftedActions.SequenceEqual(expectedShiftedActions)).IsTrue();
+        await Assert.That(shiftedActionCompleted).IsEqualTo(1);
+        var currentThreadShift =
+            (IRequireCurrentThread<int>)Signal.Sequence(One, One).DelayStart(TimeSpan.Zero, Sequencer.CurrentThread);
+        await Assert.That(currentThreadShift.IsRequiredSubscribeOnCurrentThread()).IsTrue();
+        var inlineShift = (IInlineSignal<int>)Signal.Sequence(One, One).DelayStart(TimeSpan.Zero, Sequencer.Immediate);
+        _ = Assert.Throws<ArgumentNullException>(static () => Signal.Sequence(One, One)
+            .DelayStart(TimeSpan.Zero, Sequencer.Immediate)
+            .Subscribe((IObserver<int>)null!));
+        _ = Assert.Throws<ArgumentNullException>(() => inlineShift.Subscribe((Action<int>)null!, static _ => { }, static () => { }));
+        _ = Assert.Throws<ArgumentNullException>(() => inlineShift.Subscribe(static _ => { }, static _ => { }, null!));
+        List<int> helperValues = [];
+        SequencerWorkItem<ISequencer, int> helper = new(Sequencer.Immediate, One, (_, state) =>
+        {
+            helperValues.Add(state);
+            return new ActionDisposable(static () => { });
+        });
+        helper.Invoke();
+        helper.Dispose();
+        helper.Invoke();
+        int[] expectedHelperValues = [One];
+        await Assert.That(helperValues.SequenceEqual(expectedHelperValues)).IsTrue();
+        await VerifySequencerWorkItemDisposalBranches();
+        var unusedScheduled =
+            ScheduledItem.Create(Sequencer.Immediate, "unused", static (_, _) => EmptyDisposable.Instance, One);
+        await Assert.That(new SequencerQueue<int>().Remove(unusedScheduled)).IsFalse();
+        _ = Assert.Throws<ArgumentOutOfRangeException>(CreatePriorityQueueWithInvalidCapacity);
+        PriorityQueue<int> shrink = new(ThirtyTwo);
+        for (var i = 0; i < ThirtyTwo; i++)
+        {
+            shrink.Enqueue(i);
+        }
+
+        for (var i = 0; i < TwentySix; i++)
+        {
+            await Assert.That(shrink.Dequeue()).IsEqualTo(i);
+        }
+    }
+
+    /// <summary>Verifies the sequencer work item disposes the action's disposable across invoke and dispose orderings.</summary>
+    /// <returns>A task representing the asynchronous verification.</returns>
+    private static async Task VerifySequencerWorkItemDisposalBranches()
+    {
+        // Invoke then dispose: the published disposable is released by Dispose exactly once,
+        // and a redundant second Dispose is a no-op.
+        var invokeThenDisposeReleased = 0;
+        SequencerWorkItem<ISequencer, int> invokeThenDispose = new(Sequencer.Immediate, One, (_, _) =>
+            new ActionDisposable(() => Interlocked.Increment(ref invokeThenDisposeReleased)));
+        invokeThenDispose.Invoke();
+        invokeThenDispose.Dispose();
+        invokeThenDispose.Dispose();
+        await Assert.That(invokeThenDisposeReleased).IsEqualTo(1);
+
+        // A null action result is coalesced to an empty disposable and never throws.
+        var nullActionRan = false;
+        SequencerWorkItem<ISequencer, int> nullAction = new(Sequencer.Immediate, One, (_, _) =>
+        {
+            nullActionRan = true;
+            return null!;
+        });
+        nullAction.Invoke();
+        nullAction.Dispose();
+        await Assert.That(nullActionRan).IsTrue();
+
+        await VerifySequencerWorkItemPublishBranches();
+        await VerifySequencerWorkItemDisposeRaceInvariant();
+    }
+
+    /// <summary>Verifies both compare-exchange outcomes of <c>SequencerWorkItem.Publish</c>.</summary>
+    /// <returns>A task representing the asynchronous verification.</returns>
+    private static async Task VerifySequencerWorkItemPublishBranches()
+    {
+        // Publish wins the empty slot: the disposable is stored and left alive for Dispose.
+        var stored = 0;
+        ActionDisposable storedDisposable = new(() => Interlocked.Increment(ref stored));
+        IDisposable? winSlot = null;
+        SequencerWorkItemDisposal.Publish(ref winSlot, storedDisposable);
+        await Assert.That(ReferenceEquals(winSlot, storedDisposable)).IsTrue();
+        await Assert.That(stored).IsEqualTo(0);
+
+        // Publish loses to disposal (slot already claimed): the disposable is released immediately.
+        var loserDisposed = 0;
+        ActionDisposable loser = new(() => Interlocked.Increment(ref loserDisposed));
+        IDisposable? loseSlot = EmptyDisposable.Instance;
+        SequencerWorkItemDisposal.Publish(ref loseSlot, loser);
+        await Assert.That(loserDisposed).IsEqualTo(1);
+        await Assert.That(ReferenceEquals(loseSlot, EmptyDisposable.Instance)).IsTrue();
+    }
+
+    /// <summary>Verifies the action's disposable is released exactly once when invoke and dispose race.</summary>
+    /// <returns>A task representing the asynchronous verification.</returns>
+    private static async Task VerifySequencerWorkItemDisposeRaceInvariant()
+{
+        var disposed = 0;
+        SequencerWorkItem<ISequencer, int>? item = null;
+        item = new(Sequencer.Immediate, One, (_, _) =>
+        {
+            item!.Dispose();
+            return new ActionDisposable(() => disposed++);
+        });
+        item.Invoke();
+        item.Dispose();
+        await Assert.That(disposed).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies the thread pool absolute scheduling and scheduled work item disposal branches.</summary>
+    /// <returns>A task representing the asynchronous verification.</returns>
+    private static async Task VerifyThreadPoolWorkItemBranchesAsync()
+{
+        using ManualThreadPool pool = new();
+        var absoluteValue = 0;
+        var absolute = pool.Sequencer.Schedule(Five, FixedTimestamp, (_, state) =>
+        {
+            absoluteValue = state;
+            return EmptyDisposable.Instance;
+        });
+        pool.RunReady();
+        await Assert.That(absoluteValue).IsEqualTo(Five);
+        absolute.Dispose();
+        absolute.Dispose();
+        var skipped = false;
+        ThreadPoolSequencer.ScheduledWorkItem<int> delayed = new(pool.Sequencer, One, (_, _) =>
+        {
+            skipped = true;
+            return EmptyDisposable.Instance;
+        });
+        delayed.Dispose();
+        delayed.Queue(TimeSpan.FromTicks(Ten));
+        pool.RunDue(long.MaxValue);
+        delayed.Execute();
+        await Assert.That(skipped).IsFalse();
+        var disposedReturned = 0;
+        ThreadPoolSequencer.ScheduledWorkItem<int>? selfDisposing = null;
+        selfDisposing = new(pool.Sequencer, One, (_, _) =>
+        {
+            selfDisposing!.Dispose();
+            return new ActionDisposable(() => disposedReturned++);
+        });
+        selfDisposing.Execute();
+        await Assert.That(disposedReturned).IsEqualTo(1);
+    }
+
+    /// <summary>Creates a priority queue with an invalid capacity.</summary>
+    private static void CreatePriorityQueueWithInvalidCapacity()
+    {
+        PriorityQueue<int> invalid = new(-1);
+        GC.KeepAlive(invalid);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
index a7ac4e1e..680018c3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
@@ -574,16 +574,12 @@ public async Task TaskChainDirectSignalHandlesErrorsAndDisposal()
         await Assert.That(taskFailure.Completed).IsEqualTo(0);
 
         TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        Signal<Task<int>> disposableSource = new();
         RecordingWitness<int> disposed = new();
-        {
-            var disposable = disposableSource.Chain().Subscribe(disposed);
-            disposableSource.OnNext(pending.Task);
-            disposable.Dispose();
-            pending.SetResult(Five);
-        }
+        TaskInstanceSubscription disposable = new();
+        disposable.Dispose();
+        pending.SetResult(Five);
+        await TaskInstanceSignal<int>.ObserveTaskAsync(pending.Task, disposed, disposable);
 
-        await Task.Yield();
         await Assert.That(disposed.Values.Count).IsEqualTo(0);
         await Assert.That(disposed.Errors.Count).IsEqualTo(0);
         await Assert.That(disposed.Completed).IsEqualTo(0);
@@ -731,7 +727,6 @@ private static async Task AssertTaskSignalAliasesForwardResultsCancellationAndFa
     {
         List<int> chained = [];
         _ = Signal.FromEnumerable([Task.FromResult(One), Task.FromResult(Two)]).Chain().Subscribe(chained.Add);
-        await Task.Yield();
 
         await Assert.That(chained.SequenceEqual(ExpectedOneTwo)).IsTrue();
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.PostTerminalGuards.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.PostTerminalGuards.cs
index 8fa6b724..c33d83b1 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.PostTerminalGuards.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.PostTerminalGuards.cs
@@ -4,12 +4,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the sampling and flat-map coordinators hold the Rx grammar when a source breaks it: a stale timer
-/// tick, a notification after a terminal, and a notification after disposal are all dropped instead of
-/// forwarded. Sources here are scripted so that disposing the subscription does not unhook them, which is what
-/// lets the test deliver the illegal notifications the guards exist for.
-/// </summary>
+/// <summary>Tests that sampling and flat-map coordinators reject stale callbacks and post-terminal notifications.</summary>
 public partial class SignalOperatorParityMixinsTests
 {
     /// <summary>The sample period used by the probe guard tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
similarity index 93%
rename from src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs
rename to src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
index a2322486..4b7a741c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalAliasCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
@@ -9,24 +9,9 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Focused coverage for Rx-style alias factories and parity shortcut branches.</summary>
-public class SignalAliasCoverageTests
+/// <summary>Tests Rx-style alias factories and empty-source shortcuts.</summary>
+public partial class SignalTests
 {
-    /// <summary>Reusable value one.</summary>
-    private const int One = 1;
-
-    /// <summary>Reusable value two.</summary>
-    private const int Two = 2;
-
-    /// <summary>Reusable value three.</summary>
-    private const int Three = 3;
-
-    /// <summary>Reusable value four.</summary>
-    private const int Four = 4;
-
-    /// <summary>Reusable value five.</summary>
-    private const int Five = 5;
-
     /// <summary>Verifies Rx factory aliases cover scheduled, empty, timeout, and switch range branches.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
index 9509210a..c3a13602 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
@@ -12,7 +12,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for the signal type.</summary>
-public class SignalTests
+public partial class SignalTests
 {
     /// <summary>The integer constant one.</summary>
     private const int One = 1;
@@ -523,12 +523,7 @@ public async Task SubjectsCoverMultipleSubscriberChurnLateTerminalsAndDisposalBr
         _ = Assert.Throws<ObjectDisposedException>(() => disposedSubject.OnNext(1));
     }
 
-    /// <summary>
-    /// A signal disposed from inside a subscriber's value callback has torn its state down under the dispatch
-    /// that is still running. The remaining subscribers in that dispatch snapshot still see the value — they
-    /// were already promised it — but the caller is told the signal is gone, rather than the disposal being
-    /// swallowed.
-    /// </summary>
+    /// <summary>Disposal during dispatch preserves the captured observer delivery and reports disposal to the caller.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnNextReportsDisposalWhenASubscriberDisposesTheSignalMidDispatch()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
index d979fc20..ce772ee7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
@@ -528,12 +528,7 @@ public async Task BufferSinkReleasesTheUpstreamWhenTheObserverThrowsOnACompleted
         await Assert.That(subscription.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// A <see cref = "BufferWitness{T}"/> releases its window buffer before handing the window to the observer,
-    /// so an observer that throws leaves the sink with no buffer to fill. The sink must therefore latch itself
-    /// terminal on that throw: a source that ignores the sink's disposal and keeps pushing has to be dropped
-    /// quietly, not indexed into the released buffer.
-    /// </summary>
+    /// <summary>A buffer witness stops accepting values when delivery of a completed window throws.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task BufferSinkDropsValuesFromASourceThatKeepsPushingAfterTheObserverThrows()
@@ -732,11 +727,7 @@ private static void Feed<T>(IObserver<T> sink, IEnumerable<T> values)
         public SumAggregator Add(int value) => new(Result + value);
     }
 
-    /// <summary>
-    /// An observable whose subscription retains its observer and ignores disposal, letting a test keep pushing
-    /// notifications into a sink that has already torn itself down. A well-behaved source would stop; this one is
-    /// what a sink's terminal latch exists to defend against.
-    /// </summary>
+    /// <summary>Retains its observer after disposal and permits further notifications.</summary>
     /// <typeparam name = "T">The value type.</typeparam>
     private sealed class UnstoppableSource<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
index 0c3249c4..46fd8dd2 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
@@ -143,11 +143,7 @@ public async Task StatefulSignalsReportObserverValueErrorAndDisposalState()
         await Assert.That(state.IsDisposed).IsTrue();
     }
 
-    /// <summary>
-    /// A state signal that has already completed never replays its value on subscription, so the projection has
-    /// no value to seed from its source. It must fall back to projecting the source's current value directly,
-    /// and then replay that value plus the completion to anyone who subscribes later.
-    /// </summary>
+    /// <summary>A projection created after source completion seeds from its current value and replays completion.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ReadOnlyStateProjectionSeedsItselfFromASourceThatHasAlreadyCompleted()
@@ -178,8 +174,7 @@ public async Task ReadOnlyStateProjectionIgnoresSourceNotificationsAfterItsTermi
         Recorder<string> observer = new();
         _ = projection.Subscribe(observer);
 
-        // The projection is its own observer of the source, so driving it directly is what a source that
-        // keeps notifying after the terminal looks like from the projection's side.
+        // Deliver notifications from a source that ignores termination.
         projection.OnCompleted();
         projection.OnCompleted();
         projection.OnNext(UpdatedStateValue);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/GenerationSafetyTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
similarity index 64%
rename from src/tests/ReactiveUI.Primitives.Tests/GenerationSafetyTests.cs
rename to src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
index 17d70ea3..5cdfa309 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/GenerationSafetyTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
@@ -8,12 +8,8 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests that the switch and merge coordinators keep their generation bookkeeping correct when a source
-/// behaves awkwardly: re-entering the outer sequence from a downstream handler, or signalling completion
-/// more than once. Both shapes previously lost notifications or terminated early.
-/// </summary>
-public sealed class GenerationSafetyTests
+/// <summary>Tests switch generation tracking during reentrant subscription.</summary>
+public sealed partial class SwitchWitnessTests
 {
     /// <summary>The value the first inner emits synchronously while it is being subscribed.</summary>
     private const int FirstValue = 1;
@@ -21,12 +17,7 @@ public sealed class GenerationSafetyTests
     /// <summary>The value the second inner emits after the re-entrant switch has settled.</summary>
     private const int SecondValue = 2;
 
-    /// <summary>
-    /// Subscribing an inner can push a value downstream synchronously, and a downstream handler may feed the
-    /// outer sequence again. The newer generation must survive that re-entrancy: installing the older
-    /// subscription afterwards would dispose the newer one and strand the sequence, because every surviving
-    /// notification is then filtered out by version.
-    /// </summary>
+    /// <summary>Reentrant replacement during subscription keeps the newest inner active.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchWitnessKeepsTheNewestGenerationWhenTheOuterIsReenteredWhileSubscribing()
@@ -41,7 +32,7 @@ public async Task SwitchWitnessKeepsTheNewestGenerationWhenTheOuterIsReenteredWh
         // Pushing `first` subscribes it, which emits synchronously, which re-enters the outer with `second`.
         outer.OnNext(first);
 
-        // `second` is the current generation, so it must still be live and still be heard.
+        // The replacement remains subscribed after the first subscription returns.
         second.Observer?.OnNext(SecondValue);
 
         using (Assert.Multiple())
@@ -51,36 +42,6 @@ public async Task SwitchWitnessKeepsTheNewestGenerationWhenTheOuterIsReenteredWh
         }
     }
 
-    /// <summary>
-    /// A source may signal completion more than once. A repeat must not decrement the merge's active count a
-    /// second time, because that count belongs to a sibling that is still running - the merge would otherwise
-    /// complete early and drop whatever the sibling had left.
-    /// </summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task MergeCoordinatorIgnoresARepeatedInnerCompletionWhileASiblingIsStillRunning()
-    {
-        CapturingObservable<int> left = new();
-        CapturingObservable<int> right = new();
-        RecordingObserver<int> downstream = new();
-
-        using var subscription = new MergeCoordinator<int>(downstream).Run([left, right]);
-
-        left.Observer!.OnCompleted();
-        left.Observer!.OnCompleted();
-
-        // `right` has not finished, so the merge must still be open.
-        await Assert.That(downstream.Completed).IsEqualTo(0);
-
-        right.Observer!.OnCompleted();
-
-        using (Assert.Multiple())
-        {
-            await Assert.That(downstream.Completed).IsEqualTo(1);
-            await Assert.That(right.Observer).IsNotNull();
-        }
-    }
-
     /// <summary>An observable that emits one value while it is being subscribed, and counts its disposals.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="value">The value emitted during subscription.</param>
@@ -115,21 +76,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>An observable that captures its observer for manual notification.</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    private sealed class CapturingObservable<T> : IObservable<T>
-    {
-        /// <summary>Gets the captured observer.</summary>
-        public IObserver<T>? Observer { get; private set; }
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            Observer = observer;
-            return new Tracker(static () => { });
-        }
-    }
-
     /// <summary>Records values and terminal signals.</summary>
     /// <typeparam name="T">The observed value type.</typeparam>
     private class RecordingObserver<T> : IObserver<T>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
index 3bb94515..9f0576fc 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
@@ -10,7 +10,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for <see cref="SwitchWitness{T}"/>.</summary>
-public sealed class SwitchWitnessTests
+public sealed partial class SwitchWitnessTests
 {
     /// <summary>The integer constant one.</summary>
     private const int One = 1;
@@ -18,12 +18,6 @@ public sealed class SwitchWitnessTests
     /// <summary>The integer constant two.</summary>
     private const int Two = 2;
 
-    /// <summary>Window used to confirm a gated operation stays blocked while a delivery is in flight.</summary>
-    private const int GateProbeMilliseconds = 200;
-
-    /// <summary>Timeout used while waiting for background work in these tests.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies direct switch witness completion is emitted once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -46,34 +40,42 @@ public async Task SwitchWitnessSuppressesDuplicateCompletionFromCurrentInner()
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchToDoesNotEnterObserverConcurrentlyWhenSwitchingInnerSources()
-    {
+{
         Signal<IObservable<int>> outer = new();
         CapturingObservable<int> first = new();
         CapturingObservable<int> second = new();
         using GatedObserver observer = new();
         using var subscription = outer.SwitchTo().Subscribe(observer);
-
+        var coordinator = (LinqExtensions.SwitchCoordinator<int>)subscription;
         outer.OnNext(first);
+        var firstDelivery = Task.Run(() => first.Observer!.OnNext(One));
+        observer.FirstEntered.Wait();
+        bool entered;
+        try
+        {
+#if NET9_0_OR_GREATER
+            entered = coordinator.Gate.TryEnter();
+            if (entered)
+            {
+                coordinator.Gate.Exit();
+            }
+#else
+            entered = Monitor.TryEnter(coordinator.Gate);
+            if (entered)
+            {
+                Monitor.Exit(coordinator.Gate);
+            }
+#endif
+        }
+        finally
+        {
+            observer.ReleaseFirst.Set();
+        }
 
-        // The first inner value enters the observer and blocks while the coordinator holds its gate. Run the
-        // blocking delivery on a dedicated thread rather than the thread pool: on a saturated runner a Task.Run
-        // body can sit unscheduled past the wait window, so FirstEntered would never be set in time even though
-        // the delivery is ready to run. An OS thread is not subject to pool starvation.
-        var firstDelivery = DeliveryThread.Start(() => first.Observer!.OnNext(One));
-        await Assert.That(observer.FirstEntered.Wait(WaitTimeout)).IsTrue();
-
-        // Switching sources is gated too: OnSource cannot subscribe the new inner until the delivery releases.
-        var switchDelivery = DeliveryThread.Start(() => outer.OnNext(second));
-        await Assert.That(SpinWait.SpinUntil(() => second.Observer is not null, GateProbeMilliseconds)).IsFalse();
-        await Assert.That(observer.ConcurrentOnNext).IsFalse();
-
-        observer.ReleaseFirst.Set();
-        await Assert.That(firstDelivery.ReturnedWithin(WaitTimeout)).IsTrue();
-        await Assert.That(switchDelivery.ReturnedWithin(WaitTimeout)).IsTrue();
-
-        // Once the switch completes the new inner delivers serially behind the first value.
+        await firstDelivery;
+        await Assert.That(entered).IsFalse();
+        outer.OnNext(second);
         second.Observer!.OnNext(Two);
-
         await Assert.That(observer.ConcurrentOnNext).IsFalse();
         await Assert.That(observer.Values).IsEqualTo(Two);
     }
@@ -374,7 +376,7 @@ public void OnError(Exception error)
 
         /// <inheritdoc/>
         public void OnNext(int value)
-        {
+{
             if (Interlocked.Increment(ref _inOnNext) != 1)
             {
                 _ = Interlocked.Exchange(ref _concurrent, 1);
@@ -384,14 +386,11 @@ public void OnNext(int value)
             if (index == 1)
             {
                 FirstEntered.Set();
-                if (!ReleaseFirst.Wait(WaitTimeout))
-                {
-                    throw new TimeoutException("Timed out waiting to release the blocked OnNext call.");
-                }
+                ReleaseFirst.Wait();
             }
 
             _ = Interlocked.Decrement(ref _inOnNext);
-        }
+    }
 
         /// <inheritdoc/>
         public void Dispose()
@@ -400,70 +399,4 @@ public void Dispose()
             ReleaseFirst.Dispose();
         }
     }
-
-    /// <summary>Runs a blocking notification delivery on a background thread the test can join directly.</summary>
-    /// <remarks>
-    /// The deliveries these tests drive block inside the observer while the switch coordinator holds its gate.
-    /// A <see cref="Task.Run(Action)"/> body would sit on the thread pool, so on a runner whose pool is saturated
-    /// the delivery could be dequeued after the wait window had already closed — the gate signal it sets would be
-    /// seen as never arriving even though the delivery was ready to run. <see cref="Thread.Join(TimeSpan)"/> is an
-    /// OS-level wait no pool pressure can starve, so the test observes the delivery returning rather than the pool
-    /// getting round to running it. A body that genuinely never returns still trips the timeout.
-    /// </remarks>
-    private sealed class DeliveryThread
-    {
-        /// <summary>The delivery body to run.</summary>
-        private readonly Action _body;
-
-        /// <summary>The background thread the body runs on.</summary>
-        private readonly Thread _thread;
-
-        /// <summary>The exception the body threw, if any.</summary>
-        private ExceptionDispatchInfo? _failure;
-
-        /// <summary>Initializes a new instance of the <see cref="DeliveryThread"/> class.</summary>
-        /// <param name="body">The delivery body to run.</param>
-        private DeliveryThread(Action body)
-        {
-            _body = body;
-            _thread = new(Run) { IsBackground = true, };
-        }
-
-        /// <summary>Starts a delivery body on a background thread of its own.</summary>
-        /// <param name="body">The delivery body to run.</param>
-        /// <returns>The running delivery thread.</returns>
-        internal static DeliveryThread Start(Action body)
-        {
-            DeliveryThread delivery = new(body);
-            delivery._thread.Start();
-            return delivery;
-        }
-
-        /// <summary>Waits for the delivery thread to return, rethrowing whatever the body threw.</summary>
-        /// <param name="timeout">How long the thread is given to return.</param>
-        /// <returns><see langword="true"/> when the thread returned within <paramref name="timeout"/>.</returns>
-        internal bool ReturnedWithin(TimeSpan timeout)
-        {
-            if (!_thread.Join(timeout))
-            {
-                return false;
-            }
-
-            _failure?.Throw();
-            return true;
-        }
-
-        /// <summary>Runs the delivery body, capturing a failure so it can be rethrown with its original stack.</summary>
-        private void Run()
-        {
-            try
-            {
-                _body();
-            }
-            catch (Exception error)
-            {
-                _failure = ExceptionDispatchInfo.Capture(error);
-            }
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
index 7bfb912f..9dd8fc69 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
@@ -261,11 +261,7 @@ private static Signal<int>[] CreateSources(int count)
         return sources;
     }
 
-    /// <summary>
-    /// Drives every source and asserts the combined sequence: nothing is emitted until the final source
-    /// produces its first value, the first result carries each source's value in its own selector position,
-    /// and a later value on the first source replaces only that source's contribution.
-    /// </summary>
+    /// <summary>Checks first-value synchronization, selector positions, and replacement of one source's latest value.</summary>
     /// <param name="sources">The subjects feeding the combinator, in selector-parameter order.</param>
     /// <param name="results">The results recorded from the combined sequence.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SynchronizeTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SynchronizeWitnessTests.cs
similarity index 67%
rename from src/tests/ReactiveUI.Primitives.Tests/SynchronizeTests.cs
rename to src/tests/ReactiveUI.Primitives.Tests/SynchronizeWitnessTests.cs
index 52d45d6d..94748694 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SynchronizeTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SynchronizeWitnessTests.cs
@@ -9,14 +9,8 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for the <see cref = "SynchronizeWitness{T}"/> gate and the <c>Synchronize</c> operator.</summary>
-public class SynchronizeTests
+public class SynchronizeWitnessTests
 {
-    /// <summary>The number of producer threads used by stress tests.</summary>
-    private const int Threads = 8;
-
-    /// <summary>The number of values sent by each producer thread.</summary>
-    private const int PerThread = 500;
-
     /// <summary>The literal two.</summary>
     private const int Second = 2;
 
@@ -73,51 +67,50 @@ public void SynchronizeOnNullGateThrows() =>
     /// <returns>A task that completes when the assertions have run.</returns>
     [Test]
     public async Task SharedGateSerializesAcrossTwoWitnesses()
-    {
-        ConcurrencyProbe probe = new();
+{
         Lock gate = new();
-        SynchronizeWitness<int> first = new(probe, gate);
-        SynchronizeWitness<int> second = new(probe, gate);
-        var tasks = new Task[Threads];
-        for (var t = 0; t < Threads; t++)
+        List<int> values = [];
+        var held = true;
+        var observer = new DelegateWitness<int>(
+            value =>
         {
-            var sink = t % Second == 0 ? first : second;
-            tasks[t] = Task.Run(() =>
-            {
-                for (var i = 0; i < PerThread; i++)
-                {
-                    sink.OnNext(i);
-                }
-            });
-        }
-
-        await Task.WhenAll(tasks);
-        await Assert.That(probe.OverlapDetected).IsFalse();
-        await Assert.That(probe.Count).IsEqualTo(Threads * PerThread);
+            held &= IsHeld(gate);
+            values.Add(value);
+        },
+            static _ => { },
+            static () => { });
+        using SynchronizeWitness<int> first = new(observer, gate);
+        using SynchronizeWitness<int> second = new(observer, gate);
+        first.OnNext(1);
+        second.OnNext(Second);
+        await Assert.That(held).IsTrue();
+        await Assert.That(values.SequenceEqual([1, Second])).IsTrue();
     }
 
-    /// <summary>Concurrent <c>OnNext</c> calls are serialized: the downstream is never entered re-entrantly and sees every value.</summary>
+    /// <summary>Every downstream notification runs while the witness owns its gate.</summary>
     /// <returns>A task that completes when the assertions have run.</returns>
     [Test]
-    public async Task SerializesConcurrentOnNextSoTheDownstreamNeverOverlaps()
-    {
-        ConcurrencyProbe probe = new();
-        SynchronizeWitness<int> sink = new(probe);
-        var tasks = new Task[Threads];
-        for (var t = 0; t < Threads; t++)
+    public async Task HoldsTheGateAcrossEveryDownstreamNotification()
+{
+        var held = true;
+        List<int> values = [];
+        SynchronizeWitness<int>? sink = null;
+        var observer = new DelegateWitness<int>(
+            value =>
         {
-            tasks[t] = Task.Run(() =>
-            {
-                for (var i = 0; i < PerThread; i++)
-                {
-                    sink.OnNext(i);
-                }
-            });
-        }
-
-        await Task.WhenAll(tasks);
-        await Assert.That(probe.OverlapDetected).IsFalse();
-        await Assert.That(probe.Count).IsEqualTo(Threads * PerThread);
+            held &= IsHeld(sink!.Gate);
+            values.Add(value);
+        },
+            _ => held &= IsHeld(sink!.Gate),
+            () => held &= IsHeld(sink!.Gate));
+        sink = new(observer);
+        sink.OnNext(1);
+        sink.OnNext(Second);
+        sink.OnError(new InvalidOperationException("failure"));
+        sink.OnCompleted();
+        await Assert.That(held).IsTrue();
+        await Assert.That(values.SequenceEqual([1, Second])).IsTrue();
+        sink.Dispose();
     }
 
     /// <summary>The object-gated sequence forwards every source value and its completion downstream.</summary>
@@ -177,27 +170,24 @@ public async Task ObjectGatedSynchronizeDisposesTheUpstreamSubscriptionOnce()
     /// <returns>A task that completes when the assertions have run.</returns>
     [Test]
     public async Task ObjectGatedWitnessesSharingOneGateAreSerialized()
-    {
-        ConcurrencyProbe probe = new();
+{
         var gate = new object();
-        SynchronizeObjectWitness<int> first = new(probe, gate);
-        SynchronizeObjectWitness<int> second = new(probe, gate);
-        var tasks = new Task[Threads];
-        for (var t = 0; t < Threads; t++)
+        List<int> values = [];
+        var held = true;
+        var observer = new DelegateWitness<int>(
+            value =>
         {
-            var sink = t % Second == 0 ? first : second;
-            tasks[t] = Task.Run(() =>
-            {
-                for (var i = 0; i < PerThread; i++)
-                {
-                    sink.OnNext(i);
-                }
-            });
-        }
-
-        await Task.WhenAll(tasks);
-        await Assert.That(probe.OverlapDetected).IsFalse();
-        await Assert.That(probe.Count).IsEqualTo(Threads * PerThread);
+            held &= Monitor.IsEntered(gate);
+            values.Add(value);
+        },
+            static _ => { },
+            static () => { });
+        using SynchronizeObjectWitness<int> first = new(observer, gate);
+        using SynchronizeObjectWitness<int> second = new(observer, gate);
+        first.OnNext(1);
+        second.OnNext(Second);
+        await Assert.That(held).IsTrue();
+        await Assert.That(values.SequenceEqual([1, Second])).IsTrue();
     }
 
 #if NET9_0_OR_GREATER
@@ -217,6 +207,18 @@ public async Task SynchronizeWithAnObjectGateForwardsTheSourceSequence()
     }
 #endif
 
+    /// <summary>Reports ownership of the platform synchronization gate.</summary>
+    /// <param name="gate">The gate under test.</param>
+    /// <returns>Whether the calling thread owns the gate.</returns>
+    private static bool IsHeld(Lock gate)
+    {
+#if NET9_0_OR_GREATER
+        return gate.IsHeldByCurrentThread;
+#else
+        return Monitor.IsEntered(gate);
+#endif
+    }
+
     /// <summary>An observer that records all values, errors, and completion counts.</summary>
     /// <typeparam name = "T">The type of the observed values.</typeparam>
     private sealed class Recorder<T> : IObserver<T>
@@ -266,46 +268,4 @@ public void Dispose()
         {
         }
     }
-
-    /// <summary>A downstream observer that flags any re-entrant (overlapping) notification and counts deliveries.</summary>
-    private sealed class ConcurrencyProbe : IObserver<int>
-    {
-        /// <summary>The number of wait spin iterations used to widen the re-entrancy detection window.</summary>
-        private const int SpinIterations = 50;
-
-        /// <summary>Non-zero while a notification is in flight, used to detect re-entrancy.</summary>
-        private int _inside;
-
-        /// <summary>Gets the number of values delivered.</summary>
-        public int Count { get; private set; }
-
-        /// <summary>Gets a value indicating whether two notifications were ever observed to overlap.</summary>
-        public bool OverlapDetected { get; private set; }
-
-        /// <inheritdoc/>
-        public void OnCompleted()
-        {
-        }
-
-        /// <inheritdoc/>
-        /// <param name = "error">The forwarded error (ignored).</param>
-        public void OnError(Exception error)
-        {
-        }
-
-        /// <inheritdoc/>
-        /// <param name = "value">The forwarded value.</param>
-        public void OnNext(int value)
-        {
-            if (Interlocked.Exchange(ref _inside, 1) != 0)
-            {
-                OverlapDetected = true;
-            }
-
-            // Non-atomic on purpose: the gate must serialize callers for this to stay exact.
-            Count++;
-            Thread.SpinWait(SpinIterations);
-            _ = Interlocked.Exchange(ref _inside, 0);
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskInstanceSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskInstanceSignalTests.cs
new file mode 100644
index 00000000..e4ea83c7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskInstanceSignalTests.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies task-instance results and disposal.</summary>
+public class TaskInstanceSignalTests
+{
+    /// <summary>The value emitted by a successful task.</summary>
+    private const int Value = 7;
+
+    /// <summary>Pending task instances forward success, failure, or cancellation.</summary>
+    /// <param name="outcome">Zero for success, one for failure, or two for cancellation.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(0)]
+    [Arguments(1)]
+    [Arguments(2)]
+    public async Task PendingTaskForwardsItsOutcome(int outcome)
+    {
+        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskNotificationObserver observer = new();
+        using var subscription = Signal.FromTask(pending.Task).Subscribe(observer);
+        if (outcome == 0)
+        {
+            pending.SetResult(Value);
+        }
+        else if (outcome == 1)
+        {
+            pending.SetException(new InvalidOperationException());
+        }
+        else
+        {
+            pending.SetCanceled();
+        }
+
+        await observer.Terminal.Task;
+        await Assert.That(observer.Values.Count).IsEqualTo(outcome == 0 ? 1 : 0);
+        await Assert.That(observer.Completions).IsEqualTo(outcome == 0 ? 1 : 0);
+        if (outcome == 0)
+        {
+            await Assert.That(observer.Values[0]).IsEqualTo(Value);
+            await Assert.That(observer.Error).IsNull();
+        }
+        else if (outcome == 1)
+        {
+            await Assert.That(observer.Error).IsTypeOf<InvalidOperationException>();
+        }
+        else
+        {
+            await Assert.That(observer.Error).IsTypeOf<TaskCanceledException>();
+        }
+    }
+
+    /// <summary>Disposed subscriptions suppress results and faults after observation completes.</summary>
+    /// <param name="fault">Whether the task fails.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DisposedSubscriptionSuppressesOutcome(bool fault)
+    {
+        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskNotificationObserver observer = new();
+        TaskInstanceSubscription subscription = new();
+        subscription.Dispose();
+        if (fault)
+        {
+            pending.SetException(new InvalidOperationException());
+        }
+        else
+        {
+            pending.SetResult(Value);
+        }
+
+        await TaskInstanceSignal<int>.ObserveTaskAsync(pending.Task, observer, subscription);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Error).IsNull();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
new file mode 100644
index 00000000..d94b3b26
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
@@ -0,0 +1,114 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests task-pool sequencer dispatch and cancellation.</summary>
+public class TaskPoolSequencerTests
+{
+    /// <summary>Scheduling state returns a cancellation handle.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TestCreate()
+    {
+        ManualTaskScheduler scheduler = new();
+        TaskPoolSequencer sequencer = new(new(scheduler));
+        using var disposable = sequencer.Schedule(0, static (_, _) => EmptyDisposable.Instance);
+        await Assert.That(disposable).IsNotNull();
+        scheduler.RunPending();
+    }
+
+    /// <summary>The clock returns a UTC timestamp.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolNowUsesUtc() =>
+        await Assert.That(TaskPoolSequencer.Instance.Now.Offset).IsEqualTo(TimeSpan.Zero);
+
+    /// <summary>Immediate work is queued through the supplied task factory.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolScheduleAction()
+    {
+        ManualTaskScheduler scheduler = new();
+        TaskPoolSequencer sequencer = new(new(scheduler));
+        StrongBox<bool> ran = new();
+        using var scheduled = sequencer.Schedule(ran, static state => state.Value = true);
+        await Assert.That(ran.Value).IsFalse();
+        scheduler.RunPending();
+        await Assert.That(ran.Value).IsTrue();
+    }
+
+    /// <summary>Work due immediately uses the task factory queue.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolScheduleActionDueNow()
+    {
+        ManualTaskScheduler scheduler = new();
+        TaskPoolSequencer sequencer = new(new(scheduler));
+        StrongBox<bool> ran = new();
+        using var scheduled = sequencer.Schedule(ran, TimeSpan.Zero, static state => state.Value = true);
+        await Assert.That(ran.Value).IsFalse();
+        scheduler.RunPending();
+        await Assert.That(ran.Value).IsTrue();
+    }
+
+    /// <summary>Delayed work reaches the task factory only after its delay callback runs.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolScheduleActionDue()
+    {
+        ManualTaskScheduler scheduler = new();
+        ManualSequencer delays = new();
+        TaskPoolSequencer sequencer = new(new(scheduler), delays);
+        StrongBox<bool> ran = new();
+        using var scheduled = sequencer.Schedule(ran, DateTimeOffset.MaxValue, static (_, state) =>
+        {
+            state.Value = true;
+            return EmptyDisposable.Instance;
+        });
+        scheduler.RunPending();
+        await Assert.That(ran.Value).IsFalse();
+        delays.RunPending();
+        await Assert.That(ran.Value).IsFalse();
+        scheduler.RunPending();
+        await Assert.That(ran.Value).IsTrue();
+    }
+
+    /// <summary>Cancellation suppresses delayed dispatch.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolScheduleActionCancel()
+    {
+        ManualTaskScheduler scheduler = new();
+        ManualSequencer delays = new();
+        TaskPoolSequencer sequencer = new(new(scheduler), delays);
+        StrongBox<int> runs = new();
+        var scheduled = sequencer.Schedule(runs, DateTimeOffset.MaxValue, static (_, state) =>
+        {
+            state.Value++;
+            return EmptyDisposable.Instance;
+        });
+        scheduled.Dispose();
+        delays.RunPending();
+        scheduler.RunPending();
+        await Assert.That(runs.Value).IsEqualTo(0);
+    }
+
+    /// <summary>Large delays retain their cancellation handle.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TaskPoolDelayLargerThanIntMaxValue()
+    {
+        ManualTaskScheduler scheduler = new();
+        ManualSequencer delays = new();
+        TaskPoolSequencer sequencer = new(new(scheduler), delays);
+        var dueTime = TimeSpan.FromMilliseconds((double)int.MaxValue + 1);
+        using var scheduled = sequencer.Schedule(dueTime, static () => { });
+        await Assert.That(scheduled).IsNotNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
new file mode 100644
index 00000000..60ad111a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
@@ -0,0 +1,239 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies synchronous task factory results and validation.</summary>
+public partial class TaskSignalTests
+{
+    /// <summary>The value emitted by the simple from-task result test.</summary>
+    private const int EmittedValue = 2;
+
+    /// <summary>The value produced by the successful pending task.</summary>
+    private const int SuccessValue = 7;
+
+    /// <summary>Exception message used by user exception tests.</summary>
+    private const string BreakExecutionMessage = "break execution";
+
+    /// <summary>Covers from-task cancellation callback argument validation.</summary>
+    [Test]
+    public void FromTaskValidatesCancellationCallback()
+    {
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(1), Sequencer.Immediate);
+        try
+        {
+            _ = Assert.Throws<ArgumentNullException>(() => taskSignal.GetOperationCanceled(null!));
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>Covers from-task result emission and completion.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task FromTaskEmitsResult()
+    {
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(EmittedValue), Sequencer.Immediate);
+        try
+        {
+            List<int> taskValues = [];
+            var taskCompleted = 0;
+            _ = taskSignal.Subscribe(taskValues.Add, static error => throw error, () => taskCompleted++);
+            await Assert.That(taskValues.SequenceEqual([EmittedValue])).IsTrue();
+            await Assert.That(taskCompleted).IsEqualTo(1);
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A synchronously completed task emits its result and completes through the immediate path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ImmediateSynchronousSuccessEmitsResultAndCompletes()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var completed = 0;
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.Immediate);
+        try
+        {
+            _ = taskSignal.Subscribe(
+                values.Enqueue,
+                error => errors.Enqueue(error.GetType().Name),
+                () => Interlocked.Increment(ref completed));
+            await Assert.That(values.SequenceEqual([SuccessValue])).IsTrue();
+            await Assert.That(errors).IsEmpty();
+            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(1);
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A synchronously canceled task errors with a cancellation through the immediate path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ImmediateSynchronousCanceledTaskErrors()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var taskSignal = Signal.FromTask(static _ => Task.FromCanceled<int>(new(true)), Sequencer.Immediate);
+        try
+        {
+            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
+            await Assert.That(values).IsEmpty();
+            await Assert.That(errors.SequenceEqual([nameof(OperationCanceledException)])).IsTrue();
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A synchronously faulted task forwards the exception through the immediate path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ImmediateSynchronousFaultedTaskForwardsError()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var taskSignal =
+            Signal.FromTask(
+                static _ => Task.FromException<int>(new InvalidOperationException(BreakExecutionMessage)),
+                Sequencer.Immediate);
+        try
+        {
+            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
+            await Assert.That(values).IsEmpty();
+            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A throwing task factory forwards the exception through the immediate path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ImmediateFactoryThrowForwardsError()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var taskSignal = Signal.FromTask<int>(
+            static _ => throw new InvalidOperationException(BreakExecutionMessage),
+            Sequencer.Immediate);
+        try
+        {
+            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
+            await Assert.That(values).IsEmpty();
+            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A throwing task factory forwards the exception through the scheduled path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ScheduledFactoryThrowForwardsError()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var taskSignal = Signal.FromTask<int>(static _ => throw new InvalidOperationException(BreakExecutionMessage));
+        try
+        {
+            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
+            await Assert.That(values).IsEmpty();
+            await Assert.That(errors.SequenceEqual([nameof(InvalidOperationException)])).IsTrue();
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A synchronously completed task emits its result through the scheduled synchronous fast path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ScheduledSynchronousSuccessEmitsResultAndCompletes()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var completed = 0;
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.CurrentThread);
+        try
+        {
+            _ = taskSignal.Subscribe(
+                values.Enqueue,
+                error => errors.Enqueue(error.GetType().Name),
+                () => Interlocked.Increment(ref completed));
+            await Assert.That(values.SequenceEqual([SuccessValue])).IsTrue();
+            await Assert.That(errors).IsEmpty();
+            await Assert.That(completed).IsEqualTo(1);
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>A synchronously canceled task errors through the scheduled synchronous fast path.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task ScheduledSynchronousCanceledTaskErrors()
+    {
+        ConcurrentQueue<int> values = new();
+        ConcurrentQueue<string> errors = new();
+        var taskSignal = Signal.FromTask(static _ => Task.FromCanceled<int>(new(true)), Sequencer.CurrentThread);
+        try
+        {
+            _ = taskSignal.Subscribe(values.Enqueue, error => errors.Enqueue(error.GetType().Name), static () => { });
+            await Assert.That(values).IsEmpty();
+            await Assert.That(errors.SequenceEqual([nameof(OperationCanceledException)])).IsTrue();
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>The non-generic RxVoid factory honors the scheduler overload and emits a completion.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous unit test.</returns>
+    [Test]
+    public async Task RxVoidFactoryWithSchedulerEmitsCompletion()
+    {
+        var completed = 0;
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(RxVoid.Default), Sequencer.Immediate);
+        try
+        {
+            _ = taskSignal.Subscribe(static _ => { }, static error => throw error, () => Interlocked.Increment(ref completed));
+            await Assert.That(Volatile.Read(ref completed)).IsEqualTo(1);
+        }
+        finally
+        {
+            (taskSignal as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>Subscribing to a disposed immediate signal throws.</summary>
+    [Test]
+    public void ImmediateSignalSubscribeAfterDisposeThrows()
+    {
+        var taskSignal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.Immediate);
+        ((IDisposable)taskSignal).Dispose();
+        _ = Assert.Throws<ObjectDisposedException>(() => taskSignal.Subscribe(static _ => { }));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Lifecycle.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Lifecycle.cs
new file mode 100644
index 00000000..beaf7618
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Lifecycle.cs
@@ -0,0 +1,162 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies factory completion and cancellation cleanup.</summary>
+public partial class TaskSignalTests
+{
+    /// <summary>Disposal with a cancellation handler.</summary>
+    private const int DisposedEnding = 2;
+
+    /// <summary>Cancellation requested through the source token.</summary>
+    private const int TokenEnding = 3;
+
+    /// <summary>Disposal without a cancellation handler.</summary>
+    private const int UnhandledCancellationEnding = 4;
+
+    /// <summary>Both factory overloads finish their body and subscription cleanup for each terminal path.</summary>
+    /// <param name="generic">Whether to call the generic factory overload.</param>
+    /// <param name="ending">Zero for success, one for fault, two for disposal, three for token cancellation, or four for unhandled cancellation.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false, 0)]
+    [Arguments(false, 1)]
+    [Arguments(false, 2)]
+    [Arguments(false, 3)]
+    [Arguments(false, 4)]
+    [Arguments(true, 0)]
+    [Arguments(true, 1)]
+    [Arguments(true, 2)]
+    [Arguments(true, 3)]
+    [Arguments(true, 4)]
+    public async Task FactoryLifecycleCompletesCleanup(bool generic, int ending)
+    {
+        ConcurrentQueue<string> events = new();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource cleanup = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        Task<RxVoid>? operation = null;
+        var signal = generic
+            ? Signal.FromTask<RxVoid>(cts => operation = ExecuteFactoryAsync(events, release, ending, cts.Token))
+            : Signal.FromTask(cts => operation = ExecuteFactoryAsync(events, release, ending, cts.Token));
+        using var signalLifetime = (IDisposable)signal;
+        var fixture = signal.Recover<RxVoid, Exception>(error =>
+        {
+            events.Enqueue("recovered");
+            return Signal.Fail<RxVoid>(error);
+        }).OnCleanup(() =>
+        {
+            events.Enqueue("cleanup");
+            _ = cleanup.TrySetResult();
+        });
+        var results = 0;
+        var subscription = fixture.Subscribe(_ => results++, static _ => { });
+        await Assert.That(events).Contains("started");
+        await Assert.That(operation is not null).IsTrue();
+        await CompleteFactoryAsync(ending, signal, subscription, release, operation!);
+        await cleanup.Task;
+        subscription.Dispose();
+        await AssertFactoryEventsAsync(events, ending, results);
+    }
+
+    /// <summary>Triggers the selected terminal path and joins the factory body.</summary>
+    /// <param name="ending">The terminal path.</param>
+    /// <param name="signal">The task signal.</param>
+    /// <param name="subscription">The subscription to cancel.</param>
+    /// <param name="release">The factory release signal.</param>
+    /// <param name="operation">The factory body task.</param>
+    /// <returns>The asynchronous operation.</returns>
+    private static async Task CompleteFactoryAsync(
+        int ending,
+        ITaskSignal<RxVoid> signal,
+        IDisposable subscription,
+        TaskCompletionSource release,
+        Task<RxVoid> operation)
+    {
+        if (ending < DisposedEnding)
+        {
+            release.SetResult();
+        }
+        else if (ending == TokenEnding)
+        {
+            await signal.CancellationTokenSource!.CancelAsync();
+        }
+        else
+        {
+            subscription.Dispose();
+        }
+
+        if (ending == 1)
+        {
+            await Assert.That(async () => await operation).Throws<InvalidOperationException>();
+        }
+        else if (ending == UnhandledCancellationEnding)
+        {
+            await Assert.That(async () => await operation).Throws<OperationCanceledException>();
+        }
+        else
+        {
+            await operation;
+        }
+    }
+
+    /// <summary>Checks cleanup and result delivery after the factory finishes.</summary>
+    /// <param name="events">The recorded events.</param>
+    /// <param name="ending">The terminal path.</param>
+    /// <param name="results">The result count.</param>
+    /// <returns>The asynchronous assertions.</returns>
+    private static async Task AssertFactoryEventsAsync(ConcurrentQueue<string> events, int ending, int results)
+    {
+        await Assert.That(events.Count(static value => value == "cleanup")).IsEqualTo(1);
+        await Assert.That(events.Contains("finished")).IsEqualTo(ending < DisposedEnding);
+        await Assert.That(events.Contains("cancel-start")).IsEqualTo(ending is DisposedEnding or TokenEnding);
+        await Assert.That(events.Contains("cancel-end")).IsEqualTo(ending is DisposedEnding or TokenEnding);
+        await Assert.That(results).IsEqualTo(ending == 0 ? 1 : 0);
+        await Assert.That(events.Contains("recovered")).IsEqualTo(ending is 1 or TokenEnding);
+    }
+
+    /// <summary>Runs until released or canceled, recording body cleanup.</summary>
+    /// <param name="events">The event destination.</param>
+    /// <param name="release">The factory release signal.</param>
+    /// <param name="ending">The terminal path.</param>
+    /// <param name="token">The cancellation token.</param>
+    /// <returns>The factory result.</returns>
+    /// <exception cref="InvalidOperationException">The selected terminal path is a factory failure.</exception>
+    private static async Task<RxVoid> ExecuteFactoryAsync(
+        ConcurrentQueue<string> events,
+        TaskCompletionSource release,
+        int ending,
+        CancellationToken token)
+    {
+        events.Enqueue("started");
+        var wait = release.Task.WaitAsync(token);
+        if (ending == UnhandledCancellationEnding)
+        {
+            await wait;
+        }
+        else
+        {
+            await wait.HandleCancellation(() =>
+            {
+                events.Enqueue("cancel-start");
+                events.Enqueue("cancel-end");
+            });
+        }
+
+        if (!token.IsCancellationRequested)
+        {
+            events.Enqueue("finished");
+        }
+
+        if (ending == 1)
+        {
+            throw new InvalidOperationException(BreakExecutionMessage);
+        }
+
+        return RxVoid.Default;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Observation.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Observation.cs
new file mode 100644
index 00000000..a92d7c90
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.Observation.cs
@@ -0,0 +1,194 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies task notification and cancellation ordering.</summary>
+public partial class TaskSignalTests
+{
+    /// <summary>A canceled result or token produces one cancellation error.</summary>
+    /// <param name="canceledResult">Whether cancellation is carried by the result.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task ObservationReportsCancellation(bool canceledResult)
+    {
+        using CancellationTokenSource source = new();
+        if (!canceledResult)
+        {
+            await source.CancelAsync();
+        }
+
+        var result = Task.FromResult((SuccessValue, canceledResult));
+        Signal.TaskStopGate gate = new();
+        TaskNotificationObserver observer = new();
+        await Signal.ObserveTask(result, observer, gate, source.Token);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+        await Assert.That(observer.Error).IsTypeOf<OperationCanceledException>();
+        await Assert.That(gate.TryStop()).IsFalse();
+    }
+
+    /// <summary>Pending factories deliver one terminal result through either subscription path.</summary>
+    /// <param name="immediate">Whether notifications use the immediate sequencer.</param>
+    /// <param name="outcome">Zero for success, one for failure, or two for cancellation.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(true, 0)]
+    [Arguments(true, 1)]
+    [Arguments(true, 2)]
+    [Arguments(false, 0)]
+    [Arguments(false, 1)]
+    [Arguments(false, 2)]
+    public async Task PendingFactoryDeliversTerminalResult(bool immediate, int outcome)
+    {
+        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var signal = Signal.FromTask(_ => pending.Task, immediate ? Sequencer.Immediate : Sequencer.CurrentThread);
+        TaskNotificationObserver observer = new();
+        using var signalLifetime = (IDisposable)signal;
+        using var subscription = signal.Subscribe(observer);
+        CompletePending(pending, outcome);
+        await observer.Terminal.Task;
+        await Assert.That(observer.Values.Count).IsEqualTo(outcome == 0 ? 1 : 0);
+        await Assert.That(observer.Completions).IsEqualTo(outcome == 0 ? 1 : 0);
+        if (outcome == 0)
+        {
+            await Assert.That(observer.Values[0]).IsEqualTo(SuccessValue);
+            await Assert.That(observer.Error).IsNull();
+        }
+        else if (outcome == 1)
+        {
+            await Assert.That(observer.Error).IsTypeOf<InvalidOperationException>();
+        }
+        else
+        {
+            await Assert.That(observer.Error is OperationCanceledException).IsTrue();
+        }
+    }
+
+    /// <summary>A disposal claim suppresses either a value or a fault after observation finishes.</summary>
+    /// <param name="fault">Whether the task fails.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DisposedObservationSuppressesTerminalResult(bool fault)
+    {
+        TaskCompletionSource<(int Value, bool IsCanceled)> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        Signal.TaskStopGate gate = new();
+        TaskNotificationObserver observer = new();
+        var observation = Signal.ObserveTask(pending.Task, observer, gate, CancellationToken.None);
+        await Assert.That(gate.TryStop()).IsTrue();
+        if (fault)
+        {
+            pending.SetException(new InvalidOperationException(BreakExecutionMessage));
+        }
+        else
+        {
+            pending.SetResult((SuccessValue, false));
+        }
+
+        await observation;
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Error).IsNull();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+    }
+
+    /// <summary>Disposal tolerates a released token source and suppresses the subsequent result.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task DisposalToleratesReleasedCancellationSource()
+    {
+        CancellationTokenSource source = new();
+        Signal.TaskStopGate gate = new();
+        TaskNotificationObserver observer = new();
+        TaskCompletionSource<(int Value, bool IsCanceled)> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var token = source.Token;
+        var subscription = Signal.CancelOnDispose(gate, source);
+        source.Dispose();
+        subscription.Dispose();
+        pending.SetResult((SuccessValue, false));
+        await Signal.ObserveTask(pending.Task, observer, gate, token);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Error).IsNull();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+    }
+
+    /// <summary>Disposing a pending subscription cancels the token in either subscription path.</summary>
+    /// <param name="immediate">Whether the immediate path is selected.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task SubscriptionDisposalCancelsPendingFactory(bool immediate)
+    {
+        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var signal = Signal.FromTask(_ => pending.Task, immediate ? Sequencer.Immediate : Sequencer.CurrentThread);
+        using var lifetime = (IDisposable)signal;
+        var subscription = signal.Subscribe(static _ => { });
+        subscription.Dispose();
+        await Assert.That(signal.IsCancellationRequested).IsTrue();
+        pending.SetResult(SuccessValue);
+    }
+
+    /// <summary>Cancellation before a result reaches the observer produces one error.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task ImmediateSignalCancellationPrecedesResult()
+    {
+        TaskCompletionSource<int> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var signal = Signal.FromTask(_ => pending.Task, Sequencer.Immediate);
+        using var lifetime = (IDisposable)signal;
+        TaskNotificationObserver observer = new();
+        using var subscription = signal.Subscribe(observer);
+        await Assert.That(ReferenceEquals(signal.Source, signal)).IsTrue();
+        await signal.CancellationTokenSource!.CancelAsync();
+        pending.SetResult(SuccessValue);
+        await observer.Terminal.Task;
+        await Assert.That(observer.Error).IsTypeOf<OperationCanceledException>();
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+    }
+
+    /// <summary>Repeated disposal raises the cancellation callback once and preserves the disposed state.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task ImmediateSignalDisposalRaisesCancellationOnce()
+    {
+        var signal = Signal.FromTask(static _ => Task.FromResult(SuccessValue), Sequencer.Immediate);
+        var cancellations = 0;
+        signal.GetOperationCanceled(Witness.Create<Exception>(_ => cancellations++));
+        await Assert.That(signal.IsDisposed).IsFalse();
+        await Assert.That(signal.IsCancellationRequested).IsFalse();
+        ((IDisposable)signal).Dispose();
+        ((IDisposable)signal).Dispose();
+        await Assert.That(signal.IsDisposed).IsTrue();
+        await Assert.That(signal.IsCancellationRequested).IsTrue();
+        await Assert.That(cancellations).IsEqualTo(1);
+    }
+
+    /// <summary>Completes a pending factory with the selected outcome.</summary>
+    /// <param name="pending">The controlled task source.</param>
+    /// <param name="outcome">The terminal outcome.</param>
+    private static void CompletePending(TaskCompletionSource<int> pending, int outcome)
+    {
+        if (outcome == 0)
+        {
+            pending.SetResult(SuccessValue);
+        }
+        else if (outcome == 1)
+        {
+            pending.SetException(new InvalidOperationException(BreakExecutionMessage));
+        }
+        else
+        {
+            pending.SetCanceled();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
index 93dfe02a..fbf96a62 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
@@ -9,7 +9,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Verifies <see cref="TaskSignal{T}"/> cancellation and disposal contracts.</summary>
-public class TaskSignalTests
+public partial class TaskSignalTests
 {
     /// <summary>Covers task-signal cancellation registration and disposal branches.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
@@ -57,8 +57,7 @@ public async Task TaskSignalDisposeToleratesAnAlreadyDisposedTokenSource()
         CancellationTokenSource cts = new();
         var taskSignal = TaskSignal<int>.Create(static _ => Signal.Silent<int>(), Sequencer.CurrentThread, cts);
 
-        // The task-completion path can release the token source before the outer subscription is disposed, so
-        // cancelling it during disposal throws ObjectDisposedException, which disposal has to swallow.
+        // Completion may release the token source before subscription disposal.
         cts.Dispose();
 
         taskSignal.Dispose();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
index bd73cb81..a24afd69 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
@@ -14,23 +14,6 @@ public sealed class WasmSequencerTests
     /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
-    /// <summary>Longest a test waits for scheduled work before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>How far in the future delayed work is scheduled.</summary>
-    private static readonly TimeSpan ScheduleDelay = TimeSpan.FromMilliseconds(50);
-
-    /// <summary>How long a disposed sequencer is watched to prove it never ran the work it rejected or released.</summary>
-    private static readonly TimeSpan PostDisposeObservationWindow = TimeSpan.FromMilliseconds(200);
-
-    /// <summary>
-    /// How long to wait for the marshal step to release a delayed item once it comes due. The release runs on the
-    /// shared timer's pool thread, so on a saturated runner it can fire long after the item is due; a real failure
-    /// to release the item never signals, so this window only has to outlast a slow runner and costs nothing when
-    /// the item is released promptly.
-    /// </summary>
-    private static readonly TimeSpan ReleaseTimeout = TimeSpan.FromSeconds(30);
-
     /// <summary>Verifies the shared instance is a singleton.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -58,16 +41,18 @@ public async Task ClockAdvances()
         await Assert.That(sequencer.Timestamp).IsGreaterThanOrEqualTo(before);
     }
 
-    /// <summary>Verifies immediate work executes without the caller pumping anything.</summary>
+    /// <summary>Immediate work executes when its queued drain runs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ImmediateScheduleExecutes()
     {
-        TaskCompletionSource<bool> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        WasmSequencer.Default.Schedule(new DelegateWorkItem(() => executed.TrySetResult(true)));
-
-        await Assert.That(await executed.Task.WaitAsync(WaitTimeout)).IsTrue();
+        Queue<Action> drains = new();
+        using var sequencer = CreateSequencer(drains);
+        var executed = false;
+        sequencer.Schedule(new DelegateWorkItem(() => executed = true));
+        await Assert.That(executed).IsFalse();
+        drains.Dequeue()();
+        await Assert.That(executed).IsTrue();
     }
 
     /// <summary>Verifies a burst of immediate work executes in FIFO order.</summary>
@@ -75,54 +60,49 @@ public async Task ImmediateScheduleExecutes()
     [Test]
     public async Task ImmediateBurstExecutesInOrder()
     {
-        TaskCompletionSource<bool> done = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        Queue<Action> drains = new();
+        using var sequencer = CreateSequencer(drains);
         List<int> values = [];
-
         foreach (var value in ExpectedBurst)
         {
-            var captured = value;
-            WasmSequencer.Default.Schedule(new DelegateWorkItem(() =>
-            {
-                values.Add(captured);
-                if (values.Count != ExpectedBurst.Length)
-                {
-                    return;
-                }
-
-                _ = done.TrySetResult(true);
-            }));
+            sequencer.Schedule(new DelegateWorkItem(() => values.Add(value)));
         }
 
-        _ = await done.Task.WaitAsync(WaitTimeout);
-        await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default);
+        await Assert.That(drains.Count).IsEqualTo(1);
+        drains.Dequeue()();
+        await Assert.That(values.SequenceEqual(ExpectedBurst)).IsTrue();
     }
 
-    /// <summary>Verifies delayed work executes no earlier than its due timestamp.</summary>
+    /// <summary>Delayed work enters the drain only when the delay callback runs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayedScheduleExecutesAfterDue()
     {
-        var sequencer = WasmSequencer.Default;
-        TaskCompletionSource<long> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var start = sequencer.Timestamp;
-        var due = Sequencer.AddTimestamp(start, ScheduleDelay);
-
-        sequencer.Schedule(new DelegateWorkItem(() => executed.TrySetResult(sequencer.Timestamp)), due);
-
-        var executedAt = await executed.Task.WaitAsync(WaitTimeout);
-        await Assert.That(executedAt).IsGreaterThanOrEqualTo(start);
+        Queue<Action> drains = new();
+        ManualSequencer delays = new();
+        using var sequencer = CreateSequencer(drains, delays);
+        var executed = false;
+        sequencer.Schedule(new DelegateWorkItem(() => executed = true), long.MaxValue);
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(executed).IsFalse();
+        delays.RunPending();
+        await Assert.That(drains.Count).IsEqualTo(1);
+        await Assert.That(executed).IsFalse();
+        drains.Dequeue()();
+        await Assert.That(executed).IsTrue();
     }
 
-    /// <summary>Verifies a past-due timestamp executes promptly through the immediate path.</summary>
+    /// <summary>Past-due work uses the immediate queue.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task PastDueScheduleExecutes()
     {
-        TaskCompletionSource<bool> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        WasmSequencer.Default.Schedule(new DelegateWorkItem(() => executed.TrySetResult(true)), long.MinValue);
-
-        await Assert.That(await executed.Task.WaitAsync(WaitTimeout)).IsTrue();
+        Queue<Action> drains = new();
+        using var sequencer = CreateSequencer(drains);
+        var executed = false;
+        sequencer.Schedule(new DelegateWorkItem(() => executed = true), long.MinValue);
+        drains.Dequeue()();
+        await Assert.That(executed).IsTrue();
     }
 
     /// <summary>Verifies a cancelled work item never executes while later work still runs.</summary>
@@ -130,16 +110,17 @@ public async Task PastDueScheduleExecutes()
     [Test]
     public async Task CancelledItemIsSkipped()
     {
-        TaskCompletionSource<bool> markerRan = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        Queue<Action> drains = new();
+        using var sequencer = CreateSequencer(drains);
         var cancelledRan = false;
+        var markerRan = false;
         CancellableWorkItem cancelled = new(() => cancelledRan = true);
         cancelled.Dispose();
-
-        WasmSequencer.Default.Schedule(cancelled);
-        WasmSequencer.Default.Schedule(new DelegateWorkItem(() => markerRan.TrySetResult(true)));
-
-        _ = await markerRan.Task.WaitAsync(WaitTimeout);
+        sequencer.Schedule(cancelled);
+        sequencer.Schedule(new DelegateWorkItem(() => markerRan = true));
+        drains.Dequeue()();
         await Assert.That(cancelledRan).IsFalse();
+        await Assert.That(markerRan).IsTrue();
     }
 
     /// <summary>Verifies disposing a fresh sequencer releases its drain timer and is idempotent.</summary>
@@ -154,127 +135,106 @@ public async Task DisposeReleasesDrainTimerAndIsIdempotent()
         await Assert.That(sequencer.Dispose).ThrowsNothing();
     }
 
-    /// <summary>
-    /// Verifies a disposed sequencer rejects new work rather than queueing work it can never drain. Disposal releases
-    /// the drain timer, so an accepted item would sit in the ready queue forever behind a timer that can no longer be
-    /// armed. Both scheduling overloads fail fast instead, and neither item runs.
-    /// </summary>
+    /// <summary>A disposed sequencer rejects immediate and delayed work.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduleAfterDisposeThrowsObjectDisposedException()
     {
-        WasmSequencer sequencer = new();
+        Queue<Action> drains = new();
+        var sequencer = CreateSequencer(drains);
         var ran = 0;
-        DelegateWorkItem immediate = new(() => Interlocked.Increment(ref ran));
-        DelegateWorkItem delayed = new(() => Interlocked.Increment(ref ran));
-
+        DelegateWorkItem immediate = new(() => ran++);
+        DelegateWorkItem delayed = new(() => ran++);
         sequencer.Dispose();
-
         await Assert.That(() => sequencer.Schedule(immediate)).ThrowsExactly<ObjectDisposedException>();
-        await Assert
-            .That(() => sequencer.Schedule(delayed, Sequencer.AddTimestamp(sequencer.Timestamp, ScheduleDelay)))
-            .ThrowsExactly<ObjectDisposedException>();
-
-        await Task.Delay(PostDisposeObservationWindow);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        await Assert.That(() => sequencer.Schedule(delayed, long.MaxValue)).ThrowsExactly<ObjectDisposedException>();
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies an enqueue that loses the race to disposal releases the item it just queued. The disposed check runs
-    /// before the item joins the ready queue, so a disposal landing in between would otherwise strand the item behind
-    /// a drain timer that can never fire again — the caller would hold a handle to work that neither runs nor cancels.
-    /// </summary>
+    /// <summary>The ready queue releases work received after disposal.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task ScheduleReadyThatLosesTheRaceToDisposeReleasesTheItemItQueued()
+    public async Task ScheduleReadyAfterDisposeReleasesTheItem()
     {
-        WasmSequencer sequencer = new();
+        Queue<Action> drains = new();
+        var sequencer = CreateSequencer(drains);
         var ran = 0;
-        CancellableWorkItem item = new(() => Interlocked.Increment(ref ran));
-
+        CancellableWorkItem item = new(() => ran++);
         sequencer.Dispose();
-
-        // The enqueue that was already past the disposed check when the disposal drained the ready queue.
         sequencer.ScheduleReady(item);
-
         await Assert.That(item.IsDisposed).IsTrue();
-
-        await Task.Delay(PostDisposeObservationWindow);
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies delayed work still parked on the shared timer when the sequencer is disposed is released rather than
-    /// marshalled back into a sequencer that is gone. The marshal step must neither run the item nor throw
-    /// <see cref="ObjectDisposedException"/> on the timer's thread, where nothing could catch it.
-    /// </summary>
+    /// <summary>A delay callback releases work when the destination sequencer is disposed.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposeReleasesDelayedWorkThatComesDueAfterwards()
     {
-        WasmSequencer sequencer = new();
+        Queue<Action> drains = new();
+        ManualSequencer delays = new();
+        var sequencer = CreateSequencer(drains, delays);
         var ran = 0;
-        using ManualResetEventSlim released = new();
-        CancellableWorkItem delayed = new(() => Interlocked.Increment(ref ran), released.Set);
-
-        sequencer.Schedule(delayed, Sequencer.AddTimestamp(sequencer.Timestamp, ScheduleDelay));
+        var released = 0;
+        CancellableWorkItem delayed = new(() => ran++, () => released++);
+        sequencer.Schedule(delayed, long.MaxValue);
         sequencer.Dispose();
-
-        // The marshal step disposes the item on the shared timer's pool thread once it comes due. Wait on the
-        // actual release signal rather than sleeping a fixed window: on a saturated runner the pool-driven marshal
-        // step can fire well after any fixed delay, so a fixed sleep would report the item as never released even
-        // though it was. An event wait is an OS-level wait no pool pressure can starve, and a genuine failure to
-        // release the item never signals, so the generous window still fails.
-        await Assert.That(released.Wait(ReleaseTimeout)).IsTrue();
+        delays.RunPending();
+        await Assert.That(released).IsEqualTo(1);
         await Assert.That(delayed.IsDisposed).IsTrue();
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies delayed work cancelled before it comes due is dropped by the marshal step rather than pushed onto the
-    /// drain. The shared timer still fires, but the marshalled item observes the cancellation and returns without
-    /// scheduling anything.
-    /// </summary>
+    /// <summary>Canceled delayed work never reaches the ready queue.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayedItemCancelledBeforeItIsDueIsSkippedByTheMarshalStep()
     {
-        WasmSequencer sequencer = new();
+        Queue<Action> drains = new();
+        ManualSequencer delays = new();
+        using var sequencer = CreateSequencer(drains, delays);
         var ran = 0;
-        CancellableWorkItem delayed = new(() => Interlocked.Increment(ref ran));
-
-        sequencer.Schedule(delayed, Sequencer.AddTimestamp(sequencer.Timestamp, ScheduleDelay));
+        CancellableWorkItem delayed = new(() => ran++);
+        sequencer.Schedule(delayed, long.MaxValue);
         delayed.Dispose();
-
-        // Outlast the due time: the marshal step must observe the cancellation and drop the item.
-        await Task.Delay(ScheduleDelay + PostDisposeObservationWindow);
-
+        delays.RunPending();
         await Assert.That(delayed.IsDisposed).IsTrue();
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies delayed work that carries no cancellation handle is simply dropped when the sequencer is disposed
-    /// before the item comes due. The marshal step cannot hand a non-disposable item back to a caller, so it releases
-    /// nothing and never runs it.
-    /// </summary>
+    /// <summary>Disposal suppresses delayed work without a cancellation handle.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposeDropsDelayedNonDisposableWorkThatComesDueAfterwards()
     {
-        WasmSequencer sequencer = new();
+        Queue<Action> drains = new();
+        ManualSequencer delays = new();
+        var sequencer = CreateSequencer(drains, delays);
         var ran = 0;
-        DelegateWorkItem delayed = new(() => Interlocked.Increment(ref ran));
-
-        sequencer.Schedule(delayed, Sequencer.AddTimestamp(sequencer.Timestamp, ScheduleDelay));
+        sequencer.Schedule(new DelegateWorkItem(() => ran++), long.MaxValue);
         sequencer.Dispose();
-
-        // Outlast the due time: the marshal step sees the disposed owner and, with no handle to release, drops it.
-        await Task.Delay(ScheduleDelay + PostDisposeObservationWindow);
-
-        await Assert.That(Volatile.Read(ref ran)).IsEqualTo(0);
+        delays.RunPending();
+        await Assert.That(drains.Count).IsEqualTo(0);
+        await Assert.That(ran).IsEqualTo(0);
     }
 
+    /// <summary>Creates a sequencer whose event loop is driven explicitly.</summary>
+    /// <param name="drains">The queued drain callbacks.</param>
+    /// <param name="delays">The delayed callback queue.</param>
+    /// <returns>The isolated sequencer.</returns>
+    private static WasmSequencer CreateSequencer(Queue<Action> drains, ManualSequencer? delays = null) =>
+        new(
+            drain =>
+            {
+                drains.Enqueue(drain);
+                return true;
+            },
+            (delays ?? new ManualSequencer()).Schedule);
+
     /// <summary>Work item that invokes a delegate when executed.</summary>
     private sealed class DelegateWorkItem : IWorkItem
     {
@@ -298,7 +258,7 @@ private sealed class CancellableWorkItem(Action action, Action? onDisposed = nul
         /// <summary>The action to run on execution.</summary>
         private readonly Action _action = action;
 
-        /// <summary>Invoked the instant the item is disposed, so a test can wait on the real release.</summary>
+        /// <summary>Reports disposal.</summary>
         private readonly Action? _onDisposed = onDisposed;
 
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.Helpers.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.Helpers.cs
new file mode 100644
index 00000000..f6d9d29e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.Helpers.cs
@@ -0,0 +1,155 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies <see cref="Witness"/> routing and safe-termination contracts.</summary>
+public partial class WitnessTests
+{
+    /// <summary>Asserts each witness rejects the callback or observer it cannot work without.</summary>
+    private static void AssertWitnessConstructorsRejectMissingCallbacks()
+    {
+        _ = Assert.Throws<ArgumentNullException>(static () =>
+        {
+            CallbackWitness<int> invalid = new(null!, null, null);
+            GC.KeepAlive(invalid);
+        });
+        _ = Assert.Throws<ArgumentNullException>(static () =>
+        {
+            ForwardingWitness<int> invalid = new(null!);
+            GC.KeepAlive(invalid);
+        });
+        _ = Assert.Throws<ArgumentNullException>(static () =>
+        {
+            StatefulWitness<int, string> invalid = new(State, null!, null, null);
+            GC.KeepAlive(invalid);
+        });
+    }
+
+    /// <summary>Asserts a callback witness forwards each notification, and rethrows when no error callback was given.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task AssertCallbackWitnessForwardsEachNotification()
+    {
+        List<int> callbackValues = [];
+        List<Exception> callbackErrors = [];
+        List<Result> callbackCompletions = [];
+        CallbackWitness<int> callback = new(callbackValues.Add, callbackErrors.Add, callbackCompletions.Add);
+        InvalidOperationException callbackError = new("callback");
+        callback.OnNext(One);
+        callback.OnError(callbackError);
+        callback.OnCompleted();
+        await Assert.That(callbackValues.SequenceEqual([One])).IsTrue();
+        await Assert.That(callbackErrors[0]).IsSameReferenceAs(callbackError);
+        await Assert.That(callbackCompletions[0].IsSuccess).IsTrue();
+        InvalidOperationException callbackFallback = new("callback fallback");
+        _ = Assert.Throws<InvalidOperationException>(() =>
+            new CallbackWitness<int>(static _ => { }, null, null).OnError(callbackFallback));
+        new CallbackWitness<int>(static _ => { }, null, null).OnCompleted();
+    }
+
+    /// <summary>Asserts a forwarding witness passes every notification through to the observer it wraps.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task AssertForwardingWitnessForwardsEachNotification()
+    {
+        Recorder<int> forwarded = new();
+        ForwardingWitness<int> forwarding = new(forwarded);
+        InvalidOperationException forwardingError = new("forwarding");
+        forwarding.OnNext(Two);
+        forwarding.OnError(forwardingError);
+        forwarding.OnCompleted();
+        await Assert.That(forwarded.Values.SequenceEqual([Two])).IsTrue();
+        await Assert.That(forwarded.Errors[0]).IsSameReferenceAs(forwardingError);
+        await Assert.That(forwarded.Completed).IsEqualTo(1);
+    }
+
+    /// <summary>Asserts a stateful witness hands its state to every callback, and rethrows without an error callback.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task AssertStatefulWitnessForwardsEachNotificationWithItsState()
+    {
+        List<string> statefulValues = [];
+        List<string> statefulErrors = [];
+        List<string> statefulCompletions = [];
+        StatefulWitness<int, string> stateful = new(
+            State,
+            (value, state) => statefulValues.Add($"{state}:{value}"),
+            (error, state) => statefulErrors.Add($"{state}:{error.Message}"),
+            (result, state) => statefulCompletions.Add($"{state}:{result.IsSuccess}"));
+        InvalidOperationException statefulError = new("stateful");
+        stateful.OnNext(One);
+        stateful.OnError(statefulError);
+        stateful.OnCompleted();
+        await Assert.That(statefulValues.SequenceEqual([$"{State}:{One}"])).IsTrue();
+        await Assert.That(statefulErrors.SequenceEqual([$"{State}:{statefulError.Message}"])).IsTrue();
+        await Assert.That(statefulCompletions.SequenceEqual([$"{State}:True"])).IsTrue();
+        InvalidOperationException statefulFallback = new("stateful fallback");
+        _ = Assert.Throws<InvalidOperationException>(() =>
+            new StatefulWitness<int, string>(State, static (_, _) => { }, null, null).OnError(statefulFallback));
+        new StatefulWitness<int, string>(State, static (_, _) => { }, null, null).OnCompleted();
+    }
+
+    /// <summary>Asserts a safe witness drops every notification that arrives after its first terminal one.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private static async Task AssertSafeWitnessIgnoresNotificationsAfterTheTerminal()
+    {
+        List<int> safeValues = [];
+        List<Exception> safeErrors = [];
+        var safeCompleted = 0;
+        var safe = Witness.Safe(Witness.Create<int>(safeValues.Add, safeErrors.Add, () => safeCompleted++));
+        safe.OnNext(One);
+        safe.OnCompleted();
+        safe.OnNext(Two);
+        safe.OnError(new InvalidOperationException("ignored"));
+        safe.OnCompleted();
+        await Assert.That(safeValues.SequenceEqual([One])).IsTrue();
+        await Assert.That(safeErrors.Count).IsEqualTo(0);
+        await Assert.That(safeCompleted).IsEqualTo(1);
+    }
+
+    /// <summary>Records observer notifications.</summary>
+    /// <typeparam name="T">The observed value type.</typeparam>
+    private sealed class Recorder<T> : IObserver<T>
+    {
+        /// <summary>Gets observed values.</summary>
+        public List<T> Values { get; } = [];
+
+        /// <summary>Gets observed errors.</summary>
+        public List<Exception> Errors { get; } = [];
+
+        /// <summary>Gets the number of completion notifications.</summary>
+        public int Completed { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completed++;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnError(Exception error) => Errors.Add(error);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnNext(T value) => Values.Add(value);
+    }
+
+    /// <summary>Observable with a disposable subscription tracker and captured observer.</summary>
+    /// <typeparam name="T">The source value type.</typeparam>
+    private sealed class RecordingDisposableObservable<T> : IObservable<T>
+    {
+        /// <summary>Gets the captured observer.</summary>
+        public IObserver<T>? Observer { get; private set; }
+
+        /// <summary>Gets the number of times the source subscription was disposed.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            Observer = observer;
+            return new ActionDisposable(() => DisposeCount++);
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
index 669c4c8e..70f62b03 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated 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;
 using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
@@ -11,7 +10,7 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Verifies <see cref="Witness"/> routing and safe-termination contracts.</summary>
-public class WitnessTests
+public partial class WitnessTests
 {
     /// <summary>A reusable value for one.</summary>
     private const int One = 1;
@@ -37,9 +36,6 @@ public class WitnessTests
     /// <summary>A reusable value for fourteen.</summary>
     private const int Fourteen = 14;
 
-    /// <summary>Timeout used when awaiting a witness task that has already been driven to its terminal.</summary>
-    private const int TimeoutSeconds = 2;
-
     /// <summary>Shared state value.</summary>
     private const string State = "state";
 
@@ -157,11 +153,7 @@ public async Task WitnessesCoverDisposedThrowEmptyAndSafeBranches()
         _ = Assert.Throws<ArgumentNullException>(() => safe.OnError(null!));
     }
 
-    /// <summary>
-    /// Verifies the witness holds every notification back until its sequencer runs the queued drain, then replays
-    /// values and the completion through the observer in order. The dispatch is driven by a sequencer the test owns
-    /// so the handover is observed exactly rather than raced against a pool thread.
-    /// </summary>
+    /// <summary>The witness defers notifications until its sequencer drains them in source order.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task WitnessOnDefersNextAndCompletedUntilTheSequencerDrainsThem()
@@ -280,19 +272,19 @@ public async Task TaskAnyWitnessCompletesTrueFalseErrorsAndIgnoresLateSignals()
         any.OnNext(One);
         any.OnNext(Two);
         any.OnCompleted();
-        await Assert.That(await WaitForAsync(any.Task)).IsTrue();
+        await Assert.That(await any.Task).IsTrue();
         await Assert.That(anySubscription.DisposeCount).IsEqualTo(One);
 
         TaskAnyWitness<int> unmatched = new(static value => value > Four, CancellationToken.None);
         unmatched.OnNext(One);
         unmatched.OnCompleted();
         unmatched.OnNext(Four);
-        await Assert.That(await WaitForAsync(unmatched.Task)).IsFalse();
+        await Assert.That(await unmatched.Task).IsFalse();
 
         InvalidOperationException predicateError = new("any-predicate");
         TaskAnyWitness<int> predicateFault = new(_ => throw predicateError, CancellationToken.None);
         predicateFault.OnNext(One);
-        var observedPredicateError = await Assert.That(() => WaitForAsync(predicateFault.Task))
+        var observedPredicateError = await Assert.That(() => predicateFault.Task)
             .ThrowsExactly<InvalidOperationException>();
         await Assert.That(observedPredicateError).IsSameReferenceAs(predicateError);
 
@@ -300,7 +292,7 @@ public async Task TaskAnyWitnessCompletesTrueFalseErrorsAndIgnoresLateSignals()
         TaskAnyWitness<int> sourceFault = new(CancellationToken.None);
         sourceFault.OnError(sourceError);
         sourceFault.OnCompleted();
-        var observedSourceError = await Assert.That(() => WaitForAsync(sourceFault.Task))
+        var observedSourceError = await Assert.That(() => sourceFault.Task)
             .ThrowsExactly<InvalidOperationException>();
         await Assert.That(observedSourceError).IsSameReferenceAs(sourceError);
     }
@@ -315,7 +307,7 @@ public async Task TaskCountWitnessCountsMatchesErrorsAndIgnoresLateSignals()
         all.OnNext(Two);
         all.OnCompleted();
         all.OnNext(Three);
-        await Assert.That(await WaitForAsync(all.Task)).IsEqualTo(Two);
+        await Assert.That(await all.Task).IsEqualTo(Two);
 
         TaskCountWitness<int> even = new(static value => value % Two == 0, CancellationToken.None);
         even.OnNext(One);
@@ -324,12 +316,12 @@ public async Task TaskCountWitnessCountsMatchesErrorsAndIgnoresLateSignals()
         even.OnNext(Four);
         even.OnCompleted();
         even.OnError(new InvalidOperationException("late"));
-        await Assert.That(await WaitForAsync(even.Task)).IsEqualTo(Two);
+        await Assert.That(await even.Task).IsEqualTo(Two);
 
         InvalidOperationException predicateError = new("count-predicate");
         TaskCountWitness<int> predicateFault = new(_ => throw predicateError, CancellationToken.None);
         predicateFault.OnNext(One);
-        var observedPredicateError = await Assert.That(() => WaitForAsync(predicateFault.Task))
+        var observedPredicateError = await Assert.That(() => predicateFault.Task)
             .ThrowsExactly<InvalidOperationException>();
         await Assert.That(observedPredicateError).IsSameReferenceAs(predicateError);
 
@@ -337,7 +329,7 @@ public async Task TaskCountWitnessCountsMatchesErrorsAndIgnoresLateSignals()
         TaskCountWitness<int> sourceFault = new(CancellationToken.None);
         sourceFault.OnError(sourceError);
         sourceFault.OnNext(Two);
-        var observedSourceError = await Assert.That(() => WaitForAsync(sourceFault.Task))
+        var observedSourceError = await Assert.That(() => sourceFault.Task)
             .ThrowsExactly<InvalidOperationException>();
         await Assert.That(observedSourceError).IsSameReferenceAs(sourceError);
     }
@@ -352,7 +344,7 @@ public async Task TaskTerminalWitnessesDisposeSubscriptionsOnTerminalCancelAndDi
         completed.SetSubscription(completedSubscription);
         completed.OnCompleted();
         completed.Dispose();
-        await Assert.That(await WaitForAsync(completed.Task)).IsFalse();
+        await Assert.That(await completed.Task).IsFalse();
         await Assert.That(completedSubscription.DisposeCount).IsEqualTo(One);
 
         TaskAnyWitness<int> alreadyStopped = new(CancellationToken.None);
@@ -956,172 +948,4 @@ public async Task ListWitnessRemoveReturnsTheSameWitnessWhenTheObserverIsNotPres
 
         await Assert.That(result).IsSameReferenceAs(witness);
     }
-
-    /// <summary>Asserts each witness rejects the callback or observer it cannot work without.</summary>
-    private static void AssertWitnessConstructorsRejectMissingCallbacks()
-    {
-        _ = Assert.Throws<ArgumentNullException>(static () =>
-        {
-            CallbackWitness<int> invalid = new(null!, null, null);
-            GC.KeepAlive(invalid);
-        });
-        _ = Assert.Throws<ArgumentNullException>(static () =>
-        {
-            ForwardingWitness<int> invalid = new(null!);
-            GC.KeepAlive(invalid);
-        });
-        _ = Assert.Throws<ArgumentNullException>(static () =>
-        {
-            StatefulWitness<int, string> invalid = new(State, null!, null, null);
-            GC.KeepAlive(invalid);
-        });
-    }
-
-    /// <summary>Asserts a callback witness forwards each notification, and rethrows when no error callback was given.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task AssertCallbackWitnessForwardsEachNotification()
-    {
-        List<int> callbackValues = [];
-        List<Exception> callbackErrors = [];
-        List<Result> callbackCompletions = [];
-        CallbackWitness<int> callback = new(callbackValues.Add, callbackErrors.Add, callbackCompletions.Add);
-        InvalidOperationException callbackError = new("callback");
-        callback.OnNext(One);
-        callback.OnError(callbackError);
-        callback.OnCompleted();
-        await Assert.That(callbackValues.SequenceEqual([One])).IsTrue();
-        await Assert.That(callbackErrors[0]).IsSameReferenceAs(callbackError);
-        await Assert.That(callbackCompletions[0].IsSuccess).IsTrue();
-        InvalidOperationException callbackFallback = new("callback fallback");
-        _ = Assert.Throws<InvalidOperationException>(() =>
-            new CallbackWitness<int>(static _ => { }, null, null).OnError(callbackFallback));
-        new CallbackWitness<int>(static _ => { }, null, null).OnCompleted();
-    }
-
-    /// <summary>Asserts a forwarding witness passes every notification through to the observer it wraps.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task AssertForwardingWitnessForwardsEachNotification()
-    {
-        Recorder<int> forwarded = new();
-        ForwardingWitness<int> forwarding = new(forwarded);
-        InvalidOperationException forwardingError = new("forwarding");
-        forwarding.OnNext(Two);
-        forwarding.OnError(forwardingError);
-        forwarding.OnCompleted();
-        await Assert.That(forwarded.Values.SequenceEqual([Two])).IsTrue();
-        await Assert.That(forwarded.Errors[0]).IsSameReferenceAs(forwardingError);
-        await Assert.That(forwarded.Completed).IsEqualTo(1);
-    }
-
-    /// <summary>Asserts a stateful witness hands its state to every callback, and rethrows without an error callback.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task AssertStatefulWitnessForwardsEachNotificationWithItsState()
-    {
-        List<string> statefulValues = [];
-        List<string> statefulErrors = [];
-        List<string> statefulCompletions = [];
-        StatefulWitness<int, string> stateful = new(
-            State,
-            (value, state) => statefulValues.Add($"{state}:{value}"),
-            (error, state) => statefulErrors.Add($"{state}:{error.Message}"),
-            (result, state) => statefulCompletions.Add($"{state}:{result.IsSuccess}"));
-        InvalidOperationException statefulError = new("stateful");
-        stateful.OnNext(One);
-        stateful.OnError(statefulError);
-        stateful.OnCompleted();
-        await Assert.That(statefulValues.SequenceEqual([$"{State}:{One}"])).IsTrue();
-        await Assert.That(statefulErrors.SequenceEqual([$"{State}:{statefulError.Message}"])).IsTrue();
-        await Assert.That(statefulCompletions.SequenceEqual([$"{State}:True"])).IsTrue();
-        InvalidOperationException statefulFallback = new("stateful fallback");
-        _ = Assert.Throws<InvalidOperationException>(() =>
-            new StatefulWitness<int, string>(State, static (_, _) => { }, null, null).OnError(statefulFallback));
-        new StatefulWitness<int, string>(State, static (_, _) => { }, null, null).OnCompleted();
-    }
-
-    /// <summary>Asserts a safe witness drops every notification that arrives after its first terminal one.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    private static async Task AssertSafeWitnessIgnoresNotificationsAfterTheTerminal()
-    {
-        List<int> safeValues = [];
-        List<Exception> safeErrors = [];
-        var safeCompleted = 0;
-        var safe = Witness.Safe(Witness.Create<int>(safeValues.Add, safeErrors.Add, () => safeCompleted++));
-        safe.OnNext(One);
-        safe.OnCompleted();
-        safe.OnNext(Two);
-        safe.OnError(new InvalidOperationException("ignored"));
-        safe.OnCompleted();
-        await Assert.That(safeValues.SequenceEqual([One])).IsTrue();
-        await Assert.That(safeErrors.Count).IsEqualTo(0);
-        await Assert.That(safeCompleted).IsEqualTo(1);
-    }
-
-    /// <summary>Waits for a task with a bounded timeout.</summary>
-    /// <param name="task">The task to wait for.</param>
-    /// <returns>A task that completes when the supplied task completes.</returns>
-    /// <exception cref="TimeoutException">The supplied task did not complete within the bounded timeout.</exception>
-    private static async Task WaitForAsync(Task task)
-    {
-        var timeout = Task.Delay(TimeSpan.FromSeconds(TimeoutSeconds));
-        var completed = await Task.WhenAny(task, timeout).ConfigureAwait(false);
-        if (completed == timeout)
-        {
-            throw new TimeoutException("Timed out waiting for the witness task to complete.");
-        }
-
-        await task.ConfigureAwait(false);
-    }
-
-    /// <summary>Waits for a task with a bounded timeout and returns its result.</summary>
-    /// <typeparam name="T">The task result type.</typeparam>
-    /// <param name="task">The task to wait for.</param>
-    /// <returns>The task result.</returns>
-    private static async Task<T> WaitForAsync<T>(Task<T> task)
-    {
-        await WaitForAsync((Task)task).ConfigureAwait(false);
-        return await task.ConfigureAwait(false);
-    }
-
-    /// <summary>Records observer notifications.</summary>
-    /// <typeparam name="T">The observed value type.</typeparam>
-    private sealed class Recorder<T> : IObserver<T>
-    {
-        /// <summary>Gets observed values.</summary>
-        public List<T> Values { get; } = [];
-
-        /// <summary>Gets observed errors.</summary>
-        public List<Exception> Errors { get; } = [];
-
-        /// <summary>Gets the number of completion notifications.</summary>
-        public int Completed { get; private set; }
-
-        /// <inheritdoc/>
-        public void OnCompleted() => Completed++;
-
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void OnError(Exception error) => Errors.Add(error);
-
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void OnNext(T value) => Values.Add(value);
-    }
-
-    /// <summary>Observable with a disposable subscription tracker and captured observer.</summary>
-    /// <typeparam name="T">The source value type.</typeparam>
-    private sealed class RecordingDisposableObservable<T> : IObservable<T>
-    {
-        /// <summary>Gets the captured observer.</summary>
-        public IObserver<T>? Observer { get; private set; }
-
-        /// <summary>Gets the number of times the source subscription was disposed.</summary>
-        public int DisposeCount { get; private set; }
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            Observer = observer;
-            return new ActionDisposable(() => DisposeCount++);
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
index c5eecc95..405cf6ec 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
@@ -7,16 +7,9 @@
 
 namespace ReactiveUI.Primitives.WinForms.Reactive.Tests;
 
-/// <summary>
-/// Tests for <see cref="ControlSequencer"/> as an <see cref="IScheduler"/>, exercised against a real Windows Forms
-/// <see cref="Control"/> whose handle is created on a dedicated STA thread running a message loop, so posted work
-/// runs end to end. Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests scheduler dispatch on a dedicated Windows Forms STA thread.</summary>
 public sealed class ControlSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the control thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the constructor rejects a null control.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -34,17 +27,17 @@ public async Task ImmediateScheduleExecutesOnControlThread()
 
         _ = scheduler.Schedule(() => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
-    /// <summary>Hosts a Windows Forms <see cref="Control"/> on a dedicated STA thread running a message loop, exiting it and joining the thread on disposal.</summary>
+    /// <summary>Owns the control and its STA message loop.</summary>
     private sealed class ControlHarness : IDisposable
     {
         /// <summary>The thread running the Windows Forms message loop.</summary>
         private readonly Thread _thread;
 
-        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class and waits until the control handle and message loop are running.</summary>
+        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class with a created control handle.</summary>
         public ControlHarness()
         {
             using var ready = new ManualResetEventSlim(false);
@@ -72,7 +65,7 @@ public ControlHarness()
         public void Dispose()
         {
             _ = Control.BeginInvoke(Application.ExitThread);
-            _ = _thread.Join(WaitTimeout);
+            _thread.Join();
             Control.Dispose();
         }
     }
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
index 4e397575..e921d343 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
@@ -7,16 +7,9 @@
 
 namespace ReactiveUI.Primitives.WinForms.Tests;
 
-/// <summary>
-/// Tests for <see cref="ControlSequencer"/>, exercised against a real Windows Forms <see cref="Control"/>
-/// whose handle is created on a dedicated STA thread running a message loop, so posted work runs end to end.
-/// Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests control dispatch on a dedicated Windows Forms STA thread.</summary>
 public sealed class ControlSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the control thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
     /// <summary>Verifies the constructor rejects a null control.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -34,7 +27,7 @@ public async Task ImmediateScheduleExecutesOnControlThread()
 
         sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
@@ -53,13 +46,13 @@ private sealed class DelegateWorkItem : IWorkItem
         public void Execute() => _action();
     }
 
-    /// <summary>Hosts a Windows Forms <see cref="Control"/> on a dedicated STA thread running a message loop, exiting it and joining the thread on disposal.</summary>
+    /// <summary>Owns the control and its STA message loop.</summary>
     private sealed class ControlHarness : IDisposable
     {
         /// <summary>The thread running the Windows Forms message loop.</summary>
         private readonly Thread _thread;
 
-        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class and waits until the control handle and message loop are running.</summary>
+        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class with a created control handle.</summary>
         public ControlHarness()
         {
             using var ready = new ManualResetEventSlim(false);
@@ -87,7 +80,7 @@ public ControlHarness()
         public void Dispose()
         {
             _ = Control.BeginInvoke(Application.ExitThread);
-            _ = _thread.Join(WaitTimeout);
+            _thread.Join();
             Control.Dispose();
         }
     }
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
index cb195612..9006f733 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
@@ -8,25 +8,31 @@
 
 namespace ReactiveUI.Primitives.WinUI.Reactive.Tests;
 
-/// <summary>
-/// Tests for <see cref="DispatcherQueueSequencer"/> as an <see cref="IScheduler"/>, exercised against a real WinUI
-/// <see cref="DispatcherQueue"/> running on a dedicated thread so both the immediate and timer-based dispatch
-/// paths run end to end. Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests scheduler execution on a dedicated WinUI queue thread.</summary>
 public sealed class DispatcherQueueSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the dispatcher-queue thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>How far into the future the delayed work is scheduled.</summary>
-    private static readonly TimeSpan ScheduleDelay = TimeSpan.FromMilliseconds(50);
-
     /// <summary>Verifies the constructor rejects a null dispatcher queue.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ConstructorRejectsNullDispatcherQueue() =>
         await Assert.That(static () => new DispatcherQueueSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
+    /// <summary>Verifies a stopped dispatcher queue rejects scheduled work.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SchedulingAfterQueueShutdownThrows()
+    {
+        var harness = new DispatcherQueueHarness();
+        DispatcherQueueSequencer scheduler = new(harness.DispatcherQueue);
+        await harness.DisposeAsync();
+        var executed = false;
+        await Assert.That(() => scheduler.Schedule(() => executed = true))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(() => scheduler.Schedule(() => executed = true))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(executed).IsFalse();
+    }
+
     /// <summary>Verifies immediate work is enqueued to and executed on the dispatcher-queue thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -38,22 +44,22 @@ public async Task ImmediateScheduleExecutesOnQueueThread()
 
         _ = scheduler.Schedule(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess));
 
-        var ranOnQueueThread = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnQueueThread = await completion.Task;
         await Assert.That(ranOnQueueThread).IsTrue();
     }
 
-    /// <summary>Verifies work due in the future is executed on the dispatcher-queue thread via the queue timer.</summary>
+    /// <summary>Verifies due work executes on the dispatcher queue thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnQueueThread()
+    public async Task DueScheduleExecutesOnQueueThread()
     {
         await using var harness = new DispatcherQueueHarness();
         var scheduler = new DispatcherQueueSequencer(harness.DispatcherQueue);
         var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        _ = scheduler.Schedule(ScheduleDelay, () => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess));
+        _ = scheduler.Schedule(TimeSpan.Zero, () => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess));
 
-        var ranOnQueueThread = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnQueueThread = await completion.Task;
         await Assert.That(ranOnQueueThread).IsTrue();
     }
 
@@ -75,6 +81,6 @@ public DispatcherQueueHarness()
 
         /// <inheritdoc/>
         /// <returns>A task representing the asynchronous operation.</returns>
-        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask().WaitAsync(WaitTimeout);
+        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
index bbb522d0..fee1e84b 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
@@ -2,32 +2,48 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using Microsoft.UI.Dispatching;
 using ReactiveUI.Primitives.Concurrency;
 
 namespace ReactiveUI.Primitives.WinUI.Tests;
 
-/// <summary>
-/// Tests for <see cref="DispatcherQueueSequencer"/>, exercised against a real WinUI
-/// <see cref="DispatcherQueue"/> running on a dedicated thread so both the immediate and timer-based
-/// dispatch paths run end to end. Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests dispatcher execution on a dedicated WinUI queue thread.</summary>
 public sealed class DispatcherQueueSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the dispatcher-queue thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Stopwatch ticks until the delayed work falls due: one twentieth of a second, or 50 ms.</summary>
-    private static readonly long ScheduleDelayTicks = Stopwatch.Frequency / 20;
-
     /// <summary>Verifies the constructor rejects a null dispatcher queue.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ConstructorRejectsNullDispatcherQueue() =>
         await Assert.That(static () => new DispatcherQueueSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
+    /// <summary>Verifies the clock uses UTC and debugger text identifies the sequencer.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ClockUsesUtcAndDebuggerTextIdentifiesSequencer()
+    {
+        await using var harness = new DispatcherQueueHarness();
+        DispatcherQueueSequencer sequencer = new(harness.DispatcherQueue);
+        await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(sequencer.DebuggerDisplay).IsEqualTo(typeof(DispatcherQueueSequencer).FullName);
+    }
+
+    /// <summary>Verifies a stopped dispatcher queue rejects scheduled work.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SchedulingAfterQueueShutdownThrows()
+    {
+        var harness = new DispatcherQueueHarness();
+        DispatcherQueueSequencer sequencer = new(harness.DispatcherQueue);
+        await harness.DisposeAsync();
+        var executed = false;
+        await Assert.That(() => sequencer.Schedule(new DelegateWorkItem(() => executed = true)))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(() => sequencer.Schedule(new DelegateWorkItem(() => executed = true)))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(executed).IsFalse();
+    }
+
     /// <summary>Verifies immediate work is enqueued to and executed on the dispatcher-queue thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -39,23 +55,23 @@ public async Task ImmediateScheduleExecutesOnQueueThread()
 
         sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess)));
 
-        var ranOnQueueThread = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnQueueThread = await completion.Task;
         await Assert.That(ranOnQueueThread).IsTrue();
     }
 
-    /// <summary>Verifies work due in the future is executed on the dispatcher-queue thread via the queue timer.</summary>
+    /// <summary>Verifies due work executes on the dispatcher queue thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnQueueThread()
+    public async Task DueScheduleExecutesOnQueueThread()
     {
         await using var harness = new DispatcherQueueHarness();
         var sequencer = new DispatcherQueueSequencer(harness.DispatcherQueue);
         var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        var due = sequencer.Timestamp + ScheduleDelayTicks;
+        var due = sequencer.Timestamp;
         sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess)), due);
 
-        var ranOnQueueThread = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnQueueThread = await completion.Task;
         await Assert.That(ranOnQueueThread).IsTrue();
     }
 
@@ -92,6 +108,6 @@ public DispatcherQueueHarness()
 
         /// <inheritdoc/>
         /// <returns>A task representing the asynchronous operation.</returns>
-        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask().WaitAsync(WaitTimeout);
+        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
index 97da0bb6..81be19e1 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
@@ -8,19 +8,9 @@
 
 namespace ReactiveUI.Primitives.Wpf.Reactive.Tests;
 
-/// <summary>
-/// Tests for <see cref="DispatcherSequencer"/> as an <see cref="IScheduler"/>, exercised against a real WPF
-/// <see cref="Dispatcher"/> pumped on a dedicated STA thread so both the immediate and timer-based dispatch
-/// paths run end to end. Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests scheduler execution on a dedicated WPF STA thread.</summary>
 public sealed class DispatcherSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the dispatcher thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>How far into the future the delayed work is scheduled.</summary>
-    private static readonly TimeSpan ScheduleDelay = TimeSpan.FromMilliseconds(50);
-
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -38,26 +28,26 @@ public async Task ImmediateScheduleExecutesOnDispatcherThread()
 
         _ = scheduler.Schedule(() => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
-    /// <summary>Verifies work due in the future is executed on the dispatcher thread via the dispatcher timer.</summary>
+    /// <summary>Verifies due work executes on the dispatcher thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnDispatcherThread()
+    public async Task DueScheduleExecutesOnDispatcherThread()
     {
         using var harness = new DispatcherHarness();
         var scheduler = new DispatcherSequencer(harness.Dispatcher);
         var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        _ = scheduler.Schedule(ScheduleDelay, () => completion.TrySetResult(Environment.CurrentManagedThreadId));
+        _ = scheduler.Schedule(TimeSpan.Zero, () => completion.TrySetResult(Environment.CurrentManagedThreadId));
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
-    /// <summary>Hosts a WPF <see cref="Dispatcher"/> on a dedicated STA thread and pumps its message loop, shutting it down and joining the thread on disposal.</summary>
+    /// <summary>Owns a WPF dispatcher and its STA message loop.</summary>
     private sealed class DispatcherHarness : IDisposable
     {
         /// <summary>The thread running the dispatcher message loop.</summary>
@@ -90,7 +80,7 @@ public DispatcherHarness()
         public void Dispose()
         {
             Dispatcher.InvokeShutdown();
-            _ = _thread.Join(WaitTimeout);
+            _thread.Join();
         }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
index 9f99becb..666a6753 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
@@ -2,32 +2,32 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Windows.Threading;
 using ReactiveUI.Primitives.Concurrency;
 
 namespace ReactiveUI.Primitives.Wpf.Tests;
 
-/// <summary>
-/// Tests for <see cref="DispatcherSequencer"/>, exercised against a real WPF <see cref="Dispatcher"/>
-/// pumped on a dedicated STA thread so both the immediate and timer-based dispatch paths run end to end.
-/// Compiled only on Windows builds (see the csproj).
-/// </summary>
+/// <summary>Tests dispatcher execution on a dedicated WPF STA thread.</summary>
 public sealed class DispatcherSequencerTests
 {
-    /// <summary>Maximum time to wait for work to be marshalled onto the dispatcher thread before failing.</summary>
-    private static readonly TimeSpan WaitTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>Stopwatch ticks until the delayed work falls due: one twentieth of a second, or 50 ms.</summary>
-    private static readonly long ScheduleDelayTicks = Stopwatch.Frequency / 20;
-
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ConstructorRejectsNullDispatcher() =>
         await Assert.That(static () => new DispatcherSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
+    /// <summary>Verifies the clock uses UTC and debugger text identifies the sequencer.</summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ClockUsesUtcAndDebuggerTextIdentifiesSequencer()
+    {
+        using var harness = new DispatcherHarness();
+        DispatcherSequencer sequencer = new(harness.Dispatcher);
+        await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(sequencer.DebuggerDisplay).IsEqualTo(typeof(DispatcherSequencer).FullName);
+    }
+
     /// <summary>Verifies immediate work is posted to and executed on the dispatcher thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -39,23 +39,23 @@ public async Task ImmediateScheduleExecutesOnDispatcherThread()
 
         sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
-    /// <summary>Verifies work due in the future is executed on the dispatcher thread via the dispatcher timer.</summary>
+    /// <summary>Verifies due work executes on the dispatcher thread.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
-    public async Task DelayedScheduleExecutesOnDispatcherThread()
+    public async Task DueScheduleExecutesOnDispatcherThread()
     {
         using var harness = new DispatcherHarness();
         var sequencer = new DispatcherSequencer(harness.Dispatcher);
         var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        var due = sequencer.Timestamp + ScheduleDelayTicks;
+        var due = sequencer.Timestamp;
         sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)), due);
 
-        var ranOnThreadId = await completion.Task.WaitAsync(WaitTimeout);
+        var ranOnThreadId = await completion.Task;
         await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
     }
 
@@ -74,7 +74,7 @@ private sealed class DelegateWorkItem : IWorkItem
         public void Execute() => _action();
     }
 
-    /// <summary>Hosts a WPF <see cref="Dispatcher"/> on a dedicated STA thread and pumps its message loop, shutting it down and joining the thread on disposal.</summary>
+    /// <summary>Owns a WPF dispatcher and its STA message loop.</summary>
     private sealed class DispatcherHarness : IDisposable
     {
         /// <summary>The thread running the dispatcher message loop.</summary>
@@ -107,7 +107,7 @@ public DispatcherHarness()
         public void Dispose()
         {
             Dispatcher.InvokeShutdown();
-            _ = _thread.Join(WaitTimeout);
+            _thread.Join();
         }
     }
 }
diff --git a/src/tests/Shared/AsyncTestHelpers.cs b/src/tests/Shared/AsyncTestHelpers.cs
deleted file mode 100644
index 603db651..00000000
--- a/src/tests/Shared/AsyncTestHelpers.cs
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Async.Tests;
-
-/// <summary>Shared test helpers for async observable tests.</summary>
-internal static class AsyncTestHelpers
-{
-    /// <summary>How long <see cref="CollectAsync{T}(IObservableAsync{T}, TimeProvider, CancellationToken)"/> waits for completion to propagate.</summary>
-    private static readonly TimeSpan CompletionPropagationTimeout = TimeSpan.FromSeconds(5);
-
-    /// <summary>How often a wait re-evaluates its condition when the caller does not choose an interval.</summary>
-    private static readonly TimeSpan DefaultPollInterval = TimeSpan.FromMilliseconds(10);
-
-    /// <summary>Collects all items and the completion result from an async observable.</summary>
-    /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
-    /// <param name="source">The async observable to collect from.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    /// <returns>A tuple containing the collected items and the completion result.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static Task<(List<T> Items, Result? Completion)> CollectAsync<T>(
-        IObservableAsync<T> source,
-        CancellationToken cancellationToken = default) =>
-        CollectAsync(source, TimeProvider.System, cancellationToken);
-
-    /// <summary>
-    /// Collects all items and the completion result from an async observable using the supplied
-    /// <see cref="TimeProvider"/> for the completion-propagation deadline.
-    /// </summary>
-    /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
-    /// <param name="source">The async observable to collect from.</param>
-    /// <param name="timeProvider">Time provider used to compute the propagation deadline.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    /// <returns>A tuple containing the collected items and the completion result.</returns>
-    internal static async Task<(List<T> Items, Result? Completion)> CollectAsync<T>(
-        IObservableAsync<T> source,
-        TimeProvider timeProvider,
-        CancellationToken cancellationToken = default)
-    {
-        ArgumentNullException.ThrowIfNull(timeProvider);
-
-        var items = new List<T>();
-        Result? completion = null;
-
-        await using var subscription = await source.SubscribeAsync(
-            (x, _) =>
-            {
-                items.Add(x);
-                return default;
-            },
-            null,
-            result =>
-            {
-                completion = result;
-                return default;
-            },
-            cancellationToken);
-
-        // Wait briefly for completion to propagate
-        var deadline = timeProvider.GetUtcNow().Add(CompletionPropagationTimeout);
-        using PeriodicTimer poll = new(DefaultPollInterval);
-        while (completion is null && timeProvider.GetUtcNow() < deadline)
-        {
-            _ = await poll.WaitForNextTickAsync(CancellationToken.None);
-        }
-
-        return (items, completion);
-    }
-
-    /// <summary>Collects all items from an async observable using ToListAsync.</summary>
-    /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
-    /// <param name="source">The async observable to collect from.</param>
-    /// <param name="timeoutMs">The timeout in milliseconds before the operation is cancelled.</param>
-    /// <returns>A list of all collected items.</returns>
-    internal static async Task<List<T>> ToListWithTimeoutAsync<T>(
-        IObservableAsync<T> source,
-        int timeoutMs = 5_000)
-    {
-        using var cts = new CancellationTokenSource(timeoutMs);
-        return await source.ToListAsync(cts.Token);
-    }
-
-    /// <summary>Waits until the provided condition is met or the timeout expires.</summary>
-    /// <param name="condition">Condition to evaluate.</param>
-    /// <param name="timeout">Maximum time to wait.</param>
-    /// <param name="pollInterval">Optional polling interval.</param>
-    /// <returns>True if the condition was met before timing out.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static Task<bool> WaitForConditionAsync(
-        Func<bool> condition,
-        TimeSpan timeout,
-        TimeSpan? pollInterval = null) =>
-        WaitForConditionAsync(condition, timeout, TimeProvider.System, pollInterval);
-
-    /// <summary>Waits until the provided condition is met or the timeout expires, using the supplied <see cref="TimeProvider"/> for deadline calculation.</summary>
-    /// <param name="condition">Condition to evaluate.</param>
-    /// <param name="timeout">Maximum time to wait.</param>
-    /// <param name="timeProvider">Time provider used to compute the wait deadline.</param>
-    /// <param name="pollInterval">Optional polling interval.</param>
-    /// <returns>True if the condition was met before timing out.</returns>
-    internal static async Task<bool> WaitForConditionAsync(
-        Func<bool> condition,
-        TimeSpan timeout,
-        TimeProvider timeProvider,
-        TimeSpan? pollInterval = null)
-    {
-        ArgumentNullException.ThrowIfNull(condition);
-        ArgumentNullException.ThrowIfNull(timeProvider);
-        ArgumentOutOfRangeException.ThrowIfLessThan(timeout, TimeSpan.Zero);
-
-        var interval = pollInterval ?? DefaultPollInterval;
-        var deadline = timeProvider.GetUtcNow().Add(timeout);
-
-        using PeriodicTimer poll = new(interval);
-        while (timeProvider.GetUtcNow() < deadline)
-        {
-            if (condition())
-            {
-                return true;
-            }
-
-            _ = await poll.WaitForNextTickAsync(CancellationToken.None);
-        }
-
-        return condition();
-    }
-}

From 2501532b8f5deb3cae4b6dc339633cb8bfe2bea1 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 21:42:35 +1000
Subject: [PATCH 03/11] chore: more churn

---
 src/Polyfills/ArgumentExceptionHelper.cs      |  5 +-
 .../ObjectDisposedExceptionHelper.cs          |  5 +-
 src/Primitives.Async.Shared/AsyncContext.cs   | 20 ++--
 .../Observables/FromAsync.Reactive.cs         |  4 +-
 .../Operators/ContextSwitchSignalAsync.cs     |  4 +-
 .../Operators/ParityHelpers.Reactive.cs       | 10 +-
 .../Operators/WitnessOn.cs                    |  6 +-
 .../CoalescingDispatchScheduler.cs            | 15 +--
 .../DispatchWorkItemBase.cs                   |  4 +-
 .../IDispatchWorkItem.cs                      |  2 +-
 .../Disposables/ActionDisposable.cs           |  2 +-
 .../Disposables/BooleanDisposable.cs          |  5 +-
 .../Disposables/CancellationDisposable.cs     | 16 +---
 .../Disposables/DisposableBag.cs              | 15 +--
 .../Disposables/EmptyDisposable.cs            |  2 +-
 .../Disposables/IsDisposed.cs                 |  5 +-
 .../Disposables/MultipleDisposable.cs         |  8 +-
 .../Disposables/MutableDisposable.cs          |  6 +-
 .../Disposables/OnceDisposable.cs             |  8 +-
 .../Disposables/SingleDisposable.cs           | 14 +--
 .../SingleReplaceableDisposable.cs            | 18 ++--
 .../Disposables/SwapDisposable.cs             |  6 +-
 .../ConcurrentWitnessCallsException.cs        |  5 +-
 .../ConnectableSignalAsync.cs                 |  4 +-
 .../ConnectableSignalAsyncState{T}.cs         |  5 +-
 .../Disposables/DisposableAsyncSlot.cs        |  4 +-
 .../Disposables/MultipleDisposableAsync.cs    | 26 ++---
 .../SingleAssignmentDisposableAsync.cs        |  5 +-
 .../SingleReplaceableDisposableAsync.cs       |  2 +-
 .../Helpers/FireAndForgetHelper.cs            |  8 +-
 .../IObservableAsync.cs                       |  2 +-
 .../IObserverAsync.cs                         |  4 +-
 .../Mixins/SignalExtensions.cs                | 10 +-
 .../Observables/Create.cs                     | 21 ++--
 .../Observables/Interval.cs                   |  3 +-
 .../Observables/Timer.cs                      | 14 +--
 .../Observables/ToAsyncSignal.cs              |  2 +-
 .../Operators/Pair.cs                         |  2 +-
 .../Operators/ParityHelpers.FilterFusions.cs  |  2 +-
 .../ParityHelpers.OperatorFusions.cs          |  8 +-
 .../Operators/ParityHelpers.cs                |  4 +
 .../Operators/ReduceAsync.cs                  | 28 +++---
 .../SignalAsyncExtensions.Bind.Rx.cs          |  1 +
 ...AsyncExtensions.DistinctUntilChanged.Rx.cs |  1 +
 .../SignalAsyncExtensions.Rescue.Rx.cs        |  1 +
 .../SignalAsyncExtensions.Scan.Rx.cs          |  2 +
 .../SignalAsyncExtensions.SelectMany.Rx.cs    |  5 +-
 .../SignalAsyncExtensions.Timeout.Rx.cs       |  4 +-
 .../Operators/SignalAsyncExtensions.Zip.Rx.cs |  2 +
 .../Operators/SingleAsync.cs                  | 16 ++--
 .../Operators/SingleOrDefaultAsync.cs         | 50 ++++------
 .../Operators/Skip.cs                         |  2 +-
 .../Operators/SkipWhile.cs                    |  4 +-
 .../Operators/SubscribeAsync.cs               | 14 +--
 .../Operators/TakeUntil.cs                    | 10 +-
 .../Operators/TakeWhile.cs                    |  4 +-
 .../Operators/Throttle.cs                     |  3 +-
 .../Operators/ToAsyncEnumerable.cs            | 11 +--
 .../Operators/ToDictionaryAsync.cs            | 14 +--
 .../Operators/Unique.cs                       | 11 +--
 .../Operators/Using.cs                        |  4 +-
 .../Operators/WaitCompletionAsync.cs          |  8 +-
 .../Signals/Base/Concurrent.cs                | 30 +++---
 ...yLatestSignalAsyncStateObserverLease{T}.cs |  2 +-
 .../Base/ReplayLatestSignalAsyncState{T}.cs   |  4 +-
 .../Signals/Base/SerialBroadcastHelpers.cs    |  8 +-
 .../Base/SignalAsyncStateObserverLease{T}.cs  |  2 +-
 .../Signals/Base/SignalAsyncState{T}.cs       | 12 +--
 ...yLatestSignalAsyncStateObserverLease{T}.cs |  2 +-
 ...tatelessReplayLatestSignalAsyncState{T}.cs |  4 +-
 .../Base/StatelessSignalAsyncState{T}.cs      |  2 +-
 .../ConcurrentReplayLatestSignalAsync.cs      |  7 +-
 .../Signals/ConcurrentSignalAsync.cs          |  5 +-
 ...currentStatelessReplayLatestSignalAsync.cs |  8 +-
 .../Signals/ConcurrentStatelessSignalAsync.cs |  5 +-
 .../Options/BehaviorSignalCreationOptions.cs  |  6 +-
 .../Signals/Options/PublishingOption.cs       |  2 +-
 .../ReplayLatestSignalCreationOptions.cs      |  7 +-
 .../Signals/Options/SignalCreationOptions.cs  |  7 +-
 .../Signals/SerialReplayLatestSignalAsync.cs  |  8 +-
 .../Signals/SerialSignalAsync.cs              |  2 +-
 .../SerialStatelessReplayLatestSignalAsync.cs |  9 +-
 .../Signals/SerialStatelessSignalAsync.cs     |  2 +-
 .../Signals/Signal.cs                         | 13 ++-
 .../WitnessAsync.cs                           |  8 +-
 .../Advanced/ImmediateReturnSignal{T}.cs      |  2 +-
 .../Advanced/SubscriptionSlots.cs             |  6 +-
 .../Concurrency/ScheduledItem.cs              | 23 ++---
 .../Concurrency/SequencerQueue.cs             |  2 +-
 .../Core/IObserver{TValue,TResult}.cs         | 10 +-
 .../Core/PriorityQueue.cs                     |  6 +-
 .../Core/TimeInterval{T}.cs                   | 44 ++++-----
 src/ReactiveUI.Primitives.Core/Optional.cs    | 12 +--
 src/ReactiveUI.Primitives.Core/Result.cs      |  9 +-
 .../Signals/AsyncSignal.cs                    | 77 +++++++--------
 .../Signals/AwaitWitness.cs                   | 21 ++--
 .../Signals/BehaviorSignalState{T}.cs         | 11 +--
 .../Signals/BehaviorSignal{T}.cs              | 31 +++---
 .../Signals/Broadcaster{T}.cs                 |  4 +-
 .../Signals/CommandExecution{TResult}.cs      |  3 +-
 .../Signals/CommandSignal{TResult}.cs         | 16 ++--
 .../Signals/DelayableNotificationSignal{T}.cs |  2 +-
 .../Signals/IAwaitSignal{T}.cs                | 17 ++--
 .../Signals/ISignal{TSource,TResult}.cs       |  7 +-
 .../Signals/ISignal{T}.cs                     |  2 +-
 .../Signals/ITaskSignal{T}.cs                 | 22 ++---
 .../Signals/IWitnessRemovable{T}.cs           |  4 +-
 .../Signals/KeepSignal{T}.cs                  | 34 +++----
 .../Signals/KeepWithSignal{T,TState}.cs       |  2 +-
 .../Signals/MapSignal{TSource,TResult}.cs     | 38 ++++----
 .../MapWithSignal{TSource,TState,TResult}.cs  |  2 +-
 .../Signals/ObserverHandler.cs                | 12 +--
 ...ProjectedReadOnlyState{TSource,TResult}.cs |  2 +-
 .../Signals/ReadOnlyState{T}.cs               | 11 +--
 .../Signals/Signal{T}.cs                      | 96 +++++++++----------
 .../Signals/TapWithSignal{T,TState}.cs        |  2 +-
 .../SubscribeExtensions.cs                    | 80 ++++++++--------
 .../ConcurrencyLimiter.cs                     | 34 +++----
 .../Continuation.cs                           | 52 +++++-----
 .../FirstAsTaskHelper.cs                      | 12 +--
 .../FirstAsValueTaskHelper.cs                 | 12 +--
 .../Heartbeat.cs                              |  7 +-
 .../IDrainTarget.cs                           |  6 +-
 .../IHeartbeat.cs                             | 10 +-
 .../IStale.cs                                 | 10 +-
 .../Internal/ConcurrencyRaceHelpers.cs        | 18 +---
 .../Internal/IndexedSubscribeHelper.cs        |  2 +-
 .../Internal/ObservableSubscribeExtensions.cs |  2 +-
 .../Internal/ReduceSinkState.cs               |  3 +-
 .../Observables.cs                            |  6 +-
 .../ObserverArrayHelpers.cs                   | 23 +----
 .../ObserverExtensions.cs                     |  8 +-
 .../Operators/BinaryMinMaxObservable.cs       | 16 ++--
 .../Operators/BooleanReduceObservable.cs      | 17 ++--
 .../Operators/BufferUntilObservable.cs        | 10 +-
 .../CatchAndReturnWithFactoryObservable.cs    | 12 +--
 .../Operators/CatchIgnoreEmptyObservable.cs   |  4 +-
 .../Operators/CatchIgnoreObservable.cs        |  7 +-
 .../Operators/CatchReturnObservable.cs        |  6 +-
 .../Operators/DoOnDisposeObservable.cs        |  2 +-
 .../Operators/DoOnSubscribeObservable.cs      |  2 +-
 .../Operators/DropIfBusyObservable.cs         | 10 +-
 .../Operators/FilterRegexObservable.cs        |  7 +-
 .../Operators/LatestOrDefaultObservable.cs    |  9 +-
 .../Operators/MinMaxObservable.cs             | 17 ++--
 .../Operators/NotObservable.cs                |  6 +-
 .../Operators/PairwiseObservable.cs           |  4 +-
 .../Operators/PartitionObservable.cs          | 19 ++--
 .../Operators/PropertyChangedObservable.cs    | 16 ++--
 .../Operators/RetryForeverObservable.cs       |  6 +-
 .../Operators/SampleLatestObservable.cs       | 20 ++--
 .../Operators/ScanWithInitialObservable.cs    |  9 +-
 .../SelectAsyncConcurrentObservable.cs        | 10 +-
 .../SelectAsyncSequentialObservable.cs        | 10 +-
 .../Operators/SelectConstantObservable.cs     |  7 +-
 .../Operators/SelectLatestAsyncObservable.cs  | 14 ++-
 .../Operators/SelectManyThenObservable.cs     | 14 ++-
 .../Operators/ShuffleObservable.cs            |  8 +-
 .../Operators/SkipWhileNullObservable.cs      |  5 +-
 .../Operators/SubscribeAsyncObservable.cs     | 12 ++-
 .../Operators/SwitchIfEmptyObservable.cs      | 13 ++-
 .../Operators/SynchronizeAsyncObservable.cs   | 15 +--
 .../Operators/TakeUntilInclusiveObservable.cs |  7 +-
 .../Operators/TrySelectObservable.cs          |  6 +-
 .../Operators/WaitUntilObservable.cs          |  8 +-
 .../Operators/WhereFalseObservable.cs         |  7 +-
 .../Operators/WhereIsNotNullObservable.cs     |  7 +-
 .../Operators/WhereSelectObservable.cs        | 12 +--
 .../Operators/WhereTrueObservable.cs          |  7 +-
 .../SingleValueSignal.cs                      |  5 +-
 .../Stale.cs                                  |  7 +-
 .../TimerSinkState.cs                         | 10 +-
 .../Concurrency/MauiDispatcherSequencer.cs    |  3 +
 .../CodeGeneration/GeneratedNames.cs          |  2 +-
 .../CodeGeneration/PooledStringBuilder.cs     |  2 +-
 .../CodeGeneration/SourceFileWriter.cs        |  2 +-
 .../Helpers/InstanceTargetExtractor.cs        |  2 +-
 .../Helpers/StaticTargetExtractor.cs          |  2 +-
 .../Helpers/SymbolHelpers.cs                  |  2 +-
 .../Models/EventModel.cs                      |  4 +-
 .../Concurrency/CurrentThreadSequencer.cs     |  2 +-
 .../Concurrency/WasmScheduler.cs              |  2 +-
 .../Platforms/android/HandlerSequencer.cs     |  3 +-
 .../Concurrency/ControlSequencer.cs           |  3 +
 .../Concurrency/ControlSequencer.cs           |  6 +-
 .../Concurrency/DispatcherQueueSequencer.cs   |  7 +-
 .../Concurrency/DispatcherQueueSequencer.cs   | 10 +-
 .../Concurrency/DispatcherSequencer.cs        |  9 +-
 .../Concurrency/DispatcherSequencer.cs        | 11 ++-
 .../Concurrency/CurrentThreadSequencer.cs     |  2 +-
 .../Concurrency/ImmediateSequencer.cs         |  4 +-
 .../Concurrency/SequencerExtensions.cs        |  1 -
 .../Concurrency/SynchronizedSequencerQueue.cs |  5 +-
 .../Concurrency/ThreadPoolSequencer.cs        |  2 +-
 .../Concurrency/VirtualClock.cs               |  4 +-
 .../Concurrency/VirtualTimeMessages.cs        |  4 +-
 .../VirtualTimeSequencerExtensions.cs         |  5 +-
 ...rtualTimeSequencer{TAbsolute,TRelative}.cs |  4 +-
 .../VirtualTimeState{TAbsolute,TRelative}.cs  |  7 +-
 .../Concurrency/WasmSequencer.cs              |  2 +-
 .../Platforms/android/HandlerSequencer.cs     |  3 +-
 src/ReactiveUI.Primitives/RxVoid.cs           |  2 +-
 .../AsyncExtensionsComparisonBenchmarks.cs    |  5 +-
 .../CoreRuntimeBenchmarks.cs                  |  6 +-
 .../FactoryAdapterExpansionBenchmarks.cs      |  4 +-
 .../FactoryGcProfileBenchmarks.cs             |  3 +-
 .../OperatorPassThroughBenchmarks.cs          |  6 +-
 .../OperatorStatefulFilterBenchmarks.cs       |  7 +-
 ...eratorStatefulFilterGcProfileBenchmarks.cs |  6 +-
 .../Program.cs                                |  5 +-
 .../ReactiveExtensionsComparisonBenchmarks.cs | 12 +--
 .../SubjectHotPathGcProfileBenchmarks.cs      |  7 +-
 .../SubjectMulticastBenchmarks.cs             |  4 +-
 .../DisposableSlotHelperTests.cs              |  4 +-
 .../DisposableTests.cs                        | 18 ++--
 .../MutableDisposableTests.cs                 |  4 +-
 .../SwapDisposableTests.cs                    |  4 +-
 .../AotSafeAssertionExtensions.cs             |  7 +-
 .../AsyncSerialGateTests.cs                   |  8 +-
 .../CustomTaskScheduler.cs                    |  5 +-
 .../ExpireOperatorTests.cs                    |  6 +-
 .../IntervalOperatorTests.cs                  |  9 +-
 .../UnhandledExceptionCapture.cs              |  2 +-
 .../UnhandledExceptionTestExecutor.cs         |  5 +-
 .../DiagnosticInfoTests.cs                    |  2 +-
 .../EventGeneratorTests.cs                    |  2 +-
 .../GeneratedNamesTests.cs                    |  2 +-
 .../PooledStringBuilderTests.cs               |  5 +-
 .../CurrentThreadSequencerTests.cs            | 11 +--
 .../DispatchWorkItemBaseTests.cs              |  8 +-
 .../AsyncSignalTests.cs                       | 35 ++++---
 .../BehaviorSignalTests.cs                    | 28 +++---
 .../BlendUniqueTests.cs                       | 21 ++--
 .../BroadcasterTests.cs                       | 15 +--
 .../CalmCoordinatorTests.cs                   | 11 +--
 .../ChooseSwitchSelectTests.cs                | 48 ++++------
 .../CommandExecutionTests.cs                  | 22 +----
 .../CommandSignalTests.cs                     | 51 +++-------
 .../Common/ConsumerCompilation.cs             |  5 +-
 .../Common/FirstInlineSequencer.cs            |  4 +-
 .../Common/ManualSequencer.cs                 |  5 +-
 .../Common/MinimalVirtualClock.cs             |  2 +-
 .../Common/ThrowingComparer.cs                |  2 +-
 .../ConnectableSignalTests.cs                 |  6 --
 .../DelegateWitnessTests.cs                   |  2 +-
 .../DispatchSequencerStateTests.cs            |  8 +-
 .../DisposableTests.cs                        | 10 +-
 .../EventPatternTests.cs                      | 18 ++--
 .../EverySignalTests.cs                       |  4 +-
 .../ExpireCoordinatorTests.cs                 | 12 +--
 .../ForkJoinWitnessTests.cs                   |  3 -
 .../FromAsyncSubscriptionTests.cs             | 11 +--
 .../FromEnumerableSignalTests.cs              |  4 +-
 .../IsEmptySignalTests.cs                     |  5 +-
 ...LinqExtensionsTests.CombineLatestTuples.cs |  6 +-
 .../LoopSignalTests.cs                        |  6 +-
 .../MomentTests.cs                            |  2 +-
 .../ObservableCancellationHandlingTests.cs    |  8 +-
 .../OnErrorResumeNextSignalTests.cs           |  2 +-
 .../OptionalTests.cs                          |  6 +-
 .../PriorityQueueTests.cs                     |  4 +-
 .../PrioritySemaphoreSignalTests.cs           | 10 +-
 .../R3BridgeGeneratorTests.cs                 |  4 +-
 .../ReplaySignalTests.cs                      | 23 +++--
 .../ResultTests.cs                            |  6 +-
 .../RxNamesTests.AliasOverloads.cs            |  5 +-
 .../RxNamesTests.Helpers.cs                   | 24 ++---
 .../RxNamesTests.SubscribeSafe.cs             |  6 +-
 .../RxNamesTests.cs                           | 20 ++--
 .../SafeWitnessTests.cs                       | 26 +----
 .../ScheduledSignalTests.cs                   |  4 +-
 .../SequencerTests.Pools.cs                   |  4 +-
 .../SequencerTests.VirtualTime.cs             |  5 +-
 .../SequencerTests.WorkItems.cs               | 11 +--
 .../SequencerTests.cs                         | 37 +++----
 .../SignalCollectTests.cs                     | 11 +--
 .../SignalCreateTests.cs                      | 20 ++--
 .../SignalEmitIfQuietTests.cs                 |  7 +-
 .../SignalFactoriesTests.Behavior.cs          |  2 +-
 .../SignalFactoriesTests.Composition.cs       |  6 +-
 .../SignalFactoriesTests.DefaultSequencer.cs  |  5 +-
 .../SignalFactoriesTests.EventConversion.cs   |  5 +-
 .../SignalFactoriesTests.Scheduling.cs        |  1 -
 .../SignalFactoriesTests.cs                   | 19 ++--
 .../SignalGetAwaiterTests.cs                  |  2 +-
 .../SignalOperatorMixinsTests.Advanced.cs     | 19 ++--
 .../SignalOperatorMixinsTests.Behavior.cs     |  8 +-
 .../SignalOperatorMixinsTests.Delay.cs        |  8 +-
 ...SignalOperatorMixinsTests.Deterministic.cs | 35 ++++---
 ...lOperatorMixinsTests.PostTerminalGuards.cs |  4 +-
 .../SignalOperatorMixinsTests.Scheduling.cs   | 15 ++-
 .../SignalOperatorMixinsTests.cs              | 60 ++++++------
 ...nalOperatorParityMixinsTests.Aggregates.cs | 18 ++--
 ...lOperatorParityMixinsTests.Cancellation.cs |  4 +-
 ...peratorParityMixinsTests.RangeFastPaths.cs | 10 +-
 .../SignalOperatorParityMixinsTests.cs        | 22 ++---
 .../SignalRecoverTests.cs                     |  3 +-
 .../SignalTests.Aliases.cs                    |  8 +-
 .../SignalTests.cs                            | 79 +++++++--------
 .../SinkObserverTests.cs                      | 31 ++----
 .../SinkTerminalTests.cs                      | 10 +-
 .../ReactiveUI.Primitives.Tests/SparkTests.cs |  8 +-
 .../StartSignalTests.cs                       |  5 +-
 .../StateSignalTests.cs                       | 19 +---
 .../SubscribeExtensionsTests.cs               |  4 +-
 .../SwitchMapTests.cs                         |  5 +-
 .../SwitchWitnessTests.Generation.cs          |  3 +-
 .../SwitchWitnessTests.cs                     | 15 +--
 .../SyncLatestTests.WideArity.cs              |  6 +-
 .../SyncLatestTests.cs                        | 16 +---
 .../TaskSignalTests.FromTask.cs               |  4 +-
 .../TaskSignalTests.cs                        |  4 +-
 .../TaskTerminalCompletionTests.cs            |  6 +-
 .../TaskTerminalWitnessTests.cs               |  6 +-
 .../TimeIntervalTests.cs                      |  2 +-
 .../UnfoldSignalTests.cs                      | 11 +--
 .../UseSignalTests.cs                         | 23 ++---
 .../WasmSequencerTests.cs                     |  4 +-
 .../WitnessOnSignalTests.cs                   |  3 +-
 .../WitnessTests.cs                           | 15 ++-
 320 files changed, 1374 insertions(+), 1891 deletions(-)

diff --git a/src/Polyfills/ArgumentExceptionHelper.cs b/src/Polyfills/ArgumentExceptionHelper.cs
index d154c660..3713bcc3 100644
--- a/src/Polyfills/ArgumentExceptionHelper.cs
+++ b/src/Polyfills/ArgumentExceptionHelper.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Internal;
 
-/// <summary>
-/// Polyfill for <c>ArgumentNullException.ThrowIfNull</c> on net462-net481; net8.0 and later compile no copy of this
-/// type and alias the <c>ArgumentExceptionHelper</c> identifier to <see cref="ArgumentNullException"/> instead.
-/// </summary>
+/// <summary>Polyfill for <c>ArgumentNullException.ThrowIfNull</c> on target frameworks that predate it.</summary>
 [ExcludeFromCodeCoverage]
 internal static class ArgumentExceptionHelper
 {
diff --git a/src/Polyfills/ObjectDisposedExceptionHelper.cs b/src/Polyfills/ObjectDisposedExceptionHelper.cs
index c74b6361..3af19522 100644
--- a/src/Polyfills/ObjectDisposedExceptionHelper.cs
+++ b/src/Polyfills/ObjectDisposedExceptionHelper.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Internal;
 
-/// <summary>
-/// Polyfill for <c>ObjectDisposedException.ThrowIf</c> on net462-net481; net8.0 and later compile no copy of this
-/// type and alias the <c>ObjectDisposedExceptionHelper</c> identifier to <see cref="ObjectDisposedException"/> instead.
-/// </summary>
+/// <summary>Polyfill for <c>ObjectDisposedException.ThrowIf</c> on target frameworks that predate it.</summary>
 [ExcludeFromCodeCoverage]
 internal static class ObjectDisposedExceptionHelper
 {
diff --git a/src/Primitives.Async.Shared/AsyncContext.cs b/src/Primitives.Async.Shared/AsyncContext.cs
index 67bc92bb..b95d9352 100644
--- a/src/Primitives.Async.Shared/AsyncContext.cs
+++ b/src/Primitives.Async.Shared/AsyncContext.cs
@@ -12,8 +12,7 @@ namespace ReactiveUI.Primitives.Async.Reactive;
 namespace ReactiveUI.Primitives.Async;
 #endif
 
-/// <summary>Represents an asynchronous execution context that encapsulates a specific SynchronizationContext or TaskScheduler for controlling the scheduling of asynchronous operations.</summary>
-/// <remarks>Contexts wrap a synchronization context, task scheduler, or sequencer. Default uses the default task scheduler.</remarks>
+/// <summary>An execution context that pins continuations to a <see cref="SynchronizationContext"/>, a <see cref="TaskScheduler"/>, or an <see cref="ISequencer"/>.</summary>
 [System.Diagnostics.DebuggerDisplay(
 "AsyncContext: SynchronizationContext = {SynchronizationContext}, TaskScheduler = {TaskScheduler}, Sequencer = {Sequencer}")]
 public sealed record AsyncContext
@@ -23,7 +22,7 @@ private AsyncContext()
     {
     }
 
-    /// <summary>Gets the default instance of the AsyncContext class.</summary>
+    /// <summary>Gets the context that schedules continuations on the default task scheduler.</summary>
     public static AsyncContext Default { get; } = new();
 
     /// <summary>Gets the synchronization context to use for marshaling callbacks and continuations.</summary>
@@ -90,8 +89,8 @@ public static AsyncContext GetCurrent()
     }
 
     /// <summary>Creates an awaitable that switches execution to the associated asynchronous context.</summary>
-    /// <param name="forceYielding">true to always yield execution to the context, even if already in the correct context; otherwise, false to avoid
-    /// yielding if already in the context.</param>
+    /// <param name="forceYielding">true to always yield execution to the context, even when the calling thread is on it;
+    /// otherwise, false to continue inline when the context matches.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the context switch operation.</param>
     /// <returns>An awaitable that completes when execution has switched to the asynchronous context.</returns>
     public AsyncContextSwitcherAwaitable SwitchContextAsync(bool forceYielding, CancellationToken cancellationToken) =>
@@ -99,8 +98,8 @@ public AsyncContextSwitcherAwaitable SwitchContextAsync(bool forceYielding, Canc
 
     /// <summary>Provides an awaitable that switches execution to a specified asynchronous context, optionally forcing a yield and supporting cancellation.</summary>
     /// <param name="AsyncContext">The asynchronous context to which execution should be switched when awaited.</param>
-    /// <param name="ForceYielding">true to always yield execution even if already in the target context; otherwise, false to avoid yielding if
-    /// already in the specified context.</param>
+    /// <param name="ForceYielding">true to always yield execution even when the calling thread is on the target context;
+    /// otherwise, false to continue inline when the context matches.</param>
     /// <param name="CancellationToken">A cancellation token that can be used to cancel the await operation before the continuation is scheduled.</param>
     /// <remarks>Cancellation invokes the continuation immediately; GetResult then throws OperationCanceledException.</remarks>
     [System.Diagnostics.DebuggerDisplay("AsyncContextSwitcherAwaitable: IsCompleted = {IsCompleted}, ForceYielding = {ForceYielding}")]
@@ -117,7 +116,7 @@ public readonly record struct AsyncContextSwitcherAwaitable(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void GetResult() => CancellationToken.ThrowIfCancellationRequested();
 
-        /// <summary>Returns an awaiter for this AsyncContextSwitcherAwaitable instance, enabling use of the await keyword to asynchronously switch execution context.</summary>
+        /// <summary>Returns this instance, which acts as its own awaiter.</summary>
         /// <returns>An awaiter that can be used to await this instance and perform an asynchronous context switch.</returns>
         public AsyncContextSwitcherAwaitable GetAwaiter() => this;
 
@@ -181,8 +180,7 @@ private sealed class ContinuationWorkItem(Action continuation) : IWorkItem
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Performance",
         "CA1812:Avoid uninstantiated internal classes",
-        Justification =
-            "Kept as an internal adapter for generator and test smoke scenarios that need TaskScheduler-shaped sequencer execution.")]
+        Justification = "The adapter is constructed outside this assembly, not by the library itself.")]
     internal sealed class SequencerTaskScheduler(ISequencer scheduler) : TaskScheduler
     {
         /// <summary>Gets the sequencer used by this task-scheduler adapter.</summary>
@@ -195,7 +193,7 @@ internal sealed class SequencerTaskScheduler(ISequencer scheduler) : TaskSchedul
 
         /// <summary>Attempts inline execution through the adapter.</summary>
         /// <param name="task">The task to attempt to execute inline.</param>
-        /// <param name="taskWasPreviouslyQueued">Whether the task was previously queued.</param>
+        /// <param name="taskWasPreviouslyQueued">Whether the task has been queued to this scheduler before the call.</param>
         /// <returns>The result of the protected <see cref="TryExecuteTaskInline"/> implementation.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal bool TryExecuteTaskInlineForTesting(Task task, bool taskWasPreviouslyQueued) =>
diff --git a/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs b/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
index 9fcba034..550f3571 100644
--- a/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
+++ b/src/Primitives.Async.Shared/Observables/FromAsync.Reactive.cs
@@ -28,9 +28,7 @@ public static partial class SignalAsyncReactiveExtensions
         /// <returns>An observable sequence that emits a single value of <see cref="RxVoid"/> when the factory function completes,
         /// followed by a completion notification.</returns>
         /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="factory"/> is <see langword="null"/>.</exception>
-        /// <remarks>The returned observable executes the factory function as a background job. The sequence emits
-        /// <see cref="RxVoid"/> after the factory completes and then signals completion. Cancellation is supported
-        /// via the provided token.</remarks>
+        /// <remarks>The factory is invoked once per subscription.</remarks>
         [SuppressMessage(
             "Roslynator",
             "RCS1047:Non-asynchronous method name should not end with \'Async\'",
diff --git a/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs b/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
index 39136346..d89a2911 100644
--- a/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
+++ b/src/Primitives.Async.Shared/Operators/ContextSwitchSignalAsync.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <typeparam name = "T">The type of elements in the observable sequence.</typeparam>
 /// <param name = "source">The source observable whose notifications will be context-switched.</param>
 /// <param name = "asyncContext">The async context to switch notifications onto.</param>
-/// <param name = "forceYielding">Whether to force yielding even if already on the target context.</param>
+/// <param name = "forceYielding">Whether to yield even when the calling thread is on the target context.</param>
 public sealed class ContextSwitchSignalAsync<T>(
     IObservableAsync<T> source,
     AsyncContext asyncContext,
@@ -28,7 +28,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
     /// <summary>An observer that switches each notification onto the specified async context before forwarding.</summary>
     /// <param name = "observer">The downstream observer to forward notifications to.</param>
     /// <param name = "asyncContext">The async context to switch onto.</param>
-    /// <param name = "forceYielding">Whether to force yielding even if already on the target context.</param>
+    /// <param name = "forceYielding">Whether to yield even when the calling thread is on the target context.</param>
     internal sealed class ContextSwitchWitness(
         IObserverAsync<T> observer,
         AsyncContext asyncContext,
diff --git a/src/Primitives.Async.Shared/Operators/ParityHelpers.Reactive.cs b/src/Primitives.Async.Shared/Operators/ParityHelpers.Reactive.cs
index 56a0db24..e08328fc 100644
--- a/src/Primitives.Async.Shared/Operators/ParityHelpers.Reactive.cs
+++ b/src/Primitives.Async.Shared/Operators/ParityHelpers.Reactive.cs
@@ -18,7 +18,7 @@ namespace ReactiveUI.Primitives.Async;
 [SuppressMessage(
     "StyleCop.CSharp.OrderingRules",
     "SA1201:ElementsShouldAppearInTheCorrectOrder",
-    Justification = "C# 14 extension methods")]
+    Justification = "Extension block members cannot be reordered into the conventional element order.")]
 public static partial class SignalAsyncReactiveExtensions
 {
     /// <summary>Async-native parity helper operators for an observable source sequence.</summary>
@@ -35,7 +35,7 @@ public IObservableAsync<RxVoid> AsSignal()
             return new AsRxVoidSignal<T>(source);
         }
 
-        /// <summary>Uses ObserveOn only when a context is provided.</summary>
+        /// <summary>Observes the source on the supplied context, handing back the source unchanged when no context is supplied.</summary>
         /// <param name="asyncContext">The target async context, or <see langword="null"/> to leave the sequence unchanged.</param>
         /// <returns>The source sequence, optionally observed on the provided context.</returns>
         public IObservableAsync<T> ObserveOnSafe(AsyncContext? asyncContext)
@@ -45,7 +45,7 @@ public IObservableAsync<T> ObserveOnSafe(AsyncContext? asyncContext)
             return asyncContext is null ? source : new WitnessOnSignal<T>(source, asyncContext, false);
         }
 
-        /// <summary>Uses ObserveOn only when a context is provided.</summary>
+        /// <summary>Observes the source on the supplied context, handing back the source unchanged when no context is supplied.</summary>
         /// <param name="asyncContext">The target async context, or <see langword="null"/> to leave the sequence unchanged.</param>
         /// <param name="forceYielding">Whether to force yielding when switching context.</param>
         /// <returns>The source sequence, optionally observed on the provided context.</returns>
@@ -56,7 +56,7 @@ public IObservableAsync<T> ObserveOnSafe(AsyncContext? asyncContext, bool forceY
             return asyncContext is null ? source : new WitnessOnSignal<T>(source, asyncContext, forceYielding);
         }
 
-        /// <summary>Uses ObserveOn only when a scheduler is provided.</summary>
+        /// <summary>Observes the source on the supplied scheduler, handing back the source unchanged when no scheduler is supplied.</summary>
         /// <param name="taskScheduler">The target scheduler, or <see langword="null"/> to leave the sequence unchanged.</param>
         /// <returns>The source sequence, optionally observed on the provided scheduler.</returns>
         public IObservableAsync<T> ObserveOnSafe(TaskScheduler? taskScheduler)
@@ -68,7 +68,7 @@ public IObservableAsync<T> ObserveOnSafe(TaskScheduler? taskScheduler)
                 : new WitnessOnSignal<T>(source, AsyncContext.From(taskScheduler), false);
         }
 
-        /// <summary>Uses ObserveOn only when a scheduler is provided.</summary>
+        /// <summary>Observes the source on the supplied scheduler, handing back the source unchanged when no scheduler is supplied.</summary>
         /// <param name="taskScheduler">The target scheduler, or <see langword="null"/> to leave the sequence unchanged.</param>
         /// <param name="forceYielding">Whether to force yielding when switching context.</param>
         /// <returns>The source sequence, optionally observed on the provided scheduler.</returns>
diff --git a/src/Primitives.Async.Shared/Operators/WitnessOn.cs b/src/Primitives.Async.Shared/Operators/WitnessOn.cs
index 32d900fc..5e890dd6 100644
--- a/src/Primitives.Async.Shared/Operators/WitnessOn.cs
+++ b/src/Primitives.Async.Shared/Operators/WitnessOn.cs
@@ -24,8 +24,8 @@ public static partial class SignalAsyncReactiveExtensions
     {
         /// <summary>Wraps the source observable so that observer callbacks are invoked on the specified async context.</summary>
         /// <param name="asyncContext">The async context on which observer callbacks should be invoked.</param>
-        /// <param name="forceYielding">When true, forces an asynchronous yield before invoking each callback, even if already on the target
-        /// context.</param>
+        /// <param name="forceYielding">When true, forces an asynchronous yield before invoking each callback, even when
+        /// the calling thread is on the target context.</param>
         /// <returns>An observable sequence whose observer callbacks execute on the specified context.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> WitnessOn(AsyncContext asyncContext, bool forceYielding) =>
@@ -74,7 +74,7 @@ public IObservableAsync<T> WitnessOn(TaskScheduler taskScheduler) =>
 
         /// <summary>Configures the observable sequence to notify observers on the specified scheduler.</summary>
         /// <param name="scheduler">The scheduler on which to observe and deliver notifications to observers. Cannot be null.</param>
-        /// <param name="forceYielding">true to force yielding to the scheduler even if already on the target context; otherwise, false.</param>
+        /// <param name="forceYielding">true to force yielding to the scheduler even when the calling thread is on the target context; otherwise, false.</param>
         /// <returns>An observable sequence whose notifications are delivered on the specified scheduler.</returns>
         public IObservableAsync<T> WitnessOn(ISequencer scheduler, bool forceYielding)
         {
diff --git a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
index 6fa5d1fc..43fd7b74 100644
--- a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
+++ b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
@@ -9,11 +9,12 @@
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// Base <see cref="IScheduler"/> for UI-thread dispatchers that coalesces dispatcher posts: immediate work is queued
-/// and drained one batch per post. A sealed platform scheduler supplies its dispatcher <see cref="Post"/> (and
-/// optionally a native delayed path via <see cref="ScheduleOnDispatcher"/>).
-/// </summary>
+/// <summary>Base <see cref="IScheduler"/> for UI-thread dispatchers that drains queued work one batch per dispatcher post.</summary>
+/// <remarks>Work runs on the dispatcher thread; scheduling from that thread queues the item for the next posted batch
+/// rather than running it inline, so a scheduled action never re-enters the caller. The disposable a
+/// <c>Schedule</c> overload returns suppresses work that has not started and disposes what a started action
+/// returned. A platform scheduler supplies <see cref="Post"/> and may replace the delayed path by overriding
+/// <see cref="ScheduleOnDispatcher"/>.</remarks>
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
 public abstract class CoalescingDispatchScheduler : LocalScheduler
 {
@@ -26,7 +27,7 @@ public abstract class CoalescingDispatchScheduler : LocalScheduler
     /// <summary>Schedules delays before work returns to the dispatcher.</summary>
     private readonly IScheduler _delayScheduler;
 
-    /// <summary>Approximate number of ready items; snapshots a drain batch.</summary>
+    /// <summary>Approximate count of ready items; bounds the batch one drain dequeues.</summary>
     private int _readyCount;
 
     /// <summary>Gate that keeps at most one queued drain callback pending.</summary>
@@ -106,7 +107,7 @@ protected virtual IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime
                     return Disposable.Empty;
                 }));
 
-    /// <summary>Re-posts a drain if work is still queued; platform adapters call this when the dispatcher becomes ready.</summary>
+    /// <summary>Posts a drain when queued work remains; platform adapters call this when the dispatcher becomes ready.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected void RequestDrain() => PostDrain();
 
diff --git a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
index 0704be55..5fb7f74c 100644
--- a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
+++ b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
@@ -44,7 +44,7 @@ protected DispatchWorkItemBase(
     /// <summary>Gets a value indicating whether the work item has been cancelled.</summary>
     internal bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
 
-    /// <summary>Runs the scheduled action unless it has already been cancelled, disposing its result if a cancel races the start.</summary>
+    /// <summary>Runs the scheduled action unless it has been cancelled, disposing its result when a cancel races the start.</summary>
     public void Run()
     {
         if (IsDisposed)
@@ -72,7 +72,7 @@ public void Run()
     /// <returns><see langword="true"/> for the first caller, which owns releasing the item's resources.</returns>
     protected bool TryClaimDispose() => Interlocked.Exchange(ref _isDisposed, 1) == 0;
 
-    /// <summary>Releases the disposable the action returned once it has started, so a late cancel still tears it down.</summary>
+    /// <summary>Disposes whatever the started action returned, so a cancel arriving after the start tears it down.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected void ReleaseStartedWork() => Interlocked.Exchange(ref _disposable, Disposable.Empty)?.Dispose();
 }
diff --git a/src/Primitives.Platform.Reactive.Shared/IDispatchWorkItem.cs b/src/Primitives.Platform.Reactive.Shared/IDispatchWorkItem.cs
index b23559bb..0c2f3546 100644
--- a/src/Primitives.Platform.Reactive.Shared/IDispatchWorkItem.cs
+++ b/src/Primitives.Platform.Reactive.Shared/IDispatchWorkItem.cs
@@ -7,6 +7,6 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency;
 /// <summary>A scheduled, cancellable unit of work drained by a <see cref="CoalescingDispatchScheduler"/>.</summary>
 internal interface IDispatchWorkItem : IDisposable
 {
-    /// <summary>Executes the work unless it has already been cancelled.</summary>
+    /// <summary>Executes the work unless it has been cancelled.</summary>
     void Run();
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/ActionDisposable.cs b/src/ReactiveUI.Disposables/Disposables/ActionDisposable.cs
index 08e4f4fe..a916a528 100644
--- a/src/ReactiveUI.Disposables/Disposables/ActionDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/ActionDisposable.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>An <see cref="IDisposable"/> that runs the supplied <see cref="Action"/> exactly once on <see cref="Dispose"/>. Replaces <c>new ActionDisposable(Action)</c>.</summary>
+/// <summary>An <see cref="IDisposable"/> that runs the supplied <see cref="Action"/> on the first <see cref="Dispose"/> call and does nothing on later calls.</summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ActionDisposable : IsDisposed
 {
diff --git a/src/ReactiveUI.Disposables/Disposables/BooleanDisposable.cs b/src/ReactiveUI.Disposables/Disposables/BooleanDisposable.cs
index 16db9147..0fd40cd6 100644
--- a/src/ReactiveUI.Disposables/Disposables/BooleanDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/BooleanDisposable.cs
@@ -15,16 +15,13 @@ public sealed class BooleanDisposable : IsDisposed
     private int _isDisposed;
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Latches the disposed flag; repeated calls have no further effect.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Dispose() => Interlocked.Exchange(ref _isDisposed, 1);
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs b/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
index c57f84ae..a464807f 100644
--- a/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
@@ -4,19 +4,19 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>A disposable that cancels an owned <see cref="CancellationTokenSource"/> when disposed.</summary>
+/// <summary>A disposable that cancels a <see cref="CancellationTokenSource"/> when disposed; the source itself is left undisposed.</summary>
 /// <seealso cref="IDisposable" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class CancellationDisposable : IsDisposed
 {
-    /// <summary>Cancellation source owned by this disposable.</summary>
+    /// <summary>The source cancelled on disposal.</summary>
     private readonly CancellationTokenSource _cts;
 
     /// <summary>Disposed latch; 0 when alive, 1 once disposed.</summary>
     private int _isDisposed;
 
     /// <summary>Initializes a new instance of the <see cref="CancellationDisposable"/> class.</summary>
-    /// <param name="cts">The CTS.</param>
+    /// <param name="cts">The source to cancel when this instance is disposed.</param>
     /// <exception cref="ArgumentNullException"><paramref name="cts"/> is <see langword="null"/>.</exception>
     public CancellationDisposable(CancellationTokenSource cts) =>
         _cts = cts ?? throw new ArgumentNullException(nameof(cts));
@@ -27,16 +27,10 @@ public CancellationDisposable()
     {
     }
 
-    /// <summary>Gets the token.</summary>
-    /// <value>
-    /// The token.
-    /// </value>
+    /// <summary>Gets the token that enters the cancelled state when this instance is disposed.</summary>
     public CancellationToken Token => _cts.Token;
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    /// <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
 
     /// <summary>Gets the debugger display text.</summary>
@@ -44,7 +38,7 @@ public CancellationDisposable()
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Cancels the source on the first call; repeated calls have no further effect.</summary>
     public void Dispose()
     {
         // Atomic run-once latch so concurrent disposal cannot cancel the source twice.
diff --git a/src/ReactiveUI.Disposables/Disposables/DisposableBag.cs b/src/ReactiveUI.Disposables/Disposables/DisposableBag.cs
index 36c9fdbd..687a4be3 100644
--- a/src/ReactiveUI.Disposables/Disposables/DisposableBag.cs
+++ b/src/ReactiveUI.Disposables/Disposables/DisposableBag.cs
@@ -4,17 +4,8 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>
-/// A small composite-disposable replacement specialised for the common 2-slot
-/// "subscription + sink" pair found throughout this codebase. Avoids the
-/// <see cref="List{T}"/> backing field of
-/// <c>System.Reactive.Disposables.CompositeDisposable</c>.
-/// </summary>
-/// <remarks>
-/// The first two added entries are stored inline. A third or later entry causes a fall-back
-/// to a heap-allocated array. Disposal is idempotent and disposes every contained entry,
-/// in registration order, exactly once.
-/// </remarks>
+/// <summary>A composite disposable that holds its first two entries in inline fields and spills further entries into a heap-allocated array.</summary>
+/// <remarks>Disposal is idempotent and disposes every contained entry, in registration order, exactly once.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class DisposableBag : IsDisposed
 {
@@ -77,7 +68,7 @@ public DisposableBag(IDisposable first, IDisposable second, IDisposable third)
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Adds a disposable to the bag. If the bag is already disposed, the supplied disposable is disposed immediately.</summary>
+    /// <summary>Adds a disposable to the bag, disposing it immediately if the bag is disposed and ignoring a <see langword="null"/> argument.</summary>
     /// <param name="disposable">The disposable to add.</param>
     public void Add(IDisposable disposable)
     {
diff --git a/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs b/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
index 86e6eaeb..92d07b89 100644
--- a/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>A no-op <see cref="IDisposable"/> singleton used in place of <c>EmptyDisposable.Instance</c>.</summary>
+/// <summary>A no-op <see cref="IDisposable"/> whose shared instance stands in for the absence of a resource.</summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class EmptyDisposable : IDisposable
 {
diff --git a/src/ReactiveUI.Disposables/Disposables/IsDisposed.cs b/src/ReactiveUI.Disposables/Disposables/IsDisposed.cs
index 571a0ac6..1137e1ce 100644
--- a/src/ReactiveUI.Disposables/Disposables/IsDisposed.cs
+++ b/src/ReactiveUI.Disposables/Disposables/IsDisposed.cs
@@ -4,13 +4,10 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>Is Disposed.</summary>
+/// <summary>An <see cref="IDisposable"/> that reports whether it has been disposed.</summary>
 /// <seealso cref="IDisposable" />
 public interface IsDisposed : IDisposable
 {
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     bool IsDisposed { get; }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs b/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
index 8c36bcd1..96268934 100644
--- a/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
@@ -128,7 +128,7 @@ public int Count
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IDisposable Create(params IDisposable[] disposables) => new MultipleDisposableBase(disposables);
 
-    /// <summary>Adds a disposable to the <see cref="MultipleDisposable"/> or disposes it immediately if the pocket is already disposed.</summary>
+    /// <summary>Adds a disposable to the group, or disposes it immediately when the group is disposed.</summary>
     /// <param name="item">Disposable to add.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="item"/> is <see langword="null"/>.</exception>
     public void Add(IDisposable item)
@@ -280,15 +280,15 @@ public void CopyTo(IDisposable[] array, int arrayIndex)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IEnumerator<IDisposable> GetEnumerator() => Snapshot().GetEnumerator();
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Disposes every held disposable and marks the group disposed; repeated calls have no further effect.</summary>
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
-    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    /// <summary>Releases the held disposables in registration order, the two inline slots first, then the overflow entries.</summary>
+    /// <param name="disposing"><see langword="true"/> to dispose the held disposables; <see langword="false"/> to release nothing.</param>
     protected virtual void Dispose(bool disposing)
     {
         if (!disposing)
diff --git a/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs b/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
index 822d45de..d5da0447 100644
--- a/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
@@ -7,10 +7,10 @@
 namespace ReactiveUI.Primitives.Disposables;
 
 /// <summary>
-/// A disposable holder whose inner disposable can be re-assigned. The previous inner
+/// A disposable holder whose inner disposable can be re-assigned. The displaced inner
 /// disposable is NOT disposed when replaced (in contrast to <see cref="SwapDisposable"/>).
-/// Once this object is disposed, any subsequently assigned inner disposable is disposed
-/// immediately. Replaces <c>MultipleAssignmentDisposable</c>.
+/// Once this object is disposed, any inner disposable assigned afterwards is disposed
+/// immediately.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class MutableDisposable : IsDisposed
diff --git a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
index 2f79d61b..ac3ad4f7 100644
--- a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
@@ -5,10 +5,10 @@
 namespace ReactiveUI.Primitives.Disposables;
 
 /// <summary>
-/// A disposable holder whose inner disposable can be set exactly once.
-/// Replaces <c>SingleAssignmentDisposable</c>. Subsequent assignments throw
-/// <see cref="InvalidOperationException"/>; if the holder has been disposed before
-/// assignment, the supplied disposable is disposed immediately and no exception is thrown.
+/// A disposable holder whose inner disposable can be set exactly once. A second
+/// assignment throws <see cref="InvalidOperationException"/>; if the holder was disposed
+/// before the assignment, the supplied disposable is disposed immediately and no exception
+/// is thrown.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class OnceDisposable : IsDisposed
diff --git a/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
index df798b81..76b1303d 100644
--- a/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>Single-assignment disposable slot.</summary>
+/// <summary>A disposable slot that accepts one assignment: a second assignment throws, and a value assigned after disposal is disposed immediately.</summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class SingleDisposable : IsDisposed
 {
@@ -50,7 +50,7 @@ public SingleDisposable(IDisposable disposable, Action? action)
     /// <summary>Assigns the disposable held by this slot.</summary>
     /// <param name="disposable">The disposable.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="disposable"/> is <see langword="null"/>.</exception>
-    /// <exception cref="InvalidOperationException">The slot already has an assignment.</exception>
+    /// <exception cref="InvalidOperationException">The slot holds an earlier assignment.</exception>
     public void Create(IDisposable disposable)
     {
         ArgumentExceptionHelper.ThrowIfNull(disposable);
@@ -70,15 +70,15 @@ public void Create(IDisposable disposable)
         throw new InvalidOperationException($"The {nameof(disposable)} slot has already been assigned.");
     }
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Disposes the assigned value and blocks further assignments; repeated calls have no further effect.</summary>
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
-    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    /// <summary>Runs the constructor-supplied action and then disposes the assigned value, once.</summary>
+    /// <param name="disposing"><see langword="true"/> to dispose the assigned value; <see langword="false"/> to release nothing.</param>
     protected virtual void Dispose(bool disposing)
     {
         if (!disposing)
@@ -103,8 +103,8 @@ private sealed class DisposedMarker : IDisposable
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Intentionally empty: a reference-identity sentinel marking an already-disposed slot. It is only
-            // ever compared with ReferenceEquals and never itself disposed, so this body is unreachable.
+            // Intentionally empty: a reference-identity sentinel marking a disposed slot. It is only ever
+            // compared with ReferenceEquals and never itself disposed, so this body is unreachable.
         }
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
index f87bad39..65fc271b 100644
--- a/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
@@ -44,9 +44,6 @@ public SingleReplaceableDisposable(IDisposable disposable, Action? action)
     }
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed => ReferenceEquals(Volatile.Read(ref _disposable), DisposedSentinel);
 
     /// <summary>Gets the debugger display text.</summary>
@@ -54,8 +51,8 @@ public SingleReplaceableDisposable(IDisposable disposable, Action? action)
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Creates the specified disposable.</summary>
-    /// <param name="disposable">The disposable.</param>
+    /// <summary>Assigns the inner disposable and disposes the value it displaces; once this slot is disposed the incoming value is disposed instead.</summary>
+    /// <param name="disposable">The disposable to take as the new inner value.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="disposable"/> is <see langword="null"/>.</exception>
     public void Create(IDisposable disposable)
     {
@@ -81,16 +78,15 @@ public void Create(IDisposable disposable)
         }
     }
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Disposes the inner value and blocks further assignments; repeated calls have no further effect.</summary>
     public void Dispose()
     {
-        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
-    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    /// <summary>Disposes the inner value and then invokes the constructor-supplied action, once.</summary>
+    /// <param name="disposing"><see langword="true"/> when invoked from <see cref="Dispose()"/>.</param>
     protected virtual void Dispose(bool disposing)
     {
         var old = Interlocked.Exchange(ref _disposable, DisposedSentinel);
@@ -110,8 +106,8 @@ private sealed class DisposedMarker : IDisposable
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Intentionally empty: a reference-identity sentinel marking an already-disposed slot. It is only
-            // ever compared with ReferenceEquals and never itself disposed, so this body is unreachable.
+            // Intentionally empty: a reference-identity sentinel marking a disposed slot. It is only ever
+            // compared with ReferenceEquals and never itself disposed, so this body is unreachable.
         }
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
index 7445557b..2d4aeb80 100644
--- a/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
@@ -7,10 +7,10 @@
 namespace ReactiveUI.Primitives.Disposables;
 
 /// <summary>
-/// A disposable holder whose inner disposable can be re-assigned. The previous inner
+/// A disposable holder whose inner disposable can be re-assigned. The displaced inner
 /// disposable is disposed when replaced (in contrast to <see cref="MutableDisposable"/>).
-/// Once this object is disposed, any subsequently assigned inner disposable is disposed
-/// immediately. Replaces <c>SerialDisposable</c>.
+/// Once this object is disposed, any inner disposable assigned afterwards is disposed
+/// immediately.
 /// </summary>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class SwapDisposable : IsDisposed
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
index 95bfda91..4eca4b62 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConcurrentWitnessCallsException.cs
@@ -33,10 +33,7 @@ public ConcurrentWitnessCallsException(string message)
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ConcurrentWitnessCallsException"/> class with a specified error message
-    /// and a reference to the inner exception that is the cause of this exception.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="ConcurrentWitnessCallsException"/> class with a message and an inner exception.</summary>
     /// <param name="message">The error message that explains the reason for the exception.</param>
     /// <param name="innerException">The exception that is the cause of the current exception.</param>
     public ConcurrentWitnessCallsException(string message, Exception innerException)
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
index a719cb1f..46fabde7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsync.cs
@@ -17,7 +17,7 @@ public sealed class ConnectableSignalAsync<T> : IObservableAsync<T>, IDisposable
 {
     /// <summary>Initializes a new instance of the <see cref="ConnectableSignalAsync{T}"/> class.</summary>
     /// <param name="source">The source signal to multicast.</param>
-    /// <param name="signal">The signal used to broadcast notifications to multiple observers.</param>
+    /// <param name="signal">The signal that multicasts source notifications to the subscribed observers.</param>
     public ConnectableSignalAsync(IObservableAsync<T> source, ISignalAsync<T> signal) =>
         State = new(source, signal);
 
@@ -25,7 +25,7 @@ public ConnectableSignalAsync(IObservableAsync<T> source, ISignalAsync<T> signal
     private ConnectableSignalAsyncState<T> State { get; }
 
     /// <summary>Subscribes the signal to the source, or returns the live connection when one exists.</summary>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous connection operation.</param>
+    /// <param name="cancellationToken">A token that cancels connection establishment.</param>
     /// <returns>A handle whose disposal drops the source subscription, allowing a later call to reconnect.</returns>
     /// <exception cref="OperationCanceledException">This instance has been disposed, or
     /// <paramref name="cancellationToken"/> was cancelled.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
index 7ecc671d..02e7a655 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncState{T}.cs
@@ -20,7 +20,7 @@ internal sealed class ConnectableSignalAsyncState<T> : IDisposable
         Justification = "The helper class that drives this state enters the gate directly.")]
     internal readonly AsyncSerialGate Gate = new();
 
-    /// <summary>The monitor used to make synchronous disposal idempotent.</summary>
+    /// <summary>Guards the disposal latch so only the first caller tears the state down.</summary>
     private readonly Lock _disposalGate = new();
 
     /// <summary>Initializes a new instance of the <see cref="ConnectableSignalAsyncState{T}"/> class.</summary>
@@ -48,8 +48,7 @@ public ConnectableSignalAsyncState(IObservableAsync<T> source, ISignalAsync<T> s
     /// <summary>Gets or sets a value indicating whether disposal has been claimed.</summary>
     internal bool IsDisposed { get; set; }
 
-    /// <summary>Gets the token cancelled when the connectable signal is disposed, captured at construction because
-    /// <see cref="Dispose"/> makes <see cref="CancellationTokenSource.Token"/> throw.</summary>
+    /// <summary>Gets the disposal token, captured at construction because <see cref="Dispose"/> makes <see cref="CancellationTokenSource.Token"/> throw.</summary>
     internal CancellationToken DisposedCancellationToken { get; }
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
index 02b68d82..aa266e5a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
@@ -75,7 +75,7 @@ public static bool IsDisposed(IAsyncDisposable? slot) =>
     /// <summary>Retries a swap when the slot changed after the caller's observation.</summary>
     /// <param name="slot">The slot to replace.</param>
     /// <param name="value">The incoming disposable.</param>
-    /// <param name="current">The previously observed slot value.</param>
+    /// <param name="current">The slot value the caller observed.</param>
     /// <returns>Disposal of the replaced value, or the incoming value when the slot is closed.</returns>
     internal static ValueTask SwapObservedAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value, IAsyncDisposable? current)
     {
@@ -101,7 +101,7 @@ internal static ValueTask SwapObservedAsync(ref IAsyncDisposable? slot, IAsyncDi
     internal static InvalidOperationException CreateAlreadyAssignedException() =>
         new("Disposable is already assigned.");
 
-    /// <summary>Singleton no-op disposable used to mark closed async-disposable slots.</summary>
+    /// <summary>Sentinel no-op disposable that marks a closed slot.</summary>
     private sealed class DisposedAsyncDisposable : IAsyncDisposable
     {
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
index ce047d27..6400f71b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Disposables;
 
-/// <summary>
-/// Represents a thread-safe collection of asynchronous disposable objects that are disposed together as a group.
-/// Provides methods to add, remove, and asynchronously dispose contained resources as a single operation.
-/// </summary>
+/// <summary>A thread-safe collection of asynchronous disposables whose lifetimes are owned and released as one group.</summary>
 /// <remarks>Disposal is one-way: a disposed collection holds nothing, and adding to it disposes the incoming item
 /// instead of storing it. Safe for concurrent access from several threads.</remarks>
 [System.Diagnostics.DebuggerDisplay("MultipleDisposableAsync: Count = {_count}, IsDisposed = {_isDisposed}")]
@@ -21,7 +18,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>Used-slot count at or below which a remove leaves the array uncompacted.</summary>
     private const int ShrinkThreshold = 16;
 
-    /// <summary>Divisor used to decide whether a remove triggers compaction (count * 4 &lt; length).</summary>
+    /// <summary>Occupancy divisor: a remove compacts when count multiplied by this falls below the array's length.</summary>
     private const int ShrinkOccupancyDivisor = 4;
 
     /// <summary>Factor the backing array's capacity is multiplied by when it overflows.</summary>
@@ -162,8 +159,8 @@ public ValueTask AddAsync(IAsyncDisposable item)
 
     /// <summary>Removes the specified item from the collection and disposes it asynchronously.</summary>
     /// <param name="item">The item to remove and dispose. Cannot be null.</param>
-    /// <returns>A task that represents the asynchronous remove operation. The task result is <see langword="true"/> if the item
-    /// was found and removed; otherwise, <see langword="false"/>.</returns>
+    /// <returns><see langword="true"/> when the item was found, removed and disposed; otherwise,
+    /// <see langword="false"/>.</returns>
     /// <remarks>An item this collection does not hold is left alone, not disposed.</remarks>
     public async ValueTask<bool> Remove(IAsyncDisposable item)
     {
@@ -252,12 +249,10 @@ public bool Contains(IAsyncDisposable item)
     }
 
     /// <summary>Copies the elements of the collection to the specified array, starting at the given array index.</summary>
-    /// <param name="array">The one-dimensional array of IAsyncDisposable elements that is the destination of the elements copied from the
-    /// collection. The array must have zero-based indexing.</param>
-    /// <param name="arrayIndex">The zero-based index in the destination array at which copying begins. Must be non-negative and less than the
-    /// length of the array.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when arrayIndex is less than zero, greater than or equal to the length of array, or when there is not
-    /// enough space from arrayIndex to the end of array to accommodate all elements in the collection.</exception>
+    /// <param name="array">The zero-based destination array.</param>
+    /// <param name="arrayIndex">The index in <paramref name="array"/> at which copying begins.</param>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="arrayIndex"/> falls outside
+    /// <paramref name="array"/>, or the space from it to the end of the array cannot hold every item.</exception>
     /// <remarks>A disposed collection copies nothing and raises nothing.</remarks>
     public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
     {
@@ -324,10 +319,7 @@ public async ValueTask DisposeAsync()
         }
     }
 
-    /// <summary>
-    /// Returns an enumerator that iterates a snapshot of the non-null disposables in the collection.
-    /// The snapshot is taken under the gate; subsequent mutations do not affect the enumerator.
-    /// </summary>
+    /// <summary>Returns an enumerator over a snapshot taken under the gate, so later mutations do not affect it.</summary>
     /// <returns>An enumerator over a snapshot of the collection's disposables.</returns>
     public IEnumerator<IAsyncDisposable> GetEnumerator()
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
index 2daec78b..2f126f12 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleAssignmentDisposableAsync.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async.Disposables;
 
-/// <summary>
-/// Represents an asynchronously disposable resource that allows a single assignment of its underlying disposable. Once
-/// disposed, further assignments will dispose the assigned resource immediately.
-/// </summary>
+/// <summary>Owns one asynchronous disposable: the first assignment takes, and an assignment made after disposal disposes its argument.</summary>
 /// <remarks>A second assignment throws <see cref="InvalidOperationException"/>, so this type suits the common shape
 /// where a subscription handle has to be stored before the work it cancels can produce it.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleAssignmentDisposableAsync: IsDisposed = {IsDisposed}, Current = {_current}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
index 646260bc..d9dc6ad0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Disposables;
 
-/// <summary>Provides a thread-safe mechanism for managing a single asynchronously disposable resource that can be replaced or disposed of serially.</summary>
+/// <summary>Owns one asynchronous disposable at a time, replacing it on assignment.</summary>
 /// <remarks>Exactly one resource is live at a time: each assignment disposes the one it displaces, and disposing this
 /// instance closes the slot so a further assignment disposes its argument. Safe to use from several threads.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleReplaceableDisposableAsync: Current = {_current}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
index 419e96b7..552c90ba 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
@@ -12,8 +12,8 @@ namespace ReactiveUI.Primitives.Async.Helpers;
 /// </summary>
 public static class FireAndForgetHelper
 {
-    /// <summary>Executes an async action as fire-and-forget, swallowing all exceptions.</summary>
-    /// <param name="action">The async action to execute.</param>
+    /// <summary>Starts <paramref name="action"/> with no task to await, routing any failure to <see cref="UnhandledExceptionHandler"/>.</summary>
+    /// <param name="action">The asynchronous action to start.</param>
     [SuppressMessage(
         "Concurrency",
         "SST1905:Do not use async void",
@@ -21,14 +21,14 @@ public static class FireAndForgetHelper
     [SuppressMessage(
         "ReSharper",
         "AsyncVoidMethod",
-        Justification = "This is a fire-and-forget helper.")]
+        Justification = "There is no caller to hand a Task back to, so failures go to the global handler instead.")]
     [ExcludeFromCodeCoverage]
     public static async void Run(Func<ValueTask> action) =>
         await RunAsync(action).ConfigureAwait(false);
 
     /// <summary>Runs the action and reports failures to the unhandled exception handler.</summary>
     /// <param name="action">The action to execute.</param>
-    /// <returns>The action and any exception reporting.</returns>
+    /// <returns>A task that completes once the action and any failure reporting have run.</returns>
     internal static async ValueTask RunAsync(Func<ValueTask> action)
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
index 4d507c84..1a01f50e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObservableAsync.cs
@@ -12,7 +12,7 @@ public interface IObservableAsync<T>
 {
     /// <summary>Subscribes the specified asynchronous observer to receive notifications from the observable sequence.</summary>
     /// <param name="observer">The observer that will receive asynchronous notifications. Cannot be null.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the subscription operation.</param>
+    /// <param name="cancellationToken">A token that cancels establishing the subscription.</param>
     /// <returns>A handle whose disposal unsubscribes the observer.</returns>
     /// <remarks>Implementations must tolerate several observers subscribed at once, and must release the
     /// subscription's resources when the returned handle is disposed.</remarks>
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
index f2316798..89864d45 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
@@ -17,7 +17,7 @@ public interface IObserverAsync<in T> : IAsyncDisposable
 
     /// <summary>Reports a non-terminal error, leaving the sequence free to carry on.</summary>
     /// <param name="error">The exception to report.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the error handling operation.</param>
+    /// <param name="cancellationToken">A token that cancels the observer's handling of the error.</param>
     /// <returns>A task that completes when the observer has handled the error.</returns>
     /// <remarks>Unlike a faulted <see cref="OnCompletedAsync"/>, this does not end the sequence; an implementation
     /// chooses whether to swallow the error or tear itself down.</remarks>
@@ -25,7 +25,7 @@ public interface IObserverAsync<in T> : IAsyncDisposable
 
     /// <summary>Delivers the next value in the sequence.</summary>
     /// <param name="value">The value to be processed.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+    /// <param name="cancellationToken">A token that cancels the observer's handling of the value.</param>
     /// <returns>A task that completes when the observer has consumed the value.</returns>
     ValueTask OnNextAsync(T value, CancellationToken cancellationToken);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
index 46361992..0840be17 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Mixins/SignalExtensions.cs
@@ -8,7 +8,7 @@
 
 namespace ReactiveUI.Primitives.Async;
 
-/// <summary>Provides extension methods for working with signals in a reactive programming context.</summary>
+/// <summary>Adapts a signal to an observer, and projects a signal's value sequence without changing where values are published.</summary>
 public static class SignalExtensions
 {
     /// <summary>Observer-wrapping and value-mapping operators for a signal source.</summary>
@@ -29,9 +29,8 @@ public IObserverAsync<T> AsObserverAsync()
             return new SignalAsyncWitness<T>(source);
         }
 
-        /// <summary>Creates a new signal that applies a transformation to the values of the source signal using the specified mapping function.</summary>
-        /// <param name="mapper">A function that takes an asynchronous observable of type T and returns a transformed asynchronous observable of
-        /// type T. This function defines how the values are mapped.</param>
+        /// <summary>Creates a signal whose observers see <paramref name="mapper"/> applied to the source's value sequence.</summary>
+        /// <param name="mapper">Projects the source's value sequence into the sequence observers receive.</param>
         /// <returns>A signal that publishes into <paramref name="source"/> but exposes the mapped sequence to its own
         /// subscribers.</returns>
         /// <remarks><paramref name="mapper"/> runs once, against the source's value sequence, rather than per
@@ -48,8 +47,7 @@ public ISignalAsync<T> MapValues(Func<IObservableAsync<T>, IObservableAsync<T>>
     /// <summary>A signal that applies a transformation to the observable values of the source signal.</summary>
     /// <typeparam name="T">The type of elements processed by the signal.</typeparam>
     /// <param name="original">The source signal.</param>
-    /// <param name="mapper">Transforms the source's value sequence
-    /// once during construction.</param>
+    /// <param name="mapper">Transforms the source's value sequence once during construction.</param>
     internal sealed class MappedSignal<T>(
         ISignalAsync<T> original,
         Func<IObservableAsync<T>, IObservableAsync<T>> mapper) : ISignalAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
index 56ce4820..5d9cfade 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
@@ -13,9 +13,7 @@ public static partial class SignalAsync
 {
     /// <summary>Creates a new asynchronous observable sequence using the specified subscription function.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
-    /// <param name="subscribeAsync">A function that is invoked when an observer subscribes to the sequence. The function receives an asynchronous
-    /// observer and a cancellation token, and returns a task that yields a disposable resource representing the
-    /// subscription.</param>
+    /// <param name="subscribeAsync">Wires up one observer and yields the handle that tears that wiring down.</param>
     /// <returns>An observable sequence that runs <paramref name="subscribeAsync"/> for each observer.</returns>
     /// <exception cref="ArgumentNullException">Thrown if <paramref name="subscribeAsync"/> is <see langword="null"/>.</exception>
     /// <remarks>The disposable <paramref name="subscribeAsync"/> returns owns the subscription's resources and must
@@ -28,20 +26,18 @@ subscribeAsync is null
 
     /// <summary>Creates a new observable sequence that runs the specified asynchronous job as a background task.</summary>
     /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
-    /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
-    /// a cancellation token to observe cancellation requests.</param>
+    /// <param name="job">Pushes results into the observer it is handed, stopping when its token is cancelled.</param>
     /// <returns>An observable sequence that runs <paramref name="job"/> on a scheduled task per subscriber.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> CreateAsBackgroundJob<T>(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job) =>
         new BackgroundJobSignal<T>(job, false, null);
 
-    /// <summary>Creates a new observable sequence that runs the specified asynchronous job as a background task.</summary>
+    /// <summary>Creates a new observable sequence that runs the specified asynchronous job per subscriber, optionally on the subscribing thread.</summary>
     /// <typeparam name="T">The type of elements produced by the observable sequence.</typeparam>
-    /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
-    /// a cancellation token to observe cancellation requests.</param>
-    /// <param name="startSynchronously">true to start the job synchronously on the calling thread; otherwise, false to schedule it to run
-    /// asynchronously.</param>
+    /// <param name="job">Pushes results into the observer it is handed, stopping when its token is cancelled.</param>
+    /// <param name="startSynchronously"><see langword="true"/> to run the job on the subscribing thread, so subscribe
+    /// does not return until the job yields; <see langword="false"/> to schedule it.</param>
     /// <returns>An observable sequence that runs <paramref name="job"/> per subscriber.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> CreateAsBackgroundJob<T>(
@@ -51,9 +47,8 @@ public static IObservableAsync<T> CreateAsBackgroundJob<T>(
 
     /// <summary>Creates a new observable sequence that runs the specified asynchronous job as a background task using the provided task scheduler.</summary>
     /// <typeparam name="T">The type of the elements produced by the observable sequence.</typeparam>
-    /// <param name="job">A delegate that defines the asynchronous job to execute. The delegate receives an observer to report results and
-    /// a cancellation token to observe cancellation requests.</param>
-    /// <param name="taskScheduler">The task scheduler that is used to schedule the background job.</param>
+    /// <param name="job">Pushes results into the observer it is handed, stopping when its token is cancelled.</param>
+    /// <param name="taskScheduler">The scheduler each subscriber's job is queued to.</param>
     /// <returns>An observable sequence that runs <paramref name="job"/> per subscriber on
     /// <paramref name="taskScheduler"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
index 92afac0e..552f45b3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Interval.cs
@@ -19,8 +19,7 @@ public static IObservableAsync<long> Interval(TimeSpan period) =>
 
     /// <summary>Creates an asynchronous observable sequence that emits a long integer value at each specified time interval.</summary>
     /// <param name="period">The time interval between emissions of values. Must be a positive duration.</param>
-    /// <param name="timeProvider">An optional time provider used to control the timing of emissions. If null or set to TimeProvider.System, the
-    /// system clock is used.</param>
+    /// <param name="timeProvider">The clock driving the ticks; <see langword="null"/> takes the system clock.</param>
     /// <returns>An observable sequence that emits an increasing count, starting at 1, on every tick until the
     /// subscription is disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
index d8206c9c..523005da 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Timer.cs
@@ -36,8 +36,9 @@ public static IObservableAsync<long> After(TimeSpan dueTime, TimeSpan period)
     }
 
     /// <summary>Emits monotonically increasing ticks at the specified period.</summary>
-    /// <param name="period">The interval between ticks.</param>
+    /// <param name="period">The interval between ticks. Must be positive.</param>
     /// <returns>An observable sequence of periodic ticks.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="period"/> is non-positive.</exception>
     public static IObservableAsync<long> Every(TimeSpan period)
     {
         ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(period, TimeSpan.Zero);
@@ -47,8 +48,9 @@ public static IObservableAsync<long> Every(TimeSpan period)
     }
 
     /// <summary>Alias for <see cref="Every(TimeSpan)"/>.</summary>
-    /// <param name="period">The interval between ticks.</param>
+    /// <param name="period">The interval between ticks. Must be positive.</param>
     /// <returns>An observable sequence of periodic ticks.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="period"/> is non-positive.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<long> Pulse(TimeSpan period) => Every(period);
 
@@ -61,8 +63,8 @@ public static IObservableAsync<long> Every(TimeSpan period)
 
     /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then completes.</summary>
     /// <param name="dueTime">The time span after which to produce the value. Must be non-negative.</param>
-    /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
-    /// is used.</param>
+    /// <param name="timeProvider">The clock driving the schedule; <see langword="null"/> takes
+    /// <see cref="TimeProvider.System"/>.</param>
     /// <returns>An observable sequence that produces a single value after the specified delay and then completes.</returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative.</exception>
     public static IObservableAsync<long> Timer(TimeSpan dueTime, TimeProvider? timeProvider)
@@ -85,8 +87,8 @@ public static IObservableAsync<long> Timer(TimeSpan dueTime, TimeProvider? timeP
     /// <summary>Creates an observable sequence that produces a single value (0) after the specified delay, then continues to produce sequential values at each specified period.</summary>
     /// <param name="dueTime">The initial delay before the first value is produced. Must be non-negative.</param>
     /// <param name="period">The interval between subsequent values after the initial delay. Must be positive.</param>
-    /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
-    /// is used.</param>
+    /// <param name="timeProvider">The clock driving the schedule; <see langword="null"/> takes
+    /// <see cref="TimeProvider.System"/>.</param>
     /// <returns>An observable sequence that produces values starting after the initial delay and continuing
     /// at the specified period.</returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
index 3f82bda5..cb240e00 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
@@ -51,7 +51,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Null-checks and returns the source unchanged, so generic code can convert without knowing whether it has a signal already.</summary>
+        /// <summary>Null-checks and returns the source unchanged, so generic code can convert without testing the source's type.</summary>
         /// <returns>The same sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
index ff73bfff..dfd2ff09 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
@@ -22,7 +22,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="resultSelector">A function to apply to each pair of elements. Cannot be null.</param>
         /// <returns>An observable sequence whose elements are the result of pair-wise combining the source
         /// elements using the result selector.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if any argument is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="src1"/>, <paramref name="second"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         /// <remarks>The nth element of one source is paired with the nth element of the other, so an element waits until
         /// its partner arrives. The result completes when either source completes with no pending pair.</remarks>
         public IObservableAsync<TResult> Pair<T2, TResult>(
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
index 4f062322..02a2fb54 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
@@ -7,7 +7,7 @@ namespace ReactiveUI.Primitives.Async;
 /// <summary>Fused filter / projection observables that back the parity-helper extension methods in <see cref="SignalAsyncExtensions"/>.</summary>
 public static partial class SignalAsyncExtensions
 {
-    /// <summary>Emits each adjacent pair of source values, holding the prior value in a field rather than a closure.</summary>
+    /// <summary>Emits each adjacent <c>(previous, current)</c> pair of source values.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     internal sealed class PairwiseSignal<T>(IObservableAsync<T> source) : IObservableAsync<(T Previous, T Current)>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
index 9e7d4889..f2b9b19c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
@@ -147,7 +147,7 @@ private async ValueTask AwaitAndForwardAsync(
         }
     }
 
-    /// <summary>Schedules the value without canceling superseded delays; only the current value is emitted.</summary>
+    /// <summary>Debounces the source, dropping repeated values both before the delay and before each forward, so only the newest pending value is emitted.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="dueTime">The debounce window.</param>
@@ -434,7 +434,7 @@ private async ValueTask AwaitFullAsync(ValueTask actionTask, T value, Cancellati
         }
     }
 
-    /// <summary>Schedules the latest value, discarding superseded delay results.</summary>
+    /// <summary>Forwards a value immediately when the condition holds, and otherwise after the debounce window, discarding values a newer one supersedes.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="debounce">The debounce window applied to bypass-false values.</param>
@@ -494,7 +494,7 @@ internal bool IsCurrentEmission(long id)
                 }
             }
 
-            /// <summary>Starts a delay that supersedes the previously pending value.</summary>
+            /// <summary>Starts a delay for the value, superseding any pending one.</summary>
             /// <param name="value">The pending value.</param>
             /// <param name="cancellationToken">Cancellation for the delay.</param>
             /// <returns>The delay and any downstream notification.</returns>
@@ -587,7 +587,7 @@ private async Task DelayAndEmitAsync(T value, long id, CancellationToken cancell
         }
     }
 
-    /// <summary>Forwards every element of each enumerable the source emits, walking arrays and lists by index.</summary>
+    /// <summary>Forwards every element of each enumerable the source emits, in order.</summary>
     /// <typeparam name="T">The flattened element type.</typeparam>
     /// <param name="source">The upstream observable of <see cref="IEnumerable{T}"/> snapshots.</param>
     internal sealed class ForEachEnumerableSignal<T>(IObservableAsync<IEnumerable<T>> source) : IObservableAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
index ad0c0a3b..89957229 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
@@ -20,6 +20,8 @@ public static partial class SignalAsyncExtensions
     {
         /// <summary>Emits <see langword="true"/> when the latest value from every source sequence is <see langword="false"/>.</summary>
         /// <returns>A sequence of aggregate boolean states.</returns>
+        /// <remarks>An empty <paramref name="sources"/> sequence emits a single <see langword="true"/>; otherwise nothing is
+        /// emitted until every source has produced a value.</remarks>
         public IObservableAsync<bool> CombineLatestValuesAreAllFalse()
         {
             ArgumentExceptionHelper.ThrowIfNull(sources);
@@ -43,6 +45,8 @@ public IObservableAsync<bool> CombineLatestValuesAreAllFalse()
 
         /// <summary>Emits <see langword="true"/> when the latest value from every source sequence is <see langword="true"/>.</summary>
         /// <returns>A sequence of aggregate boolean states.</returns>
+        /// <remarks>An empty <paramref name="sources"/> sequence emits a single <see langword="true"/>; otherwise nothing is
+        /// emitted until every source has produced a value.</remarks>
         public IObservableAsync<bool> CombineLatestValuesAreAllTrue()
         {
             ArgumentExceptionHelper.ThrowIfNull(sources);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
index 8cdfe496..2fdb4b5f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ReduceAsync.cs
@@ -20,7 +20,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
         /// current accumulated value, the current element, and a cancellation token.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAcc> AggregateAsync<TAcc>(
             TAcc seed,
@@ -34,7 +34,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// current accumulated value, the current element, and a cancellation token.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAcc> AggregateAsync<TAcc>(
             TAcc seed,
@@ -48,7 +48,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
         /// accumulated value and the current element.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAcc> AggregateAsync<TAcc>(
             TAcc seed,
@@ -62,7 +62,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// accumulated value and the current element.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAcc> AggregateAsync<TAcc>(
             TAcc seed,
@@ -77,8 +77,7 @@ public ValueTask<TAcc> AggregateAsync<TAcc>(
         /// <param name="accumulator">An accumulator function to invoke on each element.</param>
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
-        /// <paramref name="resultSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
             TAcc seed,
@@ -94,8 +93,7 @@ public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
-        /// <paramref name="resultSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
             TAcc seed,
@@ -110,7 +108,7 @@ public ValueTask<TResult> AggregateAsync<TAcc, TResult>(
         /// <param name="accumulator">An asynchronous accumulator function to invoke on each element. Receives the
         /// current accumulated value, the current element, and a cancellation token.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAcc> ReduceAsync<TAcc>(
             TAcc seed,
@@ -124,7 +122,7 @@ public ValueTask<TAcc> ReduceAsync<TAcc>(
         /// current accumulated value, the current element, and a cancellation token.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public async ValueTask<TAcc> ReduceAsync<TAcc>(
             TAcc seed,
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator,
@@ -145,7 +143,7 @@ public async ValueTask<TAcc> ReduceAsync<TAcc>(
         /// <param name="accumulator">An accumulator function to invoke on each element. Receives the current
         /// accumulated value and the current element.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TAccumulate> ReduceAsync<TAccumulate>(
             TAccumulate seed,
@@ -159,7 +157,7 @@ public ValueTask<TAccumulate> ReduceAsync<TAccumulate>(
         /// accumulated value and the current element.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the final accumulated value.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public async ValueTask<TAcc> ReduceAsync<TAcc>(
             TAcc seed,
             Func<TAcc, T, TAcc> accumulator,
@@ -181,8 +179,7 @@ public async ValueTask<TAcc> ReduceAsync<TAcc>(
         /// <param name="accumulator">An accumulator function to invoke on each element.</param>
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
-        /// <paramref name="resultSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<TResult> ReduceAsync<TAcc, TResult>(
             TAcc seed,
@@ -198,8 +195,7 @@ public ValueTask<TResult> ReduceAsync<TAcc, TResult>(
         /// <param name="resultSelector">A function to transform the final accumulated value into the result value.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task representing the asynchronous operation, containing the transformed result.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="accumulator"/> or
-        /// <paramref name="resultSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         public async ValueTask<TResult> ReduceAsync<TAcc, TResult>(
             TAcc seed,
             Func<TAcc, T, TAcc> accumulator,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Bind.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Bind.Rx.cs
index 3c283979..a53baec0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Bind.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Bind.Rx.cs
@@ -16,6 +16,7 @@ public static partial class SignalAsyncExtensions
         /// <typeparam name="TResult">The result element type.</typeparam>
         /// <param name="selector">The projection producing an inner sequence for each value.</param>
         /// <returns>An observable sequence of merged inner values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> Bind<TResult>(Func<T, IObservableAsync<TResult>> selector)
         {
             ArgumentExceptionHelper.ThrowIfNull(selector);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
index 5060d051..9de68bc6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.DistinctUntilChanged.Rx.cs
@@ -44,6 +44,7 @@ public IObservableAsync<T> DistinctUntilChanged(IEqualityComparer<T> equalityCom
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
         /// duplicates according to the specified key.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> DistinctUntilChangedBy<TKey>(Func<T, TKey> keySelector)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Rescue.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Rescue.Rx.cs
index 8eaa14c3..95c0c634 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Rescue.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Rescue.Rx.cs
@@ -15,6 +15,7 @@ public static partial class SignalAsyncExtensions
         /// <summary>Recovers from a terminal failure with a replacement sequence.</summary>
         /// <param name="handler">The handler that produces a replacement sequence from the error.</param>
         /// <returns>An observable sequence that recovers from failures.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="handler"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> Rescue(Func<Exception, IObservableAsync<T>> handler)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
index 88f35d07..b89dd159 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Scan.Rx.cs
@@ -17,6 +17,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An asynchronous accumulator function to be invoked on each element.</param>
         /// <returns>An observable sequence containing the accumulated values produced after each element is processed.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TAcc> Scan<TAcc>(
             TAcc seed,
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator)
@@ -31,6 +32,7 @@ public IObservableAsync<TAcc> Scan<TAcc>(
         /// <param name="seed">The initial accumulator value.</param>
         /// <param name="accumulator">An accumulator function to be invoked on each element.</param>
         /// <returns>An observable sequence containing the accumulated values produced after each element is processed.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="accumulator"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TAcc> Scan<TAcc>(TAcc seed, Func<TAcc, T, TAcc> accumulator)
         {
             ArgumentExceptionHelper.ThrowIfNull(accumulator);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
index 9b1fc010..cd19ff95 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.SelectMany.Rx.cs
@@ -16,6 +16,7 @@ public static partial class SignalAsyncExtensions
         /// <typeparam name="TResult">The type of the elements in the projected inner sequences.</typeparam>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the merged projection results.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> SelectMany<TResult>(Func<T, IObservableAsync<TResult>> selector)
         {
             ArgumentExceptionHelper.ThrowIfNull(selector);
@@ -30,6 +31,7 @@ public IObservableAsync<TResult> SelectMany<TResult>(Func<T, IObservableAsync<TR
         /// <typeparam name="TResult">The type of the elements in the projected inner sequences.</typeparam>
         /// <param name="selector">An asynchronous transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the merged projection results.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> SelectMany<TResult>(
             Func<T, CancellationToken, ValueTask<IObservableAsync<TResult>>> selector)
         {
@@ -52,8 +54,7 @@ public IObservableAsync<TResult> SelectMany<TResult>(
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform
         /// function on each element of the source sequence, and then mapping each pair of source and collection
         /// element through the result selector.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="collectionSelector"/> or
-        /// <paramref name="resultSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> SelectMany<TCollection, TResult>(
             Func<T, IObservableAsync<TCollection>> collectionSelector,
             Func<T, TCollection, TResult> resultSelector)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
index 27309ffb..e25370cc 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
@@ -53,7 +53,7 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, TimeProvider? timeProvider)
         /// <returns>An observable sequence that mirrors the source, switching to the fallback sequence
         /// if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="fallback"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="fallback"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> Timeout(TimeSpan dueTime, IObservableAsync<T> fallback)
         {
             ArgumentExceptionHelper.ThrowIfNull(fallback);
@@ -73,7 +73,7 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, IObservableAsync<T> fallbac
         /// <returns>An observable sequence that mirrors the source, switching to the fallback sequence
         /// if any inter-element interval exceeds the specified interval.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative or zero.</exception>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="fallback"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="fallback"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> Timeout(
             TimeSpan dueTime,
             IObservableAsync<T> fallback,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Zip.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Zip.Rx.cs
index 6e6f749a..48619d5d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Zip.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Zip.Rx.cs
@@ -18,6 +18,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="second">The second observable sequence.</param>
         /// <param name="resultSelector">A function to apply to each pair of elements.</param>
         /// <returns>An observable sequence whose elements are the pair-wise combination of source elements.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="src1"/>, <paramref name="second"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         public IObservableAsync<TResult> Zip<T2, TResult>(
             IObservableAsync<T2> second,
             Func<T1, T2, TResult> resultSelector)
@@ -33,6 +34,7 @@ public IObservableAsync<TResult> Zip<T2, TResult>(
         /// <typeparam name="T2">The type of elements in the second source sequence.</typeparam>
         /// <param name="second">The second observable sequence.</param>
         /// <returns>An observable sequence of tuples pairing elements from each source.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="src1"/> or <paramref name="second"/> is <see langword="null"/>.</exception>
         public IObservableAsync<(T1 First, T2 Second)> Zip<T2>(IObservableAsync<T2> second)
         {
             ArgumentExceptionHelper.ThrowIfNull(src1);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
index 4eed6c62..cadf1f93 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleAsync.cs
@@ -14,40 +14,40 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an exception if more than one such element exists.</summary>
+        /// <summary>Asynchronously returns the one element of the sequence that satisfies the specified condition.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element that matches
         /// the predicate.</returns>
-        /// <remarks>Both no match and more than one match throw.</remarks>
+        /// <exception cref="InvalidOperationException">No element satisfies <paramref name="predicate"/>, or more than one does.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(Func<T, bool> predicate) =>
             source.SingleAsync(predicate, CancellationToken.None);
 
-        /// <summary>Asynchronously returns the single element of a sequence that satisfies a specified condition, or throws an exception if more than one such element exists.</summary>
+        /// <summary>Asynchronously returns the one element of the sequence that satisfies the specified condition.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element that matches
         /// the predicate.</returns>
-        /// <remarks>Both no match and more than one match throw.</remarks>
+        /// <exception cref="InvalidOperationException">No element satisfies <paramref name="predicate"/>, or more than one does.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(Func<T, bool> predicate, CancellationToken cancellationToken) =>
             SingleCoreAsync(source, predicate, cancellationToken);
 
-        /// <summary>Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not contain exactly one element.</summary>
+        /// <summary>Asynchronously returns the one element of a sequence that contains exactly one element.</summary>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
-        /// <remarks>Both an empty sequence and a sequence of more than one element throw.</remarks>
+        /// <exception cref="InvalidOperationException">The source sequence is empty or contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync() =>
             source.SingleAsync(CancellationToken.None);
 
-        /// <summary>Asynchronously returns the single element of the sequence, and throws an exception if the sequence does not contain exactly one element.</summary>
+        /// <summary>Asynchronously returns the one element of a sequence that contains exactly one element.</summary>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence.</returns>
-        /// <remarks>Both an empty sequence and a sequence of more than one element throw.</remarks>
+        /// <exception cref="InvalidOperationException">The source sequence is empty or contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> SingleAsync(CancellationToken cancellationToken) =>
             SingleCoreAsync(source, null, cancellationToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
index d6bf893a..7c21baed 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SingleOrDefaultAsync.cs
@@ -14,35 +14,29 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Asynchronously returns the only element of a sequence that satisfies a specified condition, or a default
-        /// value if no such element exists; this operation throws if more than one matching element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the only element of the sequence that satisfies a condition, or <paramref name="defaultValue"/> when no element does.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element in the sequence satisfies the condition specified by <paramref
         /// name="predicate"/>.</param>
-        /// <returns>A value task that represents the asynchronous operation. The result contains the single element that matches
-        /// the predicate, the specified default value if no such element is found, or throws an exception if more than
-        /// one matching element exists.</returns>
+        /// <returns>A value task whose result is the single matching element, or <paramref name="defaultValue"/> when no
+        /// element matches.</returns>
+        /// <exception cref="InvalidOperationException">More than one element satisfies <paramref name="predicate"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(
             Func<T, bool> predicate,
             T? defaultValue) =>
             source.SingleOrDefaultAsync(predicate, defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the only element of a sequence that satisfies a specified condition, or a default
-        /// value if no such element exists; this operation throws if more than one matching element is found.
-        /// </summary>
+        /// <summary>Asynchronously returns the only element of the sequence that satisfies a condition, or <paramref name="defaultValue"/> when no element does.</summary>
         /// <param name="predicate">A function to test each element for a condition. The method returns the element for which this predicate
         /// returns <see langword="true"/>.</param>
         /// <param name="defaultValue">The value to return if no element in the sequence satisfies the condition specified by <paramref
         /// name="predicate"/>.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
-        /// <returns>A value task that represents the asynchronous operation. The result contains the single element that matches
-        /// the predicate, the specified default value if no such element is found, or throws an exception if more than
-        /// one matching element exists.</returns>
+        /// <returns>A value task whose result is the single matching element, or <paramref name="defaultValue"/> when no
+        /// element matches.</returns>
+        /// <exception cref="InvalidOperationException">More than one element satisfies <paramref name="predicate"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(
             Func<T, bool> predicate,
@@ -50,42 +44,38 @@ public static partial class SignalAsyncExtensions
             CancellationToken cancellationToken) =>
             SingleOrDefaultCoreAsync(source, predicate, defaultValue, cancellationToken);
 
-        /// <summary>Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this operation throws an exception if more than one element is found.</summary>
+        /// <summary>Asynchronously returns the only element of the sequence, or the default of <typeparamref name="T"/> when the sequence is empty.</summary>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, or the default value of <typeparamref name="T"/> if the sequence is empty.</returns>
+        /// <exception cref="InvalidOperationException">The source sequence contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync() =>
             source.SingleOrDefaultAsync(default, CancellationToken.None);
 
-        /// <summary>Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this operation throws an exception if more than one element is found.</summary>
+        /// <summary>Asynchronously returns the only element of the sequence, or the default of <typeparamref name="T"/> when the sequence is empty.</summary>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
         /// <returns>A value task that represents the asynchronous operation. The task result contains the single element of the
         /// sequence, or the default value of <typeparamref name="T"/> if the sequence is empty.</returns>
+        /// <exception cref="InvalidOperationException">The source sequence contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(CancellationToken cancellationToken) =>
             source.SingleOrDefaultAsync(default, cancellationToken);
 
-        /// <summary>
-        /// Asynchronously returns the single element of the sequence, or a specified default value if the sequence is
-        /// empty. Throws an exception if the sequence contains more than one element.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of the sequence, or <paramref name="defaultValue"/> when the sequence is empty.</summary>
         /// <param name="defaultValue">The value to return if the sequence contains no elements.</param>
-        /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
-        /// sequence, the specified default value if the sequence is empty, or throws if more than one element is
-        /// present.</returns>
+        /// <returns>A value task whose result is the single element of the sequence, or <paramref name="defaultValue"/> when
+        /// the sequence is empty.</returns>
+        /// <exception cref="InvalidOperationException">The source sequence contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(T? defaultValue) =>
             source.SingleOrDefaultAsync(defaultValue, CancellationToken.None);
 
-        /// <summary>
-        /// Asynchronously returns the single element of the sequence, or a specified default value if the sequence is
-        /// empty. Throws an exception if the sequence contains more than one element.
-        /// </summary>
+        /// <summary>Asynchronously returns the single element of the sequence, or <paramref name="defaultValue"/> when the sequence is empty.</summary>
         /// <param name="defaultValue">The value to return if the sequence contains no elements.</param>
         /// <param name="cancellationToken">The token that cancels the operation.</param>
-        /// <returns>A task that represents the asynchronous operation. The task result contains the single element of the
-        /// sequence, the specified default value if the sequence is empty, or throws if more than one element is
-        /// present.</returns>
+        /// <returns>A value task whose result is the single element of the sequence, or <paramref name="defaultValue"/> when
+        /// the sequence is empty.</returns>
+        /// <exception cref="InvalidOperationException">The source sequence contains more than one element.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T?> SingleOrDefaultAsync(T? defaultValue, CancellationToken cancellationToken) =>
             SingleOrDefaultCoreAsync(source, null, defaultValue, cancellationToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
index f800c91d..11aae0d0 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Skip.cs
@@ -16,7 +16,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="count">The number of elements to skip. Must be greater than or equal to 0.</param>
         /// <returns>An observable sequence that contains the elements of the source sequence after the specified number of
         /// elements have been skipped. If the count is 0, the original sequence is returned.</returns>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown if count is less than 0.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero.</exception>
         public IObservableAsync<T> Skip(int count)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
index 81f99d86..b5950391 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SkipWhile.cs
@@ -17,7 +17,7 @@ public static partial class SignalAsyncExtensions
         /// and a cancellation token.</param>
         /// <returns>An observable sequence that skips elements while the predicate returns true and emits
         /// all subsequent elements.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> SkipWhile(Func<T, CancellationToken, ValueTask<bool>> predicate)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -30,7 +30,7 @@ public IObservableAsync<T> SkipWhile(Func<T, CancellationToken, ValueTask<bool>>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns>An observable sequence that skips elements while the predicate returns true and emits
         /// all subsequent elements.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> SkipWhile(Func<T, bool> predicate)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
index b49f7a58..252a0faf 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
@@ -24,7 +24,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="cancellationToken">The token that cancels the subscription and any in-progress callbacks.</param>
         /// <returns>A value task that represents the asynchronous operation. The result is an <see cref="IAsyncDisposable"/>
         /// that can be disposed to unsubscribe from the data source.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying data source is null.</exception>
+        /// <exception cref="ArgumentNullException">The source sequence or <paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
         /// <remarks>Callbacks may be invoked concurrently, so the supplied delegates must be thread-safe.</remarks>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
@@ -44,7 +44,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
         /// <param name="onErrorResumeAsync">An optional delegate that is invoked asynchronously if an error occurs during data processing.</param>
         /// <returns>A value task that represents the asynchronous operation. The result is an <see cref="IAsyncDisposable"/>
         /// that can be disposed to unsubscribe from the data source.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying data source is null.</exception>
+        /// <exception cref="ArgumentNullException">The source sequence or <paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
@@ -57,7 +57,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
         /// <param name="onCompletedAsync">An optional delegate that is invoked asynchronously when the data source completes successfully.</param>
         /// <returns>A value task that represents the asynchronous operation. The result is an <see cref="IAsyncDisposable"/>
         /// that can be disposed to unsubscribe from the data source.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying data source is null.</exception>
+        /// <exception cref="ArgumentNullException">The source sequence or <paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
@@ -70,7 +70,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
         /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A value task that represents the asynchronous subscription operation. The result contains an <see
         /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Action<T> onNext,
             CancellationToken cancellationToken)
@@ -90,7 +90,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(
         /// <param name="onNext">An action to invoke for each element in the sequence. Cannot be null.</param>
         /// <returns>A value task that represents the asynchronous subscription operation. The result contains an <see
         /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<IAsyncDisposable> SubscribeAsync(Action<T> onNext) =>
             source.SubscribeAsync(onNext, CancellationToken.None);
@@ -104,7 +104,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(Action<T> onNext) =>
         /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A value task that represents the asynchronous subscription operation. The result is an <see
         /// cref="IAsyncDisposable"/> that can be disposed to unsubscribe from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="onNext"/> is null, or if the underlying source is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="onNext"/> or the source sequence is <see langword="null"/>.</exception>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Action<T> onNext,
             Action<Exception>? onErrorResume,
@@ -160,7 +160,7 @@ public ValueTask<IAsyncDisposable> SubscribeAsync(Func<T, CancellationToken, Val
         /// <param name="cancellationToken">The token that cancels the subscription.</param>
         /// <returns>A ValueTask that represents the asynchronous subscription operation. The result is an IAsyncDisposable that
         /// can be disposed to unsubscribe from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the underlying source is null.</exception>
+        /// <exception cref="ArgumentNullException">The source sequence or <paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
             CancellationToken cancellationToken)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
index 3c26f71e..50e41393 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
@@ -55,6 +55,7 @@ public IObservableAsync<T> TakeUntil<TOther>(IObservableAsync<TOther> other, Tak
         /// <param name="other">The observable sequence whose first emission or completion terminates the result.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if either the source sequence or the other observable is null.</exception>
         public IObservableAsync<T> TakeUntil<TOther>(
             IObservableAsync<TOther> other,
             CancellationToken cancellationToken)
@@ -75,6 +76,7 @@ public IObservableAsync<T> TakeUntil<TOther>(
         /// <param name="options">Options controlling the take-until behavior, or null for defaults.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if either the source sequence or the other observable is null.</exception>
         public IObservableAsync<T> TakeUntil<TOther>(
             IObservableAsync<TOther> other,
             TakeUntilOptions? options,
@@ -123,6 +125,7 @@ public IObservableAsync<T> TakeUntil(Task task, TakeUntilOptions? options)
         /// <param name="task">The task whose completion terminates the result.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if the source observable is null.</exception>
         public IObservableAsync<T> TakeUntil(Task task, CancellationToken cancellationToken)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -142,6 +145,7 @@ public IObservableAsync<T> TakeUntil(Task task, CancellationToken cancellationTo
         /// <param name="options">Options controlling the take-until behavior, or null for defaults.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if the source observable is null.</exception>
         public IObservableAsync<T> TakeUntil(
             Task task,
             TakeUntilOptions? options,
@@ -186,6 +190,7 @@ public IObservableAsync<T> TakeUntil(Func<T, bool> predicate)
         /// <param name="predicate">A predicate evaluated for each element; first true terminates the sequence.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="predicate"/> is null.</exception>
         public IObservableAsync<T> TakeUntil(Func<T, bool> predicate, CancellationToken cancellationToken)
         {
             ArgumentExceptionHelper.ThrowIfNull(predicate);
@@ -216,6 +221,7 @@ public IObservableAsync<T> TakeUntil(Func<T, CancellationToken, ValueTask<bool>>
         /// <param name="asyncPredicate">An async predicate evaluated for each element; first true terminates the sequence.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="asyncPredicate"/> is null.</exception>
         public IObservableAsync<T> TakeUntil(
             Func<T, CancellationToken, ValueTask<bool>> asyncPredicate,
             CancellationToken cancellationToken)
@@ -261,6 +267,7 @@ public IObservableAsync<T> TakeUntil(
         /// <param name="stopSignal">A delegate that provides the completion stop signal.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="stopSignal"/> is null.</exception>
         public IObservableAsync<T> TakeUntil(
             CompletionSignalDelegate stopSignal,
             CancellationToken cancellationToken)
@@ -279,6 +286,7 @@ public IObservableAsync<T> TakeUntil(
         /// <param name="options">Options controlling the take-until behavior, or null for defaults.</param>
         /// <param name="cancellationToken">A cancellation token that also terminates the result when cancelled.</param>
         /// <returns>An observable sequence that completes on the first of the two signals.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="stopSignal"/> is null.</exception>
         public IObservableAsync<T> TakeUntil(
             CompletionSignalDelegate stopSignal,
             TakeUntilOptions? options,
@@ -479,7 +487,7 @@ internal async ValueTask SubscribeSourcesAsync(CancellationToken cancellationTok
             internal void LinkExternalCancellation(CancellationToken external) =>
                 _lifecycle.LinkExternalCancellation(external);
 
-            /// <summary>Completes on the notifying thread when downstream completion is synchronous.</summary>
+            /// <summary>Hands the stop callback to the delegate and releases a registration that arrives after the callback has fired.</summary>
             internal void AwaitStopThenComplete()
             {
                 Volatile.Write(ref _stopRegistration, _parent._stopSignal(Stop));
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
index 69d099ba..5e3a2547 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeWhile.cs
@@ -17,7 +17,7 @@ public static partial class SignalAsyncExtensions
         /// and a cancellation token.</param>
         /// <returns>An observable sequence that contains elements from the source sequence that satisfy the
         /// condition, completing as soon as the predicate returns false.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> TakeWhile(Func<T, CancellationToken, ValueTask<bool>> predicate)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -30,7 +30,7 @@ public IObservableAsync<T> TakeWhile(Func<T, CancellationToken, ValueTask<bool>>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns>An observable sequence that contains elements from the source sequence that satisfy the
         /// condition, completing as soon as the predicate returns false.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="predicate"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
         public IObservableAsync<T> TakeWhile(Func<T, bool> predicate)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
index 86576174..3f40e1b4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
@@ -5,7 +5,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides Throttle (debounce) extension methods for asynchronous observable sequences.</summary>
-/// <remarks>Only the latest value is emitted after the quiet period; each source value restarts that period.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Throttle (debounce) operators for an observable source sequence.</summary>
@@ -19,6 +18,7 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence containing only those elements that are not followed by another
         /// element within the specified due time.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative.</exception>
+        /// <remarks>Each source element restarts the quiet period, so a continuous burst forwards only its final element.</remarks>
         public IObservableAsync<T> Throttle(TimeSpan dueTime)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(dueTime, TimeSpan.Zero);
@@ -34,6 +34,7 @@ public IObservableAsync<T> Throttle(TimeSpan dueTime)
         /// <returns>An observable sequence containing only those elements that are not followed by another
         /// element within the specified due time.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative.</exception>
+        /// <remarks>Each source element restarts the quiet period, so a continuous burst forwards only its final element.</remarks>
         public IObservableAsync<T> Throttle(TimeSpan dueTime, TimeProvider? timeProvider)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(dueTime, TimeSpan.Zero);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
index 25bee995..f901a5d8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
@@ -21,13 +21,8 @@ public static partial class SignalAsyncExtensions
         /// the buffering and backpressure behavior between the asynchronous observable and the asynchronous enumerable.</param>
         /// <returns>An asynchronous enumerable sequence that yields elements from the asynchronous observable. The
         /// enumeration completes when the source observable completes, or an unhandled error occurs.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown when <paramref name="source"/> or <paramref name="channelFactory"/>
-        /// is null.</exception>
-        /// <remarks>
-        /// The resulting asynchronous enumerable sequence reflects the items and completion behavior of the source
-        /// asynchronous observable. The buffering behavior is determined by the channel created by the provided
-        /// <paramref name="channelFactory"/>.
-        /// </remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="channelFactory"/> is <see langword="null"/>.</exception>
+        /// <remarks>The channel returned by <paramref name="channelFactory"/> determines buffering; a source error completes the enumeration with that error.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IAsyncEnumerable<T> ToAsyncEnumerable(
             Func<Channel<T>> channelFactory) =>
@@ -41,7 +36,7 @@ public IAsyncEnumerable<T> ToAsyncEnumerable(
         /// sequence completes with the error.</param>
         /// <returns>An asynchronous enumerable sequence that yields the elements produced by the observable sequence. The
         /// enumeration completes when the observable completes or an unhandled error occurs.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="source"/> or <paramref name="channelFactory"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="channelFactory"/> is <see langword="null"/>.</exception>
         /// <remarks>The channel factory controls buffering. The optional error callback handles source errors; without it, errors propagate to the enumerator.</remarks>
         public IAsyncEnumerable<T> ToAsyncEnumerable(
             Func<Channel<T>> channelFactory,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
index 13b96143..17b148f3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToDictionaryAsync.cs
@@ -22,7 +22,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary mapping keys to
         /// elements from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the keySelector parameter is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">Two elements of the source sequence produce the same key.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(
             Func<T, TKey> keySelector,
@@ -36,7 +37,8 @@ public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(
         /// <param name="keySelector">A function to extract a key from each element in the sequence. Cannot be null.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary mapping keys to
         /// elements from the sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if the keySelector parameter is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">Two elements of the source sequence produce the same key.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(Func<T, TKey> keySelector)
             where TKey : notnull =>
@@ -52,9 +54,8 @@ public ValueTask<Dictionary<TKey, T>> ToDictionaryAsync<TKey>(Func<T, TKey> keyS
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary mapping keys to
         /// values as defined by the selector functions.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="keySelector"/> or <paramref name="elementSelector"/> is null.</exception>
-        /// <remarks>If multiple elements produce the same key, an exception may be thrown. The operation
-        /// is performed asynchronously and can be cancelled using the provided cancellation token.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> or <paramref name="elementSelector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">Two elements of the source sequence produce the same key.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<Dictionary<TKey, TValue>> ToDictionaryAsync<TKey, TValue>(
             Func<T, TKey> keySelector,
@@ -74,7 +75,8 @@ public ValueTask<Dictionary<TKey, TValue>> ToDictionaryAsync<TKey, TValue>(
         /// <param name="elementSelector">A function to map each element in the sequence to a value in the resulting dictionary.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary mapping keys to
         /// values as defined by the selector functions.</returns>
-        /// <exception cref="ArgumentExceptionHelper">Thrown if <paramref name="keySelector"/> or <paramref name="elementSelector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> or <paramref name="elementSelector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">Two elements of the source sequence produce the same key.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<Dictionary<TKey, TValue>> ToDictionaryAsync<TKey, TValue>(
             Func<T, TKey> keySelector,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
index ed06637c..248bcf57 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
@@ -33,9 +33,8 @@ public IObservableAsync<T> Unique()
         /// <returns>An observable sequence that contains only distinct consecutive elements from the source sequence, as
         /// determined by the specified equality comparer.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="equalityComparer"/> is <see langword="null"/>.</exception>
-        /// <remarks>Use this method to suppress consecutive duplicate elements in the sequence. Only
-        /// elements that differ from their immediate predecessor, according to the provided comparer, are emitted to
-        /// observers.</remarks>
+        /// <remarks>Only elements that differ from their immediate predecessor, as judged by <paramref
+        /// name="equalityComparer"/>, are emitted; non-consecutive duplicates are not suppressed.</remarks>
         public IObservableAsync<T> Unique(IEqualityComparer<T> equalityComparer)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -82,7 +81,7 @@ public IObservableAsync<T> UniqueBy<TKey>(
         }
     }
 
-    /// <summary>Single-observer-layer <c>DistinctUntilChanged</c>. Replaces the previous \c Create + async-lambda + closure pattern; per-subscription state lives in observer fields.</summary>
+    /// <summary>Drops each value that the comparer judges equal to the most-recently-forwarded one.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The upstream observable.</param>
     /// <param name="comparer">The equality comparer used to detect duplicates.</param>
@@ -114,7 +113,7 @@ internal sealed class UniqueWitness(
             IEqualityComparer<T> comparer,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>The previously-forwarded value; valid only when <see cref="_hasPrevious"/> is set.</summary>
+            /// <summary>The most-recently-forwarded value; valid only when <see cref="_hasPrevious"/> is set.</summary>
             private T? _previous;
 
             /// <summary>Latches to <see langword="true"/> after the first emission has been forwarded.</summary>
@@ -182,7 +181,7 @@ internal sealed class UniqueByWitness(
             IEqualityComparer<TKey> comparer,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>The previously-forwarded key; valid only when <see cref="_hasPrevious"/> is set.</summary>
+            /// <summary>The most-recently-forwarded key; valid only when <see cref="_hasPrevious"/> is set.</summary>
             private TKey? _previousKey;
 
             /// <summary>Latches to <see langword="true"/> after the first emission has been forwarded.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
index 56e3b6ff..bfd8d880 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Using.cs
@@ -39,9 +39,7 @@ public static IObservableAsync<T> Use<TResource, T>(
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "Using is the System.Reactive name for Use. Both operators intentionally build the same signal directly "
-            + "rather than one forwarding to the other, so the Rx-named alias costs nothing at the call site.")]
+        Justification = "Using is the System.Reactive name for Use and builds the same signal.")]
     public static IObservableAsync<T> Using<T, TResource>(
         Func<CancellationToken, ValueTask<TResource>> resourceFactory,
         Func<TResource, IObservableAsync<T>> signalFactory)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/WaitCompletionAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/WaitCompletionAsync.cs
index f32ef4c0..d4942fd8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/WaitCompletionAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/WaitCompletionAsync.cs
@@ -16,8 +16,8 @@ public static partial class SignalAsyncExtensions
     {
         /// <summary>Asynchronously waits for the observable sequence to complete without retrieving any values.</summary>
         /// <returns>A ValueTask that represents the asynchronous wait operation.</returns>
-        /// <remarks>This method subscribes to the observable sequence and completes when the sequence signals
-        /// completion or when the operation is canceled. Any values produced by the sequence are ignored.</remarks>
+        /// <remarks>The source is subscribed once and its values are ignored; the returned task completes when the
+        /// sequence completes and faults with the error when it fails.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask WaitCompletionAsync() =>
             source.WaitCompletionAsync(CancellationToken.None);
@@ -25,8 +25,8 @@ public ValueTask WaitCompletionAsync() =>
         /// <summary>Asynchronously waits for the observable sequence to complete without retrieving any values.</summary>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the wait operation.</param>
         /// <returns>A ValueTask that represents the asynchronous wait operation.</returns>
-        /// <remarks>This method subscribes to the observable sequence and completes when the sequence signals
-        /// completion or when the operation is canceled. Any values produced by the sequence are ignored.</remarks>
+        /// <remarks>The source is subscribed once and its values are ignored; the returned task completes when the
+        /// sequence completes and faults with the error when it fails.</remarks>
         public async ValueTask WaitCompletionAsync(
             CancellationToken cancellationToken)
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
index 4188c29c..8bb55f5f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/Concurrent.cs
@@ -11,14 +11,12 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <remarks>All observers start concurrently; the returned task waits for every observer. Empty collections complete synchronously, and failures follow Task.WhenAll semantics.</remarks>
 public static class Concurrent
 {
-    /// <summary>Forwards the specified value to all observers concurrently by invoking their OnNextAsync methods.</summary>
+    /// <summary>Forwards a value to every observer without waiting for any one of them to finish first.</summary>
     /// <typeparam name="T">The type of the value to forward to the observers.</typeparam>
-    /// <param name="observers">A read-only list of observers that will receive the value. Cannot be null.</param>
+    /// <param name="observers">The observers to notify.</param>
     /// <param name="value">The value to forward to each observer.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the forwarding operation.</param>
-    /// <returns>A ValueTask that represents the asynchronous operation of forwarding the value to all observers. The task
-    /// completes when all observers have processed the value.</returns>
-    /// <remarks>Empty collections complete synchronously. Multiple observers follow Task.WhenAll failure semantics.</remarks>
+    /// <param name="cancellationToken">A token passed to each observer's notification.</param>
+    /// <returns>A task that completes once every observer has processed the value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnNextConcurrently<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -57,13 +55,12 @@ public static ValueTask ForwardOnNextConcurrently<T>(
         return default;
     }
 
-    /// <summary>Forwards an error notification to all specified asynchronous observers concurrently, allowing each observer to handle the error and resume as appropriate.</summary>
+    /// <summary>Forwards a non-terminal error to every observer without waiting for any one of them to finish first.</summary>
     /// <typeparam name="T">The type of the elements observed by the observers.</typeparam>
-    /// <param name="observers">A read-only list of asynchronous observers to which the error notification will be forwarded. Cannot be null.</param>
+    /// <param name="observers">The observers to notify.</param>
     /// <param name="error">The exception representing the error to forward to each observer. Cannot be null.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the forwarding operation.</param>
-    /// <returns>A ValueTask that represents the asynchronous operation of forwarding the error to all observers. The task
-    /// completes when all observers have processed the error notification.</returns>
+    /// <param name="cancellationToken">A token passed to each observer's notification.</param>
+    /// <returns>A task that completes once every observer has processed the error.</returns>
     /// <remarks>Cancellation is forwarded to each observer; it does not prevent other observers from being called.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnErrorResumeConcurrently<T>(
@@ -103,14 +100,11 @@ public static ValueTask ForwardOnErrorResumeConcurrently<T>(
         return default;
     }
 
-    /// <summary>Invokes the OnCompletedAsync method on each observer in the collection concurrently, forwarding the specified result to all observers.</summary>
+    /// <summary>Forwards the terminal result to every observer without waiting for any one of them to finish first.</summary>
     /// <typeparam name="T">The type of the elements observed by the observers.</typeparam>
-    /// <param name="observers">A read-only list of observers to which the completion notification will be forwarded. Cannot be null.</param>
-    /// <param name="result">The result to pass to each observer's OnCompletedAsync method.</param>
-    /// <returns>A ValueTask that represents the asynchronous operation of notifying all observers. The task completes when all
-    /// observers have finished processing the completion notification. If the observers list is empty, a default
-    /// ValueTask is returned.</returns>
-    /// <remarks>Empty collections complete synchronously. Multiple observers follow Task.WhenAll failure semantics.</remarks>
+    /// <param name="observers">The observers to notify.</param>
+    /// <param name="result">The terminal result to forward to each observer.</param>
+    /// <returns>A task that completes once every observer has processed the completion.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ValueTask ForwardOnCompletedConcurrently<T>(
         ImmutableArray<IObserverAsync<T>> observers,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
index a0ab9527..29fd7e11 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -12,7 +12,7 @@ internal sealed class ReplayLatestSignalAsyncStateObserverLease<T>(
     ReplayLatestSignalAsyncState<T> state,
     IObserverAsync<T> observer) : IAsyncDisposable
 {
-    /// <summary>Indicates whether the lease has already removed its observer.</summary>
+    /// <summary>Latch raised by the first disposer, so the observer is removed once.</summary>
     private int _disposed;
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
index af676fe6..dc188286 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncState{T}.cs
@@ -11,11 +11,11 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <typeparam name="T">The observed value type.</typeparam>
 internal sealed class ReplayLatestSignalAsyncState<T> : IDisposable
 {
-    /// <summary>The asynchronous gate used to synchronize mutable state.</summary>
+    /// <summary>Serializes every mutation of this state, including the replay emitted during subscribe.</summary>
     [SuppressMessage(
         "Style",
         "SST1401:Field should be private",
-        Justification = "Gate fields are intentionally direct readonly state for helper access.")]
+        Justification = "The state helpers enter this gate directly.")]
     internal readonly AsyncSerialGate Gate = new();
 
     /// <summary>Initializes a new instance of the <see cref="ReplayLatestSignalAsyncState{T}"/> class.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
index 35870106..480816a3 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SerialBroadcastHelpers.cs
@@ -15,7 +15,7 @@ internal static class SerialBroadcastHelpers
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="observers">The current observer snapshot.</param>
     /// <param name="value">The value being broadcast.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the notification operation.</param>
+    /// <param name="cancellationToken">A token passed to each observer's notification.</param>
     /// <returns>A task that represents the asynchronous notification operation.</returns>
     internal static ValueTask BroadcastOnNextAsync<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -29,7 +29,7 @@ internal static ValueTask BroadcastOnNextAsync<T>(
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="observers">The current observer snapshot.</param>
     /// <param name="value">The value being broadcast.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the notification operation.</param>
+    /// <param name="cancellationToken">A token passed to each observer's notification.</param>
     /// <returns>A task that represents the asynchronous notification operation.</returns>
     internal static ValueTask BroadcastOnNextAsyncMulti<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -54,7 +54,7 @@ internal static ValueTask BroadcastOnNextAsyncMulti<T>(
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="observers">The current observer snapshot.</param>
     /// <param name="error">The error being broadcast.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the notification operation.</param>
+    /// <param name="cancellationToken">A token passed to each observer's notification.</param>
     /// <returns>A task that represents the asynchronous notification operation.</returns>
     internal static ValueTask BroadcastOnErrorResumeAsync<T>(
         ImmutableArray<IObserverAsync<T>> observers,
@@ -105,7 +105,7 @@ internal static ValueTask BroadcastOnCompletedAsync<T>(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
         Justification =
-            "Every caller returns early unless IsCompletedSuccessfully, so this only ever consumes a task that is already done. The guard is one frame up, which the rule does not follow.")]
+            "Every caller checks IsCompletedSuccessfully and returns early otherwise, so the awaiter only ever observes a completed task.")]
     private static void ConsumeCompleted(ValueTask pending) =>
         pending.GetAwaiter().GetResult();
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncStateObserverLease{T}.cs
index bb86d9c2..671d979c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncStateObserverLease{T}.cs
@@ -12,7 +12,7 @@ internal sealed class SignalAsyncStateObserverLease<T>(
     SignalAsyncState<T> state,
     IObserverAsync<T> observer) : IAsyncDisposable
 {
-    /// <summary>Indicates whether the lease has already removed its observer.</summary>
+    /// <summary>Latch raised by the first disposer, so the observer is removed once.</summary>
     private int _disposed;
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncState{T}.cs
index eccfef2b..ad5a9c1c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/SignalAsyncState{T}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <typeparam name="T">The observed value type.</typeparam>
 internal sealed class SignalAsyncState<T>
 {
-    /// <summary>The lock used to synchronize mutable state.</summary>
+    /// <summary>Guards the observer list and the completion result against concurrent mutation.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>Gets or sets the currently subscribed observers.</summary>
@@ -19,9 +19,9 @@ internal sealed class SignalAsyncState<T>
     /// <summary>Gets or sets the completion result, or null if the signal has not completed.</summary>
     internal Result? Result { get; set; }
 
-    /// <summary>Gets a stable observer snapshot when the signal is still active.</summary>
+    /// <summary>Gets a stable observer snapshot when the signal has not completed.</summary>
     /// <param name="observers">Receives the observers to notify when the signal is active.</param>
-    /// <returns>true if observers should be notified; otherwise, false.</returns>
+    /// <returns><see langword="true"/> when observers should be notified; otherwise, <see langword="false"/>.</returns>
     internal bool TryGetObservers(out ImmutableArray<IObserverAsync<T>> observers)
     {
         lock (_gate)
@@ -40,7 +40,7 @@ internal bool TryGetObservers(out ImmutableArray<IObserverAsync<T>> observers)
     /// <summary>Marks the signal as completed and returns the observers to notify.</summary>
     /// <param name="result">The completion result to store.</param>
     /// <param name="observers">Receives the observers subscribed at completion time.</param>
-    /// <returns>true if this call completed the signal; otherwise, false.</returns>
+    /// <returns><see langword="true"/> when this call completed the signal; otherwise, <see langword="false"/>.</returns>
     internal bool TryComplete(Result result, out ImmutableArray<IObserverAsync<T>> observers)
     {
         lock (_gate)
@@ -58,9 +58,9 @@ internal bool TryComplete(Result result, out ImmutableArray<IObserverAsync<T>> o
         }
     }
 
-    /// <summary>Adds an observer unless the signal has already completed.</summary>
+    /// <summary>Adds an observer unless the signal has completed.</summary>
     /// <param name="observer">The observer to subscribe.</param>
-    /// <returns>The existing completion result when the signal is already completed; otherwise, null.</returns>
+    /// <returns>The stored completion result when the signal has completed; otherwise, null.</returns>
     internal Result? Subscribe(IObserverAsync<T> observer)
     {
         lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
index 1a6a1de9..9777bde9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -12,7 +12,7 @@ internal sealed class StatelessReplayLatestSignalAsyncStateObserverLease<T>(
     StatelessReplayLatestSignalAsyncState<T> state,
     IObserverAsync<T> observer) : IAsyncDisposable
 {
-    /// <summary>Indicates whether the lease has already removed its observer.</summary>
+    /// <summary>Latch raised by the first disposer, so the observer is removed once.</summary>
     private int _disposed;
 
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
index 2d64e4d1..f775c8c5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncState{T}.cs
@@ -11,11 +11,11 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <typeparam name="T">The observed value type.</typeparam>
 internal sealed class StatelessReplayLatestSignalAsyncState<T> : IDisposable
 {
-    /// <summary>The asynchronous gate used to synchronize mutable state.</summary>
+    /// <summary>Serializes every mutation of this state, including the replay emitted during subscribe.</summary>
     [SuppressMessage(
         "Style",
         "SST1401:Field should be private",
-        Justification = "Gate fields are intentionally direct readonly state for helper access.")]
+        Justification = "The state helpers enter this gate directly.")]
     internal readonly AsyncSerialGate Gate = new();
 
     /// <summary>Initializes a new instance of the <see cref="StatelessReplayLatestSignalAsyncState{T}"/> class.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessSignalAsyncState{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessSignalAsyncState{T}.cs
index 5514d3c5..eacf27ff 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessSignalAsyncState{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessSignalAsyncState{T}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <typeparam name="T">The observed value type.</typeparam>
 internal sealed class StatelessSignalAsyncState<T>
 {
-    /// <summary>The lock used to synchronize observer list updates.</summary>
+    /// <summary>Guards the observer list against concurrent mutation.</summary>
     private readonly Lock _gate = new();
 
     /// <summary>Gets or sets the currently subscribed observers.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
index 52e5f8c2..0c328a3a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentReplayLatestSignalAsync.cs
@@ -6,10 +6,11 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents an asynchronous Signal that replays only the latest value to new observers and supports concurrent notification of observers.</summary>
+/// <summary>An asynchronous Signal that replays its latest value to each new subscriber and notifies observers concurrently.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-/// <param name="startValue">An optional initial value to be emitted to observers upon subscription if no other value has been published.</param>
-/// <remarks>Observer notifications overlap; their completion order is unspecified.</remarks>
+/// <param name="startValue">The value replayed to new subscribers until something is published.</param>
+/// <remarks>Completion order across observers is unspecified, and a cancelled notification does not stop the
+/// others.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentReplayLatestSignalAsync: LastValue = {_state.LastValue}, IsDisposed = {_state.IsDisposed}")]
 public sealed class ConcurrentReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
index 892b5425..49c7414d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentSignalAsync.cs
@@ -6,9 +6,10 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Provides an asynchronous Signal that forwards notifications to observers concurrently.</summary>
+/// <summary>An asynchronous Signal that notifies its observers concurrently and latches the terminal result.</summary>
 /// <typeparam name="T">The type of value observed and forwarded to observers.</typeparam>
-/// <remarks>Observer notifications overlap; their completion order is unspecified.</remarks>
+/// <remarks>Completion order across observers is unspecified, and a cancelled notification does not stop the
+/// others.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentSignalAsync: Observers = {_state.Observers.Length}, Result = {_state.Result}")]
 public sealed class ConcurrentSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
index d1a95f2f..015c5b24 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
@@ -6,11 +6,11 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents an asynchronous Signal that replays the latest value to new observers and forwards notifications to all observers concurrently without maintaining internal state.</summary>
+/// <summary>An asynchronous Signal that replays its latest value to each new subscriber, notifies observers concurrently, and resets once the last observer leaves.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-/// <param name="startValue">An optional initial value to be replayed to new observers. If not specified, no value is replayed until the first
-/// value is published.</param>
-/// <remarks>Replays the latest value to new subscribers and notifies observers concurrently. Cancellation can prevent some observers from receiving a notification.</remarks>
+/// <param name="startValue">The value replayed until something is published, and restored when the last observer
+/// leaves.</param>
+/// <remarks>Cancellation can stop some observers from receiving a notification the others do receive.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentStatelessReplayLatestSignalAsync: Value = {_state.Value}, IsDisposed = {_state.IsDisposed}")]
 public sealed class ConcurrentStatelessReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
index 6a7042b7..3ed1e7a4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessSignalAsync.cs
@@ -6,9 +6,10 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents a stateless asynchronous Signal that forwards notifications to observers concurrently.</summary>
+/// <summary>An asynchronous Signal that notifies its observers concurrently and keeps publishing after a terminal notification.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-/// <remarks>Observer notifications execute concurrently; their completion order is unspecified.</remarks>
+/// <remarks>Completion order across observers is unspecified, and a cancelled notification does not stop the
+/// others.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentStatelessSignalAsync: Observers = {_state.Observers.Length}")]
 public sealed class ConcurrentStatelessSignalAsync<T> : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
index b178be7e..7d209929 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/BehaviorSignalCreationOptions.cs
@@ -8,12 +8,12 @@ namespace ReactiveUI.Primitives.Async.Signals;
 [System.Diagnostics.DebuggerDisplay("BehaviorSignalCreationOptions: PublishingOption = {PublishingOption}, IsStateless = {IsStateless}")]
 public sealed record BehaviorSignalCreationOptions
 {
-    /// <summary>Gets the default configuration options for creating a new BehaviorSignal instance.</summary>
+    /// <summary>Gets the default options: serial publishing, with completion state retained.</summary>
     public static BehaviorSignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
-    /// <summary>Gets the publishing option to use when processing the item.</summary>
+    /// <summary>Gets the order notifications are delivered to observers in.</summary>
     public required PublishingOption PublishingOption { get; init; }
 
-    /// <summary>Gets a value indicating whether the object is stateless.</summary>
+    /// <summary>Gets a value indicating whether the signal discards its completion state, resetting to the start value once the last observer leaves.</summary>
     public required bool IsStateless { get; init; }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
index bf67718e..8ab2f846 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/PublishingOption.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Specifies the available options for publishing operations, indicating whether actions are performed serially or concurrently.</summary>
+/// <summary>Specifies whether a signal awaits each observer notification before the next or starts them together.</summary>
 public enum PublishingOption
 {
     /// <summary>Awaits each observer notification before invoking the next observer.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
index b72f9410..2ced9abb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/ReplayLatestSignalCreationOptions.cs
@@ -8,13 +8,12 @@ namespace ReactiveUI.Primitives.Async.Signals;
 [System.Diagnostics.DebuggerDisplay("ReplayLatestSignalCreationOptions: PublishingOption = {PublishingOption}, IsStateless = {IsStateless}")]
 public sealed record ReplayLatestSignalCreationOptions
 {
-    /// <summary>Gets the default configuration options for creating a ReplayLatestSignal instance.</summary>
-    /// <remarks>Defaults to serial, stateful publishing.</remarks>
+    /// <summary>Gets the default options: serial publishing, with completion state retained.</summary>
     public static ReplayLatestSignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
-    /// <summary>Gets the publishing option to use when processing this item.</summary>
+    /// <summary>Gets the order notifications are delivered to observers in.</summary>
     public required PublishingOption PublishingOption { get; init; }
 
-    /// <summary>Gets a value indicating whether the object is stateless.</summary>
+    /// <summary>Gets a value indicating whether the signal discards its completion state, resetting to the initial value once the last observer leaves.</summary>
     public required bool IsStateless { get; init; }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
index 06023822..679f5cd8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Options/SignalCreationOptions.cs
@@ -8,13 +8,12 @@ namespace ReactiveUI.Primitives.Async.Signals;
 [System.Diagnostics.DebuggerDisplay("SignalCreationOptions: PublishingOption = {PublishingOption}, IsStateless = {IsStateless}")]
 public sealed record SignalCreationOptions
 {
-    /// <summary>Gets the default configuration for Signal creation options.</summary>
-    /// <remarks>Defaults to serial, stateful publishing.</remarks>
+    /// <summary>Gets the default options: serial publishing, with completion state retained.</summary>
     public static SignalCreationOptions Default { get; } = new() { PublishingOption = PublishingOption.Serial, IsStateless = false };
 
-    /// <summary>Gets the publishing option to use when processing the item.</summary>
+    /// <summary>Gets the order notifications are delivered to observers in.</summary>
     public required PublishingOption PublishingOption { get; init; }
 
-    /// <summary>Gets a value indicating whether the object is stateless.</summary>
+    /// <summary>Gets a value indicating whether the signal discards its completion state, so values can keep flowing after a terminal notification.</summary>
     public required bool IsStateless { get; init; }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
index 6ace90eb..5e1ea22d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialReplayLatestSignalAsync.cs
@@ -6,13 +6,11 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>
-/// Represents an asynchronous Signal that replays only the latest value to new subscribers and ensures that
-/// notifications are delivered to observers in a serial, thread-safe manner.
-/// </summary>
+/// <summary>An asynchronous Signal that replays its latest value to each new subscriber and notifies observers serially.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">An optional initial value to be emitted to new subscribers before any other values are published.</param>
-/// <remarks>New subscribers receive the latest value, if present. Each observer notification is awaited before invoking the next observer.</remarks>
+/// <remarks>A signal created without a start value replays nothing until one is published, and each notification
+/// finishes before the next observer is called.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialReplayLatestSignalAsync: LastValue = {_state.LastValue}, IsDisposed = {_state.IsDisposed}")]
 public sealed class SerialReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
index bf1b0429..6150a4f9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialSignalAsync.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents an asynchronous Signal that notifies observers in a serial manner, ensuring each observer is notified one at a time.</summary>
+/// <summary>An asynchronous Signal that notifies its observers serially and latches the terminal result.</summary>
 /// <typeparam name="T">The type of the elements processed and observed by the Signal.</typeparam>
 /// <remarks>Each observer notification finishes before the next observer is called.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialSignalAsync: Observers = {_state.Observers.Length}, Result = {_state.Result}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
index 91c2a6cc..ed748d0b 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessReplayLatestSignalAsync.cs
@@ -6,11 +6,12 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents a serial, stateless asynchronous Signal that replays only the last value to new observers and supports asynchronous notification delivery.</summary>
+/// <summary>An asynchronous Signal that replays its latest value to each new subscriber, notifies observers serially, and resets once the last observer leaves.</summary>
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-/// <param name="startValue">An optional initial value to be replayed to new observers before any values are published. If not specified, no
-/// value is replayed until the first value is received.</param>
-/// <remarks>Replays the latest value, if present, and awaits each observer notification in order.</remarks>
+/// <param name="startValue">The value replayed until something is published, and restored when the last observer
+/// leaves.</param>
+/// <remarks>A signal created without a start value replays nothing until one is published, and each notification
+/// finishes before the next observer is called.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialStatelessReplayLatestSignalAsync: State = {_state}")]
 public sealed class SerialStatelessReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
index 6be57af8..219941cb 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/SerialStatelessSignalAsync.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Signals;
 
-/// <summary>Represents a stateless asynchronous Signal that notifies observers of events in a serial, sequential manner.</summary>
+/// <summary>An asynchronous Signal that notifies its observers serially and keeps publishing after a terminal notification.</summary>
 /// <typeparam name="T">The type of the elements processed and observed by the Signal.</typeparam>
 /// <remarks>Observers are notified in registration order; each notification is awaited before the next begins.</remarks>
 [System.Diagnostics.DebuggerDisplay("SerialStatelessSignalAsync: Observers = {_state.Observers.Length}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
index 735bf65f..64694fc5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Signal.cs
@@ -17,19 +17,18 @@ public static class Signal
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: Signal.Create<int>().")]
+        Justification = "There are no parameters to infer from; the caller states the element type: Signal.Create<int>().")]
     public static ISignalAsync<T> Create<T>() => new SerialSignalAsync<T>();
 
     /// <summary>Creates a new asynchronous Signal instance with the specified publishing and state options.</summary>
     /// <typeparam name="T">The type of elements processed by the Signal.</typeparam>
-    /// <param name="options">The options that configure the publishing behavior and statefulness of the Signal. Must specify valid values
-    /// for publishing and statelessness.</param>
+    /// <param name="options">The publishing order and statelessness to build the signal with.</param>
     /// <returns>An asynchronous Signal instance configured according to the specified options.</returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown if the specified combination of publishing and statelessness options is not supported.</exception>
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: Signal.Create<int>(options).")]
+        Justification = "The options carry no element type to infer from; the caller states it: Signal.Create<int>(options).")]
     public static ISignalAsync<T> Create<T>(SignalCreationOptions? options) =>
         (options?.PublishingOption, options?.IsStateless) switch
         {
@@ -76,20 +75,20 @@ public static ISignalAsync<T> CreateBehavior<T>(T startValue, BehaviorSignalCrea
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: Signal.CreateReplayLatest<int>().")]
+        Justification = "There are no parameters to infer from; the caller states the element type: Signal.CreateReplayLatest<int>().")]
     public static ISignalAsync<T> CreateReplayLatest<T>() =>
         new SerialReplayLatestSignalAsync<T>(Optional<T>.Empty);
 
     /// <summary>Creates a new asynchronous Signal that replays the latest value to new subscribers, with configuration options for publishing behavior and statefulness.</summary>
     /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
-    /// <param name="options">The options that specify the publishing mode and whether the Signal maintains state. Cannot be null.</param>
+    /// <param name="options">The publishing order and statelessness to build the signal with. Cannot be null.</param>
     /// <returns>An asynchronous Signal that replays the latest value to new subscribers, configured according to the specified
     /// options.</returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown if the combination of options specified in the <paramref name="options"/> parameter is not supported.</exception>
     [SuppressMessage(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
-        Justification = "Public factory API — caller specifies T explicitly: Signal.CreateReplayLatest<int>(options).")]
+        Justification = "The options carry no element type to infer from; the caller states it: Signal.CreateReplayLatest<int>(options).")]
     public static ISignalAsync<T> CreateReplayLatest<T>(ReplayLatestSignalCreationOptions? options) =>
         (options?.PublishingOption, options?.IsStateless) switch
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
index e2e0dfb1..e1e6e7f5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
@@ -63,7 +63,7 @@ protected WitnessAsync()
     /// <summary>Delivers a value to <see cref="OnNextAsyncCore"/>, dropping it silently when this observer is disposed,
     /// the token is cancelled, or another thread holds the notification gate.</summary>
     /// <param name="value">The value to be processed.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <param name="cancellationToken">A token that cancels the delivery; it is linked with this observer's disposal token.</param>
     /// <returns>A task that completes once the core handler and its bookkeeping have run.</returns>
     public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
     {
@@ -100,7 +100,7 @@ public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
 
     /// <summary>Routes a non-terminal error to <see cref="OnErrorResumeAsyncCore"/>, never propagating a failure back to the producer.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+    /// <param name="cancellationToken">A token that cancels the handling; it is linked with this observer's disposal token.</param>
     /// <returns>A task that completes once the error has been handled.</returns>
     public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken)
     {
@@ -441,13 +441,13 @@ protected virtual async ValueTask DisposeAsyncCore()
 
     /// <summary>Handles non-terminal errors; callback failures reach the unhandled-exception handler.</summary>
     /// <param name="error">The exception that triggered the error handling logic. Cannot be null.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous error handling operation.</param>
+    /// <param name="cancellationToken">The effective token for this notification.</param>
     /// <returns>A task that completes when the error has been handled.</returns>
     protected abstract ValueTask OnErrorResumeAsyncCore(Exception error, CancellationToken cancellationToken);
 
     /// <summary>Delivers the value, forwarding callback failures to error-resume handling and swallowing cancellation.</summary>
     /// <param name="value">The value to be processed.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+    /// <param name="cancellationToken">The effective token for this notification.</param>
     /// <returns>A task that completes when the value has been handled.</returns>
     protected abstract ValueTask OnNextAsyncCore(T value, CancellationToken cancellationToken);
 
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
index 3a9848db..1d3a8544 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/ImmediateReturnSignal{T}.cs
@@ -16,7 +16,7 @@ public sealed class ImmediateReturnSignal<T> : IRequireCurrentThread<T>, IInline
     private readonly T _value;
 
     /// <summary>Initializes a new instance of the <see cref="ImmediateReturnSignal{T}"/> class.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The value emitted to every subscriber.</param>
     public ImmediateReturnSignal(T value) => _value = value;
 
     /// <summary>Indicates whether subscription has to happen on the calling thread.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
index d2f17bc4..ba06a5df 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
@@ -5,10 +5,8 @@
 namespace ReactiveUI.Primitives.Advanced;
 
 /// <summary>
-/// Helpers for the interlocked single-assignment subscription slots shared by the catch-style sinks
-/// (<c>RecoverSignal</c>, <c>ResumeSignal</c>): a slot holds at most one live
-/// subscription and, once the sink is disposed, swaps to a sentinel so a late assignment is disposed instead of
-/// stored.
+/// Interlocked single-assignment subscription slots for a sink that resubscribes: a slot holds at most one live
+/// subscription and, once released, swaps to a sentinel so a late assignment is disposed instead of stored.
 /// </summary>
 public static class SubscriptionSlots
 {
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
index 743a54c6..b1c697c4 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
@@ -8,9 +8,7 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Provides the base implementation for a scheduled unit of work that is ordered by an absolute due time.</summary>
-/// <typeparam name="TAbsolute">
-/// The absolute-time representation, which must be comparable so scheduled items can be ordered.
-/// </typeparam>
+/// <typeparam name="TAbsolute">The absolute-time representation, which must be comparable so items can be ordered.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, IComparable<ScheduledItem<TAbsolute>>,
     IsDisposed, IComparable
@@ -22,16 +20,13 @@ public sealed class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, ICompa
     /// <summary>The work performed when the item is invoked; receives this item so callers can self-deregister.</summary>
     private readonly Func<ScheduledItem<TAbsolute>, IDisposable> _invokeCore;
 
-    /// <summary>Invocation disposable.</summary>
+    /// <summary>The disposable returned by the invoked work, latched once so cancellation can reach it.</summary>
     private IDisposable? _disposable;
 
-    /// <summary>Disposal flag.</summary>
+    /// <summary>Non-zero once the item has been canceled or disposed.</summary>
     private int _isDisposed;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ScheduledItem{TAbsolute}"/> class with the due time, comparer,
-    /// and the callback that supplies the work performed by <see cref="Invoke"/>.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="ScheduledItem{TAbsolute}"/> class.</summary>
     /// <param name="dueTime">The absolute time at which this item is due to run.</param>
     /// <param name="comparer">The comparer that orders due-time values.</param>
     /// <param name="invokeCore">
@@ -52,14 +47,10 @@ public ScheduledItem(
     /// <summary>Gets the absolute time at which this work item is scheduled to run.</summary>
     public TAbsolute DueTime { get; }
 
-    /// <summary>Gets a value indicating whether this work item has been canceled or disposed.</summary>
-    /// <remarks>
-    /// Once this is <see langword="true"/>, <see cref="Invoke"/> starts no new work, and a disposable returned by
-    /// work that has begun is disposed as soon as it is available.
-    /// </remarks>
+    /// <summary>Gets a value indicating whether this work item has been canceled or disposed, so <see cref="Invoke"/> starts no work.</summary>
     public bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
 
-    /// <summary>Gets the Debugger text.</summary>
+    /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
@@ -125,7 +116,7 @@ public ScheduledItem(
     public static bool operator >=(ScheduledItem<TAbsolute> left, ScheduledItem<TAbsolute> right) =>
         Comparer<ScheduledItem<TAbsolute>>.Default.Compare(left, right) >= 0;
 
-    /// <summary>Cancels this scheduled work item: work that has not started does not run, and a disposable returned by work that has begun is disposed as soon as it is available.</summary>
+    /// <summary>Cancels this scheduled work item; an alias for <see cref="Dispose"/>.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Cancel() => Dispose();
 
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs b/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
index b2c6b61f..02c3d16a 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/SequencerQueue.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Scheduler queue that keeps scheduled items ordered by absolute due time.</summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
-/// <remarks>This type is not thread safe; users should ensure proper synchronization.</remarks>
+/// <remarks>This type is not thread safe; concurrent callers must provide their own synchronization.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class SequencerQueue<TAbsolute>
     where TAbsolute : IComparable<TAbsolute>
diff --git a/src/ReactiveUI.Primitives.Core/Core/IObserver{TValue,TResult}.cs b/src/ReactiveUI.Primitives.Core/Core/IObserver{TValue,TResult}.cs
index 8b108948..b78a009e 100644
--- a/src/ReactiveUI.Primitives.Core/Core/IObserver{TValue,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Core/IObserver{TValue,TResult}.cs
@@ -5,14 +5,8 @@
 namespace ReactiveUI.Primitives.Core;
 
 /// <summary>Provides a mechanism for receiving push-based notifications and returning a response.</summary>
-/// <typeparam name="TValue">
-/// The type of the elements received by the observer.
-/// This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived.
-/// </typeparam>
-/// <typeparam name="TResult">
-/// The type of the result returned from the observer's notification handlers.
-/// This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived.
-/// </typeparam>
+/// <typeparam name="TValue">The element type received by the observer.</typeparam>
+/// <typeparam name="TResult">The result type returned from the observer's notification handlers.</typeparam>
 public interface IObserver<in TValue, out TResult>
 {
     /// <summary>Notifies the observer of a new element in the sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Core/PriorityQueue.cs b/src/ReactiveUI.Primitives.Core/Core/PriorityQueue.cs
index 3f59b71b..de594545 100644
--- a/src/ReactiveUI.Primitives.Core/Core/PriorityQueue.cs
+++ b/src/ReactiveUI.Primitives.Core/Core/PriorityQueue.cs
@@ -24,10 +24,10 @@ public sealed class PriorityQueue<T>
     /// <summary>Offset from a node's doubled index to its right child.</summary>
     private const int RightChildOffset = 2;
 
-    /// <summary>Capacity divisor used to shrink sparse queues.</summary>
+    /// <summary>Capacity divisor that decides when a sparse queue shrinks.</summary>
     private const int ShrinkDivisor = 4;
 
-    /// <summary>Offset from <see cref="Count"/> to the last index that can still have a child.</summary>
+    /// <summary>Offset from <see cref="Count"/> to the last index with a child.</summary>
     private const int LastParentCountOffset = 2;
 
     /// <summary>Monotonic tie-breaker for equal-priority items.</summary>
@@ -251,7 +251,6 @@ private void Heapify(int index)
                 break;
             }
 
-            // swap index and first
             (_items[first], _items[index]) = (_items[index], _items[first]);
             index = first;
         }
@@ -276,7 +275,6 @@ private int Percolate(int index)
         var parent = (index - 1) / HeapBranchingFactor;
         while (parent >= 0 && parent != index && IsHigherPriority(index, parent))
         {
-            // swap index and parent
             (_items[parent], _items[index]) = (_items[index], _items[parent]);
             index = parent;
             parent = (index - 1) / HeapBranchingFactor;
diff --git a/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs b/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
index a03a9060..2a89f996 100644
--- a/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
@@ -8,27 +8,27 @@
 namespace ReactiveUI.Primitives.Core;
 
 /// <summary>
-/// Represents a value associated with time interval information.
-/// The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc.
+/// Represents a value paired with a time interval, whose meaning is the producer's: how long the value took to
+/// produce, the gap since the previous value, or its delivery time relative to a base.
 /// </summary>
-/// <typeparam name="T">The type of the value being annotated with time interval information.</typeparam>
+/// <typeparam name="T">The annotated value type.</typeparam>
 [Serializable]
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public readonly struct TimeInterval<T> : IEquatable<TimeInterval<T>>
 {
     /// <summary>Initializes a new instance of the <see cref="TimeInterval{T}"/> struct.</summary>
-    /// <param name="value">The value to be annotated with a time interval.</param>
-    /// <param name="interval">Time interval associated with the value.</param>
+    /// <param name="value">The value to annotate.</param>
+    /// <param name="interval">The time interval associated with the value.</param>
     public TimeInterval(T value, TimeSpan interval)
     {
         Interval = interval;
         Value = value;
     }
 
-    /// <summary>Gets the value.</summary>
+    /// <summary>Gets the annotated value.</summary>
     public T Value { get; }
 
-    /// <summary>Gets the interval.</summary>
+    /// <summary>Gets the time interval associated with the value.</summary>
     public TimeSpan Interval { get; }
 
     /// <summary>Gets the debugger display text.</summary>
@@ -36,34 +36,29 @@ public TimeInterval(T value, TimeSpan interval)
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Determines whether the two specified TimeInterval values have the same Value and Interval.</summary>
-    /// <param name="first">The first TimeInterval value to compare.</param>
-    /// <param name="second">The second TimeInterval value to compare.</param>
-    /// <returns>true if the first TimeInterval value has the same Value and Interval as the second TimeInterval value; otherwise, false.</returns>
+    /// <summary>Compares two annotated values for equality.</summary>
+    /// <param name="first">First value.</param>
+    /// <param name="second">Second value.</param>
+    /// <returns><c>true</c> when both values and intervals are equal.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(TimeInterval<T> first, TimeInterval<T> second) =>
         first.Equals(second);
 
-    /// <summary>Determines whether the two specified TimeInterval values don't have the same Value and Interval.</summary>
-    /// <param name="first">The first TimeInterval value to compare.</param>
-    /// <param name="second">The second TimeInterval value to compare.</param>
-    /// <returns>true if the first TimeInterval value has a different Value or Interval as the second TimeInterval value; otherwise, false.</returns>
+    /// <summary>Compares two annotated values for inequality.</summary>
+    /// <param name="first">First value.</param>
+    /// <param name="second">Second value.</param>
+    /// <returns><c>true</c> when either value or interval differs.</returns>
     public static bool operator !=(TimeInterval<T> first, TimeInterval<T> second) =>
         !first.Equals(second);
 
-    /// <summary>Determines whether the current TimeInterval value has the same Value and Interval as a specified TimeInterval value.</summary>
-    /// <param name="other">An object to compare to the current TimeInterval value.</param>
-    /// <returns>true if both TimeInterval values have the same Value and Interval; otherwise, false.</returns>
+    /// <inheritdoc/>
     public bool Equals(TimeInterval<T> other) =>
         other.Interval.Equals(Interval) && EqualityComparer<T>.Default.Equals(Value, other.Value);
 
-    /// <summary>Determines whether the specified System.Object is equal to the current TimeInterval.</summary>
-    /// <param name="obj">The System.Object to compare with the current TimeInterval.</param>
-    /// <returns>true if the specified System.Object is equal to the current TimeInterval; otherwise, false.</returns>
+    /// <inheritdoc/>
     public override bool Equals(object? obj) => obj is TimeInterval<T> other && Equals(other);
 
-    /// <summary>Returns the hash code for the current TimeInterval value.</summary>
-    /// <returns>A hash code for the current TimeInterval value.</returns>
+    /// <inheritdoc/>
     public override int GetHashCode()
     {
         var valueHashCode = Value is null ? 1963 : EqualityComparer<T>.Default.GetHashCode(Value);
@@ -71,8 +66,7 @@ public override int GetHashCode()
         return Interval.GetHashCode() ^ valueHashCode;
     }
 
-    /// <summary>Returns a string representation of the current TimeInterval value.</summary>
-    /// <returns>String representation of the current TimeInterval value.</returns>
+    /// <inheritdoc/>
     public override string ToString() =>
 #if NET8_0_OR_GREATER
         string.Format(CultureInfo.CurrentCulture, CoreCompositeFormats.TimeInterval, Value, Interval);
diff --git a/src/ReactiveUI.Primitives.Core/Optional.cs b/src/ReactiveUI.Primitives.Core/Optional.cs
index 18339261..201f27c5 100644
--- a/src/ReactiveUI.Primitives.Core/Optional.cs
+++ b/src/ReactiveUI.Primitives.Core/Optional.cs
@@ -22,11 +22,11 @@ public readonly record struct Optional<T>
     public Optional() => (_value, HasValue) = (default, false);
 
     /// <summary>Initializes a new instance of the <see cref="Optional{T}"/> struct.</summary>
-    /// <param name="value">The value to be contained in the <see cref="Optional{T}"/>  instance.</param>
+    /// <param name="value">The value to be contained in the <see cref="Optional{T}"/> instance.</param>
     public Optional([AllowNull] T value) => (_value, HasValue) = value is null ? (default, false) : (value, true);
 
     /// <summary>Initializes a new instance of the <see cref="Optional{T}"/> struct.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The value to contain, treated as absent when <see langword="null"/>.</param>
     /// <param name="hasValue">A value indicating whether a value is present.</param>
     private Optional([AllowNull] T value, bool hasValue) =>
         (_value, HasValue) = hasValue && value is not null ? (value, true) : (default, false);
@@ -53,7 +53,7 @@ private Optional([AllowNull] T value, bool hasValue) =>
     public static Optional<T> Some([AllowNull] T value) => new(value, true);
 
     /// <summary>Implicit cast from the value to the optional.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The value to wrap, treated as absent when <see langword="null"/>.</param>
     /// <returns>The optional value.</returns>
     public static implicit operator Optional<T>([AllowNull] T value) => ToOptional(value);
 
@@ -63,13 +63,13 @@ private Optional([AllowNull] T value, bool hasValue) =>
     public static explicit operator T?(in Optional<T> value) => FromOptional(value);
 
     /// <summary>Creates an optional value, treating a <see langword="null"/> value as absent.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The value to wrap.</param>
     /// <returns>The optional value.</returns>
     public static Optional<T> Create([AllowNull] T value) => new(value);
 
     /// <summary>Gets the value from the optional value.</summary>
-    /// <param name="value">The optional value.</param>
-    /// <returns>The value.</returns>
+    /// <param name="value">The optional value to unwrap.</param>
+    /// <returns>The contained value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static T? FromOptional(in Optional<T> value) => value.Value;
 
diff --git a/src/ReactiveUI.Primitives.Core/Result.cs b/src/ReactiveUI.Primitives.Core/Result.cs
index 9206c34d..6a378af4 100644
--- a/src/ReactiveUI.Primitives.Core/Result.cs
+++ b/src/ReactiveUI.Primitives.Core/Result.cs
@@ -24,16 +24,14 @@ public Result(Exception exception)
     /// <summary>Gets a predefined result instance that indicates a successful operation.</summary>
     public static Result Success => default;
 
-    /// <summary>Gets the exception that caused the current operation to fail, if any.</summary>
+    /// <summary>Gets the exception that caused the operation to fail, or <see langword="null"/> when it succeeded.</summary>
     public Exception? Exception { get; }
 
-    /// <summary>Gets a value indicating whether the operation completed successfully without an exception.</summary>
-    /// <remarks>When <see langword="false"/>, <see cref="Exception"/> is non-null.</remarks>
+    /// <summary>Gets a value indicating whether the operation completed without an exception.</summary>
     [MemberNotNullWhen(false, nameof(Exception))]
     public bool IsSuccess => Exception is null;
 
     /// <summary>Gets a value indicating whether the operation has failed.</summary>
-    /// <remarks>When <see langword="true"/>, <see cref="Exception"/> is non-null.</remarks>
     [MemberNotNullWhen(true, nameof(Exception))]
     public bool IsFailure => Exception is not null;
 
@@ -57,7 +55,6 @@ public void TryThrow()
     }
 
     /// <summary>Returns a string that represents the result status of the operation.</summary>
-    /// <returns>A string indicating "Success" if the operation was successful; otherwise, a string in the format
-    /// "Failure{exception message}" containing the associated exception message.</returns>
+    /// <returns><c>Success</c>, or <c>Failure{message}</c> carrying the failure exception's message.</returns>
     public override string ToString() => IsSuccess ? "Success" : $"Failure{{{Exception.Message}}}";
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
index 6b545449..b412ba6a 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
@@ -8,38 +8,31 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>A signal that exposes its next value as an awaitable operation.</summary>
-/// <typeparam name="T">The Type.</typeparam>
-/// <seealso cref="ISignal&lt;T&gt;" />
+/// <summary>A signal that records the latest value and replays it to observers when it completes, so the completion can be awaited.</summary>
+/// <typeparam name="T">The observed value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class AsyncSignal<T> : IAwaitSignal<T>
 {
     /// <summary>Serializes observer changes and terminal-state transitions.</summary>
     private readonly Lock _observerLock = new();
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The most recent value, replayed when the signal completes.</summary>
     private T? _lastValue;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether a value has been recorded.</summary>
     private bool _hasValue;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The terminal error, when the signal faulted.</summary>
     private Exception? _lastError;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The dispatch target: the empty witness, a single observer, or a <see cref="ListWitness{T}"/> fan-out.</summary>
     private IObserver<T> _outObserver = EmptyWitness<T>.Instance;
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed { get; private set; }
 
-    /// <summary>Gets the value.</summary>
-    /// <value>
-    /// The value.
-    /// </value>
-    /// <exception cref="InvalidOperationException">The final signal is not completed yet.</exception>
+    /// <summary>Gets the value the signal completed with.</summary>
+    /// <exception cref="InvalidOperationException">The signal has not completed.</exception>
     public T Value
     {
         get
@@ -56,16 +49,10 @@ public T Value
         }
     }
 
-    /// <summary>Gets a value indicating whether this instance has observers.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance has observers; otherwise, <c>false</c>.
-    /// </value>
+    /// <summary>Gets a value indicating whether an observer is subscribed and the signal has neither completed nor been disposed.</summary>
     public bool HasObservers => _outObserver is not EmptyWitness<T> && !IsCompleted && !IsDisposed;
 
     /// <summary>Gets a value indicating whether this instance is completed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is completed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsCompleted { get; private set; }
 
     /// <summary>Gets the debugger display text.</summary>
@@ -73,7 +60,7 @@ public T Value
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Called when [completed].</summary>
+    /// <summary>Completes the signal, emitting the recorded value to the current observers first when one was recorded.</summary>
     public void OnCompleted()
     {
         IObserver<T> observers;
@@ -105,9 +92,9 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Specifies a callback action that will be invoked when the subject completes.</summary>
-    /// <param name="continuation">Callback action that will be invoked when the subject completes.</param>
-    /// <exception cref="ArgumentExceptionHelper"><paramref name="continuation"/> is null.</exception>
+    /// <summary>Registers a callback to run when the signal terminates, on the captured synchronization context.</summary>
+    /// <param name="continuation">The callback to run on completion or failure.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="continuation"/> is <see langword="null"/>.</exception>
     public void OnCompleted(Action continuation)
     {
         ArgumentExceptionHelper.ThrowIfNull(continuation);
@@ -115,9 +102,9 @@ public void OnCompleted(Action continuation)
         SubscribeCompletion(continuation, true);
     }
 
-    /// <summary>Called when [error].</summary>
-    /// <param name="error">The error.</param>
-    /// <exception cref="ArgumentExceptionHelper">error.</exception>
+    /// <summary>Faults the signal and forwards <paramref name="error"/> to the current observers, discarding any recorded value.</summary>
+    /// <param name="error">The terminal error.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="error"/> is <see langword="null"/>.</exception>
     public void OnError(Exception error)
     {
         ArgumentExceptionHelper.ThrowIfNull(error);
@@ -140,8 +127,8 @@ public void OnError(Exception error)
         observers.OnError(error);
     }
 
-    /// <summary>Called when [next].</summary>
-    /// <param name="value">The value.</param>
+    /// <summary>Records <paramref name="value"/> as the value replayed on completion; observers are not notified here.</summary>
+    /// <param name="value">The value to record.</param>
     public void OnNext(T value)
     {
         lock (_observerLock)
@@ -157,10 +144,10 @@ public void OnNext(T value)
         }
     }
 
-    /// <summary>Subscribes the specified observer.</summary>
-    /// <param name="observer">The observer.</param>
-    /// <returns>A Disposable.</returns>
-    /// <exception cref="ArgumentExceptionHelper">observer.</exception>
+    /// <summary>Subscribes an observer, delivering the terminal value or error immediately when the signal has completed.</summary>
+    /// <param name="observer">The observer to subscribe.</param>
+    /// <returns>A handle that removes the observer when disposed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <see langword="null"/>.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -211,7 +198,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Drops the observers and the recorded value, making every later notification throw.</summary>
     public void Dispose()
     {
         if (IsDisposed)
@@ -229,13 +216,13 @@ public void Dispose()
         IsDisposed = true;
     }
 
-    /// <summary>Gets an awaitable object for the current final signal.</summary>
-    /// <returns>Object that can be awaited.</returns>
+    /// <summary>Gets the awaiter for this signal.</summary>
+    /// <returns>The signal itself, which acts as its own awaiter.</returns>
     public IAwaitSignal<T> GetAwaiter() => this;
 
-    /// <summary>Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally.</summary>
-    /// <returns>The last element of the subject. Throws an InvalidOperationException if no element was received.</returns>
-    /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+    /// <summary>Gets the completed value, blocking the calling thread until the signal completes or faults.</summary>
+    /// <returns>The recorded value, after rethrowing the terminal error when the signal faulted.</returns>
+    /// <exception cref="InvalidOperationException">The signal completed without recording a value.</exception>
     public T GetResult()
     {
         WaitIfPending(WaitForCompletion);
@@ -249,7 +236,7 @@ public T GetResult()
         return _lastValue!;
     }
 
-    /// <summary>Removes an observer previously registered via <see cref="Subscribe"/>. Called by the observer's subscription handle when it is disposed.</summary>
+    /// <summary>Removes an observer registered via <see cref="Subscribe"/>; the observer's subscription handle calls this on disposal.</summary>
     /// <param name="observer">The observer to remove.</param>
     public void RemoveObserver(IObserver<T> observer)
     {
@@ -285,7 +272,7 @@ private static void WaitForCompletion(AsyncSignal<T> signal)
     }
 
     /// <summary>Rejects operations after the signal has been disposed.</summary>
-    /// <exception cref="ObjectDisposedException">This instance has already been disposed.</exception>
+    /// <exception cref="ObjectDisposedException">The signal is disposed.</exception>
     private void ThrowIfDisposed()
     {
         if (!IsDisposed)
@@ -297,8 +284,8 @@ private void ThrowIfDisposed()
     }
 
     /// <summary>Registers a callback for either terminal notification.</summary>
-    /// <param name="continuation">The continuation value.</param>
-    /// <param name="originalContext">The originalContext value.</param>
+    /// <param name="continuation">The callback invoked on the terminal notification.</param>
+    /// <param name="originalContext">Whether to resume the callback on the captured synchronization context.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void SubscribeCompletion(Action continuation, bool originalContext) =>
         Subscribe(new AwaitWitness<T>(continuation, originalContext));
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
index 4cd4a90c..89f66d2a 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
@@ -6,20 +6,20 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>Represents the AwaitWitness class.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <summary>Observer that discards values and runs a continuation on the first terminal notification.</summary>
+/// <typeparam name="T">The observed value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("AwaitWitness: Callback = {_callback}, Context = {_context}")]
 public sealed class AwaitWitness<T> : IObserver<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The context captured at construction, or <see langword="null"/> to run the continuation inline.</summary>
     private readonly SynchronizationContext? _context;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The continuation run on completion or failure.</summary>
     private readonly Action _callback;
 
     /// <summary>Initializes a new instance of the <see cref="AwaitWitness{T}"/> class.</summary>
-    /// <param name="callback">The callback value.</param>
-    /// <param name="originalContext">The originalContext value.</param>
+    /// <param name="callback">The continuation to run on the terminal notification.</param>
+    /// <param name="originalContext">Whether to capture the current synchronization context and post the continuation to it.</param>
     public AwaitWitness(Action callback, bool originalContext)
     {
         if (originalContext)
@@ -35,19 +35,16 @@ public AwaitWitness(Action callback, bool originalContext)
     public void OnCompleted() => InvokeOnOriginalContext();
 
     /// <summary>Resumes the awaiting continuation when the source fails.</summary>
-    /// <param name="error">The error value.</param>
+    /// <param name="error">The terminal error, which the continuation does not receive.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "OnCompleted and OnError are distinct IObserver<T> terminal notifications that intentionally both fire the "
-            + "witness by delegating to the shared InvokeOnOriginalContext helper. They are not a copy-paste of each "
-            + "other; having one call the other would misrepresent an error as a completion.")]
+        Justification = "Both terminal notifications resume the same continuation, and neither may delegate to the other.")]
     public void OnError(Exception error) => InvokeOnOriginalContext();
 
     /// <summary>Ignores values; only terminal notifications resume the continuation.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The ignored value.</param>
     public void OnNext(T value)
     {
     }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
index 0df1f8c7..16da1d35 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Signals;
 [System.Diagnostics.CodeAnalysis.SuppressMessage(
     "Performance",
     "SST1803:Make record struct readonly",
-    Justification = "This is mutable signal state; its members mutate the fields in place, so it cannot be readonly.")]
+    Justification = "The members mutate these fields in place.")]
 internal record struct BehaviorSignalState<T>
 {
     /// <summary>Protects observer and terminal-state mutations.</summary>
@@ -21,8 +21,7 @@ internal record struct BehaviorSignalState<T>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Performance",
         "SST1424:Make field readonly",
-        Justification =
-            "Broadcaster<T> is a mutable struct; readonly fields would mutate defensive copies and lose observer updates.")]
+        Justification = "A readonly field would mutate a defensive copy of this mutable struct and lose observer updates.")]
     private Broadcaster<T> _broadcaster;
 
     /// <summary>The last error, when terminated exceptionally.</summary>
@@ -137,7 +136,7 @@ internal void OnNext(T value)
     }
 
     /// <summary>Subscribes an observer, replaying the current value or terminal notification.</summary>
-    /// <param name="owner">The owning signal used to remove the observer on disposal.</param>
+    /// <param name="owner">The owning signal that the returned handle removes the observer from.</param>
     /// <param name="observer">The observer to subscribe.</param>
     /// <returns>A handle that unsubscribes the observer when disposed.</returns>
     internal IDisposable Subscribe(IWitnessRemovable<T> owner, IObserver<T> observer)
@@ -173,7 +172,7 @@ internal IDisposable Subscribe(IWitnessRemovable<T> owner, IObserver<T> observer
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Removes a previously subscribed observer.</summary>
+    /// <summary>Removes a subscribed observer from the broadcaster.</summary>
     /// <param name="observer">The observer to remove.</param>
     internal void RemoveObserver(IObserver<T> observer)
     {
@@ -200,7 +199,7 @@ internal void Release()
     }
 
     /// <summary>Throws when the signal has been disposed.</summary>
-    /// <exception cref="ObjectDisposedException">The signal has already been released.</exception>
+    /// <exception cref="ObjectDisposedException">The signal is released.</exception>
     private readonly void ThrowIfDisposed()
     {
         if (_isDisposed == 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
index ba80e2d5..f7c525d9 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignal{T}.cs
@@ -7,7 +7,7 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal that replays its most recent value to new subscribers.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class BehaviorSignal<T> : ISignal<T>, IWitnessRemovable<T>
 {
@@ -18,31 +18,24 @@ public sealed class BehaviorSignal<T> : ISignal<T>, IWitnessRemovable<T>
     /// <param name="defaultValue">The default value.</param>
     public BehaviorSignal(T defaultValue) => _state = new(defaultValue);
 
-    /// <summary>Gets the current value or throws an exception.</summary>
-    /// <value>The initial value passed to the constructor until <see cref="OnNext"/> is called; after which, the last value passed to <see cref="OnNext"/>.</value>
-    /// <remarks>Completion freezes the value. Failure makes value reads throw the terminal exception, and disposal makes them throw ObjectDisposedException.</remarks>
+    /// <summary>Gets the most recent value, which is the constructor's default until <see cref="OnNext"/> supplies one.</summary>
+    /// <remarks>Completion freezes the value; a failure makes reads throw the terminal error and disposal makes them throw <see cref="ObjectDisposedException"/>.</remarks>
     public T Value => _state.GetValue();
 
     /// <summary>Gets a value indicating whether this instance has observers.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance has observers; otherwise, <c>false</c>.
-    /// </value>
     public bool HasObservers => _state.HasObservers;
 
     /// <summary>Gets a value indicating whether this instance is disposed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is disposed; otherwise, <c>false</c>.
-    /// </value>
     public bool IsDisposed => _state.IsDisposed;
 
-    /// <summary>Gets the string representation of this object for debugger display purposes.</summary>
+    /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string? DebuggerDisplay => ToString();
 
-    /// <summary>Tries to get the current value or throws an exception.</summary>
-    /// <param name="value">The initial value passed to the constructor until <see cref="OnNext"/> is called; after which, the last value passed to <see cref="OnNext"/>.</param>
-    /// <returns>true if a value is available; false if the subject was disposed.</returns>
-    /// <remarks>Completion freezes the value; failure makes reads throw the terminal exception. Each read is synchronized, but a separate read and state check are not atomic.</remarks>
+    /// <summary>Tries to read the most recent value.</summary>
+    /// <param name="value">The most recent value, or <see langword="default"/> when the signal is disposed.</param>
+    /// <returns><see langword="true"/> when a value is available; <see langword="false"/> when the signal is disposed.</returns>
+    /// <remarks>A read throws the terminal error after a failure, and is not atomic with a separate state check.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool TryGetValue(out T? value) => _state.TryGetValue(out value);
 
@@ -61,14 +54,14 @@ public sealed class BehaviorSignal<T> : ISignal<T>, IWitnessRemovable<T>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void OnNext(T value) => _state.OnNext(value);
 
-    /// <summary>Subscribes an observer to the subject.</summary>
-    /// <param name="observer">Observer to subscribe to the subject.</param>
-    /// <returns>Disposable object that can be used to unsubscribe the observer from the subject.</returns>
+    /// <summary>Subscribes an observer, replaying the current value or the terminal notification.</summary>
+    /// <param name="observer">The observer to subscribe.</param>
+    /// <returns>A handle that unsubscribes the observer when disposed.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="observer"/> is <c>null</c>.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) => _state.Subscribe(this, observer);
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Drops the observers and the cached value, making later reads throw.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Dispose() => _state.Release();
 
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
index 62f76e23..cf8679b2 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
@@ -37,7 +37,7 @@ public struct Broadcaster<T> : IEquatable<Broadcaster<T>>
     /// <returns><see langword="true"/> when the broadcasters reference different observer sets; otherwise, <see langword="false"/>.</returns>
     public static bool operator !=(Broadcaster<T> left, Broadcaster<T> right) => !left.Equals(right);
 
-    /// <summary>Adds an observer to the broadcaster. The update is a lock-free compare-and-swap, so the broadcaster is self-contained and does not rely on an external lock for correctness.</summary>
+    /// <summary>Adds an observer with a lock-free compare-and-swap, so no external lock is required.</summary>
     /// <param name="observer">Observer to add.</param>
     public void Add(IObserver<T> observer)
     {
@@ -174,7 +174,7 @@ public override readonly bool Equals(object? obj) =>
     [SuppressMessage(
         "Maintainability",
         "SST1482:GetHashCode reads mutable state",
-        Justification = "Equality is the observer set, so the hash must follow it; a Broadcaster is compared, never used as a hash key.")]
+        Justification = "Equality compares the observer set, so the hash must follow it.")]
     public override readonly int GetHashCode()
     {
         var snapshot = _observers;
diff --git a/src/ReactiveUI.Primitives.Core/Signals/CommandExecution{TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/CommandExecution{TResult}.cs
index c47ec0ec..7acbf1e0 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/CommandExecution{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/CommandExecution{TResult}.cs
@@ -116,8 +116,7 @@ public Awaiter(Task<TResult>? task, TResult? result, Exception? exception, bool
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Concurrency",
             "PSH1315:A blocking wait on an awaitable that may not be done",
-            Justification =
-                "Awaiter GetResult must be synchronous; it runs only after completion and unwraps exceptions without AggregateException wrapping.")]
+            Justification = "An awaiter's GetResult is synchronous by contract and runs only once the task is complete.")]
         public TResult GetResult()
         {
             if (_task is not null)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
index 25412439..41fd43ed 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
@@ -11,10 +11,10 @@ namespace ReactiveUI.Primitives.Signals;
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class CommandSignal<TResult> : IObservable<TResult>, IDisposable
 {
-    /// <summary>Stores asynchronous command execution.</summary>
+    /// <summary>The asynchronous command body, or <see langword="null"/> for a synchronous command.</summary>
     private readonly Func<CancellationToken, Task<TResult>>? _executeAsync;
 
-    /// <summary>Stores synchronous command execution.</summary>
+    /// <summary>The synchronous command body, or <see langword="null"/> for an asynchronous command.</summary>
     private readonly Func<TResult>? _executeSync;
 
     /// <summary>Serializes running-flag writes with running-state stream notifications so the two never diverge.</summary>
@@ -29,10 +29,10 @@ public sealed class CommandSignal<TResult> : IObservable<TResult>, IDisposable
     /// <summary>Lazily created running state stream.</summary>
     private StateSignal<bool>? _isRunningState;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The subscription to the gating signal, or <see langword="null"/> when the command is ungated.</summary>
     private IDisposable? _canRunSubscription;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The latest value from the gating signal.</summary>
     private bool _canRun;
 
     /// <summary>Stores the current running flag without forcing the public state stream to allocate.</summary>
@@ -41,7 +41,7 @@ public sealed class CommandSignal<TResult> : IObservable<TResult>, IDisposable
     /// <summary>Non-zero while an execution is active.</summary>
     private int _running;
 
-    /// <summary>Stores disposal state.</summary>
+    /// <summary>Non-zero once the command has been disposed.</summary>
     private int _disposed;
 
     /// <summary>Initializes a new instance of the <see cref="CommandSignal{TResult}"/> class.</summary>
@@ -154,7 +154,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
 
     /// <summary>Attempts to append an observer to an unchanged snapshot.</summary>
     /// <param name="storage">The published observer snapshot.</param>
-    /// <param name="current">The snapshot used to prepare the update.</param>
+    /// <param name="current">The snapshot the update was prepared against.</param>
     /// <param name="observer">The observer to append.</param>
     /// <returns>Whether the update was published.</returns>
     internal static bool TryAddResult(ref object? storage, object? current, IObserver<TResult> observer)
@@ -181,7 +181,7 @@ internal static bool TryAddResult(ref object? storage, object? current, IObserve
 
     /// <summary>Attempts to remove an observer from an unchanged snapshot.</summary>
     /// <param name="storage">The published observer snapshot.</param>
-    /// <param name="current">The snapshot used to prepare the update.</param>
+    /// <param name="current">The snapshot the update was prepared against.</param>
     /// <param name="observer">The observer to remove.</param>
     /// <returns>Whether no retry is required.</returns>
     internal static bool TryRemoveResult(ref object? storage, object? current, IObserver<TResult> observer)
@@ -326,7 +326,7 @@ private async Task<TResult> ExecuteAsyncCore(CancellationToken cancellationToken
     }
 
     /// <summary>Enters the running state after validating gate state.</summary>
-    /// <exception cref="InvalidOperationException">The command is gated off or an execution is already in flight.</exception>
+    /// <exception cref="InvalidOperationException">The command is gated off or another execution is in flight.</exception>
     private void BeginExecution()
     {
         if (!CanRun || Interlocked.CompareExchange(ref _running, 1, 0) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
index c8d64a50..602e60a7 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>
 /// A signal that passes notifications through immediately while they are not delayed, but buffers them while delayed
 /// and emits a de-duplicated batch when <see cref="Flush"/> is called (typically as the delay window opens or closes).
-/// Fuses the <c>Buffer(boundary).SelectMany(distinct).Publish().RefCount()</c> pipeline into one allocation-light sink.
+/// Equivalent to the <c>Buffer(boundary).SelectMany(distinct).Publish().RefCount()</c> pipeline in a single sink.
 /// </summary>
 /// <typeparam name="T">The notification type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("DelayableNotificationSignal: Stopped = {_stopped}, Buffer = {_buffer}")]
diff --git a/src/ReactiveUI.Primitives.Core/Signals/IAwaitSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/IAwaitSignal{T}.cs
index bea95cbd..2d79842f 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/IAwaitSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/IAwaitSignal{T}.cs
@@ -5,22 +5,17 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal whose next value can be awaited.</summary>
-/// <typeparam name="T">The Type of Signal.</typeparam>
-/// <seealso cref="ISignal&lt;T&gt;" />
-/// <seealso cref="System.Runtime.CompilerServices.INotifyCompletion" />
+/// <typeparam name="T">The value type.</typeparam>
 public interface IAwaitSignal<T> : ISignal<T>, System.Runtime.CompilerServices.INotifyCompletion
 {
-    /// <summary>Gets a value indicating whether this instance is completed.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is completed; otherwise, <c>false</c>.
-    /// </value>
+    /// <summary>Gets a value indicating whether the signal has terminated, so an awaiting continuation runs inline.</summary>
     bool IsCompleted { get; }
 
-    /// <summary>Gets the awaiter.</summary>
-    /// <returns>An IAwaitSignal.</returns>
+    /// <summary>Gets the awaiter for this signal.</summary>
+    /// <returns>The signal itself, which acts as its own awaiter.</returns>
     IAwaitSignal<T> GetAwaiter();
 
-    /// <summary>Gets the result.</summary>
-    /// <returns>A value of T.</returns>
+    /// <summary>Gets the awaited value, rethrowing the terminal error when the signal faulted.</summary>
+    /// <returns>The value the signal terminated with.</returns>
     T GetResult();
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ISignal{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/ISignal{TSource,TResult}.cs
index 59be5d58..9b47ff7d 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ISignal{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ISignal{TSource,TResult}.cs
@@ -7,13 +7,10 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal that observes one type and emits another.</summary>
-/// <typeparam name="TSource">The type of the source.</typeparam>
-/// <typeparam name="TResult">The type of the result.</typeparam>
+/// <typeparam name="TSource">The observed value type.</typeparam>
+/// <typeparam name="TResult">The emitted value type.</typeparam>
 public interface ISignal<in TSource, out TResult> : IObserver<TSource>, IObservable<TResult>, IsDisposed
 {
     /// <summary>Gets a value indicating whether this instance has observers.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance has observers; otherwise, <c>false</c>.
-    /// </value>
     bool HasObservers { get; }
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ISignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/ISignal{T}.cs
index cf5d6929..5bd4b2a9 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ISignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ISignal{T}.cs
@@ -5,5 +5,5 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal that is both an observer and observable of the same type.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <typeparam name="T">The value type observed and emitted.</typeparam>
 public interface ISignal<T> : ISignal<T, T>;
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ITaskSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/ITaskSignal{T}.cs
index f5e8988c..727db516 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ITaskSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ITaskSignal{T}.cs
@@ -7,29 +7,19 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal backed by a task.</summary>
-/// <typeparam name="T">The object that provides notification information.</typeparam>
-/// <seealso cref="IObservable&lt;T&gt;" />
+/// <typeparam name="T">The value type.</typeparam>
 public interface ITaskSignal<out T> : IObservable<T>, IsDisposed
 {
-    /// <summary>Gets the cancellation token source.</summary>
-    /// <value>
-    /// The cancellation token source.
-    /// </value>
+    /// <summary>Gets the source that cancels the backing task, or <see langword="null"/> when the signal is not cancellable.</summary>
     CancellationTokenSource? CancellationTokenSource { get; }
 
-    /// <summary>Gets a value indicating whether this instance is cancellation requested.</summary>
-    /// <value>
-    ///   <c>true</c> if this instance is cancellation requested; otherwise, <c>false</c>.
-    /// </value>
+    /// <summary>Gets a value indicating whether cancellation of the backing task has been requested.</summary>
     bool IsCancellationRequested { get; }
 
-    /// <summary>Gets the source.</summary>
-    /// <value>
-    /// The source.
-    /// </value>
+    /// <summary>Gets the sequence the backing task produces, or <see langword="null"/> before the task starts.</summary>
     IObservable<T>? Source { get; }
 
-    /// <summary>Gets the operation canceled.</summary>
-    /// <param name="observer">The observer.</param>
+    /// <summary>Notifies an observer with the exception produced by cancelling the backing task.</summary>
+    /// <param name="observer">The observer that receives the cancellation exception.</param>
     void GetOperationCanceled(IObserver<Exception> observer);
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/IWitnessRemovable{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/IWitnessRemovable{T}.cs
index 6614eceb..e7ac23b8 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/IWitnessRemovable{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/IWitnessRemovable{T}.cs
@@ -4,11 +4,11 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>A signal that can remove a previously subscribed observer when its subscription handle is disposed.</summary>
+/// <summary>A signal that a subscription handle can detach its observer from when the handle is disposed.</summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 internal interface IWitnessRemovable<out T>
 {
-    /// <summary>Removes an observer previously registered via subscription.</summary>
+    /// <summary>Removes a subscribed observer from the signal.</summary>
     /// <param name="observer">The observer to remove.</param>
     void RemoveObserver(IObserver<T> observer);
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
index 5beab2a7..0134e6cc 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/KeepSignal{T}.cs
@@ -6,27 +6,27 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>Represents the KeepSignal class.</summary>
-/// <typeparam name="T">The T type.</typeparam>
-/// <param name="source">The source value.</param>
-/// <param name="predicate">The predicate value.</param>
+/// <summary>Signal that forwards only the source values the predicate accepts.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="source">The source sequence.</param>
+/// <param name="predicate">The predicate applied to each source value.</param>
 [System.Diagnostics.DebuggerDisplay("KeepSignal: Source = {_source}, Predicate = {_predicate}")]
 public sealed class KeepSignal<T>(IObservable<T> source, Func<T, bool> predicate) : IRequireCurrentThread<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The source sequence.</summary>
     private readonly IObservable<T> _source = source;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The predicate applied to each source value.</summary>
     private readonly Func<T, bool> _predicate = predicate;
 
     /// <summary>Preserves the source's current-thread subscription requirement.</summary>
-    /// <returns>The result.</returns>
+    /// <returns><see langword="true"/> when the source requires current-thread subscription.</returns>
     public bool IsRequiredSubscribeOnCurrentThread() =>
         _source is IRequireCurrentThread<T> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread();
 
     /// <summary>Subscribes an observer to source values accepted by the predicate.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The subscription handle.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -34,18 +34,18 @@ public IDisposable Subscribe(IObserver<T> observer)
         return _source.Subscribe(new KeepWitness(observer, _predicate));
     }
 
-    /// <summary>Represents the KeepWitness class.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="predicate">The predicate value.</param>
+    /// <summary>Applies the predicate to each source value and forwards the ones it accepts.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="predicate">The predicate applied to each source value.</param>
     private sealed class KeepWitness(IObserver<T> observer, Func<T, bool> predicate) : IObserver<T>
     {
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<T> _observer = observer;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The predicate applied to each source value.</summary>
         private readonly Func<T, bool> _predicate = predicate;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>Non-zero once a terminal notification has been forwarded.</summary>
         private int _stopped;
 
         /// <summary>Forwards completion only while the sink is active.</summary>
@@ -60,7 +60,7 @@ public void OnCompleted()
         }
 
         /// <summary>Stops the sink and forwards its first error.</summary>
-        /// <param name="error">The error value.</param>
+        /// <param name="error">The terminal error.</param>
         public void OnError(Exception error)
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
@@ -72,7 +72,7 @@ public void OnError(Exception error)
         }
 
         /// <summary>Filters active values and turns predicate failures into terminal errors.</summary>
-        /// <param name="value">The value.</param>
+        /// <param name="value">The source value.</param>
         public void OnNext(T value)
         {
             if (Volatile.Read(ref _stopped) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs b/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
index 795ebb02..48ec0161 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/KeepWithSignal{T,TState}.cs
@@ -69,7 +69,7 @@ public void OnCompleted()
         }
 
         /// <summary>Forwards an error downstream.</summary>
-        /// <param name="error">The error value.</param>
+        /// <param name="error">The terminal error.</param>
         public void OnError(Exception error)
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
index 35e72aff..40bd40b2 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/MapSignal{TSource,TResult}.cs
@@ -6,28 +6,28 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>Represents the MapSignal class.</summary>
-/// <typeparam name="TSource">The TSource type.</typeparam>
-/// <typeparam name="TResult">The TResult type.</typeparam>
-/// <param name="source">The source value.</param>
-/// <param name="selector">The selector value.</param>
+/// <summary>Signal that projects each source value through a selector before forwarding it.</summary>
+/// <typeparam name="TSource">The source value type.</typeparam>
+/// <typeparam name="TResult">The projected value type.</typeparam>
+/// <param name="source">The source sequence.</param>
+/// <param name="selector">The projection applied to each source value.</param>
 [System.Diagnostics.DebuggerDisplay("MapSignal: Source = {_source}, Selector = {_selector}")]
 public sealed class MapSignal<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector) : IRequireCurrentThread<TResult>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The source sequence.</summary>
     private readonly IObservable<TSource> _source = source;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The projection applied to each source value.</summary>
     private readonly Func<TSource, TResult> _selector = selector;
 
     /// <summary>Preserves the source's current-thread subscription requirement.</summary>
-    /// <returns>The result.</returns>
+    /// <returns><see langword="true"/> when the source requires current-thread subscription.</returns>
     public bool IsRequiredSubscribeOnCurrentThread() =>
         _source is IRequireCurrentThread<TSource> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread();
 
-    /// <summary>Subscribes an observer to the selected source values.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Subscribes an observer to the projected source values.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The subscription handle.</returns>
     public IDisposable Subscribe(IObserver<TResult> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -35,18 +35,18 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return _source.Subscribe(new MapWitness(observer, _selector));
     }
 
-    /// <summary>Represents the MapWitness class.</summary>
-    /// <param name="observer">The observer value.</param>
-    /// <param name="selector">The selector value.</param>
+    /// <summary>Applies the selector to each source value and forwards the projection.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="selector">The projection applied to each source value.</param>
     private sealed class MapWitness(IObserver<TResult> observer, Func<TSource, TResult> selector) : IObserver<TSource>
     {
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The downstream observer.</summary>
         private readonly IObserver<TResult> _observer = observer;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The projection applied to each source value.</summary>
         private readonly Func<TSource, TResult> _selector = selector;
 
-        /// <summary>Stores state for the signal implementation; non-zero once the sink has terminated.</summary>
+        /// <summary>Non-zero once a terminal notification has been forwarded.</summary>
         private int _stopped;
 
         /// <summary>Forwards completion only while the sink is active.</summary>
@@ -61,7 +61,7 @@ public void OnCompleted()
         }
 
         /// <summary>Stops the sink and forwards its first error.</summary>
-        /// <param name="error">The error value.</param>
+        /// <param name="error">The terminal error.</param>
         public void OnError(Exception error)
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
@@ -73,7 +73,7 @@ public void OnError(Exception error)
         }
 
         /// <summary>Projects active values and turns selector failures into terminal errors.</summary>
-        /// <param name="value">The value.</param>
+        /// <param name="value">The source value.</param>
         public void OnNext(TSource value)
         {
             if (Volatile.Read(ref _stopped) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
index f8ba2089..41468767 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
@@ -79,7 +79,7 @@ public void OnCompleted()
         }
 
         /// <summary>Forwards an error downstream.</summary>
-        /// <param name="error">The error value.</param>
+        /// <param name="error">The terminal error.</param>
         public void OnError(Exception error)
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs b/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
index 9cc1c700..7e954d43 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ObserverHandler.cs
@@ -4,21 +4,21 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>Represents the ObserverHandler class.</summary>
-/// <typeparam name="T">The Type.</typeparam>
-/// <param name="subject">The subject value.</param>
-/// <param name="observer">The observer value.</param>
+/// <summary>Subscription handle that removes its observer from the signal exactly once when disposed.</summary>
+/// <typeparam name="T">The observed value type.</typeparam>
+/// <param name="subject">The signal the observer is subscribed to.</param>
+/// <param name="observer">The subscribed observer.</param>
 [System.Diagnostics.DebuggerDisplay("ObserverHandler: Subject = {_subject}, Observer = {_observer}")]
 public sealed class ObserverHandler<T>(AsyncSignal<T> subject, IObserver<T> observer) : IDisposable
 {
     /// <summary>Serializes detachment from the signal.</summary>
     private readonly Lock _gate = new();
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The signal to unsubscribe from, cleared by the first disposal.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Back-reference to the subject; unsubscribed, not owned.")]
     private AsyncSignal<T>? _subject = subject;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The observer to remove, cleared by the first disposal.</summary>
     private IObserver<T>? _observer = observer;
 
     /// <summary>Detaches the observer once and releases references to both endpoints.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
index a9063ac3..4e2f174a 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ProjectedReadOnlyState{TSource,TResult}.cs
@@ -214,7 +214,7 @@ private void Remove(IObserver<TResult> observer)
     }
 
     /// <summary>Throws if disposed.</summary>
-    /// <exception cref="ObjectDisposedException">The projection has already been disposed.</exception>
+    /// <exception cref="ObjectDisposedException">The projection is disposed.</exception>
     private void ThrowIfDisposed()
     {
         if (!_isDisposed)
diff --git a/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
index 8fa1fd3b..906b0050 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/ReadOnlyState{T}.cs
@@ -11,10 +11,10 @@ namespace ReactiveUI.Primitives.Signals;
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ReadOnlyState<T> : IObservable<T>, IDisposable
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The state signal holding the mirrored value and its subscribers.</summary>
     private readonly StateSignal<T> _inner;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The subscription feeding source values into the inner state.</summary>
     private readonly IDisposable _subscription;
 
     /// <summary>Initializes a new instance of the <see cref="ReadOnlyState{T}"/> class.</summary>
@@ -38,10 +38,9 @@ public ReadOnlyState(IObservable<T> source, T initialValue)
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Notifies the provider that an observer is to receive notifications.</summary>
-    /// <param name="observer">The object that is to receive notifications.</param>
-    /// <returns>A reference to an interface that allows observers to stop receiving notifications before the provider has
-    /// finished sending them.</returns>
+    /// <summary>Subscribes an observer, which receives the current value followed by every later one.</summary>
+    /// <param name="observer">The observer to subscribe.</param>
+    /// <returns>A handle that unsubscribes the observer when disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IDisposable Subscribe(IObserver<T> observer) => _inner.Subscribe(observer);
 
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
index b6dffb44..073f3bcf 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
@@ -9,11 +9,11 @@
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>A signal that is both an observer and observable of values.</summary>
-/// <typeparam name="T">The Type.</typeparam>
+/// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class Signal<T> : ISignal<T>
 {
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The number of slots the subscription array starts with.</summary>
     private const int InitialSubscriptionCapacity = 4;
 
     /// <summary>The factor the subscription array grows by when it fills.</summary>
@@ -28,7 +28,7 @@ public class Signal<T> : ISignal<T>
     /// <summary>Serializes observer-set and terminal-state mutations; dispatch reads the published target without this gate.</summary>
     private readonly Lock _observerLock = new();
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The terminal error, when the signal faulted.</summary>
     private Exception? _exception;
 
     /// <summary>Atomically published dispatch target: empty, one subscription, a slot array, or a terminal marker.</summary>
@@ -37,19 +37,19 @@ public class Signal<T> : ISignal<T>
     /// <summary>The reusable slot array backing the multi-subscriber shape, kept across an empty period.</summary>
     private SignalSubscription?[]? _slots;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The number of occupied slots in the slot array.</summary>
     private int _subscriptionCount;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>The exclusive upper bound of slots that have been handed out, so a scan for a free slot stops there.</summary>
     private int _subscriptionTail;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether the signal has been disposed.</summary>
     private bool _isDisposed;
 
-    /// <summary>Stores state for the signal implementation.</summary>
+    /// <summary>Whether a terminal notification has been delivered.</summary>
     private bool _isStopped;
 
-    /// <summary>Gets a value indicating whether indicates whether the subject has observers subscribed to it.</summary>
+    /// <summary>Gets a value indicating whether any observer is subscribed to the signal.</summary>
     public virtual bool HasObservers
     {
         get
@@ -60,7 +60,7 @@ public virtual bool HasObservers
         }
     }
 
-    /// <summary>Gets a value indicating whether indicates whether the subject has been disposed.</summary>
+    /// <summary>Gets a value indicating whether the signal has been disposed.</summary>
     public virtual bool IsDisposed => _isDisposed;
 
     /// <summary>Gets the debugger display text.</summary>
@@ -68,14 +68,14 @@ public virtual bool HasObservers
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Detaches every subscription and makes later notifications throw.</summary>
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Called when [completed].</summary>
+    /// <summary>Completes the current observers and stops the signal, so later notifications are ignored.</summary>
     public void OnCompleted()
     {
         object? observers;
@@ -95,8 +95,8 @@ public void OnCompleted()
         Completed(observers);
     }
 
-    /// <summary>Called when [error].</summary>
-    /// <param name="error">The error.</param>
+    /// <summary>Faults the current observers and stops the signal, rethrowing to the caller when a value-only callback is subscribed.</summary>
+    /// <param name="error">The terminal error.</param>
     public void OnError(Exception error)
     {
         ArgumentExceptionHelper.ThrowIfNull(error);
@@ -125,9 +125,9 @@ public void OnError(Exception error)
         ExceptionDispatchInfo.Capture(error).Throw();
     }
 
-    /// <summary>Called when [next].</summary>
-    /// <param name="value">The value.</param>
-    /// <remarks>Emission reads the published observer state without locking. Terminal signals ignore subsequent values; disposed signals throw.</remarks>
+    /// <summary>Emits a value to the current observers; a stopped signal drops it and a disposed signal throws <see cref="ObjectDisposedException"/>.</summary>
+    /// <param name="value">The value to emit.</param>
+    /// <remarks>Dispatch reads the published observer set without taking the lock, so concurrent calls are not serialized against each other.</remarks>
     public void OnNext(T value)
     {
         var observers = Volatile.Read(ref _observers);
@@ -151,11 +151,9 @@ public void OnNext(T value)
         throw Disposed();
     }
 
-    /// <summary>Subscribes the specified observer.</summary>
-    /// <param name="observer">The observer.</param>
-    /// <returns>
-    /// A IDisposable.
-    /// </returns>
+    /// <summary>Subscribes an observer, delivering the stored terminal notification immediately when the signal has stopped.</summary>
+    /// <param name="observer">The observer to subscribe.</param>
+    /// <returns>A handle that detaches the observer when disposed.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         ArgumentExceptionHelper.ThrowIfNull(observer);
@@ -193,9 +191,9 @@ public IDisposable Subscribe(IObserver<T> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Registers a value callback, or rethrows the stored error if the signal has already failed.</summary>
-    /// <param name="onNext">The onNext value.</param>
-    /// <returns>The result.</returns>
+    /// <summary>Registers a value-only callback, rethrowing the stored error when the signal has faulted.</summary>
+    /// <param name="onNext">The callback invoked for each value.</param>
+    /// <returns>A handle that detaches the callback when disposed.</returns>
     public IDisposable SubscribeAction(Action<T> onNext)
     {
         ArgumentExceptionHelper.ThrowIfNull(onNext);
@@ -229,7 +227,7 @@ public IDisposable SubscribeAction(Action<T> onNext)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Publishes the disposed marker and detaches the subscriptions it replaced.</summary>
     /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
     protected virtual void Dispose(bool disposing)
     {
@@ -262,7 +260,7 @@ protected virtual void Dispose(bool disposing)
     private static ObjectDisposedException Disposed() => new(string.Empty);
 
     /// <summary>Forwards completion to each subscription in the captured observer snapshot.</summary>
-    /// <param name="observers">The observer shape captured while the signal was still running.</param>
+    /// <param name="observers">The observer shape the terminal marker replaced.</param>
     private static void Completed(object? observers)
     {
         if (observers is SignalSubscription single)
@@ -283,8 +281,8 @@ private static void Completed(object? observers)
     }
 
     /// <summary>Forwards an error to each subscription in the captured observer snapshot.</summary>
-    /// <param name="observers">The observer shape captured while the signal was still running.</param>
-    /// <param name="exception">The exception value.</param>
+    /// <param name="observers">The observer shape the terminal marker replaced.</param>
+    /// <param name="exception">The error to forward.</param>
     private static void Error(object? observers, Exception exception)
     {
         if (observers is SignalSubscription single)
@@ -305,8 +303,8 @@ private static void Error(object? observers, Exception exception)
     }
 
     /// <summary>Checks whether the captured snapshot contains any value-only callback subscriptions.</summary>
-    /// <param name="observers">The observer shape captured while the signal was still running.</param>
-    /// <returns>The result.</returns>
+    /// <param name="observers">The observer shape the terminal marker replaced.</param>
+    /// <returns><see langword="true"/> when at least one subscription holds a value-only callback.</returns>
     private static bool HasActionSubscribers(object? observers)
     {
         if (observers is SignalSubscription single)
@@ -352,8 +350,8 @@ private static void DisposeSubscriptions(object? observers)
     }
 
     /// <summary>Forwards a value to each occupied subscription slot.</summary>
-    /// <param name="subscriptions">The subscription snapshot, which the observer field only ever holds non-null.</param>
-    /// <param name="value">The value.</param>
+    /// <param name="subscriptions">The slot array to walk.</param>
+    /// <param name="value">The value to forward.</param>
     private static void DispatchSubscriptions(SignalSubscription?[] subscriptions, T value)
     {
         for (var i = 0; i < subscriptions.Length; i++)
@@ -370,7 +368,7 @@ private static void DispatchSubscriptions(SignalSubscription?[] subscriptions, T
 
     /// <summary>Dispatches to every live slot, then reports a disposal that raced the dispatch.</summary>
     /// <param name="subscriptions">The slot array this dispatch captured.</param>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The value to forward.</param>
     private void DispatchToSlots(SignalSubscription?[] subscriptions, T value)
     {
         DispatchSubscriptions(subscriptions, value);
@@ -394,7 +392,7 @@ private void ThrowIfDisposed()
     }
 
     /// <summary>Adds a subscription and publishes the resulting observer shape.</summary>
-    /// <param name="subscription">The subscription value.</param>
+    /// <param name="subscription">The subscription to add.</param>
     private void AddSubscriptionLocked(SignalSubscription subscription)
     {
         if (_observers is null)
@@ -415,8 +413,8 @@ private void AddSubscriptionLocked(SignalSubscription subscription)
     }
 
     /// <summary>Places a subscription in the reusable slot array, growing it when every slot is taken.</summary>
-    /// <param name="subscription">The subscription value.</param>
-    /// <returns>The slot array the subscription now lives in.</returns>
+    /// <param name="subscription">The subscription to store.</param>
+    /// <returns>The slot array holding the subscription.</returns>
     private SignalSubscription?[] AddToSlotsLocked(SignalSubscription subscription)
     {
         var slots = _slots;
@@ -466,7 +464,7 @@ private void AddSubscriptionLocked(SignalSubscription subscription)
     }
 
     /// <summary>Removes a subscription while holding the observer lock.</summary>
-    /// <param name="subscription">The subscription value.</param>
+    /// <param name="subscription">The subscription to remove.</param>
     private void Remove(SignalSubscription subscription)
     {
         lock (_observerLock)
@@ -487,7 +485,7 @@ private void Remove(SignalSubscription subscription)
 
     /// <summary>Removes a subscription from its owning slot array.</summary>
     /// <param name="slots">The active slot array.</param>
-    /// <param name="subscription">The subscription value.</param>
+    /// <param name="subscription">The subscription to clear.</param>
     private void RemoveFromSlotsLocked(SignalSubscription?[] slots, SignalSubscription subscription)
     {
         var index = Array.IndexOf(slots, subscription);
@@ -516,7 +514,7 @@ private void ClearSlotLocked(SignalSubscription?[] slots, int index)
         Volatile.Write(ref _observers, null);
     }
 
-    /// <summary>Represents the SignalSubscription class.</summary>
+    /// <summary>One subscription's handle, holding either an observer or a value-only callback.</summary>
     private sealed class SignalSubscription : IDisposable
     {
         /// <summary>The observer target, or <see langword="null"/> when this subscription stores an action callback.</summary>
@@ -525,12 +523,12 @@ private sealed class SignalSubscription : IDisposable
         /// <summary>The action target, or <see langword="null"/> when this subscription stores an observer.</summary>
         private readonly Action<T>? _action;
 
-        /// <summary>Stores state for the signal implementation.</summary>
+        /// <summary>The owning signal, cleared by the first disposal.</summary>
         private Signal<T>? _subject;
 
         /// <summary>Initializes a new instance of the <see cref="SignalSubscription"/> class.</summary>
-        /// <param name="subject">The subject value.</param>
-        /// <param name="observer">The observer value.</param>
+        /// <param name="subject">The owning signal.</param>
+        /// <param name="observer">The subscribed observer.</param>
         public SignalSubscription(Signal<T> subject, IObserver<T> observer)
         {
             _subject = subject;
@@ -538,8 +536,8 @@ public SignalSubscription(Signal<T> subject, IObserver<T> observer)
         }
 
         /// <summary>Initializes a new instance of the <see cref="SignalSubscription"/> class.</summary>
-        /// <param name="subject">The subject value.</param>
-        /// <param name="onNext">The onNext value.</param>
+        /// <param name="subject">The owning signal.</param>
+        /// <param name="onNext">The callback invoked for each value.</param>
         public SignalSubscription(Signal<T> subject, Action<T> onNext)
         {
             _subject = subject;
@@ -549,8 +547,8 @@ public SignalSubscription(Signal<T> subject, Action<T> onNext)
         /// <summary>Gets a value indicating whether this subscription stores an action callback.</summary>
         public bool IsAction => _action is not null;
 
-        /// <summary>Sends a value to the subscription target.</summary>
-        /// <param name="value">The value.</param>
+        /// <summary>Sends a value to the observer or the callback, whichever this subscription holds.</summary>
+        /// <param name="value">The value to send.</param>
         public void OnNext(T value)
         {
             var observer = _observer;
@@ -563,12 +561,12 @@ public void OnNext(T value)
             _action!(value);
         }
 
-        /// <summary>Sends an error to observer subscriptions.</summary>
-        /// <param name="exception">The exception.</param>
+        /// <summary>Sends an error to the observer; a value-only callback receives nothing.</summary>
+        /// <param name="exception">The error to send.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnError(Exception exception) => _observer?.OnError(exception);
 
-        /// <summary>Sends completion to observer subscriptions.</summary>
+        /// <summary>Sends completion to the observer; a value-only callback receives nothing.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted() => _observer?.OnCompleted();
 
diff --git a/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs b/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
index d6e7c243..9156e8b7 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
@@ -72,7 +72,7 @@ public void OnCompleted()
         }
 
         /// <summary>Forwards an error downstream.</summary>
-        /// <param name="error">The error value.</param>
+        /// <param name="error">The terminal error.</param>
         public void OnError(Exception error)
         {
             if (Interlocked.Exchange(ref _stopped, 1) != 0)
diff --git a/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs b/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
index 77456a7c..a42bc13e 100644
--- a/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
+++ b/src/ReactiveUI.Primitives.Core/SubscribeExtensions.cs
@@ -18,10 +18,10 @@ public static class SubscribeExtensions
     private static readonly Action nop = static () => { };
 
     /// <summary>Exception helpers for a nullable exception receiver.</summary>
-    /// <param name="exception">The exception.</param>
+    /// <param name="exception">The receiver exception, which may be <see langword="null"/>.</param>
     extension(Exception? exception)
     {
-        /// <summary>Rethrows Exception.</summary>
+        /// <summary>Rethrows the exception, doing nothing when there is none.</summary>
         public void Rethrow()
         {
             if (exception is null)
@@ -38,9 +38,9 @@ public void Rethrow()
     /// <param name="source">Signals sequence to subscribe to.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Subscribes to the Signals sequence without specifying any handlers. This method can be used to evaluate the Signals sequence for its side-effects only.</summary>
-        /// <returns><see cref="IDisposable"/> object used to unsubscribe from the Signals sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <c>null</c>.</exception>
+        /// <summary>Subscribes without any handlers, so the source sequence runs for its side effects alone.</summary>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <c>null</c>.</exception>
         public IDisposable Subscribe()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -48,9 +48,9 @@ public IDisposable Subscribe()
             return source.Subscribe(OnNextNoOpCache<T>.Instance, nop);
         }
 
-        /// <summary>Subscribes to the Signals providing just the <paramref name="onNext" /> delegate.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes a value callback; a terminal error is rethrown to the producer and completion is ignored.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         public IDisposable Subscribe(Action<T> onNext)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -65,10 +65,10 @@ public IDisposable Subscribe(Action<T> onNext)
             };
         }
 
-        /// <summary>Subscribes to the Signals providing both the <paramref name="onNext" /> and <paramref name="onError" /> delegates.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onError">The on error.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value and error callbacks; completion is ignored.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onError">The callback invoked with the terminal error.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError)
         {
             ArgumentExceptionHelper.ThrowIfNull(onError);
@@ -76,10 +76,10 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError)
             return source.Subscribe(onNext, onError, nop);
         }
 
-        /// <summary>Subscribes to the Signals providing both the <paramref name="onNext" /> and <paramref name="onCompleted" /> delegates.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onCompleted">The on completed.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value and completion callbacks; a terminal error is rethrown to the producer.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onCompleted">The callback invoked when the sequence completes.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         public IDisposable Subscribe(Action<T> onNext, Action onCompleted)
         {
             ArgumentExceptionHelper.ThrowIfNull(onCompleted);
@@ -87,11 +87,11 @@ public IDisposable Subscribe(Action<T> onNext, Action onCompleted)
             return source.Subscribe(onNext, rethrow, onCompleted);
         }
 
-        /// <summary>Subscribes to the Signals providing all three <paramref name="onNext" />, <paramref name="onError" /> and <paramref name="onCompleted" /> delegates.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onError">The on error.</param>
-        /// <param name="onCompleted">The on completed.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value, error, and completion callbacks.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onError">The callback invoked with the terminal error.</param>
+        /// <param name="onCompleted">The callback invoked when the sequence completes.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -107,39 +107,39 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
                 : source.Subscribe(new EmptyWitness<T>(onNext, onError, onCompleted));
         }
 
-        /// <summary>Subscribes to the Signals sequence without specifying any handlers using a Primitives-specific name.</summary>
-        /// <returns><see cref="IDisposable"/> object used to unsubscribe from the Signals sequence.</returns>
-        /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <c>null</c>.</exception>
+        /// <summary>Subscribes without any handlers, under the Primitives-specific name.</summary>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <c>null</c>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribePrimitives() => Subscribe(source);
 
-        /// <summary>Subscribes to the Signals providing just the <paramref name="onNext" /> delegate using a Primitives-specific name.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes a value callback, under the Primitives-specific name.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribePrimitives(Action<T> onNext) => Subscribe(source, onNext);
 
-        /// <summary>Subscribes to the Signals providing next and error delegates using a Primitives-specific name.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onError">The on error.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value and error callbacks, under the Primitives-specific name.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onError">The callback invoked with the terminal error.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribePrimitives(Action<T> onNext, Action<Exception> onError) =>
             Subscribe(source, onNext, onError);
 
-        /// <summary>Subscribes to the Signals providing next and completed delegates using a Primitives-specific name.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onCompleted">The on completed.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value and completion callbacks, under the Primitives-specific name.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onCompleted">The callback invoked when the sequence completes.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribePrimitives(Action<T> onNext, Action onCompleted) =>
             Subscribe(source, onNext, onCompleted);
 
-        /// <summary>Subscribes to the Signals providing all callback delegates using a Primitives-specific name.</summary>
-        /// <param name="onNext">The on next.</param>
-        /// <param name="onError">The on error.</param>
-        /// <param name="onCompleted">The on completed.</param>
-        /// <returns>A IDisposable.</returns>
+        /// <summary>Subscribes value, error, and completion callbacks, under the Primitives-specific name.</summary>
+        /// <param name="onNext">The callback invoked for each value.</param>
+        /// <param name="onError">The callback invoked with the terminal error.</param>
+        /// <param name="onCompleted">The callback invoked when the sequence completes.</param>
+        /// <returns>A handle that unsubscribes from the source sequence when disposed.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribePrimitives(Action<T> onNext, Action<Exception> onError, Action onCompleted) =>
             Subscribe(source, onNext, onError, onCompleted);
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
index eb6c9e1c..a01e09c2 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
@@ -8,11 +8,10 @@
 namespace ReactiveUI.Primitives.Extensions;
 
 /// <summary>
-/// Limits the concurrency of task execution and emits results through an observable sequence.
-/// Implements <see cref="IObservable{T}"/> directly so the surface needs no
-/// <c>ActionDisposable</c> closure wrappers; the per-task continuation state is the
-/// per-subscription <see cref="Subscription"/> instance, which is already a reference type
-/// and therefore needs no boxing through <see cref="object"/>.
+/// Drains a task sequence with at most <paramref name="maxConcurrency"/> tasks in flight, emitting each result as it
+/// completes and completing once the sequence is exhausted. A faulted or cancelled task terminates the sequence with
+/// that task's exception. Subscribers share one enumerator over <paramref name="taskFunctions"/>, so a second
+/// subscription continues draining where the first stopped, and disposing any subscription halts the drain for all.
 /// </summary>
 /// <typeparam name="T">The type of the task results.</typeparam>
 /// <param name="taskFunctions">The task functions to drain.</param>
@@ -26,20 +25,16 @@ public sealed class ConcurrencyLimiter<T>(IEnumerable<Task<T>> taskFunctions, in
     /// <summary>The number of tasks currently in flight that have not yet completed.</summary>
     private int _outstanding;
 
-    /// <summary>Global disposal latch set by any <see cref="Subscription.Dispose"/>. Preserves the
-    /// existing single-subscription-at-a-time semantics: once any consumer disposes, the limiter
-    /// stops pulling further tasks.</summary>
+    /// <summary>Disposal latch set by any subscription; once set, no further tasks are pulled.</summary>
     private int _disposed;
 
-    /// <summary>Lazy enumerator over the source task sequence; <see langword="null"/> once exhausted.</summary>
+    /// <summary>Lazy enumerator over the source task sequence; <see langword="null"/> when exhausted.</summary>
     private IEnumerator<Task<T>>? _rator;
 
-    /// <summary>Gets the observable sequence — the limiter is its own <see cref="IObservable{T}"/>.</summary>
+    /// <summary>Gets this limiter as an observable sequence of task results.</summary>
     public IObservable<T> Observable => this;
 
-    /// <summary>Gets or sets a value indicating whether the limiter has been disposed by any
-    /// consumer. Exposed to internal tests; production paths set it via
-    /// <see cref="Subscription.Dispose"/>.</summary>
+    /// <summary>Gets or sets a value indicating whether any subscription has disposed the limiter.</summary>
     [SuppressMessage(
         "RoslynCommonAnalyzers",
         "SST2200:Replace this single-use backing field with the 'field' keyword",
@@ -68,29 +63,27 @@ public IDisposable Subscribe(IObserver<T> observer)
         return subscription;
     }
 
-    /// <summary>Clears the lazy enumerator. Caller must hold <see cref="_gate"/> on the production paths; exposed to internal tests that exercise the idempotent-second-call branch.</summary>
+    /// <summary>Disposes and drops the task enumerator; callers must hold <see cref="_gate"/>.</summary>
     internal void ClearRator()
     {
         _rator?.Dispose();
         _rator = null;
     }
 
-    /// <summary>Test entry point that adapts a raw <see cref="IObserver{T}"/> into a fresh
-    /// <see cref="Subscription"/> and pulls the next task. Production paths go through
-    /// <see cref="Subscribe"/> which creates the subscription once.</summary>
+    /// <summary>Wraps the observer in a fresh subscription and pulls the next task for it.</summary>
     /// <param name="observer">The observer that will receive notifications.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void PullNextTask(IObserver<T> observer) =>
         PullNextTask(new Subscription(this, observer));
 
-    /// <summary>Processes the completion of a previously-scheduled task.</summary>
+    /// <summary>Delivers a finished task's result and pulls the next one, or terminates the sequence on failure.</summary>
     /// <param name="subscription">The owning subscription.</param>
     /// <param name="completed">The completed task.</param>
     [SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
         Justification =
-            "Task is guaranteed complete at this call site (IsFaulted/IsCanceled were both false above); reading .Result drives the synchronous IObserver<T> contract without blocking.")]
+            "The task is complete at this call site, so reading Result does not block.")]
     internal void ProcessTaskCompletion(Subscription subscription, Task<T> completed)
     {
         lock (_gate)
@@ -151,7 +144,6 @@ private void PullNextTask(Subscription subscription)
 
             _outstanding++;
 
-            // The subscription carries continuation state without boxing or closure capture.
             _rator.Current?.ContinueWith(
                 static (ant, state) =>
                 {
@@ -165,7 +157,7 @@ private void PullNextTask(Subscription subscription)
         }
     }
 
-    /// <summary>Holds the observer and prevents notification delivery after disposal.</summary>
+    /// <summary>Pairs an observer with its limiter and reports the limiter's disposal state to the drain loop.</summary>
     /// <param name="limiter">The owning limiter.</param>
     /// <param name="observer">The downstream observer.</param>
     internal sealed class Subscription(ConcurrencyLimiter<T> limiter, IObserver<T> observer) : IDisposable
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
index 2782b64e..2296206c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
@@ -6,11 +6,15 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>Coordinates phase synchronization between a lock holder and its continuation.</summary>
+/// <summary>
+/// Pairs an emitted item with a release handle so a producer can wait on its consumer: <see cref="Lock{T}"/> hands the
+/// item and this instance to an observer and returns a task that completes once that handle is disposed. The barrier
+/// behind it takes two participants and is torn down by <see cref="Dispose()"/>, so an instance gates one handoff.
+/// </summary>
 [System.Diagnostics.DebuggerDisplay("Continuation: Locked = {_locked}, CompletedPhases = {CompletedPhases}")]
 public class Continuation : IDisposable
 {
-    /// <summary>The barrier used to synchronize phases between the lock holder and the continuation.</summary>
+    /// <summary>The two-participant barrier that synchronizes phases between the gate holder and its continuation.</summary>
     private readonly Barrier _phaseSync = new(2);
 
     /// <summary>One once this instance has been disposed; otherwise zero.</summary>
@@ -19,25 +23,26 @@ public class Continuation : IDisposable
     /// <summary>One while the continuation is locked; otherwise zero.</summary>
     private int _locked;
 
-    /// <summary>Gets the number of completed phases.</summary>
-    /// <value>
-    /// The completed phases.
-    /// </value>
+    /// <summary>Gets the number of barrier phases that have completed.</summary>
     public long CompletedPhases => _phaseSync.CurrentPhaseNumber;
 
-    /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+    /// <summary>Releases the gate, completing the task returned by <see cref="Lock{T}"/>, and tears down the barrier.</summary>
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>Locks this instance.</summary>
+    /// <summary>
+    /// Takes the gate and hands <paramref name="item"/> to <paramref name="observer"/> paired with this instance as the
+    /// release handle. A call made while the gate is held emits nothing.
+    /// </summary>
     /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
-    /// <param name="item">The item.</param>
-    /// <param name="observer">The observer.</param>
+    /// <param name="item">The item handed to the observer.</param>
+    /// <param name="observer">The observer receiving the item and its release handle; ignored when <see langword="null"/>.</param>
     /// <returns>
-    /// A <see cref="Task" /> representing the asynchronous operation.
+    /// A <see cref="Task" /> that completes once the release handle is disposed, or a completed task when the gate was
+    /// held.
     /// </returns>
     public Task Lock<T>(T item, IObserver<(T Value, IDisposable Sync)>? observer)
     {
@@ -50,15 +55,11 @@ public Task Lock<T>(T item, IObserver<(T Value, IDisposable Sync)>? observer)
         return ScheduleSignalPhase();
     }
 
-    /// <summary>
-    /// <see cref="ValueTask"/>-returning counterpart to <see cref="Lock{T}"/>. Use this at per-emission
-    /// call sites where the returned task is awaited exactly once — saves the boxed <see cref="Task"/>
-    /// wrapper allocation in the already-locked fast path.
-    /// </summary>
+    /// <summary><see cref="ValueTask"/>-returning counterpart to <see cref="Lock{T}"/>, for call sites that await the result exactly once.</summary>
     /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
-    /// <param name="item">The item.</param>
-    /// <param name="observer">The observer.</param>
-    /// <returns>A <see cref="ValueTask"/> representing the asynchronous operation.</returns>
+    /// <param name="item">The item handed to the observer.</param>
+    /// <param name="observer">The observer receiving the item and its release handle; ignored when <see langword="null"/>.</param>
+    /// <returns>A <see cref="ValueTask"/> that completes once the release handle is disposed, or a completed task when the gate was held.</returns>
     public ValueTask LockValueTask<T>(T item, IObserver<(T Value, IDisposable Sync)>? observer)
     {
         if (Interlocked.Exchange(ref _locked, 1) != 0)
@@ -70,8 +71,8 @@ public ValueTask LockValueTask<T>(T item, IObserver<(T Value, IDisposable Sync)>
         return new(ScheduleSignalPhase());
     }
 
-    /// <summary>UnLocks this instance.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Releases the gate and signals the barrier phase; a no-op when the gate is not held.</summary>
+    /// <returns>A <see cref="Task"/> that completes once the barrier phase is signalled.</returns>
     internal Task UnLock() =>
         Interlocked.Exchange(ref _locked, 0) == 0 ? Task.CompletedTask : ScheduleSignalPhase();
 
@@ -81,8 +82,7 @@ internal Task UnLock() =>
         "Concurrency",
         "SST1905:Do not use async void",
         Justification =
-            "This is the Dispose(bool) disposal-pattern overload, whose signature is fixed to return void; it cannot return "
-            + "Task. The await is best-effort teardown of the phase barrier during disposal, with no caller positioned to observe it.")]
+            "The disposal-pattern overload must return void, and no caller is positioned to observe the awaited barrier teardown.")]
     protected virtual async void Dispose(bool disposing)
     {
         if (Interlocked.Exchange(ref _disposedValue, 1) != 0 || !disposing)
@@ -94,14 +94,14 @@ protected virtual async void Dispose(bool disposing)
         _phaseSync.Dispose();
     }
 
-    /// <summary>Static state-carrying signal callback; avoids the per-call closure allocation a captured lambda would produce.</summary>
+    /// <summary>Signals the phase barrier and waits there for the paired participant.</summary>
     /// <param name="state">The owning <see cref="Continuation"/> instance.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void SignalPhaseSync(object? state) =>
         ((Continuation)state!)._phaseSync.SignalAndWait(CancellationToken.None);
 
-    /// <summary>Schedules an action on the default task scheduler.</summary>
-    /// <returns>The task representing the scheduled signal work.</returns>
+    /// <summary>Runs the barrier signal on the default task scheduler.</summary>
+    /// <returns>The task for the scheduled signal work.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private Task ScheduleSignalPhase() =>
         Task.Factory.StartNew(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsTaskHelper.cs b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsTaskHelper.cs
index 17cd70be..23040c12 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsTaskHelper.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsTaskHelper.cs
@@ -4,14 +4,10 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Subscribes once and completes the returned <see cref="Task{T}"/> with the first emitted value;
-/// faults the task on source error or on empty completion. Combines the <see cref="TaskCompletionSource{T}"/>
-/// and the IObserver into a single allocation per call.
-/// </summary>
+/// <summary>Bridges the first value of an observable to a <see cref="Task{T}"/>, faulting on source error and on completion without a value.</summary>
 public static class FirstAsTaskHelper
 {
-    /// <summary>Subscribes and resolves a task with the first value.</summary>
+    /// <summary>Subscribes to <paramref name="source"/> and settles the returned task from its first notification, disposing the subscription at that point.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="source">The source observable.</param>
     /// <returns>A task that completes with the first value, faults on error, or faults on empty completion.</returns>
@@ -23,11 +19,11 @@ public static Task<T> FirstAsTask<T>(IObservable<T> source)
         return observer.Task;
     }
 
-    /// <summary>Combined TaskCompletionSource + IObserver — one heap allocation per call instead of two.</summary>
+    /// <summary>Observer that settles its own task from the first notification it receives.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     private sealed class FirstWitness<T>() : TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously), IObserver<T>
     {
-        /// <summary>Latches to <c>1</c> once the task has been settled so subsequent callbacks are no-ops.</summary>
+        /// <summary>Latches to <c>1</c> when the task is settled so later callbacks are no-ops.</summary>
         private int _settled;
 
         /// <summary>Gets or sets the source subscription so the first-value path can dispose it on completion.</summary>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
index 4449aa55..1b488707 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
@@ -8,14 +8,14 @@
 namespace ReactiveUI.Primitives.Extensions;
 
 /// <summary>
-/// <see cref="ValueTask{T}"/>-returning counterpart to <see cref="FirstAsTaskHelper"/>. Backs the
-/// <c>ToHotValueTask</c> extension with a pooled <see cref="IValueTaskSource{T}"/> implementation
-/// so steady-state callers pay zero allocations after the pool warms up.
+/// <see cref="ValueTask{T}"/>-returning counterpart to <see cref="FirstAsTaskHelper"/>. The returned value task is
+/// backed by a pooled <see cref="IValueTaskSource{T}"/>, so each one must be consumed exactly once: awaiting it twice,
+/// or reading its result after the backing instance returns to the pool, observes another caller's outcome.
 /// </summary>
 /// <typeparam name="T">The element type.</typeparam>
 public static class FirstAsValueTaskHelper<T>
 {
-    /// <summary>Single-slot pool. <c>null</c> when the previous instance is in flight.</summary>
+    /// <summary>Single-slot pool holding the idle witness; <see langword="null"/> while the witness is in flight.</summary>
     private static PooledFirstWitness? _pooled;
 
     /// <summary>Subscribes once and resolves a <see cref="ValueTask{T}"/> with the first value.</summary>
@@ -29,13 +29,13 @@ public static ValueTask<T> FirstAsValueTask(IObservable<T> source)
         return inst.Begin(source);
     }
 
-    /// <summary>Pooled combined <see cref="IValueTaskSource{T}"/> + <see cref="IObserver{T}"/>.</summary>
+    /// <summary>Observer that settles a reusable value-task source from the first notification, then returns itself to the pool once the result is read.</summary>
     private sealed class PooledFirstWitness : IValueTaskSource<T>, IObserver<T>
     {
         /// <summary>The reset-able backing store for the <see cref="ValueTask{T}"/> machinery.</summary>
         private ManualResetValueTaskSourceCore<T> _core = new() { RunContinuationsAsynchronously = true };
 
-        /// <summary>Latches to <c>1</c> once the source has been settled so subsequent callbacks no-op.</summary>
+        /// <summary>Latches to <c>1</c> when the source is settled so later callbacks no-op.</summary>
         private int _settled;
 
         /// <summary>The upstream subscription, retained so <see cref="OnNext"/> can cancel it on first match.</summary>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs b/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
index 73784d70..a27b1f82 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
@@ -5,10 +5,9 @@
 namespace ReactiveUI.Primitives.Extensions;
 
 /// <summary>
-/// Represents either a heartbeat signal or a value update from an observable stream. Value-type shape; the
-/// heartbeat operator emits these directly so per-emission allocations are zero. Note that
-/// <c>default(Heartbeat&lt;T&gt;)</c> represents a value update with the default <typeparamref name="T"/>; use
-/// <c>new Heartbeat&lt;T&gt;()</c> to construct a heartbeat tick.
+/// Carries either a heartbeat tick or a value update from an observable sequence. <c>default(Heartbeat&lt;T&gt;)</c> is a
+/// value update holding the default <typeparamref name="T"/>; construct a heartbeat tick with
+/// <c>new Heartbeat&lt;T&gt;()</c>.
 /// </summary>
 /// <typeparam name="T">The type of the update value.</typeparam>
 [System.Diagnostics.DebuggerDisplay("Heartbeat: IsHeartbeat = {IsHeartbeat}, Update = {Update}")]
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/IDrainTarget.cs b/src/ReactiveUI.Primitives.Extensions.Core/IDrainTarget.cs
index 25033338..3b7c066c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/IDrainTarget.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/IDrainTarget.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Implemented by sinks that drive a <c>ScheduledDrainState&lt;T&gt;</c>. The state helper invokes
-/// <see cref="Drain"/> once per scheduled burst via a static scheduler callback, so passing the sink
-/// as an <see cref="IDrainTarget"/> keeps the scheduled action allocation-free (no captured closure).
-/// </summary>
+/// <summary>Receives the drain callback a <c>ScheduledDrainState&lt;T&gt;</c> raises once per scheduled pass.</summary>
 public interface IDrainTarget
 {
     /// <summary>Drains the queued notifications on the scheduler thread.</summary>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/IHeartbeat.cs b/src/ReactiveUI.Primitives.Extensions.Core/IHeartbeat.cs
index f9c2b795..f5bb80be 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/IHeartbeat.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/IHeartbeat.cs
@@ -4,15 +4,13 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>Heart beat.</summary>
-/// <typeparam name="T">The type.</typeparam>
+/// <summary>Carries either a heartbeat tick or a value update from an observable sequence.</summary>
+/// <typeparam name="T">The type of the update value.</typeparam>
 public interface IHeartbeat<out T>
 {
-    /// <summary>Gets a value indicating whether this instance is heartbeat.</summary>
-    /// <value><c>true</c> if this instance is heartbeat; otherwise, <c>false</c>.</value>
+    /// <summary>Gets a value indicating whether this notification is a heartbeat tick rather than an update.</summary>
     bool IsHeartbeat { get; }
 
-    /// <summary>Gets the update.</summary>
-    /// <value>The update.</value>
+    /// <summary>Gets the update value, which carries no meaning while <see cref="IsHeartbeat"/> is <see langword="true"/>.</summary>
     T? Update { get; }
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/IStale.cs b/src/ReactiveUI.Primitives.Extensions.Core/IStale.cs
index 3bdb4f49..285754a6 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/IStale.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/IStale.cs
@@ -4,15 +4,13 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>Indicator for connection that has become stale.</summary>
-/// <typeparam name="T">The type.</typeparam>
+/// <summary>Carries either a staleness signal or a value update from an observable sequence.</summary>
+/// <typeparam name="T">The type of the update value.</typeparam>
 public interface IStale<out T>
 {
-    /// <summary>Gets a value indicating whether this instance is stale.</summary>
-    /// <value><c>true</c> if this instance is stale; otherwise, <c>false</c>.</value>
+    /// <summary>Gets a value indicating whether this notification signals staleness rather than an update.</summary>
     bool IsStale { get; }
 
-    /// <summary>Gets the update.</summary>
-    /// <value>The update.</value>
+    /// <summary>Gets the update value; an implementation may reject the read while <see cref="IsStale"/> is <see langword="true"/>.</summary>
     T? Update { get; }
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
index 876b034d..a27c2f06 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ConcurrencyRaceHelpers.cs
@@ -7,27 +7,17 @@ namespace ReactiveUI.Primitives.Extensions.Internal;
 /// <summary>Claims one-time transitions and tolerates cancellation of disposed token sources.</summary>
 internal static class ConcurrencyRaceHelpers
 {
-    /// <summary>
-    /// Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/>
-    /// to <paramref name="claimedSentinel"/>. Returns <see langword="true"/> if this caller
-    /// won the race; <see langword="false"/> if another caller had already claimed the state.
-    /// </summary>
+    /// <summary>Atomically moves <paramref name="state"/> from <paramref name="openSentinel"/> to <paramref name="claimedSentinel"/>.</summary>
     /// <param name="state">The reference to the state field.</param>
-    /// <param name="openSentinel">The sentinel value the state must currently hold.</param>
+    /// <param name="openSentinel">The sentinel value the state must hold for the claim to succeed.</param>
     /// <param name="claimedSentinel">The sentinel value the state transitions to on success.</param>
-    /// <returns>
-    /// <see langword="true"/> if the claim succeeded; <see langword="false"/> if another caller
-    /// already claimed the state.
-    /// </returns>
+    /// <returns><see langword="true"/> when this caller made the transition; <see langword="false"/> when another caller holds the claim.</returns>
     internal static bool TryClaim(ref int state, int openSentinel, int claimedSentinel) =>
         Interlocked.CompareExchange(ref state, claimedSentinel, openSentinel) == openSentinel;
 
     /// <summary>Cancels the source asynchronously, tolerating concurrent disposal.</summary>
     /// <param name="cts">The cancellation token source to cancel.</param>
-    /// <returns>
-    /// <see langword="true"/> if the cancellation completed; <see langword="false"/> if the
-    /// source was already disposed.
-    /// </returns>
+    /// <returns><see langword="true"/> when the cancellation ran; <see langword="false"/> when the source was disposed first.</returns>
     internal static async ValueTask<bool> TryCancelAsync(CancellationTokenSource cts)
     {
         try
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
index f82aca30..597d433e 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/IndexedSubscribeHelper.cs
@@ -37,7 +37,7 @@ internal static IDisposable SubscribeIndexed<T>(
         return composite;
     }
 
-    /// <summary>Observer that carries a source index without allocating per-source callback closures.</summary>
+    /// <summary>Observer that tags each notification with its source index before invoking the shared hooks.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="index">The source index.</param>
     /// <param name="onNext">Per-source OnNext hook.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
index 921ca609..3b44768f 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ObservableSubscribeExtensions.cs
@@ -14,7 +14,7 @@ internal static class ObservableSubscribeExtensions
     /// <param name="source">The source observable.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Subscribes delegate callbacks through the core sink; the distinct name avoids ambiguity with System.Reactive extensions.</summary>
+        /// <summary>Subscribes the three delegate callbacks to the source through the core sink.</summary>
         /// <param name="onNext">Per-value callback.</param>
         /// <param name="onError">Error callback.</param>
         /// <param name="onCompleted">Completion callback.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
index bb3123fc..8e26104b 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
@@ -5,8 +5,7 @@
 namespace ReactiveUI.Primitives.Extensions.Internal;
 
 /// <summary>Stores synchronized reduction state and coordinates terminal notifications.</summary>
-/// <typeparam name="TIn">The source element type (must be a struct so <c>TIn?</c> doubles as the
-/// "value seen yet?" Optional).</typeparam>
+/// <typeparam name="TIn">The source element type; the struct constraint lets <c>TIn?</c> record whether a value has arrived.</typeparam>
 /// <typeparam name="TOut">The downstream element type the operator emits after reducing.</typeparam>
 internal sealed class ReduceSinkState<TIn, TOut>
     where TIn : struct
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Observables.cs b/src/ReactiveUI.Primitives.Extensions.Core/Observables.cs
index a5c933d9..fb8bf400 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Observables.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Observables.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Factory methods that build <see cref="IObservable{T}"/> instances. The plural name avoids
-/// resolution collisions with other observable factory types at call sites that import multiple
-/// reactive namespaces.
-/// </summary>
+/// <summary>Factory methods that build <see cref="IObservable{T}"/> sequences.</summary>
 public static class Observables
 {
     /// <summary>Returns an observable sequence that emits a single value and completes synchronously inside <see cref="IObservable{T}.Subscribe"/>.</summary>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/ObserverArrayHelpers.cs b/src/ReactiveUI.Primitives.Extensions.Core/ObserverArrayHelpers.cs
index 46cda195..d0fe7ccd 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/ObserverArrayHelpers.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/ObserverArrayHelpers.cs
@@ -4,19 +4,10 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Pure-plumbing helpers for swap-on-write <see cref="IObserver{T}"/> arrays. Centralizes the
-/// empty-array short-circuit on broadcast and the not-present short-circuit on remove so the
-/// operator hot paths stay branchless on the steady state. Every branch is a pure function
-/// over its inputs and is directly RxVoid-testable through this class.
-/// </summary>
+/// <summary>Helpers for broadcasting to, and removing from, swap-on-write <see cref="IObserver{T}"/> arrays.</summary>
 public static class ObserverArrayHelpers
 {
-    /// <summary>
-    /// Snapshots the supplied observer array and fans the value out to every observer in order.
-    /// Returns silently if the array is empty (which happens during the race between the last
-    /// unsubscribe and an already-scheduled broadcast).
-    /// </summary>
+    /// <summary>Fans <paramref name="value"/> out to every observer in <paramref name="observers"/> in order; an empty array emits nothing.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="observers">The observer array snapshot.</param>
     /// <param name="value">The value to broadcast.</param>
@@ -33,18 +24,14 @@ public static void Broadcast<T>(IObserver<T>[] observers, T value)
         }
     }
 
-    /// <summary>
-    /// Returns a new observer array with <paramref name="observer"/> removed, or
-    /// <see langword="null"/> if the observer was not in the array (which happens during
-    /// the race between an idempotent subscription dispose and a previous successful remove).
-    /// </summary>
+    /// <summary>Copies <paramref name="current"/> without <paramref name="observer"/>, reporting absence so a caller can skip the swap entirely.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="current">The current observer array snapshot.</param>
     /// <param name="observer">The observer to remove.</param>
     /// <param name="empty">The sentinel empty array.</param>
     /// <returns>
-    /// The new array (possibly the empty sentinel), or <see langword="null"/> if the observer
-    /// was not present.
+    /// The shortened array, <paramref name="empty"/> when the removed observer was the last one, or
+    /// <see langword="null"/> when the observer is absent from <paramref name="current"/>.
     /// </returns>
     public static IObserver<T>[]? RemoveOrNull<T>(
         IObserver<T>[] current,
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/ObserverExtensions.cs b/src/ReactiveUI.Primitives.Extensions.Core/ObserverExtensions.cs
index bb905bd3..325e2cfa 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/ObserverExtensions.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/ObserverExtensions.cs
@@ -13,11 +13,9 @@ public static class ObserverExtensions
     extension<T>(IObserver<T> observer)
     {
         /// <summary>
-        /// Emits each element from <paramref name="source"/> to the observer
-        /// via <see cref="IObserver{T}.OnNext(T)"/> using a fast-path iteration for known
-        /// concrete collection types (<see cref="List{T}"/>, arrays, <see cref="IList{T}"/>).
-        /// Avoids the per-iteration enumerator allocation that <c>foreach</c> over a bare
-        /// <see cref="IEnumerable{T}"/> would incur on these common shapes.
+        /// Emits every element of <paramref name="source"/> to the observer in order through
+        /// <see cref="IObserver{T}.OnNext(T)"/>, indexing arrays, <see cref="List{T}"/> and the list interfaces directly
+        /// and enumerating anything else.
         /// </summary>
         /// <param name="source">The source collection to iterate.</param>
         public void FastForEach(IEnumerable<T> source)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
index 50adafc2..15247b6f 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
@@ -7,7 +7,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Fast path for the common two-source min/max case.</summary>
+/// <summary>
+/// Emits the larger or smaller of the latest values from two sources, starting once both have produced one. An error
+/// from either source terminates the sequence; completion waits for both sources, or fires as soon as one completes
+/// without having emitted.
+/// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="left">The first source.</param>
 /// <param name="right">The second source.</param>
@@ -62,7 +66,7 @@ private sealed class Sink(IObserver<T> downstream, bool emitMaximum)
         /// <summary>Whether the sink is terminal.</summary>
         private bool _isDone;
 
-        /// <summary>Handles a source value.</summary>
+        /// <summary>Records one side's latest value and emits the winning comparison once both sides have a value.</summary>
         /// <param name="isLeft"><c>true</c> for the left source.</param>
         /// <param name="value">The value.</param>
         public void OnNext(bool isLeft, T value)
@@ -96,7 +100,7 @@ public void OnNext(bool isLeft, T value)
             }
         }
 
-        /// <summary>Handles a source error.</summary>
+        /// <summary>Forwards the first error downstream and marks the sink terminal.</summary>
         /// <param name="error">The error.</param>
         public void OnError(Exception error)
         {
@@ -112,7 +116,7 @@ public void OnError(Exception error)
             }
         }
 
-        /// <summary>Handles source completion.</summary>
+        /// <summary>Records one side's completion, completing downstream when both sides finish or when this side never emitted.</summary>
         /// <param name="isLeft"><c>true</c> for the left source.</param>
         public void OnCompleted(bool isLeft)
         {
@@ -159,7 +163,7 @@ public void OnCompleted(bool isLeft)
             }
         }
 
-        /// <summary>Completes once.</summary>
+        /// <summary>Marks the sink terminal and completes the downstream observer.</summary>
         private void Complete()
         {
             _isDone = true;
@@ -167,7 +171,7 @@ private void Complete()
         }
     }
 
-    /// <summary>Observer that labels left/right without per-callback closures.</summary>
+    /// <summary>Observer that forwards notifications to the shared sink tagged with the side it came from.</summary>
     /// <param name="sink">The shared sink.</param>
     /// <param name="isLeft"><c>true</c> when observing the left source.</param>
     private sealed class IndexedWitness(Sink sink, bool isLeft) : IObserver<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
index eb36b262..24cd7c7c 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
@@ -9,10 +9,9 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Combines the latest boolean values from multiple sources and emits <c>true</c> iff every latest
-/// value equals <paramref name="target"/>. Backs both <c>AllTrue</c> (target=true) and <c>AllFalse</c>
-/// (target=false) without the array allocations a generic <c>CombineLatest(...).Select(xs =&gt; xs.All(...))</c>
-/// pipeline would incur.
+/// Emits whether every source's latest boolean equals <paramref name="target"/>, re-evaluating on each value once all
+/// sources have produced one. An empty source list emits <c>true</c> and completes on subscribe; any source's error
+/// terminates the sequence, and the sequence completes when every source completes or one completes without emitting.
 /// </summary>
 /// <param name="sources">The source observables.</param>
 /// <param name="target">The value every source must hold for the operator to emit <c>true</c>.</param>
@@ -44,7 +43,7 @@ public IDisposable Subscribe(IObserver<bool> observer)
         return IndexedSubscribeHelper.SubscribeIndexed(_sourceList, sink.OnNext, sink.OnError, sink.OnCompleted);
     }
 
-    /// <summary>Materializes source enumeration once without using LINQ in shipping code.</summary>
+    /// <summary>Copies the sources into an indexable list, enumerating the sequence at most once.</summary>
     /// <param name="sources">The sources to materialize.</param>
     /// <returns>The source list.</returns>
     private static IReadOnlyList<IObservable<bool>> MaterializeSources(IEnumerable<IObservable<bool>> sources)
@@ -94,7 +93,7 @@ private static IReadOnlyList<IObservable<bool>> MaterializeSources(IEnumerable<I
     /// <param name="target">The value every source must hold for emit to be <c>true</c>.</param>
     private sealed class Sink(IObserver<bool> downstream, int count, bool target)
     {
-        /// <summary>Shared gate / value cache / terminal-state plumbing.</summary>
+        /// <summary>The shared gate, per-source value cache and terminal-state bookkeeping.</summary>
         private readonly ReduceSinkState<bool, bool> _state = new(downstream, count);
 
         /// <summary>Reduces the per-source latest values to whether every source holds the target value.</summary>
@@ -111,18 +110,18 @@ private sealed class Sink(IObserver<bool> downstream, int count, bool target)
             return true;
         };
 
-        /// <summary>Handles OnNext from a source.</summary>
+        /// <summary>Records one source's latest value and re-evaluates the combined result.</summary>
         /// <param name="index">Source index.</param>
         /// <param name="value">Emitted value.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(int index, bool value) => _state.HandleNext(index, value, _reduce);
 
-        /// <summary>Handles OnError from any source.</summary>
+        /// <summary>Forwards an error from any source downstream and terminates the sink.</summary>
         /// <param name="error">The error.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnError(Exception error) => _state.HandleError(error);
 
-        /// <summary>Handles OnCompleted from a source.</summary>
+        /// <summary>Records one source's completion and completes downstream when the sequence is finished.</summary>
         /// <param name="index">Source index.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted(int index) => _state.HandleCompleted(index);
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
index 278b0a74..13f90a05 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
@@ -7,7 +7,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Operator that buffers characters until a start and end delimiter are found.</summary>
+/// <summary>
+/// Buffers characters from <paramref name="startsWith"/> through <paramref name="endsWith"/> inclusive and emits each
+/// delimited run as one string, discarding characters outside a run. Completion flushes a run whose end delimiter never
+/// arrived.
+/// </summary>
 /// <param name="source">The source observable of characters.</param>
 /// <param name="startsWith">The starting delimiter.</param>
 /// <param name="endsWith">The ending delimiter.</param>
@@ -33,10 +37,10 @@ private sealed class BufferUntilWitness(
         char startsWith,
         char endsWith) : IObserver<char>
     {
-        /// <summary>The string builder.</summary>
+        /// <summary>Accumulates the characters of the run being buffered.</summary>
         private readonly StringBuilder _sb = new();
 
-        /// <summary>Whether the start delimiter has been found.</summary>
+        /// <summary>Set while a run is open, meaning the start delimiter has arrived and the end delimiter has not.</summary>
         private bool _startFound;
 
         /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
index 137c4edb..f132df7d 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
@@ -6,7 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Catches the configured exception type, emits a fallback built from the exception, and completes. Other exception types propagate downstream.</summary>
+/// <summary>
+/// Catches <typeparamref name="TException"/>, emits a fallback built from it, and completes. Other exception types
+/// propagate unchanged, and an exception thrown by <paramref name="fallbackFactory"/> terminates the sequence in place
+/// of the caught one.
+/// </summary>
 /// <typeparam name="T">Element type.</typeparam>
 /// <typeparam name="TException">Exception type to catch.</typeparam>
 /// <param name="source">Upstream source.</param>
@@ -25,11 +29,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return source.Subscribe(new CatchAndReturnWithFactoryWitness(observer, fallbackFactory));
     }
 
-    /// <summary>
-    /// Forwarding observer that passes <see cref="OnNext"/> / <see cref="OnCompleted"/>
-    /// through and converts a matching <see cref="OnError"/> into an inline emit of the
-    /// factory-produced fallback followed by terminal <see cref="IObserver{T}.OnCompleted"/>.
-    /// </summary>
+    /// <summary>Forwarding observer that turns a matching error into the factory's fallback value followed by completion.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="fallbackFactory">The fallback factory.</param>
     private sealed class CatchAndReturnWithFactoryWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreEmptyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreEmptyObservable.cs
index 05a87fde..a51d1d62 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreEmptyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreEmptyObservable.cs
@@ -37,9 +37,7 @@ private sealed class CatchIgnoreEmptyWitness(IObserver<T> downstream) : IObserve
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "This witness deliberately swaps a terminal error for downstream completion, so OnError and OnCompleted "
-                + "both forward to downstream.OnCompleted by design. They are distinct IObserver<T> channels, not a copy "
-                + "that was meant to differ.")]
+                "Swapping a terminal error for completion makes both observer channels forward to the same downstream call.")]
         public void OnCompleted() => downstream.OnCompleted();
     }
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
index c7b3d9e7..02e171cf 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
@@ -6,7 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Operator that catches exceptions of a specific type and completes.</summary>
+/// <summary>
+/// Catches <typeparamref name="TException"/>, hands it to <paramref name="errorAction"/> and completes. Other exception
+/// types propagate unchanged, and an exception thrown by the action terminates the sequence in place of the caught one.
+/// </summary>
 /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
 /// <typeparam name="TException">The type of the exception to catch.</typeparam>
 /// <param name="source">The source observable sequence.</param>
@@ -30,7 +33,7 @@ public IDisposable Subscribe(IObserver<TSource> observer)
         return _source.Subscribe(new CatchIgnoreWitness(observer, _errorAction));
     }
 
-    /// <summary>Observer that catches specific exceptions.</summary>
+    /// <summary>Forwarding observer that diverts a matching error into the action and completes instead.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="errorAction">The error action.</param>
     private sealed class CatchIgnoreWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchReturnObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchReturnObservable.cs
index 523993b8..5d9282c1 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchReturnObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchReturnObservable.cs
@@ -20,11 +20,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return source.Subscribe(new CatchReturnWitness(observer, fallback));
     }
 
-    /// <summary>
-    /// Forwarding observer that passes <see cref="OnNext"/>/<see cref="OnCompleted"/>
-    /// through and replaces <see cref="OnError"/> with an inline emit of the stored
-    /// fallback followed by terminal <see cref="IObserver{T}.OnCompleted"/>.
-    /// </summary>
+    /// <summary>Forwarding observer that replaces any error with the stored fallback value followed by completion.</summary>
     /// <param name="downstream">The downstream observer receiving the forwarded signals.</param>
     /// <param name="fallback">The fallback value to emit when the source errors.</param>
     private sealed class CatchReturnWitness(IObserver<T> downstream, T fallback) : IObserver<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
index 93d4ba87..95e69f0b 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnDisposeObservable.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Executes an action when the subscription is disposed.</summary>
+/// <summary>Forwards the source and runs an action exactly once when the subscription is disposed, after the upstream subscription is released.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="disposeAction">The action to execute when the subscription is disposed.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnSubscribeObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnSubscribeObservable.cs
index d9384e82..eea92481 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnSubscribeObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DoOnSubscribeObservable.cs
@@ -4,7 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Executes an action at subscription time.</summary>
+/// <summary>Runs an action before subscribing the observer to the source, so an exception from the action propagates out of <c>Subscribe</c>.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="action">The action to execute when subscribed.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
index 8f18f0ee..0a31b029 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
@@ -6,7 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Operator that drops source elements while an asynchronous action is in progress. Replaces the closure-based implementation in ReactiveExtensions.DropIfBusy.</summary>
+/// <summary>
+/// Runs <paramref name="asyncAction"/> for each source value and forwards the value once it finishes, dropping every
+/// value that arrives while an action is in flight. An exception from the action terminates the sequence.
+/// </summary>
 /// <typeparam name = "T">The element type.</typeparam>
 /// <param name = "source">The source observable.</param>
 /// <param name = "asyncAction">The asynchronous action to execute for each forwarded element.</param>
@@ -60,7 +63,7 @@ public void OnCompleted()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose() => Volatile.Write(ref _done, 1);
 
-        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <summary>Starts the action for the value when the sink is idle, and drops the value otherwise.</summary>
         /// <param name = "value">The source value.</param>
         /// <returns>The processing task, or a completed task when no work starts.</returns>
         internal Task OnNextAsync(T value)
@@ -70,13 +73,12 @@ internal Task OnNextAsync(T value)
                 return Task.CompletedTask;
             }
 
-            // If we can transition from 0 to 1, we handle this value.
             return Interlocked.CompareExchange(ref _isBusy, 1, 0) != 0
                 ? Task.CompletedTask
                 : ProcessAsync(value);
         }
 
-        /// <summary>Executes the async action and manages the busy state transition.</summary>
+        /// <summary>Awaits the action, forwards the value unless the sink has terminated, and clears the busy flag.</summary>
         /// <param name = "value">The value to process.</param>
         /// <returns>A task representing the async operation.</returns>
         private async Task ProcessAsync(T value)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
index c6af7913..80bbdab0 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
@@ -7,7 +7,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Filters strings using a regular expression and forwards matching errors to the observer.</summary>
+/// <summary>
+/// Forwards the source strings that <paramref name="regex"/> matches, dropping non-matches and nulls. An exception
+/// raised while matching, such as a regex timeout, terminates the sequence.
+/// </summary>
 /// <param name="source">The source observable emitting strings.</param>
 /// <param name="regex">The regex to use for filtering.</param>
 public sealed class FilterRegexObservable(
@@ -23,7 +26,7 @@ public IDisposable Subscribe(IObserver<string> observer)
         return source.Subscribe(new FilterRegexWitness(observer, regex));
     }
 
-    /// <summary>Observer that filters strings using regex.</summary>
+    /// <summary>Observer that forwards matching strings and turns a failure raised by the match into an error.</summary>
     /// <param name="downstream">The downstream observer receiving strings that match the regex.</param>
     /// <param name="regex">The regex used for filtering.</param>
     private sealed class FilterRegexWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
index 2fd49d88..114dc5f1 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
@@ -6,7 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Emits the latest value from the source sequence or a default value if no value has been emitted.</summary>
+/// <summary>
+/// Emits <paramref name="defaultValue"/> on subscribe, then each source value that differs from the one emitted before
+/// it under <see cref="EqualityComparer{T}.Default"/>.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="defaultValue">The value to emit initially.</param>
@@ -25,7 +28,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return source.Subscribe(sink);
     }
 
-    /// <summary>Sink that implements the latest or default logic.</summary>
+    /// <summary>Observer that seeds the downstream with the default value and suppresses repeats of the last value.</summary>
     /// <param name="downstream">The observer to forward elements to.</param>
     /// <param name="defaultValue">The value to emit initially.</param>
     private sealed class LatestOrDefaultSink(IObserver<T> downstream, T defaultValue) : IObserver<T>
@@ -36,7 +39,7 @@ private sealed class LatestOrDefaultSink(IObserver<T> downstream, T defaultValue
         /// <summary>Whether any value has been emitted yet.</summary>
         private bool _hasEmitted;
 
-        /// <summary>Initializes the sink by emitting the default value.</summary>
+        /// <summary>Emits the seed value downstream, which the caller does before subscribing the source.</summary>
         public void Initialize()
         {
             downstream.OnNext(_last!);
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
index f581d7d2..072f4781 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
@@ -9,10 +9,9 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Combines the latest values from multiple sources and emits either the maximum or minimum on each
-/// tick. Backs both the <c>Max</c> (<paramref name="emitMaximum"/>=true) and <c>Min</c>
-/// (<paramref name="emitMaximum"/>=false) operators without the array allocations a generic
-/// <c>CombineLatest(...).Select(xs =&gt; xs.Max())</c> pipeline would incur.
+/// Emits the maximum or minimum of the latest values from every source, re-evaluating on each value once all sources
+/// have produced one. An empty source list completes on subscribe; any source's error terminates the sequence, and the
+/// sequence completes when every source completes or one completes without emitting.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="sources">The source observables.</param>
@@ -39,13 +38,13 @@ public IDisposable Subscribe(IObserver<T> observer)
         return IndexedSubscribeHelper.SubscribeIndexed(_sourceList, sink.OnNext, sink.OnError, sink.OnCompleted);
     }
 
-    /// <summary>Sink that holds the latest value per source and emits either the max or the min. Composes <see cref="ReduceSinkState{TIn, TOut}"/> for the shared plumbing.</summary>
+    /// <summary>Sink that holds the latest value per source and emits the maximum or the minimum of them.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="count">The number of sources.</param>
     /// <param name="emitMaximum"><c>true</c> for max; <c>false</c> for min.</param>
     private sealed class Sink(IObserver<T> downstream, int count, bool emitMaximum)
     {
-        /// <summary>Shared gate / value cache / terminal-state plumbing.</summary>
+        /// <summary>The shared gate, per-source value cache and terminal-state bookkeeping.</summary>
         private readonly ReduceSinkState<T, T> _state = new(downstream, count);
 
         /// <summary>Reduces the per-source latest values to the maximum or minimum.</summary>
@@ -65,18 +64,18 @@ private sealed class Sink(IObserver<T> downstream, int count, bool emitMaximum)
             return result;
         };
 
-        /// <summary>Handles OnNext from a source.</summary>
+        /// <summary>Records one source's latest value and re-evaluates the emitted extreme.</summary>
         /// <param name="index">Source index.</param>
         /// <param name="value">Emitted value.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnNext(int index, T value) => _state.HandleNext(index, value, _reduce);
 
-        /// <summary>Handles OnError from any source.</summary>
+        /// <summary>Forwards an error from any source downstream and terminates the sink.</summary>
         /// <param name="error">The error.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnError(Exception error) => _state.HandleError(error);
 
-        /// <summary>Handles OnCompleted from a source.</summary>
+        /// <summary>Records one source's completion and completes downstream when the sequence is finished.</summary>
         /// <param name="index">Source index.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted(int index) => _state.HandleCompleted(index);
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/NotObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/NotObservable.cs
index f330df4c..b2230a39 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/NotObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/NotObservable.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Boolean negation operator. Replaces the <c>source.Select(b =&gt; !b)</c>
-/// pattern with a dedicated forwarding observer, avoiding the per-subscription
-/// closure allocation that the projection lambda would otherwise capture.
-/// </summary>
+/// <summary>Emits each source boolean negated, passing errors and completion through unchanged.</summary>
 /// <param name="source">The boolean source observable.</param>
 public sealed class NotObservable(IObservable<bool> source) : IObservable<bool>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PairwiseObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PairwiseObservable.cs
index 503641f5..8677c29b 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PairwiseObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PairwiseObservable.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Emits (previous, current) pairs from a sequence.</summary>
+/// <summary>Emits each adjacent pair of source values as <c>(Previous, Current)</c>, so the first value produces nothing on its own.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 public sealed class PairwiseObservable<T>(IObservable<T> source) : IObservable<(T Previous, T Current)>
@@ -20,7 +20,7 @@ public IDisposable Subscribe(IObserver<(T Previous, T Current)> observer)
         return source.Subscribe(new PairwiseWitness(observer));
     }
 
-    /// <summary>The observer for the pairwise operator.</summary>
+    /// <summary>Observer that holds the last value under a gate and pairs it with the next one.</summary>
     /// <param name="downstream">The downstream observer.</param>
     private sealed class PairwiseWitness(IObserver<(T Previous, T Current)> downstream) : IObserver<T>
     {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
index d5570e6c..6efebca2 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
@@ -8,7 +8,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Partitions a sequence into two observables based on a predicate.</summary>
+/// <summary>
+/// Splits a sequence into a <see cref="True"/> and a <see cref="False"/> side by predicate. Both sides share one
+/// subscription to the source, opened when the first side is subscribed and released when the last subscription is
+/// disposed; each value reaches one side only, while an error or completion reaches both.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 [System.Diagnostics.DebuggerDisplay("PartitionObservable: Source = {_source}, Subscriptions = {_subscriptionCount}")]
 public sealed class PartitionObservable<T>
@@ -25,10 +29,10 @@ public sealed class PartitionObservable<T>
     /// <summary>The source subscription.</summary>
     private IDisposable? _sourceSubscription;
 
-    /// <summary>The observer for the source.</summary>
+    /// <summary>The shared source observer, live only while at least one side is subscribed.</summary>
     private PartitionSink? _sink;
 
-    /// <summary>The number of subscriptions.</summary>
+    /// <summary>The number of live subscriptions across both sides.</summary>
     private int _subscriptionCount;
 
     /// <summary>Initializes a new instance of the <see cref="PartitionObservable{T}"/> class.</summary>
@@ -107,8 +111,7 @@ public void Dispose()
                 _parent._subscriptionCount--;
                 if (_parent._subscriptionCount == 0)
                 {
-                    // Subscribe set _sourceSubscription alongside _sink under the same lock,
-                    // so when the last branch disposes here it is non-null by construction.
+                    // Set alongside the sink under this same lock, so the last disposal finds it non-null.
                     _parent._sourceSubscription!.Dispose();
                     _parent._sourceSubscription = null;
                     _parent._sink = null;
@@ -127,7 +130,7 @@ private sealed class PartitionSide(PartitionObservable<T> parent, bool side) : I
         public IDisposable Subscribe(IObserver<T> observer) => parent.Subscribe(observer, side);
     }
 
-    /// <summary>Sink that partitions elements.</summary>
+    /// <summary>Observer that fans each value to the observers on the matching side.</summary>
     /// <param name="parent">The parent observable.</param>
     private sealed class PartitionSink(PartitionObservable<T> parent) : IObserver<T>
     {
@@ -137,7 +140,7 @@ private sealed class PartitionSink(PartitionObservable<T> parent) : IObserver<T>
         /// <summary>The observers for the false side.</summary>
         private IObserver<T>[] _falseObservers = [];
 
-        /// <summary>Adds an observer to the specified side.</summary>
+        /// <summary>Adds an observer to one side's array; callers hold the parent gate.</summary>
         /// <param name="observer">The observer to add.</param>
         /// <param name="side">The side.</param>
         public void Add(IObserver<T> observer, bool side)
@@ -152,7 +155,7 @@ public void Add(IObserver<T> observer, bool side)
             }
         }
 
-        /// <summary>Removes an observer from the specified side.</summary>
+        /// <summary>Removes an observer from one side's array; callers hold the parent gate.</summary>
         /// <param name="observer">The observer to remove.</param>
         /// <param name="side">The side.</param>
         public void Remove(IObserver<T> observer, bool side)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
index 7db5bebc..2aaf0a98 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PropertyChangedObservable.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <typeparam name="TProperty">The property element type.</typeparam>
 /// <param name="source">The owning instance.</param>
 /// <param name="propertyName">The property name to filter by.</param>
-/// <param name="getter">The compiled property getter (compiled once at construction).</param>
+/// <param name="getter">Reads the property value from the owning instance.</param>
 public sealed class PropertyChangedObservable<T, TProperty>(
     T source,
     string propertyName,
@@ -33,11 +33,7 @@ public IDisposable Subscribe(IObserver<TProperty> observer)
         return sink;
     }
 
-    /// <summary>
-    /// Sink that holds the bound <see cref="PropertyChangedEventHandler"/> and detaches
-    /// it on dispose. Filters by property name inline and pulls the value through the
-    /// pre-compiled getter.
-    /// </summary>
+    /// <summary>Sink that owns the bound <see cref="PropertyChangedEventHandler"/>, filters it by property name, and detaches it on dispose.</summary>
     private sealed class PropertyChangedSink : IDisposable
     {
         /// <summary>The downstream observer receiving filtered property values.</summary>
@@ -49,17 +45,17 @@ private sealed class PropertyChangedSink : IDisposable
         /// <summary>The property name to filter on.</summary>
         private readonly string _propertyName;
 
-        /// <summary>The pre-compiled property getter.</summary>
+        /// <summary>Reads the property value from the owning instance.</summary>
         private readonly Func<T, TProperty> _getter;
 
-        /// <summary>Disposed flag (0 = active, 1 = disposed). Updated lock-free.</summary>
+        /// <summary>Disposal latch: 0 while the handler is attached, 1 once detached.</summary>
         private int _disposed;
 
         /// <summary>Initializes a new instance of the <see cref="PropertyChangedSink"/> class.</summary>
         /// <param name="downstream">The downstream observer.</param>
         /// <param name="source">The owning instance.</param>
         /// <param name="propertyName">The property name to filter on.</param>
-        /// <param name="getter">The pre-compiled property getter.</param>
+        /// <param name="getter">Reads the property value from the owning instance.</param>
         public PropertyChangedSink(
             IObserver<TProperty> downstream,
             T source,
@@ -87,7 +83,7 @@ public void Dispose()
             _source.PropertyChanged -= Handler;
         }
 
-        /// <summary>Bound <see cref="INotifyPropertyChanged.PropertyChanged"/> handler — filters by property name then forwards the pre-compiled getter result downstream.</summary>
+        /// <summary>Forwards a freshly read value for the watched property, turning a getter failure into an error that also detaches the handler.</summary>
         /// <param name="sender">Event sender (unused).</param>
         /// <param name="e">Event payload carrying the changed property name.</param>
         private void OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/RetryForeverObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/RetryForeverObservable.cs
index 96f2739b..a34c94e3 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/RetryForeverObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/RetryForeverObservable.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Re-subscribes to the source indefinitely on error. Forwards values verbatim and completes when
-/// the source completes. Per-subscription state is held in a single sink; resubscription swaps the
-/// inner disposable rather than allocating a new wrapper chain.
-/// </summary>
+/// <summary>Re-subscribes to the source indefinitely whenever it errors, discarding the error; values pass through and the source's completion ends the sequence.</summary>
 /// <typeparam name="T">Element type.</typeparam>
 /// <param name="source">Upstream source.</param>
 public sealed class RetryForeverObservable<T>(IObservable<T> source) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
index def0c048..27dcfb83 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
@@ -7,7 +7,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Samples the latest value from the source observable whenever a trigger observable emits.</summary>
+/// <summary>
+/// Emits the source's latest value each time <paramref name="trigger"/> fires, repeating it when no newer value has
+/// arrived and emitting nothing until the source produces its first. An error from either sequence terminates the
+/// result; the source's completion completes it, while the trigger's completion is ignored.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="trigger">The trigger observable.</param>
@@ -28,7 +32,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return new DisposableBag(sourceSub, triggerSub, sink);
     }
 
-    /// <summary>Sinks the source observable and samples it based on the trigger.</summary>
+    /// <summary>Holds the latest source value and the terminal state shared by the source and trigger observers.</summary>
     /// <param name="downstream">The downstream observer.</param>
     private sealed class SampleLatestSink(IObserver<T> downstream) : IDisposable
     {
@@ -44,10 +48,10 @@ private sealed class SampleLatestSink(IObserver<T> downstream) : IDisposable
         /// <summary>Whether the sequence is done.</summary>
         private bool _done;
 
-        /// <summary>Gets the source observer.</summary>
+        /// <summary>Gets a new observer that records source values into this sink.</summary>
         public IObserver<T> SourceWitness => new SourceSampleWitness(this);
 
-        /// <summary>Gets the trigger observer.</summary>
+        /// <summary>Gets a new observer that samples this sink on each trigger notification.</summary>
         public IObserver<object> TriggerObserver => new TriggerSampleWitness(this);
 
         /// <inheritdoc/>
@@ -86,7 +90,7 @@ private void OnAnyError(Exception error)
             }
         }
 
-        /// <summary>Forwards source completion.</summary>
+        /// <summary>Completes the downstream observer once, ignoring later notifications.</summary>
         private void OnSourceCompleted()
         {
             lock (_gate)
@@ -120,7 +124,7 @@ private void OnTriggerNext()
             downstream.OnNext(value!);
         }
 
-        /// <summary>Observer for source values.</summary>
+        /// <summary>Observer that stores each source value in the sink.</summary>
         /// <param name="sink">The owning sink.</param>
         private sealed class SourceSampleWitness(SampleLatestSink sink) : IObserver<T>
         {
@@ -137,7 +141,7 @@ private sealed class SourceSampleWitness(SampleLatestSink sink) : IObserver<T>
             public void OnCompleted() => sink.OnSourceCompleted();
         }
 
-        /// <summary>Observer for trigger values.</summary>
+        /// <summary>Observer that asks the sink to emit its latest value on each trigger notification.</summary>
         /// <param name="sink">The owning sink.</param>
         private sealed class TriggerSampleWitness(SampleLatestSink sink) : IObserver<object>
         {
@@ -152,7 +156,7 @@ private sealed class TriggerSampleWitness(SampleLatestSink sink) : IObserver<obj
             /// <inheritdoc/>
             public void OnCompleted()
             {
-                /* Trigger completion does not affect sample */
+                // A completed trigger leaves the sampled sequence running.
             }
         }
     }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
index 8bd966cc..ed7f452b 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
@@ -6,7 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>Scans the source sequence and emits the initial value immediately upon subscription.</summary>
+/// <summary>
+/// Emits <paramref name="initial"/> on subscribe, then the running accumulation after each source element. An exception
+/// thrown by <paramref name="accumulator"/> terminates the sequence and the accumulation stops there.
+/// </summary>
 /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name="TAccumulate">The type of the accumulated value.</typeparam>
 /// <param name="source">The source observable.</param>
@@ -29,7 +32,7 @@ public IDisposable Subscribe(IObserver<TAccumulate> observer)
         return source.Subscribe(sink);
     }
 
-    /// <summary>Sink that implements the scan with initial logic.</summary>
+    /// <summary>Observer that keeps the running accumulation under a gate and emits it after each element.</summary>
     /// <param name="downstream">The observer to forward elements to.</param>
     /// <param name="initial">The initial accumulated value.</param>
     /// <param name="accumulator">The accumulator function.</param>
@@ -47,7 +50,7 @@ private sealed class ScanWithInitialSink(
         /// <summary>Whether the sink has finished.</summary>
         private bool _done;
 
-        /// <summary>Initializes the sink by emitting the initial value.</summary>
+        /// <summary>Emits the seed accumulation downstream, which the caller does before subscribing the source.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Initialize() => downstream.OnNext(_current);
 
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
index ed6d5d89..2e87fd00 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
@@ -5,7 +5,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Projects each element to an asynchronous operation with limited concurrency.</summary>
+/// <summary>
+/// Projects each element through an asynchronous selector with at most <paramref name="maxConcurrency"/> operations in
+/// flight and queues the rest, so results arrive in completion order rather than source order. The first selector
+/// failure terminates the sequence, and the source's completion is held back until the queue drains.
+/// </summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
@@ -91,7 +95,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <summary>Queues the value and starts as many operations as the concurrency limit allows.</summary>
         /// <param name = "value">The source value.</param>
         /// <returns>The processing task, or a completed task when no work starts.</returns>
         internal Task OnNextAsync(TSource value)
@@ -126,7 +130,7 @@ private Task TryProcessNext()
             return processing;
         }
 
-        /// <summary>Processes the async operation.</summary>
+        /// <summary>Awaits the selector, emits its result, then starts queued work or completes the sequence.</summary>
         /// <param name = "value">The value to project.</param>
         /// <returns>A task representing the operation.</returns>
         private async Task ProcessAsync(TSource value)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
index dbe6a704..cee3b71a 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
@@ -5,7 +5,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Projects each element to an asynchronous operation, preserving order and handling sequential execution.</summary>
+/// <summary>
+/// Projects each element through an asynchronous selector one operation at a time, queueing values that arrive while an
+/// operation runs so results keep source order. The first selector failure terminates the sequence, and the source's
+/// completion waits for the queue to drain.
+/// </summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
@@ -89,7 +93,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <summary>Queues the value and starts the drain loop when no operation is running.</summary>
         /// <param name = "value">The source value.</param>
         /// <returns>The processing task, or a completed task when no work starts.</returns>
         internal Task OnNextAsync(TSource value)
@@ -113,7 +117,7 @@ internal Task OnNextAsync(TSource value)
             return processing;
         }
 
-        /// <summary>Processes the next value in the queue.</summary>
+        /// <summary>Projects queued values one at a time, completing the sequence when the queue empties after the source finishes.</summary>
         /// <returns>A task representing the operation.</returns>
         private async Task ProcessNextAsync()
         {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
index 13e4b11d..47ad790a 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projection operator that ignores every source element and emits a stored constant
-/// instead. Replaces the common <c>.Select(_ =&gt; value)</c> pattern, avoiding the
-/// per-subscription closure allocation that the lambda <c>_ =&gt; value</c> would
-/// capture.
-/// </summary>
+/// <summary>Emits <paramref name="constant"/> once per source element, ignoring the element itself; errors and completion pass through unchanged.</summary>
 /// <typeparam name="TSource">The source element type (ignored).</typeparam>
 /// <typeparam name="TResult">The result element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source observable whose values are ignored.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
index 3b43bb5c..219328db 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
@@ -5,7 +5,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Projects each element to an asynchronous operation, but only the result of the latest operation is emitted.</summary>
+/// <summary>
+/// Projects each element through an asynchronous selector and emits only the latest projection's result. A superseded
+/// operation keeps running but its result and its failure are both discarded, and the source's completion is deferred
+/// until the latest projection finishes.
+/// </summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
@@ -31,7 +35,7 @@ internal sealed class SelectLatestAsyncSink(IObserver<TResult> downstream, Func<
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>The current operation ID to track latest.</summary>
+        /// <summary>Identifier of the most recent projection; a result carrying an older identifier is dropped.</summary>
         private long _currentId;
 
         /// <summary>Whether the source has completed (no more values will arrive).</summary>
@@ -40,7 +44,7 @@ internal sealed class SelectLatestAsyncSink(IObserver<TResult> downstream, Func<
         /// <summary>Whether downstream completion has been signalled.</summary>
         private bool _completionSignalled;
 
-        /// <summary>The latest in-flight projection task, used to delay completion until it finishes.</summary>
+        /// <summary>The latest in-flight projection task, whose completion gates the downstream completion.</summary>
         private Task? _latestTask;
 
         /// <summary>Whether the sink has been disposed.</summary>
@@ -99,7 +103,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Processes a value and returns its active operation.</summary>
+        /// <summary>Starts a projection for the value and records it as the latest, superseding any in-flight one.</summary>
         /// <param name = "value">The source value.</param>
         /// <returns>The processing task, or a completed task when no work starts.</returns>
         internal Task OnNextAsync(TSource value)
@@ -139,7 +143,7 @@ internal void SignalCompleted()
             }
         }
 
-        /// <summary>Processes the async operation and checks for latest ID.</summary>
+        /// <summary>Awaits the selector and emits or faults only while this operation is the latest one.</summary>
         /// <param name = "value">The value to project.</param>
         /// <param name = "id">The ID of this operation.</param>
         /// <returns>A task representing the operation.</returns>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
index 98f0b109..222b2a3e 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
@@ -6,7 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Chains two one-shot observable projections and forwards errors from either stage.</summary>
+/// <summary>
+/// Projects each source element through <paramref name="first"/> and each intermediate element through
+/// <paramref name="second"/>, emitting the second stage's values. An exception from either projection terminates the
+/// sequence, and the first inner sequence to complete completes the result.
+/// </summary>
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TMid">The intermediate element type produced by the first projection.</typeparam>
 /// <typeparam name="TResult">The final element type produced by the second projection.</typeparam>
@@ -28,7 +32,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return source.Subscribe(new SourceWitness(observer, first, second));
     }
 
-    /// <summary>Subscribes the reusable intermediate observer to the first projection.</summary>
+    /// <summary>Observer that runs the first projection per source element and feeds its sequence to the shared intermediate observer.</summary>
     private sealed class SourceWitness : IObserver<TSource>
     {
         /// <summary>The downstream observer that ultimately receives <typeparamref name="TResult"/> values.</summary>
@@ -37,10 +41,10 @@ private sealed class SourceWitness : IObserver<TSource>
         /// <summary>First projection delegate.</summary>
         private readonly Func<TSource, IObservable<TMid>> _first;
 
-        /// <summary>Pre-allocated intermediate observer shared across every source emission.</summary>
+        /// <summary>Intermediate observer shared across every source emission.</summary>
         private readonly MidWitness _midObserver;
 
-        /// <summary>Initializes a new instance of the <see cref="SourceWitness"/> class and primes the reusable mid observer.</summary>
+        /// <summary>Initializes a new instance of the <see cref="SourceWitness"/> class.</summary>
         /// <param name="downstream">The downstream observer.</param>
         /// <param name="first">First projection delegate.</param>
         /// <param name="second">Second projection delegate.</param>
@@ -76,7 +80,7 @@ public void OnNext(TSource value)
         public void OnCompleted() => _downstream.OnCompleted();
     }
 
-    /// <summary>Receives the intermediate value, applies <c>second</c>, and subscribes the resulting observable directly to <c>downstream</c> — no separate final-stage observer needed.</summary>
+    /// <summary>Observer that runs the second projection and subscribes its sequence straight to the downstream observer.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="second">Second projection delegate.</param>
     private sealed class MidWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
index fa3186ce..bb74a950 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
@@ -7,7 +7,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Shuffles arrays in place using non-cryptographic randomness.</summary>
+/// <summary>
+/// Reorders each array the source emits in place with non-cryptographic randomness and forwards that same instance, so
+/// any other holder of the array sees the new order. A null array is forwarded untouched.
+/// </summary>
 /// <typeparam name="T">The array element type.</typeparam>
 /// <param name="source">The source observable emitting arrays.</param>
 public sealed class ShuffleObservable<T>(IObservable<T[]> source) : IObservable<T[]>
@@ -20,7 +23,7 @@ public IDisposable Subscribe(IObserver<T[]> observer)
         return source.Subscribe(new ShuffleWitness(observer));
     }
 
-    /// <summary>Randomizes buffered values for non-security use.</summary>
+    /// <summary>Observer that reorders each array in place before forwarding it.</summary>
     /// <param name="downstream">The downstream observer receiving shuffled arrays.</param>
     [SuppressMessage(
         "Security",
@@ -67,7 +70,6 @@ public void OnNext(T[] value)
         /// <param name="array">The array to shuffle in place.</param>
         private static void ShuffleInPlace(T[] array)
         {
-            // This shuffle requires no cryptographic randomness.
             var random = _threadRandom;
             if (random is null)
             {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
index c71ffcfa..274c33dc 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SkipWhileNullObservable.cs
@@ -21,10 +21,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return source.Subscribe(new SkipWhileNullWitness(observer));
     }
 
-    /// <summary>
-    /// Forwarding observer that swallows leading <see langword="null"/> values until the first
-    /// non-null value, then becomes a transparent forwarder for the remainder of the sequence.
-    /// </summary>
+    /// <summary>Forwarding observer that drops leading nulls and forwards everything from the first non-null value onward.</summary>
     /// <param name="downstream">The downstream observer.</param>
     private sealed class SkipWhileNullWitness(IObserver<T> downstream) : IObserver<T>
     {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
index afaa9203..b4d9a622 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
@@ -6,7 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Subscribes to an observable sequence and executes an asynchronous handler for each element.</summary>
+/// <summary>
+/// Subscribes to a source and runs an asynchronous handler for each element, one at a time, queueing values that arrive
+/// while a handler runs. A handler failure goes to the error callback and stops further processing; the completion
+/// callback runs once the queue drains after the source completes, and disposal drops the subscription and the queue.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 [System.Diagnostics.DebuggerDisplay("SubscribeAsyncObservable: Queued = {_queue.Count}, Processing = {_isProcessing}, Done = {_done}")]
 public sealed class SubscribeAsyncObservable<T> : IDisposable
@@ -94,7 +98,7 @@ internal Task OnNextAsync(T value)
     [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     private void OnNext(T value) => _ = OnNextAsync(value);
 
-    /// <summary>Called when an error occurs in the source.</summary>
+    /// <summary>Routes a source error to the error callback and stops processing the queue.</summary>
     /// <param name="error">The error that occurred.</param>
     private void OnError(Exception error)
     {
@@ -110,7 +114,7 @@ private void OnError(Exception error)
         }
     }
 
-    /// <summary>Called when the source completes.</summary>
+    /// <summary>Marks the source finished and runs the completion callback when no handler is in flight.</summary>
     private void OnCompleted()
     {
         lock (_gate)
@@ -128,7 +132,7 @@ private void OnCompleted()
         }
     }
 
-    /// <summary>Processes the next value in the queue.</summary>
+    /// <summary>Runs the handler for queued values in turn, invoking the completion callback when the queue empties after the source finishes.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     private async Task ProcessNextAsync()
     {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
index 1f3ab5c7..d5924f09 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
@@ -6,7 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Provides a fallback observable if the source sequence completes without emitting any elements.</summary>
+/// <summary>
+/// Forwards the source's values, and when the source completes without having emitted any, subscribes
+/// <paramref name="fallback"/> and forwards that sequence instead. A source error propagates without the fallback being
+/// tried.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="fallback">The fallback observable.</param>
@@ -27,7 +31,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return sink;
     }
 
-    /// <summary>The sink for the <see cref="SwitchIfEmptyObservable{T}"/>.</summary>
+    /// <summary>Observer that tracks whether the source emitted and swaps in the fallback subscription when it did not.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="fallback">The fallback observable.</param>
     private sealed class SwitchIfEmptySink(
@@ -37,7 +41,7 @@ private sealed class SwitchIfEmptySink(
         /// <summary>The gate for state access.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>The current subscription.</summary>
+        /// <summary>The active subscription, replaced by the fallback's when the source turns out empty.</summary>
         private readonly MutableDisposable _subscription = new();
 
         /// <summary>Whether the source has emitted a value.</summary>
@@ -46,7 +50,7 @@ private sealed class SwitchIfEmptySink(
         /// <summary>Whether the sink has completed or been disposed.</summary>
         private bool _done;
 
-        /// <summary>Sets the subscription to the source observable.</summary>
+        /// <summary>Stores the source subscription so the fallback subscription can take its place.</summary>
         /// <param name="sub">The subscription.</param>
         public void SetSubscription(IDisposable sub) => _subscription.Disposable = sub;
 
@@ -98,7 +102,6 @@ public void OnCompleted()
                 }
                 else
                 {
-                    // Source was empty, switch to fallback
                     _subscription.Disposable = fallback.Subscribe(downstream);
                 }
             }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
index c26fdc65..eecb42ab 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
@@ -6,7 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Wraps elements in a synchronization context that waits for a disposal signal before proceeding to the next element.</summary>
+/// <summary>
+/// Forwards each source value paired with a fresh disposable handle the consumer disposes to acknowledge it. Each value
+/// carries its own handle, and a handle left undisposed leaves only its own acknowledgement wait outstanding.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 public sealed class SynchronizeAsyncObservable<T>(IObservable<T> source) : IObservable<(T Value, IDisposable Sync)>
@@ -22,7 +25,7 @@ public IDisposable Subscribe(IObserver<(T Value, IDisposable Sync)> observer)
         return new DisposableBag(sub, sink);
     }
 
-    /// <summary>The sink for the <see cref="SynchronizeAsyncObservable{T}"/>.</summary>
+    /// <summary>Observer that pairs each value with a new acknowledgement handle and forwards the pair downstream.</summary>
     /// <param name="downstream">The downstream observer.</param>
     internal sealed class SynchronizeAsyncSink(IObserver<(T Value, IDisposable Sync)> downstream) : IObserver<T>, IDisposable
     {
@@ -89,7 +92,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Delivers the value and waits for the consumer to dispose its acknowledgement signal.</summary>
+        /// <summary>Delivers the value with a fresh acknowledgement signal and returns the task that the signal's disposal completes.</summary>
         /// <param name="value">The value to process.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         private Task ProcessAsync(T value)
@@ -99,10 +102,10 @@ private Task ProcessAsync(T value)
             return signal.WaitForDisposeAsync();
         }
 
-        /// <summary>Releases one emission when the consumer disposes it, allocating completion state only for an asynchronous wait.</summary>
+        /// <summary>Acknowledgement handle for one emission whose disposal completes that emission's wait task.</summary>
         internal sealed class SyncSignal : IDisposable
         {
-            /// <summary>The lazily-created completion source; only allocated on the slow path.</summary>
+            /// <summary>The completion source, created only when the wait cannot finish synchronously.</summary>
             private TaskCompletionSource<bool>? _tcs;
 
             /// <summary>Latches to <c>1</c> on the first dispose so signalling is idempotent.</summary>
@@ -120,7 +123,7 @@ public void Dispose()
             }
 
             /// <summary>Returns the disposal task; the producer must call this exactly once per emission.</summary>
-            /// <returns>A completed task if the consumer already disposed; otherwise the lazily-allocated TCS task.</returns>
+            /// <returns>A completed task when the handle has been disposed; otherwise the task that its disposal completes.</returns>
             internal Task WaitForDisposeAsync()
             {
                 if (Volatile.Read(ref _disposed) == 1)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
index 01201e07..86cd9e05 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
@@ -4,7 +4,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>Takes elements from the source sequence until a predicate returns true for an element. The element that satisfies the predicate is included in the sequence.</summary>
+/// <summary>
+/// Forwards source elements until <paramref name="predicate"/> returns <see langword="true"/>, emits that element too,
+/// then completes. An exception from the predicate terminates the sequence before that element is emitted.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="predicate">The predicate to determine when to stop taking elements.</param>
@@ -22,7 +25,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         return source.Subscribe(new TakeUntilInclusiveWitness(observer, predicate));
     }
 
-    /// <summary>The observer for the <see cref="TakeUntilInclusiveObservable{T}"/>.</summary>
+    /// <summary>Observer that completes the sequence right after forwarding the first element the predicate accepts.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="predicate">The predicate to determine when to stop taking elements.</param>
     private sealed class TakeUntilInclusiveWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
index 4f72e53b..fa5c7138 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Fused <c>.Select(selector).Where(x =&gt; x is not null).Select(x =&gt; x!)</c> operator
-/// that applies a transform and emits only non-null results. Replaces the 3-operator
-/// null-filtering chain with a single operator + observer allocation.
-/// </summary>
+/// <summary>Applies <paramref name="selector"/> to each source element and emits only the non-null results; an exception from the selector terminates the sequence.</summary>
 /// <typeparam name="TIn">The source element type.</typeparam>
 /// <typeparam name="TOut">The projected element type.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
index 1c812559..66c49651 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
@@ -7,11 +7,9 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Fused <c>Where(predicate).Take(1)</c>. Subscribes a single observer to the source,
-/// emits the first value satisfying <paramref name="predicate"/> followed by
-/// <see cref="IObserver{T}.OnCompleted"/>, then disposes the source subscription —
-/// avoiding the two intermediate observer wrappers that the equivalent Rx chain would
-/// allocate per subscription.
+/// Emits the first source value that satisfies <paramref name="predicate"/>, completes, and disposes the source
+/// subscription. An exception from the predicate terminates the sequence, and the source completing first ends the
+/// sequence without a value.
 /// </summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereFalseObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereFalseObservable.cs
index 10997edd..57bbb0b9 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereFalseObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereFalseObservable.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Filtering operator that forwards only <c>false</c> values from a boolean source.
-/// Replaces the <c>source.Where(b =&gt; !b)</c> pattern with a dedicated forwarding
-/// observer, avoiding the per-subscription closure allocation that the predicate
-/// lambda would otherwise capture.
-/// </summary>
+/// <summary>Forwards only the <c>false</c> values of a boolean source, passing errors and completion through unchanged.</summary>
 /// <param name="source">The boolean source observable.</param>
 public sealed class WhereFalseObservable(IObservable<bool> source) : IObservable<bool>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereIsNotNullObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereIsNotNullObservable.cs
index d99fb441..b5df59c7 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereIsNotNullObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereIsNotNullObservable.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Filtering operator that forwards only the non-null values of the source
-/// sequence. Replaces the <c>source.Where(x =&gt; x is not null)</c> pattern,
-/// avoiding the per-subscription closure allocation that the predicate lambda
-/// would otherwise capture.
-/// </summary>
+/// <summary>Forwards only the non-null values of the source sequence, passing errors and completion through unchanged.</summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable whose null values are filtered out.</param>
 public sealed class WhereIsNotNullObservable<T>(IObservable<T> source) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
index 942d9850..36e48a61 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
@@ -7,10 +7,8 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Fused <c>Where(predicate).Select(selector)</c> operator. Replaces the two-operator
-/// Rx chain with a single observable + observer pair, saving the intermediate
-/// <c>Select</c> operator allocation (and its <see cref="IObserver{T}"/>) per
-/// subscription on hot paths.
+/// Emits <paramref name="selector"/> applied to each source element that <paramref name="predicate"/> accepts. An
+/// exception from either delegate terminates the sequence.
 /// </summary>
 /// <typeparam name="TIn">The source element type.</typeparam>
 /// <typeparam name="TOut">The projected element type after applying the selector.</typeparam>
@@ -32,11 +30,7 @@ public IDisposable Subscribe(IObserver<TOut> observer)
         return source.Subscribe(new WhereSelectWitness(observer, predicate, selector));
     }
 
-    /// <summary>
-    /// Forwarding observer that applies the predicate and selector inline on each
-    /// <see cref="OnNext"/>. Any exception thrown by either delegate is routed to
-    /// <see cref="IObserver{T}.OnError"/> on the downstream observer.
-    /// </summary>
+    /// <summary>Forwarding observer that applies the predicate then the selector, routing an exception from either to the downstream error channel.</summary>
     /// <param name="downstream">The downstream observer receiving projected values.</param>
     /// <param name="predicate">Filter delegate.</param>
     /// <param name="selector">Projection delegate.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereTrueObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereTrueObservable.cs
index 030968c1..17b9fec9 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereTrueObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereTrueObservable.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Filtering operator that forwards only <c>true</c> values from a boolean source.
-/// Replaces the <c>source.Where(b =&gt; b)</c> pattern with a dedicated forwarding
-/// observer, avoiding the per-subscription closure allocation that the predicate
-/// lambda would otherwise capture.
-/// </summary>
+/// <summary>Forwards only the <c>true</c> values of a boolean source, passing errors and completion through unchanged.</summary>
 /// <param name="source">The boolean source observable.</param>
 public sealed class WhereTrueObservable(IObservable<bool> source) : IObservable<bool>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/SingleValueSignal.cs b/src/ReactiveUI.Primitives.Extensions.Core/SingleValueSignal.cs
index 53d5cf07..828fb097 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/SingleValueSignal.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/SingleValueSignal.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Synchronously emits a single cached value to each subscriber and completes. Drop-in for
-/// the Rx <c>Observable.Return</c> pattern when sharing the observable instance across calls.
-/// </summary>
+/// <summary>Emits one cached value to each subscriber and completes, both inside <c>Subscribe</c>; the Rx spelling is <c>Observable.Return</c>.</summary>
 /// <typeparam name="T">The element type.</typeparam>
 /// <param name="value">The value emitted to every subscriber.</param>
 public sealed class SingleValueSignal<T>(T value) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs b/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
index f12bd06c..4563c921 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
@@ -5,10 +5,9 @@
 namespace ReactiveUI.Primitives.Extensions;
 
 /// <summary>
-/// Represents either a staleness indicator or a value update from an observable stream. Value-type shape;
-/// the stale-detection operator emits these directly so per-emission allocations are zero. Note that
-/// <c>default(Stale&lt;T&gt;)</c> represents a value update with the default <typeparamref name="T"/>; use
-/// <c>new Stale&lt;T&gt;()</c> to construct a staleness signal.
+/// Carries either a staleness signal or a value update from an observable sequence. <c>default(Stale&lt;T&gt;)</c> is a
+/// value update holding the default <typeparamref name="T"/>; construct a staleness signal with
+/// <c>new Stale&lt;T&gt;()</c>, and read <see cref="Update"/> only when <see cref="IsStale"/> is <see langword="false"/>.
 /// </summary>
 /// <typeparam name="T">The type of the update value.</typeparam>
 [System.Diagnostics.DebuggerDisplay("Stale: IsStale = {IsStale}")]
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
index e6c368f1..ec8bf461 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
@@ -13,19 +13,15 @@ namespace ReactiveUI.Primitives.Extensions;
     "Design",
     "SST2315:A type that owns a disposable should be disposable",
     Justification =
-        "The timer's lifetime is owned by the parent operator sink, which releases it under its own gate through "
-        + "HandleErrorLocked/HandleCompletedLocked/HandleDisposeLocked. This state object is deliberately not independently "
-        + "IDisposable: adding IDisposable would expose an ungated disposal path that races the sink's gate.")]
+        "The parent operator sink owns the timer's lifetime and releases it under its own gate, so an independent "
+        + "disposal path on this state object would race that gate.")]
 [System.Diagnostics.DebuggerDisplay("TimerSinkState: Done = {Done}, Timer = {Timer}")]
 public sealed class TimerSinkState<T>(IObserver<T> downstream)
 {
     /// <summary>Gets the timer slot used by the operator's OnNext logic to schedule deferred emissions.</summary>
     public SwapDisposable Timer { get; } = new();
 
-    /// <summary>
-    /// Gets a value indicating whether the sink has reached a terminal state (OnError, OnCompleted,
-    /// or Dispose). Read inside the owning sink's gate by callers that need to short-circuit a deferred operation.
-    /// </summary>
+    /// <summary>Gets a value indicating whether the sink has terminated through error, completion or disposal; read it under the owning sink's gate.</summary>
     public bool Done { get; private set; }
 
     /// <summary>Forwards a terminal error to the downstream observer and tears the sink down. The caller must hold the sink's gate.</summary>
diff --git a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
index ce3d54a4..182a0c42 100644
--- a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
@@ -9,6 +9,9 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>MAUI dispatcher sequencer that coalesces scheduled work through an <see cref="IDispatcher"/>.</summary>
+/// <remarks>Work runs on the dispatcher's thread, one batch per posted drain; scheduling from that thread queues the
+/// item for the next drain rather than running it inline. Delayed work goes to the dispatcher's own delayed dispatch,
+/// which cannot be called off once armed, so a cancelled item is skipped when the delay elapses.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class MauiDispatcherSequencer : ISequencer
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
index f995af85..77aa8837 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
@@ -71,7 +71,7 @@ private static void AppendSanitized(PooledStringBuilder builder, string identity
         var start = 0;
         var end = identity.Length;
 
-        // Leading and trailing punctuation would sanitize to uninformative underscores; the hash still separates
+        // Leading and trailing punctuation would sanitize to uninformative underscores; the hash separates
         // identities that differ only there.
         while (start < end && !char.IsLetterOrDigit(identity[start]))
         {
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
index 7e25fc67..6f269ca7 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
@@ -237,7 +237,7 @@ private static void ReturnBuffer(char[] buffer)
         _pooledCount++;
     }
 
-    /// <summary>Grows the buffer when the requested length no longer fits.</summary>
+    /// <summary>Grows the buffer when the requested length exceeds its capacity.</summary>
     /// <param name="required">The total capacity required.</param>
     private void EnsureCapacity(int required)
     {
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
index c613ae05..7ecd47c5 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/SourceFileWriter.cs
@@ -51,7 +51,7 @@ internal static void AppendFooter(PooledStringBuilder builder, string namespaceN
         _ = builder.AppendLine("}");
     }
 
-    /// <summary>Emits a local event handler with the delegate's return type.</summary>
+    /// <summary>Emits one event's observable property, including the local handler that forwards the payload to the observer.</summary>
     /// <param name="builder">The destination builder.</param>
     /// <param name="model">The event to wrap.</param>
     /// <param name="provider">The observable implementation to write against.</param>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
index a3affeae..8659b6c1 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
@@ -52,7 +52,7 @@ internal static bool IsActivationInvocation(SyntaxNode node, CancellationToken c
             : null;
     }
 
-    /// <summary>Extracts a host's original generic definition for a shared wrapper.</summary>
+    /// <summary>Builds the wrapper model for a host, collecting its events and any diagnostics they raise.</summary>
     /// <param name="host">The host to wrap, reduced to its original definition.</param>
     /// <param name="location">The call site, for diagnostics.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
index 37bca49c..7429e67d 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/StaticTargetExtractor.cs
@@ -66,7 +66,7 @@ private static bool IsRequestAttributeName(NameSyntax name)
         _ => string.Empty,
     };
 
-    /// <summary>Rejects generic static hosts whose type arguments cannot be inferred.</summary>
+    /// <summary>Builds the model for a static host, reporting a diagnostic instead when the host is generic.</summary>
     /// <param name="host">The host to expose, reduced to its original definition.</param>
     /// <param name="location">The attribute application, for diagnostics.</param>
     /// <param name="supportsNullableAnnotations">Whether the consumer's language can express an annotation.</param>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
index 2b5ca5d2..b9a0c997 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
@@ -251,7 +251,7 @@ private static string SelectPrimaryConstraint(ITypeParameterSymbol parameter, bo
         return parameter.HasNotNullConstraint ? "notnull" : string.Empty;
     }
 
-    /// <summary>Appends the constraint separator when something has already been written.</summary>
+    /// <summary>Appends the constraint separator unless the builder is empty.</summary>
     /// <param name="builder">The destination builder.</param>
     /// <returns>The builder, for chaining.</returns>
     private static PooledStringBuilder AppendSeparator(PooledStringBuilder builder) =>
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs b/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
index 8a99328a..4fc2fd28 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Models/EventModel.cs
@@ -5,8 +5,8 @@
 namespace ReactiveUI.Primitives.ObservableEvents.Models;
 
 /// <summary>Stores event emission data without compiler objects; parameterless payloads remain provider-independent.</summary>
-/// <param name="PropertyName">The generated property name, already escaped.</param>
-/// <param name="EventAccess">The subscription target and event name, already escaped.</param>
+/// <param name="PropertyName">The generated property name, escaped for use as an identifier.</param>
+/// <param name="EventAccess">The subscription target and event name, escaped for use as an identifier.</param>
 /// <param name="PayloadType">The observable payload type, or empty when the delegate takes no parameters.</param>
 /// <param name="PayloadValue">The value passed to OnNext, or empty when the delegate takes no parameters.</param>
 /// <param name="HandlerParameters">The generated handler's parameter list.</param>
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/CurrentThreadSequencer.cs
index 5bc4e9b1..f4ce7a4e 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/CurrentThreadSequencer.cs
@@ -12,6 +12,6 @@ internal static class CurrentThreadSequencer
     /// <summary>Gets the singleton current-thread scheduler.</summary>
     internal static IScheduler Instance => CurrentThreadScheduler.Instance;
 
-    /// <summary>Gets a value indicating whether the caller must call a Schedule method.</summary>
+    /// <summary>Gets a value indicating whether the caller must schedule work instead of running it inline.</summary>
     internal static bool IsScheduleRequired => CurrentThreadScheduler.IsScheduleRequired;
 }
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
index 61a49691..0f6f4fb9 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
@@ -199,7 +199,7 @@ internal void RunReadyBatch()
         }
     }
 
-    /// <summary>Claims a drain or requests another pass if the observed state is still current.</summary>
+    /// <summary>Claims a drain, or requests another pass when the observed state has not changed.</summary>
     /// <param name="observedState">The drain state observed before attempting the transition.</param>
     /// <returns>True when no further claim attempt is needed; false when the observed state changed.</returns>
     internal bool TryPostDrain(int observedState)
diff --git a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
index de0d9f10..5af649b3 100644
--- a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
@@ -21,8 +21,7 @@ public sealed class HandlerSequencer : CoalescingDispatchScheduler
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
-        Justification =
-            "Persistent lazy cache: the JNI runnable bridge is built once and reused across every Post call, so it cannot be a method local.")]
+        Justification = "The JNI runnable bridge is built once and reused across every posted batch.")]
     private Java.Lang.IRunnable? _drainRunnable;
 
     /// <summary>Initializes a new instance of the <see cref="HandlerSequencer"/> class.</summary>
diff --git a/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs b/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
index 1f8d04b6..24c38195 100644
--- a/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
@@ -7,6 +7,9 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>Windows Forms scheduler that coalesces scheduled work through a UI control.</summary>
+/// <remarks>Work runs on the control's UI thread. Work scheduled before the control has a handle stays queued until
+/// handle creation posts a drain, and delayed work waits on a background scheduler that marshals it back through the
+/// control when due.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("ControlSequencer: Control = {Control}")]
 public sealed class ControlSequencer : CoalescingDispatchScheduler
diff --git a/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs b/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
index 1bd4ba56..4d883877 100644
--- a/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
@@ -8,6 +8,10 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Windows Forms sequencer that coalesces scheduled work through a UI control.</summary>
+/// <remarks>Work runs on the control's UI thread, one batch per posted drain; scheduling from that thread queues the
+/// item for the next drain rather than running it inline. Work scheduled before the control has a handle stays queued
+/// until handle creation posts a drain, and delayed work waits on a shared timer that marshals it back through the
+/// control when due.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ControlSequencer : ISequencer
@@ -70,7 +74,7 @@ private bool Post(Action drain)
         }
     }
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
index 58638557..23724cdc 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
@@ -8,6 +8,8 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>WinUI dispatcher queue scheduler that coalesces scheduled work through a <see cref="DispatcherQueue"/>.</summary>
+/// <remarks>Work runs on the dispatcher queue's thread and delayed work fires on a dispatcher queue timer, so disposing
+/// the returned subscription stops that timer as well as suppressing work that has not started.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("DispatcherQueueSequencer: DispatcherQueue = {DispatcherQueue}, Priority = {Priority}")]
 public sealed class DispatcherQueueSequencer : CoalescingDispatchScheduler
@@ -16,8 +18,7 @@ public sealed class DispatcherQueueSequencer : CoalescingDispatchScheduler
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
-        Justification =
-            "Persistent lazy cache: the dispatcher queue handler is built once and reused across every post, so it cannot be a method local.")]
+        Justification = "The handler delegate is cached across every post, so it cannot be a method local.")]
     private DispatcherQueueHandler? _handler;
 
     /// <summary>Initializes a new instance of the <see cref="DispatcherQueueSequencer"/> class.</summary>
@@ -45,7 +46,7 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
     public DispatcherQueuePriority Priority { get; }
 
     /// <inheritdoc/>
-    /// <exception cref="InvalidOperationException">The dispatcher queue is no longer accepting work.</exception>
+    /// <exception cref="InvalidOperationException">The dispatcher queue rejected the work.</exception>
     protected override bool Post(Action drain)
     {
         _handler ??= drain.Invoke;
diff --git a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
index eae31d1f..d4b3ffed 100644
--- a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
@@ -9,6 +9,9 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>WinUI dispatcher queue sequencer that coalesces scheduled work through a <see cref="DispatcherQueue"/>.</summary>
+/// <remarks>Work runs on the dispatcher queue's thread, one batch per posted drain; scheduling from that thread queues
+/// the item for the next drain rather than running it inline. Delayed work fires on a dispatcher queue timer, and an
+/// item cancelled before its drain reaches it is skipped.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class DispatcherQueueSequencer : ISequencer
@@ -20,8 +23,7 @@ public sealed class DispatcherQueueSequencer : ISequencer
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
-        Justification =
-            "Persistent lazy cache: the dispatcher queue handler is built once and reused across every post, so it cannot be a method local.")]
+        Justification = "The handler delegate is cached across every post, so it cannot be a method local.")]
     private DispatcherQueueHandler? _handler;
 
     /// <summary>Initializes a new instance of the <see cref="DispatcherQueueSequencer"/> class.</summary>
@@ -70,7 +72,7 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
     /// <summary>Marshals the cached drain callback through the dispatcher queue.</summary>
     /// <param name="drain">The drain callback.</param>
     /// <returns><see langword="true"/> when the drain was enqueued.</returns>
-    /// <exception cref="InvalidOperationException">The dispatcher queue is no longer accepting work.</exception>
+    /// <exception cref="InvalidOperationException">The dispatcher queue rejected the work.</exception>
     private bool Post(Action drain)
     {
         _handler ??= drain.Invoke;
@@ -99,7 +101,7 @@ private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
         timer.Start();
     }
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
index 3c262918..aa360fc7 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
@@ -8,12 +8,15 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>WPF dispatcher scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
+/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/> and delayed work fires on a
+/// <see cref="DispatcherTimer"/>, so disposing the returned subscription stops that timer as well as suppressing work
+/// that has not started.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("DispatcherSequencer: Dispatcher = {Dispatcher}, Priority = {Priority}")]
 public sealed class DispatcherSequencer : CoalescingDispatchScheduler
 {
     /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
-    /// <param name="dispatcher">The dispatcher.</param>
+    /// <param name="dispatcher">The dispatcher whose thread runs the scheduled work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher)
         : this(dispatcher, DispatcherPriority.Normal)
@@ -21,7 +24,7 @@ public DispatcherSequencer(Dispatcher dispatcher)
     }
 
     /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
-    /// <param name="dispatcher">The dispatcher.</param>
+    /// <param name="dispatcher">The dispatcher whose thread runs the scheduled work.</param>
     /// <param name="priority">Dispatcher priority used for posted drains.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
@@ -30,7 +33,7 @@ public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
         Priority = priority;
     }
 
-    /// <summary>Gets the dispatcher.</summary>
+    /// <summary>Gets the dispatcher whose thread runs the scheduled work.</summary>
     public Dispatcher Dispatcher { get; }
 
     /// <summary>Gets the dispatcher priority used for posted drains.</summary>
diff --git a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
index 9047b599..b8680340 100644
--- a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
@@ -9,6 +9,9 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>WPF dispatcher sequencer that coalesces scheduled work onto a dispatcher drain.</summary>
+/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/>, one batch per posted drain; scheduling from
+/// that thread queues the item for the next drain rather than running it inline. Delayed work fires on a
+/// <see cref="DispatcherTimer"/>, and an item cancelled before its drain reaches it is skipped.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class DispatcherSequencer : ISequencer
@@ -17,7 +20,7 @@ public sealed class DispatcherSequencer : ISequencer
     private DispatchSequencerState _state;
 
     /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
-    /// <param name="dispatcher">The dispatcher.</param>
+    /// <param name="dispatcher">The dispatcher whose thread runs the scheduled work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher)
         : this(dispatcher, DispatcherPriority.Normal)
@@ -25,7 +28,7 @@ public DispatcherSequencer(Dispatcher dispatcher)
     }
 
     /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
-    /// <param name="dispatcher">The dispatcher.</param>
+    /// <param name="dispatcher">The dispatcher whose thread runs the scheduled work.</param>
     /// <param name="priority">Dispatcher priority used for posted drains.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
@@ -35,7 +38,7 @@ public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
         _state = new(this, Post, RunDrain, ScheduleDelayed);
     }
 
-    /// <summary>Gets the dispatcher.</summary>
+    /// <summary>Gets the dispatcher whose thread runs the scheduled work.</summary>
     public Dispatcher Dispatcher { get; }
 
     /// <summary>Gets the dispatcher priority used for posted drains.</summary>
@@ -84,7 +87,7 @@ private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
         timer.Start();
     }
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index a609bb3a..97957e2b 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -95,7 +95,7 @@ public void Schedule(IWorkItem item)
         Schedule(item, Timestamp);
     }
 
-    /// <summary>Schedules a work item to be executed at the specified monotonic timestamp.</summary>
+    /// <summary>Runs the work item on the calling thread once due, blocking until then, or queues it on the trampoline when that thread is running scheduled work.</summary>
     /// <param name="item">Work item to execute.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="item"/> is <see langword="null"/>.</exception>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
index b02cc01e..88bf8903 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
@@ -45,7 +45,7 @@ public IDisposable Schedule(Action action)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>Schedules the specified work item.</summary>
+    /// <summary>Executes the work item on the calling thread unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="item"/> is <see langword="null"/>.</exception>
     public void Schedule(IWorkItem item)
@@ -60,7 +60,7 @@ public void Schedule(IWorkItem item)
         item.Execute();
     }
 
-    /// <summary>Schedules the specified work item.</summary>
+    /// <summary>Blocks the calling thread until the due timestamp, then executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="item"/> is <see langword="null"/>.</exception>
diff --git a/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs b/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
index fd187d0c..7bea91ee 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SequencerExtensions.cs
@@ -192,7 +192,6 @@ public IDisposable Schedule(Action<Action> action)
         /// <param name="action">Action to execute.</param>
         /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler" /> or <paramref name="action" /> is <c>null</c>.</exception>
-        /// <remarks>Named <c>ScheduleAction</c> because a <c>Schedule</c> overload taking state plus an action would be ambiguous with the others.</remarks>
         public IDisposable ScheduleAction<TState>(TState state, Action<TState> action)
         {
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
index c67d9449..7865337f 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizedSequencerQueue.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Thread-safe wrapper around <see cref="SequencerQueue{TAbsolute}"/> that pairs the queue with its lock, so the
-/// virtual-time self-removal callback synchronizes through one reference instead of capturing the owning struct.
-/// </summary>
+/// <summary>Pairs a <see cref="SequencerQueue{TAbsolute}"/> with the gate guarding it, so a callback synchronizes through one reference rather than capturing the owning struct.</summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 internal sealed class SynchronizedSequencerQueue<TAbsolute>
     where TAbsolute : IComparable<TAbsolute>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index f18b34f6..f7de0562 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -301,7 +301,7 @@ internal sealed class ScheduledWorkItem<TState>(
         [SuppressMessage(
             "Usage",
             "CA2213:Disposable fields should be disposed",
-            Justification = "_owner is the sequencer that queued this work item, not a resource it owns; disposing it would shut the sequencer down when one item completes.")]
+            Justification = "The sequencer that queued this work item is not a resource the work item owns.")]
         private readonly ThreadPoolSequencer _owner = owner;
 
         /// <summary>Scheduled state.</summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
index 2dfece9d..0addf589 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
@@ -112,9 +112,7 @@ public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequen
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "The relative (TimeSpan) and absolute (DateTimeOffset) Schedule overloads forward to _state.Schedule with "
-            + "the same argument names, so the source text matches, but overload resolution binds each to a different "
-            + "_state.Schedule overload by dueTime's type. Both are required by the scheduler contract.")]
+            "The dueTime type binds this body to a different state overload than the relative one it matches textually.")]
     public IDisposable Schedule<TState>(
         TState state,
         DateTimeOffset dueTime,
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
index f502c324..9ba9e375 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeMessages.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>Shares virtual-time message formats across clock types.</summary>
 internal static class VirtualTimeMessages
 {
-    /// <summary>Format of the message thrown when the clock is advanced while the scheduler is already running.</summary>
+    /// <summary>Format of the message thrown when the clock is advanced while the scheduler is running.</summary>
     private const string SchedulerAlreadyRunningFormat =
         "{0} cannot be called when the scheduler is already running. Try using Sleep instead.";
 
@@ -23,7 +23,7 @@ internal static class VirtualTimeMessages
         CompositeFormat.Parse(SchedulerAlreadyRunningFormat);
 #endif
 
-    /// <summary>Builds the message thrown when a clock-advancing method runs against an already-running scheduler.</summary>
+    /// <summary>Builds the message thrown when a clock-advancing method runs against a running scheduler.</summary>
     /// <param name="methodName">The name of the clock-advancing method that was called.</param>
     /// <returns>The formatted message.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
index e808ee42..fe630a61 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
@@ -60,10 +60,7 @@ public IDisposable ScheduleRelative(TRelative dueTime, Action action)
 
             ArgumentExceptionHelper.ThrowIfNull(action);
 
-            // As stated in Sequencer.Simple.cs,
-            // an anonymous delegate will allow delegate caching.
-            // Watch https://github.com/dotnet/roslyn/issues/5835 for compiler
-            // support for caching delegates from method groups.
+            // A static lambda rather than a method group, so the compiler caches the delegate.
             return scheduler.ScheduleRelative(action, dueTime, static (_, a) => Invoke(a));
         }
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
index 41fd4ce1..b39a30f4 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
@@ -113,9 +113,7 @@ public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequen
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "The relative (TimeSpan) and absolute (DateTimeOffset) Schedule overloads forward to _state.Schedule with "
-            + "the same argument names, so the source text matches, but overload resolution binds each to a different "
-            + "_state.Schedule overload by dueTime's type. Both are required by the scheduler contract.")]
+            "The dueTime type binds this body to a different state overload than the relative one it matches textually.")]
     public IDisposable Schedule<TState>(
         TState state,
         DateTimeOffset dueTime,
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
index 54220103..d95c085e 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
@@ -13,8 +13,7 @@ namespace ReactiveUI.Primitives.Concurrency;
 [System.Diagnostics.CodeAnalysis.SuppressMessage(
     "Performance",
     "SST1803:Make record struct readonly",
-    Justification =
-        "This is mutable scheduler state; its members mutate the clock and running flag in place, so it cannot be readonly.")]
+    Justification = "Members mutate the clock and the running latch in place.")]
 internal record struct VirtualTimeState<TAbsolute, TRelative>
     where TAbsolute : IComparable<TAbsolute>
 {
@@ -76,7 +75,7 @@ public VirtualTimeState(
     /// <summary>Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan.</summary>
     /// <param name="time">Relative time to advance the scheduler's clock by.</param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="time"/> is negative.</exception>
-    /// <exception cref="InvalidOperationException">The scheduler is already running.</exception>
+    /// <exception cref="InvalidOperationException">The scheduler is running work.</exception>
     internal void AdvanceBy(TRelative time)
     {
         var dt = _add(_clock, time);
@@ -103,7 +102,7 @@ internal void AdvanceBy(TRelative time)
     /// <summary>Advances the scheduler's clock to the specified time, running all work till that point.</summary>
     /// <param name="time">Absolute time to advance the scheduler's clock to.</param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="time"/> is in the past.</exception>
-    /// <exception cref="InvalidOperationException">The scheduler is already running.</exception>
+    /// <exception cref="InvalidOperationException">The scheduler is running work.</exception>
     internal void AdvanceTo(TAbsolute time)
     {
         var dueToClock = _comparer.Compare(time, _clock);
diff --git a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
index 23a1f68d..6c594f3b 100644
--- a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
@@ -197,7 +197,7 @@ public void Execute()
             _owner.ScheduleReady(_item);
         }
 
-        /// <summary>Cancels the marshalled item, handing it back to the caller that still holds it.</summary>
+        /// <summary>Cancels the marshalled item, handing it back to the caller holding it.</summary>
         private void Release()
         {
             if (_item is not IDisposable cancellable)
diff --git a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
index d3611a72..91ebc63d 100644
--- a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
@@ -24,8 +24,7 @@ public sealed class HandlerSequencer : ISequencer
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
         "SST1422:Move this field into the method that uses it",
-        Justification =
-            "Persistent lazy cache: the JNI runnable bridge is built once and reused across every Post call, so it cannot be a method local.")]
+        Justification = "The JNI runnable bridge is built once and reused across every posted batch.")]
     private Java.Lang.IRunnable? _drainRunnable;
 
     /// <summary>Initializes a new instance of the <see cref="HandlerSequencer"/> class.</summary>
diff --git a/src/ReactiveUI.Primitives/RxVoid.cs b/src/ReactiveUI.Primitives/RxVoid.cs
index 88fc9eb4..9762bbcb 100644
--- a/src/ReactiveUI.Primitives/RxVoid.cs
+++ b/src/ReactiveUI.Primitives/RxVoid.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives;
 
-/// <summary>A Reactive Void.</summary>
+/// <summary>A unit type with exactly one value, carried by sequences that signal an occurrence rather than data.</summary>
 [Serializable]
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public readonly struct RxVoid : IEquatable<RxVoid>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AsyncExtensionsComparisonBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AsyncExtensionsComparisonBenchmarks.cs
index d00ce00c..78f17674 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AsyncExtensionsComparisonBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/AsyncExtensionsComparisonBenchmarks.cs
@@ -13,7 +13,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>Benchmarks the new async primitives API against ReactiveUI.Extensions 4.0.0.</summary>
+/// <summary>Benchmarks the async primitives API against the ReactiveUI.Extensions async equivalents.</summary>
 [MemoryDiagnoser]
 public class AsyncExtensionsComparisonBenchmarks
 {
@@ -234,8 +234,7 @@ private static int Sum(PrimitivesCountingWitness[] observers)
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "Type-specialized overloads over different witness array types. The summation loop is identical, but the "
-            + "overloads take different element types and cannot forward to one another.")]
+            "The Sum overloads take different witness array element types and cannot forward to one another.")]
     private static int Sum(ExtensionsCountingWitness[] observers)
     {
         var total = 0;
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/CoreRuntimeBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/CoreRuntimeBenchmarks.cs
index 42fab69a..bfa1dff9 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/CoreRuntimeBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/CoreRuntimeBenchmarks.cs
@@ -44,7 +44,7 @@ public int PrimitivesPocketDispose()
     [SuppressMessage(
         "Allocations",
         "PSH1011:Use the overload with a state argument so this lambda does not capture",
-        Justification = "The baseline builds the same closure through a constructor, which has no state overload; de-closuring only this arm would invert the memory column it is compared on.")]
+        Justification = "De-closuring only this arm would skew the memory column it is compared on.")]
     public int SystemReactiveCompositeDispose()
     {
         var disposed = 0;
@@ -63,7 +63,7 @@ public int SystemReactiveCompositeDispose()
     [SuppressMessage(
         "Allocations",
         "PSH1011:Use the overload with a state argument so this lambda does not capture",
-        Justification = "The baseline builds the same closure through a constructor, which has no state overload; de-closuring only this arm would invert the memory column it is compared on.")]
+        Justification = "De-closuring only this arm would skew the memory column it is compared on.")]
     public int R3CompositeDispose()
     {
         var disposed = 0;
@@ -142,7 +142,7 @@ public int R3SafeWitness()
         return value;
     }
 
-    /// <summary>Allocating a completed spark should remain allocation efficient.</summary>
+    /// <summary>Allocating a completed spark with ReactiveUI.Primitives.</summary>
     /// <returns>An integer marker extracted from kind.</returns>
     [Benchmark]
     public int PrimitivesCompletedSpark()
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryAdapterExpansionBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryAdapterExpansionBenchmarks.cs
index 153fc666..4ac6a0cb 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryAdapterExpansionBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryAdapterExpansionBenchmarks.cs
@@ -293,8 +293,8 @@ public int R3NeverSubscribeDispose()
         return observer.NextCount + observer.CompletionCount + observer.ErrorCount;
     }
 
-    /// <summary>Gets the values.</summary>
-    /// <returns>The enumerable of values.</returns>
+    /// <summary>Yields the benchmark values asynchronously after an initial scheduler yield.</summary>
+    /// <returns>An async sequence of <see cref="Count"/> ascending values.</returns>
     private static async IAsyncEnumerable<int> ValuesAsync()
     {
         await Task.Yield();
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryGcProfileBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryGcProfileBenchmarks.cs
index 91794798..f8514223 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryGcProfileBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/FactoryGcProfileBenchmarks.cs
@@ -10,8 +10,7 @@ namespace ReactiveUI.Primitives.Benchmarks;
 
 /// <summary>
 /// GC-verbose allocation baselines for the factory operators, across Primitives, System.Reactive,
-/// and R3. Delegates to the comparison benchmark methods so the scenarios stay in one place.
-/// Opt in with <c>--filter "*GcProfile*"</c>.
+/// and R3. Delegates to the comparison benchmark methods. Opt in with <c>--filter "*GcProfile*"</c>.
 /// </summary>
 [ShortRunJob]
 [MemoryDiagnoser]
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
index 52a64aa6..f254fe8a 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorPassThroughBenchmarks.cs
@@ -13,7 +13,7 @@
 
 namespace ReactiveUI.Primitives.Benchmarks;
 
-/// <summary>Benchmarks for the pass-through and materialization operators converted to dedicated signals (Tap, IgnoreValues, Spark/Unspark materialize round-trip, SubscribeOn, Reattempt).</summary>
+/// <summary>Benchmarks the pass-through and materialization operators (Tap, IgnoreValues, Spark/Unspark materialize round-trip, SubscribeOn, Reattempt).</summary>
 [MemoryDiagnoser]
 public class OperatorPassThroughBenchmarks
 {
@@ -217,9 +217,7 @@ private sealed class ImmediateSynchronizationContext : SynchronizationContext, I
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "Post and Send are distinct SynchronizationContext overrides that this immediate context deliberately "
-                + "implements the same way: run the callback inline. They are separate base-class overrides and cannot "
-                + "be collapsed.")]
+                "Post and Send are distinct SynchronizationContext overrides and cannot be collapsed into one.")]
         public override void Send(SendOrPostCallback d, object? state) => d(state);
 
         /// <summary>Releases the resources used by the synchronization context.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterBenchmarks.cs
index 60eebb1c..a9e5015d 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterBenchmarks.cs
@@ -10,10 +10,9 @@
 namespace ReactiveUI.Primitives.Benchmarks;
 
 /// <summary>
-/// Subscribe-and-drain benchmarks for the stateful single-source operators that were converted
-/// from per-subscription closures to dedicated single-source sinks (Skip, Unique, Fold,
-/// Reduce, TakeWhile, SkipWhile, UniqueBy). The Allocated column reflects the closure-to-sink
-/// reduction; System.Reactive is the comparison baseline.
+/// Subscribe-and-drain benchmarks for the stateful single-source operators (Skip, Unique, Fold,
+/// Reduce, TakeWhile, SkipWhile, UniqueBy), measured against the System.Reactive equivalents as
+/// the comparison baseline.
 /// </summary>
 [MemoryDiagnoser]
 public class OperatorStatefulFilterBenchmarks
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterGcProfileBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterGcProfileBenchmarks.cs
index 74f81472..ac719ae3 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterGcProfileBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorStatefulFilterGcProfileBenchmarks.cs
@@ -9,9 +9,9 @@
 namespace ReactiveUI.Primitives.Benchmarks;
 
 /// <summary>
-/// GC-verbose allocation profile for the stateful single-source operators converted to dedicated
-/// single-source sinks. Pairs with <see cref="OperatorStatefulFilterBenchmarks"/>; the
-/// EventPipe trace captures per-subscription allocations on the subscribe-and-drain path.
+/// GC-verbose allocation profile for the stateful single-source operators, pairing with
+/// <see cref="OperatorStatefulFilterBenchmarks"/>. The EventPipe trace captures per-subscription
+/// allocations on the subscribe-and-drain path.
 /// </summary>
 [ShortRunJob]
 [MemoryDiagnoser]
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/Program.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/Program.cs
index 99774a46..94b3380b 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/Program.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/Program.cs
@@ -104,9 +104,8 @@ public override void Write(char value)
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "Write(char) and Write(string?) are distinct TextWriter overrides that this tee-writer implements the "
-                + "same way: forward to both underlying writers. They are separate base-class overrides over different "
-                + "parameter types and cannot be collapsed.")]
+                "Write(char) and Write(string?) are distinct TextWriter overrides over different parameter types and "
+                + "cannot be collapsed into one.")]
         public override void Write(string? value)
         {
             primary.Write(value);
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs
index 89ba6259..12d817b2 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs
@@ -167,9 +167,7 @@ private enum ExtensionsLibrary
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "Distinct BenchmarkDotNet benchmarks that measure the same operation across libraries. The method body is "
-            + "identical by design; the library being compared is supplied by each method's own [ArgumentsSource]. They "
-            + "must stay separate so BenchmarkDotNet reports one row per library.")]
+            "Each benchmark must stay a separate method so BenchmarkDotNet reports one row per library.")]
     public int ReactiveUIExtensions(ExtensionScenario scenario) => scenario.Run();
 
     /// <summary>Runs a System.Reactive comparison scenario.</summary>
@@ -182,9 +180,7 @@ private enum ExtensionsLibrary
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "Distinct BenchmarkDotNet benchmarks that measure the same operation across libraries. The method body is "
-            + "identical by design; the library being compared is supplied by each method's own [ArgumentsSource]. They "
-            + "must stay separate so BenchmarkDotNet reports one row per library.")]
+            "Each benchmark must stay a separate method so BenchmarkDotNet reports one row per library.")]
     public int SystemReactive(ExtensionScenario scenario) => scenario.Run();
 
     /// <summary>Runs an R3 comparison scenario.</summary>
@@ -197,9 +193,7 @@ private enum ExtensionsLibrary
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "Distinct BenchmarkDotNet benchmarks that measure the same operation across libraries. The method body is "
-            + "identical by design; the library being compared is supplied by each method's own [ArgumentsSource]. They "
-            + "must stay separate so BenchmarkDotNet reports one row per library.")]
+            "Each benchmark must stay a separate method so BenchmarkDotNet reports one row per library.")]
     public int R3Library(ExtensionScenario scenario) => scenario.Run();
 
     /// <summary>Creates the full paired library scenario list.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectHotPathGcProfileBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectHotPathGcProfileBenchmarks.cs
index 22278924..3fa758c5 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectHotPathGcProfileBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectHotPathGcProfileBenchmarks.cs
@@ -9,10 +9,9 @@
 namespace ReactiveUI.Primitives.Benchmarks;
 
 /// <summary>
-/// GC-verbose profile for the subject hot paths touched by the lock-free copy-on-write rewrite of
-/// <see cref="Signal{T}"/>, the System.Threading.Lock migration of the value-carrying subjects, and
-/// the readonly-Observer change. Covers steady-state emission (per-OnNext should be allocation-free)
-/// and subscribe/unsubscribe churn (exercises the copy-on-write add/remove path).
+/// GC-verbose profile for the subject hot paths: steady-state emission through <see cref="Signal{T}"/>
+/// and the value-carrying subjects, and single- and multi-subscriber subscribe/dispose churn over the
+/// copy-on-write observer list.
 /// </summary>
 [ShortRunJob]
 [MemoryDiagnoser]
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectMulticastBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectMulticastBenchmarks.cs
index 0e3df1ba..c81680b0 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectMulticastBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/SubjectMulticastBenchmarks.cs
@@ -11,8 +11,8 @@
 namespace ReactiveUI.Primitives.Benchmarks;
 
 /// <summary>
-/// Benchmarks fan-out emission throughput: emitting a stream of values into a subject that already has several
-/// observers attached, so the cost is dominated by the per-observer dispatch loop rather than subscription setup.
+/// Benchmarks fan-out emission throughput: emitting a stream of values into a subject with several observers
+/// attached, so the cost is dominated by the per-observer dispatch loop rather than subscription setup.
 /// </summary>
 [MemoryDiagnoser]
 public class SubjectMulticastBenchmarks
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
index 98c0d3a7..21593a7d 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Disposables.Tests;
 /// <summary>Tests slot assignment, replacement disposal, and idempotent disposal.</summary>
 public class DisposableSlotHelperTests
 {
-    /// <summary>Verifies that an incoming value is disposed immediately if the slot is already disposed.</summary>
+    /// <summary>Verifies that an incoming value is disposed immediately when the slot is disposed.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAssignWithoutDisposingPreviousIntoDisposedSlot_ThenIncomingDisposed()
@@ -72,7 +72,7 @@ public async Task WhenSwapAndDisposePreviousOpen_ThenPreviousDisposed()
         await Assert.That(second.DisposeCount).IsEqualTo(0);
     }
 
-    /// <summary>Verifies the swap path disposes the incoming value if the slot is already disposed.</summary>
+    /// <summary>Verifies the swap path disposes the incoming value when the slot is disposed.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSwapAndDisposePreviousIntoDisposedSlot_ThenIncomingDisposed()
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableTests.cs
index 3cded947..ba7e2955 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableTests.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Disposables.Tests;
 /// <summary>Tests for the disposables family of types.</summary>
 public class DisposableTests
 {
-    /// <summary>Called when [dispose once].</summary>
+    /// <summary>Verifies an action disposable runs its action exactly once across repeated disposal.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task OnlyDisposeOnce()
@@ -22,7 +22,7 @@ public async Task OnlyDisposeOnce()
         await Assert.That(disposed).IsEqualTo(1);
     }
 
-    /// <summary>Empties the disposable.</summary>
+    /// <summary>Verifies the empty disposable singleton tolerates repeated disposal without effect.</summary>
     [Test]
     public void EmptyDisposableInstanceDoesNothing()
     {
@@ -48,7 +48,7 @@ public async Task CancellationDisposableDefaultConstructorCancelsOwnedToken()
         await Assert.That(disposable.IsDisposed).IsTrue();
     }
 
-    /// <summary>Singles the disposable dispose.</summary>
+    /// <summary>Verifies a single disposable reports itself disposed once disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task SingleDisposableDispose()
@@ -58,7 +58,7 @@ public async Task SingleDisposableDispose()
         await Assert.That(disposable.IsDisposed).IsTrue();
     }
 
-    /// <summary>Singles the disposable dispose with action.</summary>
+    /// <summary>Verifies a single disposable runs its dispose action exactly once across repeated disposal.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task SingleDisposableDisposeWithAction()
@@ -76,7 +76,7 @@ public async Task SingleDisposableDisposeWithAction()
         await Assert.That(disposed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies action runs once and late assigned disposable is still disposed.</summary>
+    /// <summary>Verifies the dispose action runs once and a disposable created after disposal is disposed too.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task SingleDisposableDisposeThenCreateRunsActionOnce()
@@ -93,7 +93,7 @@ public async Task SingleDisposableDisposeThenCreateRunsActionOnce()
         await Assert.That(created).IsEqualTo(1);
     }
 
-    /// <summary>Multiples the disposable dispose.</summary>
+    /// <summary>Verifies an empty group reports itself disposed once disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task MultipleDisposableDispose()
@@ -103,7 +103,7 @@ public async Task MultipleDisposableDispose()
         await Assert.That(disposable.IsDisposed).IsTrue();
     }
 
-    /// <summary>Multiples the disposable with items dispose.</summary>
+    /// <summary>Verifies disposing a group disposes every disposable it holds.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task MultipleDisposableWithItemsDispose()
@@ -111,7 +111,6 @@ public async Task MultipleDisposableWithItemsDispose()
         MultipleDisposable disposable = [EmptyDisposable.Instance];
         var disposed = 0;
 
-        // A child disposable whose action runs when the group is disposed.
         SingleDisposable singleDisposable = new(EmptyDisposable.Instance, () => disposed++);
         disposable.Add(singleDisposable);
         SingleDisposable singleDisposable2 = new(EmptyDisposable.Instance);
@@ -233,7 +232,6 @@ public async Task MultipleDisposableHandlesOverflow()
         MultipleDisposable disposable = [.. items];
         await Assert.That(disposable.Count).IsEqualTo(items.Length);
 
-        // Enumerate and copy while the group spills into the overflow store.
         var seen = 0;
         foreach (var _ in disposable)
         {
@@ -252,7 +250,6 @@ public async Task MultipleDisposableHandlesOverflow()
         await Assert.That(disposable.Remove(missing)).IsFalse();
         await Assert.That(disposable.Count).IsEqualTo(items.Length - 1);
 
-        // Clear disposes the remaining items, including the overflow store.
         disposable.Clear();
         await Assert.That(disposedCount).IsEqualTo(items.Length);
     }
@@ -304,7 +301,6 @@ public async Task MultipleDisposableAfterDisposeIsEmptyAndDisposesNewItems()
         disposable.Add(new ActionDisposable(() => lateDisposed++));
         await Assert.That(lateDisposed).IsEqualTo(1);
 
-        // Clear and a redundant Dispose are no-ops on an already-disposed group.
         disposable.Clear();
         disposable.Dispose();
         await Assert.That(disposable.IsDisposed).IsTrue();
diff --git a/src/tests/ReactiveUI.Disposables.Tests/MutableDisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/MutableDisposableTests.cs
index a6b554bc..791e1bb7 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/MutableDisposableTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/MutableDisposableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Disposables.Tests;
 
-/// <summary>Tests for <see cref="MutableDisposable"/> — verifies that reassigning the inner does
-/// NOT dispose the previous, that assigning after disposal immediately disposes the incoming
-/// value, and that <c>Dispose</c> is idempotent.</summary>
+/// <summary>Tests for <see cref="MutableDisposable"/>, whose inner can be replaced without disposing the value it held.</summary>
 public class MutableDisposableTests
 {
     /// <summary>Verifies replacement leaves the previous inner alone.</summary>
diff --git a/src/tests/ReactiveUI.Disposables.Tests/SwapDisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/SwapDisposableTests.cs
index 9651a29e..56644a5b 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/SwapDisposableTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/SwapDisposableTests.cs
@@ -6,9 +6,7 @@
 
 namespace ReactiveUI.Disposables.Tests;
 
-/// <summary>Tests for <see cref="SwapDisposable"/> — verifies replacement disposes the previous
-/// inner, assigning after disposal immediately disposes the incoming value, and <c>Dispose</c>
-/// is idempotent.</summary>
+/// <summary>Tests for <see cref="SwapDisposable"/>, which disposes the value it held each time its inner is replaced.</summary>
 public class SwapDisposableTests
 {
     /// <summary>Verifies that replacement disposes the previous inner.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AotSafeAssertionExtensions.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AotSafeAssertionExtensions.cs
index 4b1b986b..99c16375 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AotSafeAssertionExtensions.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AotSafeAssertionExtensions.cs
@@ -18,12 +18,7 @@ internal static class AotSafeAssertionExtensions
     extension<TCollection, TItem>(IAssertionSource<TCollection> source)
         where TCollection : IEnumerable<TItem>
     {
-        /// <summary>
-        /// Asserts the collection is equivalent to <paramref name="expected"/>
-        /// using the element type's default <see cref="EqualityComparer{T}"/>
-        /// (mirroring <c>IsEquivalentTo</c>) without the reflection-based structural
-        /// comparison that triggers trim/AOT warnings.
-        /// </summary>
+        /// <summary>Asserts element-wise equality with <paramref name="expected"/> using <see cref="EqualityComparer{T}"/>, which keeps the assertion trim-safe.</summary>
         /// <param name="expected">The expected element sequence.</param>
         /// <returns>The chained collection-equivalency assertion.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
index 04c8123c..1876ce79 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncSerialGateTests.cs
@@ -7,7 +7,7 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests gate acquisition, reentry, contention and idempotent disposal.</summary>
 public class AsyncSerialGateTests
 {
-    /// <summary>Verifies that the uncontended fast path acquires the gate via pure CAS.</summary>
+    /// <summary>Verifies that an uncontended gate can be acquired again after release.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenUncontendedLock_ThenAcquiresAndReleases()
@@ -19,14 +19,13 @@ public async Task WhenUncontendedLock_ThenAcquiresAndReleases()
             await Assert.That(gate).IsNotNull();
         }
 
-        // After release the gate must be re-acquirable.
         using (await gate.EnterAsync())
         {
             await Assert.That(gate).IsNotNull();
         }
     }
 
-    /// <summary>Verifies that same-thread reentry bumps the recursion depth and does not block.</summary>
+    /// <summary>Verifies that nested acquisitions on the owning thread are granted without blocking.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSameThreadReentry_ThenAllowedWithoutBlocking()
@@ -47,7 +46,6 @@ public async Task WhenSameThreadReentry_ThenAllowedWithoutBlocking()
             lease1.Dispose();
         }
 
-        // Gate must release cleanly after nested acquisitions.
         using (await gate.EnterAsync())
         {
             await Assert.That(gate).IsNotNull();
@@ -69,7 +67,7 @@ public async Task WhenContendedWaiter_ThenResumesAfterRelease()
         await Assert.That(gate.WaitersCount).IsEqualTo(0);
     }
 
-    /// <summary>Verifies that double-dispose is idempotent.</summary>
+    /// <summary>Verifies that a second dispose of the gate has no effect.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenDisposeCalledTwice_ThenIdempotent()
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
index 011c2212..29cbcefa 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// A <see cref="TaskScheduler"/> that is not <see cref="TaskScheduler.Default"/> and runs each queued task
-/// on the thread pool. Used to exercise the code paths that branch on a caller-supplied scheduler.
-/// </summary>
+/// <summary>A scheduler distinct from <see cref="TaskScheduler.Default"/> that runs each queued task on the thread pool.</summary>
 internal sealed class CustomTaskScheduler : TaskScheduler
 {
     /// <summary>Singleton instance.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
index f9fd33e3..7dd57b85 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ExpireOperatorTests.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Tests for the <c>Expire</c> operator — the inter-element deadline that completes the sequence with a
-/// <see cref="TimeoutException"/>. Covers the deadline firing, and the tick of a deadline that was rearmed
-/// by a source value arriving after the sequence had already expired.
-/// </summary>
+/// <summary>Tests the <c>Expire</c> operator's inter-element deadline, which completes the sequence with a <see cref="TimeoutException"/>.</summary>
 public class ExpireOperatorTests
 {
     /// <summary>The inter-element deadline used by the tests.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
index a44c2a24..7d51a55d 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalOperatorTests.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Tests for the <c>Interval</c> operator's shutdown path: disposing the subscription from inside a tick
-/// cancels the tick loop between one notification and the next, so the loop exits on its own cancellation
-/// check rather than by tearing a pending delay down with an exception.
-/// </summary>
+/// <summary>Tests the <c>Interval</c> operator's tick loop and its shutdown path.</summary>
 public class IntervalOperatorTests
 {
     /// <summary>The tick the handler disposes on.</summary>
@@ -17,8 +13,7 @@ public class IntervalOperatorTests
     /// <summary>The interval between ticks.</summary>
     private static readonly TimeSpan TickPeriod = TimeSpan.FromMilliseconds(20);
 
-    /// <summary>Verifies that disposing the interval subscription from inside a tick handler ends the tick loop:
-    /// the ticks seen so far start at one and are consecutive, and nothing arrives after the dispose.</summary>
+    /// <summary>Verifies that disposing from inside a tick handler delivers no tick after the one that disposed.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenDisposedFromWithinATick_ThenTheTickLoopStops()
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
index 4118c091..9f584cea 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionCapture.cs
@@ -21,7 +21,7 @@ internal sealed class UnhandledExceptionCapture : IDisposable
     /// <summary>Signals the next captured exception.</summary>
     private TaskCompletionSource _arrival = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-    /// <summary>Tracks whether the capture has already restored the previous handler.</summary>
+    /// <summary>Set to one once the prior handler has been restored.</summary>
     private int _disposed;
 
     /// <summary>Initializes a new instance of the <see cref="UnhandledExceptionCapture"/> class.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
index 024a48bd..d33ca978 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Test executor that saves and restores the <see cref="UnhandledExceptionHandler"/> global state
-/// around each test, ensuring test isolation for tests that register custom handlers.
-/// </summary>
+/// <summary>Saves and restores the <see cref="UnhandledExceptionHandler"/> global state around each test.</summary>
 public sealed class UnhandledExceptionTestExecutor : ITestExecutor
 {
     /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/DiagnosticInfoTests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/DiagnosticInfoTests.cs
index b2e0dacc..20f1711c 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/DiagnosticInfoTests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/DiagnosticInfoTests.cs
@@ -50,7 +50,7 @@ public async Task DiagnosticInfoRebuildsATwoArgumentDiagnostic()
         await Assert.That(diagnostic.GetMessage()).Contains(HostDisplayName);
     }
 
-    /// <summary>Verifies a diagnostic with nowhere to point still reports rather than throwing.</summary>
+    /// <summary>Verifies a diagnostic with nowhere to point reports rather than throwing.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DiagnosticInfoReportsWithoutALocation()
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
index 89d95732..8c3a55c1 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/EventGeneratorTests.cs
@@ -892,7 +892,7 @@ private static List<MetadataReference> CreateReferences(
         return references;
     }
 
-    /// <summary>Adds a metadata reference unless the same assembly path is already present.</summary>
+    /// <summary>Adds a metadata reference unless the same assembly path is present.</summary>
     /// <param name="references">The destination references.</param>
     /// <param name="path">The assembly path to add.</param>
     private static void AddReference(List<MetadataReference> references, string path)
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/GeneratedNamesTests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/GeneratedNamesTests.cs
index c76142ea..8b21c371 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/GeneratedNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/GeneratedNamesTests.cs
@@ -34,7 +34,7 @@ public async Task GeneratedNamesTrimsLeadingAndTrailingPunctuation()
         await Assert.That(trimmed).IsNotEqualTo(bare);
     }
 
-    /// <summary>Verifies an identity with nothing nameable still produces a usable identifier.</summary>
+    /// <summary>Verifies an identity with nothing nameable produces a usable identifier.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GeneratedNamesHandlesAnIdentityWithNothingNameable()
diff --git a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/PooledStringBuilderTests.cs b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/PooledStringBuilderTests.cs
index fef5a047..ec30bd60 100644
--- a/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/PooledStringBuilderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.ObservableEvents.Tests/PooledStringBuilderTests.cs
@@ -142,8 +142,7 @@ public async Task PooledStringBuilderDropsBuffersBeyondTheFreeListCapacity()
             builder.Return();
         }
 
-        // The pool is now full; a fresh builder still has to work, whether it was handed a pooled buffer or a
-        // newly allocated one.
+        // With the free list saturated, this builder gets either a pooled buffer or a fresh allocation.
         await Assert.That(new PooledStringBuilder().Append("after").ToStringAndReturn()).IsEqualTo("after");
     }
 
@@ -159,7 +158,7 @@ public async Task PooledStringBuilderIndentsEveryNonEmptyLine()
         await Assert.That(builder.ToStringAndReturn()).IsEqualTo("  first\n\n  third\n");
     }
 
-    /// <summary>Verifies a block whose last line has no terminator still gets one.</summary>
+    /// <summary>Verifies a block whose last line has no terminator gets one appended.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task PooledStringBuilderTerminatesAnUnterminatedFinalLine()
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/CurrentThreadSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/CurrentThreadSequencerTests.cs
index c6dd36ac..3e23fe7e 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/CurrentThreadSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/CurrentThreadSequencerTests.cs
@@ -8,10 +8,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>
-/// Verifies <see cref="CurrentThreadSequencer"/> forwards to System.Reactive's current-thread scheduler,
-/// including the trampoline flag callers use to decide whether they must schedule.
-/// </summary>
+/// <summary>Verifies <see cref="CurrentThreadSequencer"/> forwards to System.Reactive's current-thread scheduler, trampoline flag included.</summary>
 public class CurrentThreadSequencerTests
 {
     /// <summary>Verifies the exposed instance is System.Reactive's current-thread scheduler singleton.</summary>
@@ -21,11 +18,7 @@ public async Task WhenInstanceRead_ThenItIsTheCurrentThreadScheduler() =>
         await Assert.That(CurrentThreadSequencer.Instance)
             .IsSameReferenceAs(System.Reactive.Concurrency.CurrentThreadScheduler.Instance);
 
-    /// <summary>
-    /// Verifies the schedule-required flag mirrors System.Reactive. Outside a trampoline both are
-    /// <see langword="true"/>; the assertion compares the two rather than a literal so the test states the
-    /// forwarding contract rather than a snapshot of the runtime's state.
-    /// </summary>
+    /// <summary>Verifies the schedule-required flag mirrors System.Reactive's.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenScheduleRequiredRead_ThenItMirrorsTheCurrentThreadScheduler() =>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
index e79f6de2..517dfb5c 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/DispatchWorkItemBaseTests.cs
@@ -9,17 +9,13 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>
-/// Tests for the run/cancel handshake in <see cref="DispatchWorkItemBase{TState}"/>: when a cancel claims the
-/// item after its action has started but before the run finishes, the disposable the action produced must still
-/// be torn down.
-/// </summary>
+/// <summary>Tests the run/cancel handshake in <see cref="DispatchWorkItemBase{TState}"/>, which tears down work a cancelled action returned.</summary>
 public sealed class DispatchWorkItemBaseTests
 {
     /// <summary>The scheduled state value the probe work item carries.</summary>
     private const int ProbeState = 0;
 
-    /// <summary>Verifies a cancel that races the running action still disposes the work the action returned.</summary>
+    /// <summary>Verifies a cancel that races the running action disposes the work the action returned.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task RunDisposesTheStartedWorkWhenCancellationClaimsTheItemDuringItsAction()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
index 9a108b57..7f942eb1 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/AsyncSignalTests.cs
@@ -22,19 +22,19 @@ public class AsyncSignalTests
     /// <summary>The values expected after the first emission.</summary>
     private static readonly int[] FirstEmittedValues = [FirstEmittedValue];
 
-    /// <summary>Subscribes the argument checking.</summary>
+    /// <summary>Subscribing with a null observer is rejected.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void Subscribe_ArgumentChecking() =>
         Assert.Throws<ArgumentNullException>(static () => new AsyncSignal<int>().Subscribe(null!));
 
-    /// <summary>Called when [error argument checking].</summary>
+    /// <summary>Faulting with a null error is rejected.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void OnError_ArgumentChecking() =>
         Assert.Throws<ArgumentNullException>(static () => new AsyncSignal<int>().OnError(null!));
 
-    /// <summary>Awaits the blocking.</summary>
+    /// <summary>The signal is its own awaiter and reports completion once a value arrives.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Await_Blocking()
@@ -45,7 +45,7 @@ public async Task Await_Blocking()
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
-    /// <summary>Awaits the throw.</summary>
+    /// <summary>The signal is its own awaiter and reports completion once a fault arrives.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Await_Throw()
@@ -56,7 +56,7 @@ public async Task Await_Throw()
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
-    /// <summary>Gets the result empty.</summary>
+    /// <summary>Reading the result of a signal that completed without a value throws.</summary>
     [Test]
     public void GetResult_Empty()
     {
@@ -65,7 +65,7 @@ public void GetResult_Empty()
         _ = Assert.Throws<InvalidOperationException>(() => s.GetResult());
     }
 
-    /// <summary>Gets the result blocking.</summary>
+    /// <summary>A pending wait delivers a value and leaves the signal completed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GetResult_Blocking()
@@ -75,7 +75,7 @@ public async Task GetResult_Blocking()
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
-    /// <summary>Gets the result blocking throw.</summary>
+    /// <summary>A pending wait delivers a fault and leaves the signal completed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GetResult_Blocking_Throw()
@@ -85,7 +85,7 @@ public async Task GetResult_Blocking_Throw()
         await Assert.That(s.IsCompleted).IsTrue();
     }
 
-    /// <summary>Gets the result context.</summary>
+    /// <summary>A continuation registered under a synchronization context is posted through that context.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GetResult_Context()
@@ -110,7 +110,7 @@ public async Task GetResult_Context()
         await Assert.That(context.Ran).IsTrue();
     }
 
-    /// <summary>Determines whether this instance has observers.</summary>
+    /// <summary>Observer presence tracks subscriptions as they are added and disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers()
@@ -131,7 +131,7 @@ public async Task HasObservers()
         await Assert.That(s.HasObservers).IsFalse();
     }
 
-    /// <summary>Determines whether [has observers dispose1].</summary>
+    /// <summary>Disposing the signal drops its observers, and disposing a live subscription afterwards is safe.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose1()
@@ -150,7 +150,7 @@ public async Task HasObservers_Dispose1()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers dispose2].</summary>
+    /// <summary>Disposing the last subscription clears the observers and leaves the signal undisposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose2()
@@ -169,7 +169,7 @@ public async Task HasObservers_Dispose2()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers dispose3].</summary>
+    /// <summary>Disposing a signal that was never subscribed to reports no observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose3()
@@ -182,7 +182,7 @@ public async Task HasObservers_Dispose3()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers on completed].</summary>
+    /// <summary>Completing the signal releases its observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnCompleted()
@@ -198,7 +198,7 @@ public async Task HasObservers_OnCompleted()
         d.Dispose();
     }
 
-    /// <summary>Determines whether [has observers on error].</summary>
+    /// <summary>Faulting the signal releases its observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnError()
@@ -216,10 +216,7 @@ public async Task HasObservers_OnError()
         d.Dispose();
     }
 
-    /// <summary>
-    /// An async signal that completes without ever producing a value has no terminal value to replay. A late
-    /// subscriber must simply be completed — not handed a fabricated default, and not left hanging.
-    /// </summary>
+    /// <summary>A signal that completes without producing a value only completes its late subscribers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CompletingWithoutAValueOnlyCompletesLateSubscribers()
@@ -237,7 +234,7 @@ public async Task CompletingWithoutAValueOnlyCompletesLateSubscribers()
         await Assert.That(signal.HasObservers).IsFalse();
     }
 
-    /// <summary>Covers async-signal subscriber churn, late subscriptions, disposal, and terminal no-op branches.</summary>
+    /// <summary>Subscriber churn, late subscriptions, repeated terminals, and disposal all hold on an async signal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AsyncSignalSubscriberChurnLateTerminalsAndDisposalCoverBranches()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
index dcf4edd8..07fc5708 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
@@ -22,19 +22,19 @@ public class BehaviorSignalTests
     /// <summary>Value that should be ignored after completion.</summary>
     private const int IgnoredAfterCompletionValue = 1234;
 
-    /// <summary>Subscribes the argument checking.</summary>
+    /// <summary>Verifies a behavior signal rejects a null observer.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void Subscribe_ArgumentChecking() =>
         Assert.Throws<ArgumentNullException>(static () => new BehaviorSignal<int>(1).Subscribe(null!));
 
-    /// <summary>Called when [error argument checking].</summary>
+    /// <summary>Verifies a behavior signal rejects a null error.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void OnError_ArgumentChecking() =>
         Assert.Throws<ArgumentNullException>(static () => new BehaviorSignal<int>(1).OnError(null!));
 
-    /// <summary>Determines whether this instance has observers.</summary>
+    /// <summary>Verifies a behavior signal tracks observers as subscriptions are added and removed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers()
@@ -55,7 +55,7 @@ public async Task HasObservers()
         await Assert.That(s.HasObservers).IsFalse();
     }
 
-    /// <summary>Determines whether [has observers dispose1].</summary>
+    /// <summary>Verifies a behavior signal drops its observers when the signal is disposed first.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose1()
@@ -74,7 +74,7 @@ public async Task HasObservers_Dispose1()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers dispose2].</summary>
+    /// <summary>Verifies a behavior signal drops its observers when the subscription is disposed first.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose2()
@@ -93,7 +93,7 @@ public async Task HasObservers_Dispose2()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers dispose3].</summary>
+    /// <summary>Verifies a behavior signal with no subscribers reports itself as disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose3()
@@ -106,7 +106,7 @@ public async Task HasObservers_Dispose3()
         await Assert.That(s.IsDisposed).IsTrue();
     }
 
-    /// <summary>Determines whether [has observers on completed].</summary>
+    /// <summary>Verifies completion drops a behavior signal's observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnCompleted()
@@ -121,7 +121,7 @@ public async Task HasObservers_OnCompleted()
         await Assert.That(s.HasObservers).IsFalse();
     }
 
-    /// <summary>Determines whether [has observers on error].</summary>
+    /// <summary>Verifies an error drops a behavior signal's observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnError()
@@ -138,7 +138,7 @@ public async Task HasObservers_OnError()
         await Assert.That(s.HasObservers).IsFalse();
     }
 
-    /// <summary>Values the initial.</summary>
+    /// <summary>Verifies a new behavior signal exposes the initial value it was constructed with.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_Initial()
@@ -149,7 +149,7 @@ public async Task Value_Initial()
         await Assert.That(x).IsEqualTo(InitialValue);
     }
 
-    /// <summary>Values the first.</summary>
+    /// <summary>Verifies a behavior signal's value follows the first emitted value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_First()
@@ -164,7 +164,7 @@ public async Task Value_First()
         await Assert.That(x).IsEqualTo(FirstUpdatedValue);
     }
 
-    /// <summary>Values the second.</summary>
+    /// <summary>Verifies a behavior signal's value follows each subsequent emitted value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_Second()
@@ -183,7 +183,7 @@ public async Task Value_Second()
         await Assert.That(x).IsEqualTo(SecondUpdatedValue);
     }
 
-    /// <summary>Values the frozen after on completed.</summary>
+    /// <summary>Verifies a completed behavior signal keeps its last value and ignores later values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_FrozenAfterOnCompleted()
@@ -210,7 +210,7 @@ public async Task Value_FrozenAfterOnCompleted()
         await Assert.That(x).IsEqualTo(SecondUpdatedValue);
     }
 
-    /// <summary>Values the throws after on error.</summary>
+    /// <summary>Verifies reading the value of a faulted behavior signal rethrows its error.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_ThrowsAfterOnError()
@@ -222,7 +222,7 @@ public async Task Value_ThrowsAfterOnError()
         _ = Assert.Throws<InvalidOperationException>(() => s.TryGetValue(out _));
     }
 
-    /// <summary>Values the throws on dispose.</summary>
+    /// <summary>Verifies reading the value of a disposed behavior signal throws.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Value_ThrowsOnDispose()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
index d8915ad2..d8f19a47 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Tests for the fused <see cref = "LinqExtensions.BlendUnique{T}(IObservable{T}[])"/> operator (merge + distinct-until-changed in a single sink).</summary>
+/// <summary>Tests for the fused <see cref = "LinqExtensions.BlendUnique{T}(IObservable{T}[])"/> operator.</summary>
 public class BlendUniqueTests
 {
     /// <summary>The value one.</summary>
@@ -39,10 +39,7 @@ public class BlendUniqueTests
     /// <summary>Expected case-insensitive distinct result.</summary>
     private static readonly string[] _distinctCaseInsensitive = ["a", "B"];
 
-    /// <summary>
-    /// Verifies that the merged stream forwards only values that differ from the previously forwarded one
-    /// and completes once every source has completed.
-    /// </summary>
+    /// <summary>Verifies the merged stream drops values equal to the last forwarded one and completes once every source does.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task MergesSourcesAndSuppressesConsecutiveDuplicates()
@@ -50,7 +47,6 @@ public async Task MergesSourcesAndSuppressesConsecutiveDuplicates()
         List<int> values = [];
         var completed = 0;
 
-        // source0 emits 1,1,2 (-> 1,2) then source1 emits 2,3,3 (2 == last, dropped -> 3).
         _ = LinqExtensions
             .BlendUnique(
                 Signal.FromEnumerable(_firstDuplicatedThenSecond),
@@ -79,7 +75,6 @@ public async Task UsesSuppliedComparer()
     {
         List<string> values = [];
 
-        // Case-insensitive: "a","A" collapse; "B" forwarded.
         _ = LinqExtensions.BlendUnique([Signal.FromEnumerable(_caseVariants)], StringComparer.OrdinalIgnoreCase)
             .Subscribe(values.Add);
         await Assert.That(values.SequenceEqual(_distinctCaseInsensitive)).IsTrue();
@@ -110,7 +105,7 @@ public async Task DisposeUnsubscribesFromSources()
         var subscription = LinqExtensions.BlendUnique(source).Subscribe(values.Add);
         source.OnNext(One);
         subscription.Dispose();
-        source.OnNext(Two); // no longer subscribed -> ignored
+        source.OnNext(Two);
         await Assert.That(values.SequenceEqual(_single)).IsTrue();
     }
 
@@ -126,11 +121,11 @@ public async Task SuppressesNotificationsAfterTerminalError()
         Exception? error = null;
         var completed = 0;
         _ = LinqExtensions.BlendUnique(first, second, third).Subscribe(values.Add, ex => error = ex, () => completed++);
-        first.OnNext(One); // forwarded
-        second.OnError(new InvalidOperationException("boom")); // terminal
-        first.OnNext(Two); // value suppressed (done)
-        first.OnCompleted(); // completion suppressed (done)
-        third.OnError(new InvalidOperationException("again")); // error suppressed (done)
+        first.OnNext(One);
+        second.OnError(new InvalidOperationException("boom"));
+        first.OnNext(Two);
+        first.OnCompleted();
+        third.OnError(new InvalidOperationException("again"));
         await Assert.That(values.SequenceEqual(_single)).IsTrue();
         await Assert.That(error).IsNotNull();
         await Assert.That(completed).IsEqualTo(0);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
index cce2b2b8..9ba2fc4e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Coverage for the public <see cref="Broadcaster{T}"/> equality and copy-on-write surface.</summary>
+/// <summary>Tests for the public <see cref="Broadcaster{T}"/> equality and copy-on-write surface.</summary>
 public class BroadcasterTests
 {
     /// <summary>The literal one.</summary>
@@ -27,21 +27,16 @@ public async Task BroadcasterEqualityOperatorsCompareTheObserverSet()
         Broadcaster<int> left = default;
         Broadcaster<int> right = default;
 
-        // Both empty -> same (null) observer set.
         await Assert.That(left == right).IsTrue();
         await Assert.That(left != right).IsFalse();
         left.Add(new DelegateWitness<int>(static _ => { }));
 
-        // Left now references an observer set; right is still empty.
+        // Left references an observer set; right is empty.
         await Assert.That(left != right).IsTrue();
         await Assert.That(left == right).IsFalse();
     }
 
-    /// <summary>
-    /// The hash follows the observer set, which has three shapes. An empty broadcaster hashes to zero, and a
-    /// broadcaster holding exactly one observer hashes to that observer's identity — so two broadcasters over
-    /// the same single observer agree, which is what equality promises.
-    /// </summary>
+    /// <summary>An empty broadcaster hashes to zero and a single-observer broadcaster hashes to that observer's identity.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task BroadcasterHashesToZeroWhenEmptyAndToTheObserverIdentityWhenSingle()
@@ -61,7 +56,7 @@ public async Task BroadcasterHashesToZeroWhenEmptyAndToTheObserverIdentityWhenSi
         await Assert.That(single.Equals(alsoSingle)).IsTrue();
     }
 
-    /// <summary>Covers broadcaster copy-on-write, signal late-terminal, and buffer disposal/error branches.</summary>
+    /// <summary>Verifies broadcaster copy-on-write, late terminal notifications on a signal, and buffer error handling.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task BroadcasterCopyOnWriteSignalAndBufferCoverTerminalEdges()
@@ -109,7 +104,7 @@ public async Task BroadcasterCopyOnWriteSignalAndBufferCoverTerminalEdges()
             source.OnNext(One);
             source.OnNext(Two);
 
-            // The window (size 3) is incomplete; completion flushes the partial trailing window.
+            // The size-3 window is incomplete, so completion flushes the partial window.
             source.OnCompleted();
         }
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
index d0cb15ef..1085355f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for the quiet-period coordinator behind <c>Calm</c> and its <c>Throttle</c> alias, whose completion
-/// has to deliver the value still waiting inside the quiet window instead of discarding it.
-/// </summary>
+/// <summary>Tests for the quiet-period coordinator behind <c>Calm</c> and its <c>Throttle</c> alias.</summary>
 public sealed class CalmCoordinatorTests
 {
     /// <summary>The integer constant one.</summary>
@@ -22,10 +19,10 @@ public sealed class CalmCoordinatorTests
     /// <summary>The marker for a completion that has not been observed yet.</summary>
     private const int NoCompletionObserved = -1;
 
-    /// <summary>The quiet period used by these tests; its timer only fires when the test runs it.</summary>
+    /// <summary>The quiet period used by these tests.</summary>
     private static readonly TimeSpan QuietPeriod = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>Verifies each new value extends the quiet period without emitting the previous value.</summary>
+    /// <summary>Verifies each new value extends the quiet period without emitting the earlier value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ThrottleWaitsForTheQuietPeriodAfterTheLatestValue()
@@ -118,7 +115,7 @@ public async Task CompletionFlushesOnlyTheNewestBufferedValue()
         await Assert.That(witness.Completed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies completion does not repeat a value the quiet-period timer has already delivered.</summary>
+    /// <summary>Verifies completion does not repeat a value the quiet-period timer delivered.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CompletionDoesNotRepeatAValueTheTimerAlreadyDelivered()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
index e236e3d2..63efd95b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
@@ -14,7 +14,7 @@ public class ChooseSwitchSelectTests
     /// <summary>The value ten.</summary>
     private const int Ten = 10;
 
-    /// <summary>The value eleven (stale inner value that must be ignored).</summary>
+    /// <summary>The value eleven, emitted by a superseded inner source.</summary>
     private const int Eleven = 11;
 
     /// <summary>The value twenty.</summary>
@@ -72,10 +72,7 @@ public async Task ChooseForwardsChooserError()
         await Assert.That(error is InvalidOperationException).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that SwitchSelect skips null source values, mirrors the latest inner observable, and ignores
-    /// values from a superseded inner observable.
-    /// </summary>
+    /// <summary>Verifies SwitchSelect skips null values, mirrors the latest inner source, and ignores a superseded one.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchSelectFiltersNullSwitchesAndIgnoresStaleInner()
@@ -85,12 +82,12 @@ public async Task SwitchSelectFiltersNullSwitchesAndIgnoresStaleInner()
         Signal<int> inner2 = new();
         List<int> values = [];
         _ = outer.SwitchSelect(key => key == KeyA ? inner1 : inner2).Subscribe(values.Add);
-        outer.OnNext(null); // skipped (null)
-        outer.OnNext(KeyA); // subscribe inner1
-        inner1.OnNext(Ten); // forwarded
-        outer.OnNext(KeyB); // switch to inner2; inner1 superseded
-        inner1.OnNext(Eleven); // stale -> ignored
-        inner2.OnNext(Twenty); // forwarded
+        outer.OnNext(null);
+        outer.OnNext(KeyA);
+        inner1.OnNext(Ten);
+        outer.OnNext(KeyB);
+        inner1.OnNext(Eleven);
+        inner2.OnNext(Twenty);
         await Assert.That(values.SequenceEqual(_tenThenTwenty)).IsTrue();
     }
 
@@ -106,10 +103,10 @@ public async Task SwitchSelectCompletesAfterOuterAndInner()
             static _ => { },
             static ex => throw ex,
             () => completed++);
-        outer.OnNext(KeyA); // active inner
-        outer.OnCompleted(); // outer done, inner still active -> not complete
+        outer.OnNext(KeyA);
+        outer.OnCompleted();
         await Assert.That(completed).IsEqualTo(0);
-        inner.OnCompleted(); // now complete
+        inner.OnCompleted();
         await Assert.That(completed).IsEqualTo(Once);
     }
 
@@ -189,8 +186,8 @@ public async Task SwitchSelectDisposeUnsubscribes()
         outer.OnNext(KeyA);
         inner.OnNext(Ten);
         subscription.Dispose();
-        inner.OnNext(Eleven); // disposed -> ignored
-        outer.OnNext(KeyB); // disposed -> ignored
+        inner.OnNext(Eleven);
+        outer.OnNext(KeyB);
         await Assert.That(values.SequenceEqual(_tenOnly)).IsTrue();
     }
 
@@ -207,9 +204,9 @@ public async Task SwitchSelectCompletesWhenInnerThenOuterComplete()
             static ex => throw ex,
             () => completed++);
         outer.OnNext(KeyA);
-        inner.OnCompleted(); // inner done; outer still open -> not complete
+        inner.OnCompleted();
         await Assert.That(completed).IsEqualTo(0);
-        outer.OnCompleted(); // outer done, no active inner -> complete
+        outer.OnCompleted();
         await Assert.That(completed).IsEqualTo(Once);
     }
 
@@ -228,11 +225,7 @@ public async Task SwitchSelectCompletesWhenOuterCompletesWithNoValue()
         await Assert.That(completed).IsEqualTo(Once);
     }
 
-    /// <summary>
-    /// Verifies the SwitchSelect race guards drop notifications from a superseded inner observable and
-    /// from the outer/active-inner sources after disposal — the defensive early-returns that a
-    /// well-behaved (unsubscribing) source would otherwise hide.
-    /// </summary>
+    /// <summary>Verifies the SwitchSelect guards drop superseded-inner notifications and every notification after disposal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchSelectGuardsIgnoreStaleAndPostDisposeNotifications()
@@ -245,17 +238,16 @@ public async Task SwitchSelectGuardsIgnoreStaleAndPostDisposeNotifications()
         var completed = 0;
         var subscription = outer.SwitchSelect(key => key == KeyA ? inner1 : inner2)
             .Subscribe(values.Add, ex => error = ex, () => completed++);
-        outer.Next(KeyA); // inner1 active
-        outer.Next(KeyB); // inner2 active; inner1 now superseded
+        outer.Next(KeyA);
+        outer.Next(KeyB);
 
-        // Superseded inner1 (its id != the latest): every notification hits the stale guard.
         inner1.Next(Eleven);
         inner1.Error(new InvalidOperationException(Boom));
         inner1.Complete();
         subscription.Dispose();
-        subscription.Dispose(); // idempotent: the second dispose hits the disposed guard
+        subscription.Dispose(); // Disposing twice must be a no-op.
 
-        // After disposal every outer and active-inner notification hits the disposed guard.
+        // ManualObservable keeps pushing after disposal, so the guards are what drop these.
         outer.Next(KeyA);
         outer.Error(new InvalidOperationException(Boom));
         outer.Complete();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
index 4f78e7ef..ab8b2529 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CommandExecutionTests.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies <see cref="CommandExecution{TResult}"/>, the awaitable a command hands back. It exists so a command
-/// that finishes synchronously does not have to allocate a task, which means it has three shapes to honour —
-/// a task, a bare result, and a bare exception — behind one awaiter.
-/// </summary>
+/// <summary>Verifies <see cref="CommandExecution{TResult}"/>, the awaitable a command hands back.</summary>
 public class CommandExecutionTests
 {
     /// <summary>The value a successful command produces.</summary>
@@ -31,10 +27,7 @@ public async Task AwaitingASynchronousCommandReturnsItsResult()
         await Assert.That(await execution).IsEqualTo(CommandResult);
     }
 
-    /// <summary>
-    /// A synchronous command that fails is carried as a bare exception, and awaiting it must rethrow that exact
-    /// exception rather than an <see cref="AggregateException"/> wrapper.
-    /// </summary>
+    /// <summary>Awaiting a failed synchronous command rethrows the original exception, not an <see cref="AggregateException"/>.</summary>
     /// <returns>A task that completes when the synchronous-fault assertions finish.</returns>
     [Test]
     public async Task AwaitingAFailedSynchronousCommandRethrowsTheOriginalException()
@@ -49,10 +42,7 @@ public async Task AwaitingAFailedSynchronousCommandRethrowsTheOriginalException(
         await Assert.That(thrown!).IsSameReferenceAs(fault);
     }
 
-    /// <summary>
-    /// <c>ConfigureAwait</c> hands back a fresh awaitable that carries the same outcome. It must not lose the
-    /// result on the way through, whichever of the three shapes the execution is carrying.
-    /// </summary>
+    /// <summary><c>ConfigureAwait</c> preserves the outcome of a task, a bare result, and a bare exception alike.</summary>
     /// <returns>A task that completes when the configure-await assertions finish.</returns>
     [Test]
     public async Task ConfigureAwaitPreservesTheOutcomeOfEveryExecutionShape()
@@ -75,11 +65,7 @@ public async Task ConfigureAwaitPreservesTheOutcomeOfEveryExecutionShape()
         await Assert.That(thrown!).IsSameReferenceAs(fault);
     }
 
-    /// <summary>
-    /// The awaiter implements the plain <see cref="System.Runtime.CompilerServices.INotifyCompletion"/>
-    /// continuation path as well as the critical one the C# compiler prefers. A caller that schedules through it
-    /// must still be resumed, and must still see the result.
-    /// </summary>
+    /// <summary>A continuation scheduled through <see cref="System.Runtime.CompilerServices.INotifyCompletion"/> is resumed and sees the result.</summary>
     /// <returns>A task that completes when the continuation assertions finish.</returns>
     [Test]
     public async Task TheAwaiterResumesAContinuationScheduledThroughOnCompleted()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
index b2bb0e42..051b2eca 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CommandSignalTests.cs
@@ -68,7 +68,7 @@ public async Task CommandSignalPublishesResultsFailuresAndRunningState()
         await Assert.That(rejected!.Message).IsEqualTo("Command cannot run.");
     }
 
-    /// <summary>Verifies command aliases, sync execution failures, and disposal branches.</summary>
+    /// <summary>A synchronous command that throws publishes the fault, and a disposed command rejects execution.</summary>
     /// <returns>A task that completes when command assertions finish.</returns>
     [Test]
     public async Task CommandSignalCoversSyncFaultAndDisposalBranches()
@@ -130,11 +130,7 @@ public async Task InstallingAStaleRunningSnapshotReconcilesCompletion()
         await Assert.That(installed.Value).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies the running-state stream is allocated lazily, cached on the second access, and
-    /// reports <see langword="false"/> when first observed on an idle command (the install CAS wins
-    /// and the post-install reconcile publishes the authoritative flag).
-    /// </summary>
+    /// <summary>The running-state stream is allocated lazily, cached, and reports <see langword="false"/> on an idle command.</summary>
     /// <returns>A task that completes when the lazy-allocation assertions finish.</returns>
     [Test]
     public async Task IsRunningAllocatesLazilyAndCachesTheStream()
@@ -148,11 +144,7 @@ public async Task IsRunningAllocatesLazilyAndCachesTheStream()
         await Assert.That(first.Value).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies a normal true-then-false transition flows through an already-installed stream: the
-    /// stream is observed before execution, so <c>SetRunning</c> takes the "stream present" path on
-    /// both edges and the running flag returns to <see langword="false"/> at the end.
-    /// </summary>
+    /// <summary>A stream observed before execution sees the true-then-false transition and ends at <see langword="false"/>.</summary>
     /// <returns>A task that completes when the transition assertions finish.</returns>
     [Test]
     public async Task IsRunningTransitionsTrueThenFalseThroughInstalledStream()
@@ -167,11 +159,7 @@ public async Task IsRunningTransitionsTrueThenFalseThroughInstalledStream()
         await Assert.That(running.SequenceEqual(ExpectedRunningValues)).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that when an execution completes without the running-state stream ever having been
-    /// observed, <c>SetRunning</c> exercises the "stream still null" reconciliation branch and a
-    /// later first observation still reports <see langword="false"/>.
-    /// </summary>
+    /// <summary>A first observation made after the execution completes reports <see langword="false"/>.</summary>
     /// <returns>A task that completes when the deferred-observation assertions finish.</returns>
     [Test]
     public async Task IsRunningReportsFalseWhenObservedOnlyAfterExecution()
@@ -183,12 +171,7 @@ public async Task IsRunningReportsFalseWhenObservedOnlyAfterExecution()
         await Assert.That(command.IsRunning.Value).IsFalse();
     }
 
-    /// <summary>
-    /// Drives the lazy install deterministically: the stream is first observed while an async
-    /// execution is in flight (running flag true), then the execution completes and lowers it. This
-    /// exercises the install-side re-sync seeding a <see langword="true"/> value followed by the
-    /// installed-stream completion edge.
-    /// </summary>
+    /// <summary>A stream first observed mid-flight reports <see langword="true"/>, then <see langword="false"/> once the execution completes.</summary>
     /// <returns>A task that completes when the mid-flight assertions finish.</returns>
     [Test]
     public async Task IsRunningObservedMidFlightSettlesFalseAfterCompletion()
@@ -219,15 +202,13 @@ public async Task ResultsFanOutToEverySubscriberAndStopAtUnsubscribe()
 
         _ = command.ExecuteAsync();
 
-        // Remove from the middle of a three-observer array: the survivors must both keep receiving.
+        // Removing the middle of a three-observer array leaves both survivors receiving.
         secondSubscription.Dispose();
         _ = command.ExecuteAsync();
 
-        // Remove from a two-observer array, collapsing it back to a single observer.
         thirdSubscription.Dispose();
         _ = command.ExecuteAsync();
 
-        // Removing the last observer, then disposing the same handle again, must both be safe.
         firstSubscription.Dispose();
         firstSubscription.Dispose();
         _ = command.ExecuteAsync();
@@ -238,10 +219,7 @@ public async Task ResultsFanOutToEverySubscriberAndStopAtUnsubscribe()
         await Assert.That(first.TrueForAll(static value => value == CommandResult)).IsTrue();
     }
 
-    /// <summary>
-    /// Disposing the command drops its observer set, so a subscription handle disposed afterwards has nothing
-    /// to detach from. That must be a quiet no-op rather than a failure.
-    /// </summary>
+    /// <summary>Disposing a result subscription after the command is disposed is a quiet no-op.</summary>
     /// <returns>A task that completes when the post-disposal assertions finish.</returns>
     [Test]
     public async Task ResultSubscriptionDisposedAfterTheCommandIsSafe()
@@ -257,18 +235,14 @@ public async Task ResultSubscriptionDisposedAfterTheCommandIsSafe()
         _ = Assert.Throws<ObjectDisposedException>(() => command.Results.Subscribe(results.Add));
     }
 
-    /// <summary>
-    /// An async command that faults publishes the fault to the fault stream before the awaited task rethrows it,
-    /// and still lowers the running flag on the way out.
-    /// </summary>
+    /// <summary>An async command that faults publishes the fault before the await rethrows it, and lowers the running flag.</summary>
     /// <returns>A task that completes when the async-fault assertions finish.</returns>
     [Test]
     public async Task AsyncExecutionPublishesTheFaultAndStillLowersTheRunningFlag()
     {
         InvalidOperationException fault = new("async failed");
 
-        // The delegate type is spelled out because a body that only throws gives the compiler no return
-        // expression to infer Task<int> from.
+        // The delegate type is spelled out: a throw-only body gives the compiler nothing to infer Task<int> from.
         Func<CancellationToken, Task<int>> execute = async token =>
         {
             await Task.Yield();
@@ -299,10 +273,7 @@ public async Task AsyncExecutionPublishesTheFaultAndStillLowersTheRunningFlag()
         await Assert.That(command.IsRunning.Value).IsFalse();
     }
 
-    /// <summary>
-    /// The fault stream is allocated on first use and cached thereafter, and disposing the command tears down
-    /// the gate subscription along with the streams it created.
-    /// </summary>
+    /// <summary>The fault stream is cached after first use, and disposing the command releases the gate subscription.</summary>
     /// <returns>A task that completes when the lazy-fault-stream assertions finish.</returns>
     [Test]
     public async Task FaultsAllocateLazilyAndDisposalReleasesTheGateSubscription()
@@ -319,7 +290,7 @@ public async Task FaultsAllocateLazilyAndDisposalReleasesTheGateSubscription()
 
         command.Dispose();
 
-        // The command released the gate, so the gate signal no longer feeds anything.
+        // The command released the gate, so the gate signal feeds nothing.
         await Assert.That(canRun.HasObservers).IsFalse();
         await Assert.That(running.IsDisposed).IsTrue();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
index 94a77a1a..cb79a139 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
@@ -10,9 +10,8 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>
-/// Compiles a snippet of consumer code against the shipped Primitives assemblies so a test can assert what a
-/// downstream project's compiler resolves. Overload resolution against a referenced assembly is not observable
-/// from inside this assembly, where the same names bind through source rather than metadata.
+/// Compiles consumer code against the shipped Primitives assemblies to assert what a downstream compiler resolves.
+/// Overload resolution against a referenced assembly binds through metadata, not through this assembly's source.
 /// </summary>
 public static class ConsumerCompilation
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
index a3be5b8d..7bbc0e0b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/FirstInlineSequencer.cs
@@ -12,10 +12,10 @@ namespace ReactiveUI.Primitives.Tests;
 [System.Diagnostics.DebuggerDisplay("FirstInlineSequencer: Now = {Now}, Started = {_started}, Pending = {_pending.Count}")]
 public sealed class FirstInlineSequencer(TimeSpan advanceBeforeFirst) : ISequencer
 {
-    /// <summary>The work items queued after the first, still waiting to run.</summary>
+    /// <summary>The work items queued after the first, waiting to run.</summary>
     private readonly List<IWorkItem> _pending = [];
 
-    /// <summary>Whether the inline first item has already run.</summary>
+    /// <summary>Whether the inline first item has run.</summary>
     private bool _started;
 
     /// <summary>Gets the sequencer's notion of current time.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
index 390da735..c346c6b3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ManualSequencer.cs
@@ -34,10 +34,7 @@ internal sealed class ManualSequencer : ISequencer
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
-        Justification =
-            "The relative and absolute Schedule overloads of this test-double sequencer intentionally behave the same "
-            + "way; both are required by the ISequencer contract and, as distinct interface overloads, cannot forward "
-            + "to one another.")]
+        Justification = "Both ISequencer Schedule overloads of this test double queue the item without honoring a due time.")]
     public void Schedule(IWorkItem item, long dueTimestamp) => _pending.Add(item);
 
     /// <summary>Moves the sequencer's clock forward without running any work.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
index 42469d70..505dabf5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Creates a minimal tick-based <see cref="VirtualTimeSequencer{TAbsolute, TRelative}"/> used to exercise scheduling edge branches.</summary>
+/// <summary>Creates a minimal tick-based <see cref="VirtualTimeSequencer{TAbsolute, TRelative}"/>.</summary>
 internal static class MinimalVirtualClock
 {
     /// <summary>Adds a tick offset to an absolute tick value.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ThrowingComparer.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ThrowingComparer.cs
index f4d33540..ebd6f3fc 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/ThrowingComparer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ThrowingComparer.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>An equality comparer that throws when comparing values.</summary>
 internal sealed class ThrowingComparer : IEqualityComparer<int>
 {
-    /// <summary>Defers to a faulting comparison so the equality comparison throws when invoked.</summary>
+    /// <summary>Throws instead of comparing the two values.</summary>
     /// <param name="x">The first value to compare.</param>
     /// <param name="y">The second value to compare.</param>
     /// <returns>This method never returns; the faulting comparison always throws.</returns>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
index c18c71fd..5f0ca985 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs
@@ -123,7 +123,6 @@ public async Task MulticastRoutesSourceValuesThroughTheSuppliedHub()
         List<int> observed = [];
         using var subscription = multicast.Subscribe(observed.Add);
 
-        // No connection yet, so the hub must not see the source at all.
         source.OnNext(UnobservedSharedValue);
         await Assert.That(observed.Count).IsEqualTo(0);
 
@@ -299,7 +298,6 @@ public async Task AutoShareConnectsOnFirstSubscriberAndDisconnectsOnLast()
         var secondSubscription = shared.Subscribe(second.Add);
         source.OnNext(FirstSharedValue);
 
-        // The single upstream connection feeds every observer.
         await Assert.That(sourceSubscriptions).IsEqualTo(1);
 
         firstSubscription.Dispose();
@@ -307,7 +305,6 @@ public async Task AutoShareConnectsOnFirstSubscriberAndDisconnectsOnLast()
 
         secondSubscription.Dispose();
 
-        // The connection is disposed only once the final subscriber leaves.
         await Assert.That(sourceDisposals).IsEqualTo(1);
         await Assert.That(first.SequenceEqual(ExpectedFirstSharedValues)).IsTrue();
         await Assert.That(second.SequenceEqual(ExpectedFirstSharedValues)).IsTrue();
@@ -339,7 +336,6 @@ public async Task AutoShareReconnectsAfterAllSubscribersLeave()
         await Assert.That(sourceSubscriptions).IsEqualTo(1);
         await Assert.That(sourceDisposals).IsEqualTo(1);
 
-        // A fresh subscriber after the count returned to zero forces a new connection.
         using var second = shared.Subscribe(static _ => { });
         await Assert.That(sourceSubscriptions).IsEqualTo(ExpectedConnections);
         await Assert.That(sourceDisposals).IsEqualTo(1);
@@ -368,12 +364,10 @@ public async Task AutoShareConnectFailureUnwindsRefcount()
 
         var shared = cold.Share().AutoShare();
 
-        // Connect runs outside the gate; a synchronous failure surfaces to the caller.
         var thrown = Assert.Throws<InvalidOperationException>(() => shared.Subscribe(static _ => { }));
         await Assert.That(thrown).IsSameReferenceAs(expected);
         await Assert.That(subscribeAttempts).IsEqualTo(1);
 
-        // The failed attempt unwound the count, so the next subscriber reconnects rather than stalling.
         shouldThrow = false;
         List<int> values = [];
         using var recovered = shared.Subscribe(values.Add);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DelegateWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DelegateWitnessTests.cs
index 2b3dca91..c703857c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DelegateWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DelegateWitnessTests.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Coverage for the public <see cref="DelegateWitness{T}"/> surface.</summary>
+/// <summary>Tests for <see cref="DelegateWitness{T}"/>.</summary>
 public class DelegateWitnessTests
 {
     /// <summary>The literal one.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
index 79e72b09..e425e2b0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DispatchSequencerStateTests.cs
@@ -228,14 +228,13 @@ public async Task RejectedPostReleasesTheDrainLatch()
         sequencer.PostSucceeds = true;
         sequencer.Schedule(new RecordingWorkItem(values, NestedDrainValue));
 
-        // A latch left set by the rejected post would swallow this second post, stranding both work items.
         await Assert.That(sequencer.PostCount).IsEqualTo(ExpectedRetriedPostCount);
 
         sequencer.RunNextDrain();
         await Assert.That(values.SequenceEqual(ExpectedDrainPair)).IsTrue();
     }
 
-    /// <summary>Verifies a dispatcher post that throws surfaces the failure and still releases the drain latch.</summary>
+    /// <summary>Verifies a dispatcher post that throws surfaces the failure and releases the drain latch.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FailedPostReleasesTheDrainLatchAndRethrows()
@@ -255,7 +254,7 @@ await Assert.That(() => sequencer.Schedule(new RecordingWorkItem(values, OuterDr
         await Assert.That(values.SequenceEqual(ExpectedDrainPair)).IsTrue();
     }
 
-    /// <summary>Verifies a drain re-entered by one of its own work items still runs every queued item exactly once.</summary>
+    /// <summary>Verifies a drain re-entered by one of its own work items runs every queued item exactly once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ReentrantDrainRunsEachQueuedItemExactlyOnce()
@@ -294,8 +293,7 @@ private TestDispatchSequencer()
         /// <inheritdoc/>
         public long Timestamp => DispatchSequencerState.Timestamp;
 
-        /// <summary>Creates a sequencer whose dispatch state is wired only after construction has finished,
-        /// so the engine never sees a half-built owner.</summary>
+        /// <summary>Creates a sequencer wired to a dispatch state.</summary>
         /// <param name="sharedTimer">The optional fallback delay sequencer.</param>
         /// <returns>The wired sequencer.</returns>
         public static TestDispatchSequencer Create(ISequencer? sharedTimer = null)
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
index b879f1b3..6282ea44 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DisposableTests.cs
@@ -99,7 +99,7 @@ public async Task SingleReplaceableDisposableRunsActionOnlyOnce()
         await Assert.That(actionCount).IsEqualTo(1);
     }
 
-    /// <summary>Covers disposable slot constructor, disposal, removal, and disposed-assignment branches.</summary>
+    /// <summary>Verifies slot assignment after disposal, replacement, and removal from a disposable group.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposableSlotsCoverAssignmentReplacementAndRemovalBranches()
@@ -125,7 +125,7 @@ public async Task DisposableSlotsCoverAssignmentReplacementAndRemovalBranches()
         DisposeEveryConstructedSlotShape();
     }
 
-    /// <summary>Verifies low-level disposables, collections, and schedulers cover deterministic edges.</summary>
+    /// <summary>Verifies the disposable, copy-on-write list, priority queue, and scheduling contracts.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task LowLevelDisposablesCollectionsAndSchedulersCoverDeterministicEdges()
@@ -188,7 +188,7 @@ public async Task LowLevelDisposablesCollectionsAndSchedulersCoverDeterministicE
         await Assert.That(scheduled.Count).IsEqualTo(Two);
     }
 
-    /// <summary>Exercises value types, disposables, and handle delegates.</summary>
+    /// <summary>Verifies core value-type equality, disposable lifecycles, and the handle delegates.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CoreValueTypesDisposablesAndHandlesCoverEqualityAndLifecycleBranches()
@@ -268,7 +268,7 @@ private static async Task AssertDisposableLifecycleBranches()
         await Assert.That(multiple.IsDisposed).IsTrue();
     }
 
-    /// <summary>Asserts the protected <c>Dispose(false)</c> path still disposes the underlying disposable exactly once.</summary>
+    /// <summary>Asserts the protected <c>Dispose(false)</c> path disposes the underlying disposable exactly once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task AssertProtectedDisposePathRunsTheUnderlyingDisposableOnce()
     {
@@ -290,7 +290,7 @@ private static async Task AssertProtectedDisposePathRunsTheUnderlyingDisposableO
         await Assert.That(multipleFalse).IsEqualTo(1);
     }
 
-    /// <summary>Asserts removal detaches an item from the group and disposal reaches only the items still in it.</summary>
+    /// <summary>Asserts removal detaches an item from the group and disposal reaches only the remaining items.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task AssertMultipleDisposableRemovesItemsAndDisposesTheRest()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs
index 40f34363..669b51d5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies <see cref="EventPattern{TEventArgs}"/> equality and formatting contracts.</summary>
 public class EventPatternTests
 {
-    /// <summary>Covers event-pattern equality, hashing, formatting, and argument validation.</summary>
+    /// <summary>Verifies event-pattern equality, hashing, formatting, and argument validation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EventPatternEqualityAndFormattingCoverContracts()
@@ -36,7 +36,7 @@ public async Task EventPatternEqualityAndFormattingCoverContracts()
         });
     }
 
-    /// <summary>Covers typed-sender event-pattern equality, hashing, and formatting.</summary>
+    /// <summary>Verifies typed-sender event-pattern equality, hashing, and formatting.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TypedSenderEventPatternEqualityAndFormattingCoverContracts()
@@ -199,7 +199,7 @@ private sealed class TestEventArgs(int value) : EventArgs
         public int Value { get; } = value;
     }
 
-    /// <summary>Source used to exercise generic <see cref="EventHandler{TEventArgs}"/> event conversion.</summary>
+    /// <summary>An event source that raises a generic handler event carrying an integer value.</summary>
     private sealed class GenericEventSource
     {
         /// <summary>Raised by the test source.</summary>
@@ -211,7 +211,7 @@ private sealed class GenericEventSource
         public void Raise(int value) => Changed?.Invoke(this, new(value));
     }
 
-    /// <summary>Source used to exercise a WPF-style non-generic event handler shape.</summary>
+    /// <summary>An event source that raises an assembly-load event through a non-generic handler.</summary>
     private sealed class AssemblyLoadEventSource
     {
         /// <summary>The handlers attached to the test source.</summary>
@@ -234,13 +234,13 @@ private sealed class AssemblyLoadEventSource
         public void Raise(System.Reflection.Assembly assembly) => _assemblyLoaded?.Invoke(this, new(assembly));
     }
 
-    /// <summary>Source used to exercise <see cref="PropertyChangedEventHandler"/> event conversion.</summary>
+    /// <summary>An event source that raises a property-changed event for a named property.</summary>
     private sealed class PropertyChangedEventSource
     {
         /// <summary>The handlers attached to the test source.</summary>
         private PropertyChangedEventHandler? _propertyChanged;
 
-        /// <summary>Gets a placeholder property name used by the event test.</summary>
+        /// <summary>Gets a placeholder property whose name the raised event carries.</summary>
         public static int Value => 0;
 
         /// <summary>Adds a handler to the test source.</summary>
@@ -257,7 +257,7 @@ private sealed class PropertyChangedEventSource
         public void Raise(string propertyName) => _propertyChanged?.Invoke(this, new(propertyName));
     }
 
-    /// <summary>Source used to exercise <see cref="NotifyCollectionChangedEventHandler"/> event conversion.</summary>
+    /// <summary>An event source that raises a collection-changed event with an add action.</summary>
     private sealed class CollectionChangedEventSource
     {
         /// <summary>The handlers attached to the test source.</summary>
@@ -277,7 +277,7 @@ public void RaiseAdd() =>
             _collectionChanged?.Invoke(this, new(NotifyCollectionChangedAction.Add, "value"));
     }
 
-    /// <summary>Source used to exercise <see cref="ListChangedEventHandler"/> event conversion.</summary>
+    /// <summary>An event source that raises a list-changed event with an item-added action.</summary>
     private sealed class ListChangedEventSource
     {
         /// <summary>The handlers attached to the test source.</summary>
@@ -307,7 +307,7 @@ private sealed class FakeClickEventArgs : EventArgs
         public string Command { get; }
     }
 
-    /// <summary>Fake event source used by event-pattern bridge scenarios.</summary>
+    /// <summary>An event source that raises a click event carrying a command name.</summary>
     private sealed class FakeButton
     {
         /// <summary>Raised when the fake button is clicked.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
index bcf39bb5..9d25ca5a 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
@@ -26,7 +26,7 @@ public sealed class EverySignalTests
     /// <summary>The inactivity window <c>Expire</c> allows before it times the sequence out.</summary>
     private static readonly TimeSpan ExpiryPeriod = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>An inline first tick retains the successor it schedules before the initial scheduling call returns.</summary>
+    /// <summary>A tick that fires inline during scheduling keeps the successor tick it arms.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EveryRetainsTheTickArmedByAnInlineFirstTick()
@@ -56,7 +56,7 @@ public async Task EveryOnTheCurrentThreadSequencerStopsWhenTakeReachesItsCount()
         await Assert.That(completions).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the current-thread ticks stay on the subscribing thread rather than moving to a pool thread.</summary>
+    /// <summary>Verifies the current-thread ticks are delivered on the subscribing thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EveryOnTheCurrentThreadSequencerTicksOnTheSubscribingThread()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
index d0edd33e..29253f48 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
@@ -23,7 +23,7 @@ public sealed class ExpireCoordinatorTests
     /// <summary>A gap shorter than <see cref="DueTicks"/> that must not expire the timeout.</summary>
     private const int ActiveGapTicks = 9;
 
-    /// <summary>A gap shorter than <see cref="DueTicks"/> after which a value still arrives in time.</summary>
+    /// <summary>A gap shorter than <see cref="DueTicks"/> after which a value arrives in time.</summary>
     private const int ShortGapTicks = 5;
 
     /// <summary>The values forwarded by the active-source re-arming test.</summary>
@@ -51,7 +51,7 @@ public async Task TimeoutResetsOnEachValueSoActiveSourceNeverExpires()
         await Assert.That(values.SequenceEqual(ExpectedActiveValues)).IsTrue();
     }
 
-    /// <summary>Verifies silence longer than the timeout still expires after re-arming.</summary>
+    /// <summary>Verifies silence longer than the timeout expires the sequence after re-arming.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TimeoutExpiresWhenSilenceExceedsDueTimeAfterAValue()
@@ -198,15 +198,11 @@ private sealed class UndispatchedSequencer(DateTimeOffset start) : ISequencer
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2318:Members should not have identical bodies",
-            Justification =
-                "The relative and absolute Schedule overloads of this test-double sequencer intentionally behave the "
-                + "same way; both are required by the ISequencer contract and, as distinct interface overloads, cannot "
-                + "forward to one another.")]
+            Justification = "Distinct interface overloads cannot forward to one another.")]
         public void Schedule(IWorkItem item, long dueTimestamp) => Pending++;
     }
 
-    /// <summary>Observer that makes the armed timeout due from inside <see cref="OnNext"/>, so the timeout is
-    /// dispatched while the value is still in flight.</summary>
+    /// <summary>Observer that makes the armed timeout due from inside <see cref="OnNext"/>.</summary>
     /// <param name="clock">The clock that dispatches due work inline.</param>
     /// <param name="dueTime">The amount to advance the clock by so the armed timeout becomes due.</param>
     private sealed class ReentrantTimeoutObserver(VirtualClock clock, TimeSpan dueTime) : IObserver<int>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ForkJoinWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ForkJoinWitnessTests.cs
index 267bff31..c3cb7d7d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ForkJoinWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ForkJoinWitnessTests.cs
@@ -53,7 +53,6 @@ public async Task ForkJoinWitnessForwardsFirstErrorAndGatesAfterwards()
         await Assert.That(observer.Errors).HasSingleItem();
         await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
 
-        // Everything from either side is gated after the terminal error.
         right.Observer!.OnNext(Two);
         right.Observer.OnError(new InvalidOperationException("right"));
         right.Observer.OnCompleted();
@@ -100,7 +99,6 @@ public async Task ForkJoinWitnessIgnoresErrorAfterCompletion()
 
         await Assert.That(observer.Completed).IsEqualTo(One);
 
-        // A late error from either side must not deliver a second terminal.
         left.Observer.OnError(new InvalidOperationException("late"));
         right.Observer.OnError(new InvalidOperationException("late"));
 
@@ -121,7 +119,6 @@ public async Task ForkJoinWitnessCompletesWithoutResultWhenASideIsEmpty()
         left.Observer!.OnNext(One);
         left.Observer.OnCompleted();
 
-        // Right completes empty: no result, single completion.
         right.Observer!.OnCompleted();
 
         await Assert.That(observer.Values).IsEmpty();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
index 28773c13..e0289f27 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
@@ -6,20 +6,13 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for <see cref="FromAsyncSubscription{T}"/>'s synchronous-completion path when the external
-/// cancellation token forwards a terminal error while the task factory is still running: the subscription is
-/// already completed by the time the completed task is inspected, so it forwards nothing further.
-/// </summary>
+/// <summary>Tests for the synchronous-completion path of <see cref="FromAsyncSubscription{T}"/>.</summary>
 public sealed class FromAsyncSubscriptionTests
 {
     /// <summary>The value produced by the task factory that completes synchronously.</summary>
     private const int FactoryValue = 11;
 
-    /// <summary>
-    /// Verifies that when the external token is cancelled while the factory runs, the forwarded cancellation is
-    /// the only notification and the already-complete task the factory returned is not forwarded a second time.
-    /// </summary>
+    /// <summary>Cancellation raised while the factory runs is the only notification, and the task result is dropped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ExternalCancellationDuringTheFactoryForwardsCancellationAndDropsTheCompletedResult()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
index de75b9b8..2b0d01fa 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
@@ -37,7 +37,7 @@ public class FromEnumerableSignalTests
     /// <summary>Expected five-six value sequence.</summary>
     private static readonly int[] ExpectedFiveSix = [Five, Six];
 
-    /// <summary>Covers enumerable signal fast paths for arrays, read-only lists, iterators, and delegate subscriptions.</summary>
+    /// <summary>Verifies an enumerable signal emits values from arrays, lists, and iterators, then completes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromEnumerableSignalCoversAllSynchronousFastPaths()
@@ -69,7 +69,7 @@ public async Task FromEnumerableSignalCoversAllSynchronousFastPaths()
         _ = Assert.Throws<ArgumentNullException>(() => arraySignal.Subscribe(static _ => { }, static ex => { }, null!));
     }
 
-    /// <summary>Creates an iterator-backed enumerable for the non-indexable enumerable path.</summary>
+    /// <summary>Creates an iterator-backed enumerable that cannot be indexed.</summary>
     /// <returns>The yielded values.</returns>
     private static IEnumerable<int> YieldValues()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/IsEmptySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/IsEmptySignalTests.cs
index d9deaad4..df1ee62f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/IsEmptySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/IsEmptySignalTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for <c>IsEmpty</c> over an ordinary source, which does not require the current thread and therefore
-/// settles on the direct subscribe path rather than the current-thread trampoline the timer sources use.
-/// </summary>
+/// <summary>Verifies <c>IsEmpty</c> reports whether an ordinary source produced a value before completing.</summary>
 public sealed class IsEmptySignalTests
 {
     /// <summary>The value produced by the non-empty source.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.CombineLatestTuples.cs b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.CombineLatestTuples.cs
index 95072e43..99fc85a4 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.CombineLatestTuples.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.CombineLatestTuples.cs
@@ -273,11 +273,7 @@ public async Task CombineLatestTupleOverloadsRejectNullSources()
         await Assert.That(source2.HasObservers).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies a fully generic call passing an untyped null selector still binds to the selector overload.
-    /// That call shape fits both the arity-2 selector overload and the arity-3 tuple overload, so it is only
-    /// unambiguous while the tuple overloads keep their lower overload resolution priority.
-    /// </summary>
+    /// <summary>Verifies a fully generic call passing an untyped null selector binds to the selector overload.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     [RequiresAssemblyFiles("Builds metadata references from loaded assembly locations.")]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
index eddcd39f..2adea242 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for the infinite <c>Loop</c> signal, whose current-thread trampoline repeats a value until a bounding
-/// operator disposes the subscription. A bounded loop must stop repeating once the bound is reached instead of
-/// livelocking the subscribing thread.
-/// </summary>
+/// <summary>Verifies the infinite <c>Loop</c> signal repeats its value until a bounding operator stops it.</summary>
 public sealed class LoopSignalTests
 {
     /// <summary>The value repeated by the loop.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/MomentTests.cs b/src/tests/ReactiveUI.Primitives.Tests/MomentTests.cs
index 150be74d..3fa16668 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/MomentTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/MomentTests.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies <see cref="Moment{T}"/> equality and hashing contracts.</summary>
 public class MomentTests
 {
-    /// <summary>The timestamp used by moment tests; only its stability matters.</summary>
+    /// <summary>A fixed timestamp shared by the moment tests.</summary>
     private static readonly DateTimeOffset SampleTimestamp = new(2026, 5, 24, 22, 52, 0, TimeSpan.Zero);
 
     /// <summary>Verifies a moment with a null value uses a deterministic null hash code.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ObservableCancellationHandlingTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ObservableCancellationHandlingTests.cs
index be9b9f14..1e7e6939 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ObservableCancellationHandlingTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ObservableCancellationHandlingTests.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for the <c>HandleCancellation</c> operators on an observable source, which await the source through a
-/// cancellable task and either return its value or, on cancellation, run the cleanup action and return the
-/// default.
-/// </summary>
+/// <summary>Tests the <c>HandleCancellation</c> operators on an observable source.</summary>
 public sealed class ObservableCancellationHandlingTests
 {
     /// <summary>The value emitted by the source observable.</summary>
@@ -26,7 +22,7 @@ public async Task HandleCancellationReturnsTheSourceValueWhenNotCancelled()
         await Assert.That(result).IsEqualTo(SourceValue);
     }
 
-    /// <summary>Verifies an already-cancelled token runs the cleanup action and yields the default value.</summary>
+    /// <summary>Verifies a pre-cancelled token runs the cleanup action and yields the default value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HandleCancellationRunsTheCleanupActionAndReturnsDefaultWhenCancelled()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
index 4fd86be2..ea2281a0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/OnErrorResumeNextSignalTests.cs
@@ -181,7 +181,7 @@ private sealed class ThrowingEnumerable<T>(Exception error) : IEnumerable<IObser
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
     }
 
-    /// <summary>Enumerable that returns a null enumerator to cover the defensive null path.</summary>
+    /// <summary>Enumerable that returns a null enumerator.</summary>
     /// <typeparam name="T">The source value type.</typeparam>
     /// <param name="returnsNull">Whether <see cref="IEnumerable{T}.GetEnumerator"/> returns null.</param>
     private sealed class NullEnumeratorEnumerable<T>(bool returnsNull) : IEnumerable<IObservable<T>>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs
index d1d8840c..9379a533 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs
@@ -13,7 +13,7 @@ public class OptionalTests
     /// <summary>The second expected value.</summary>
     private const int Second = 2;
 
-    /// <summary>Covers optional value creation and empty value access.</summary>
+    /// <summary>Verifies an empty optional rejects value access and a created optional exposes its value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OptionalCoversEmptyAndValueContracts()
@@ -33,7 +33,7 @@ public async Task OptionalCoversEmptyAndValueContracts()
         await Assert.That(some.Value).IsEqualTo(Second);
     }
 
-    /// <summary>Covers optional conversion helpers and operators.</summary>
+    /// <summary>Verifies the optional conversion helpers and operators round-trip a value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OptionalSupportsConversionHelpers()
@@ -55,7 +55,7 @@ public async Task OptionalSupportsConversionHelpers()
         await Assert.That(some.Value).IsEqualTo(Second);
     }
 
-    /// <summary>Covers optional string formatting for values and empty values.</summary>
+    /// <summary>Verifies an optional formats its value, and an empty optional formats as none.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OptionalToStringFormatsValueAndNone()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PriorityQueueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PriorityQueueTests.cs
index 55a09b62..279b976e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PriorityQueueTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PriorityQueueTests.cs
@@ -121,7 +121,7 @@ public async Task VerifyHeapPropertyDetectsMutablePriorityDrift()
         await Assert.That(rightQueue.VerifyHeapProperty()).IsFalse();
     }
 
-    /// <summary>Covers indexed-item equality, hashing, and type mismatch handling.</summary>
+    /// <summary>Verifies indexed-item equality, hashing, and the comparison operators.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task IndexedItemEqualityCoversContracts()
@@ -162,7 +162,7 @@ private static PriorityQueue<PriorityItem> CreateMutableQueue(
         return queue;
     }
 
-    /// <summary>A mutable comparable item used to invalidate heap ordering after enqueue.</summary>
+    /// <summary>A comparable item whose priority can change after it is enqueued.</summary>
     /// <param name="priority">The initial priority.</param>
     private sealed class PriorityItem(int priority) : IComparable<PriorityItem>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
index 1e680f78..802da0c3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
@@ -299,7 +299,7 @@ public async Task ReentrantErrorWaitsForValueDelivery()
         await Assert.That(overlap).IsFalse();
     }
 
-    /// <summary>A terminal notification arriving after the signal is already terminal is ignored.</summary>
+    /// <summary>A second error notification after the signal has terminated is ignored.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnErrorAfterTerminalIsIgnored()
@@ -316,7 +316,7 @@ public async Task OnErrorAfterTerminalIsIgnored()
         await Assert.That(observer.Errors[0]).IsSameReferenceAs(first);
     }
 
-    /// <summary>A throwing delivery still releases drain ownership so a later release can drain again.</summary>
+    /// <summary>A throwing delivery releases drain ownership so a later release drains again.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DrainReleasesOwnershipWhenDeliveryThrows()
@@ -333,14 +333,14 @@ public async Task DrainReleasesOwnershipWhenDeliveryThrows()
             static _ => { },
             static () => { });
 
-        // Delivery throws out of the drain loop; the finally path must still release ownership.
+        // Delivery throws out of the drain loop; the finally path releases ownership.
         var first = Assert.Throws<InvalidOperationException>(() => signal.OnNext(FirstValue));
         await Assert.That(first).IsSameReferenceAs(failure);
 
-        // Capacity is now exhausted, so this value only enqueues.
+        // Capacity is exhausted, so this value only enqueues.
         signal.OnNext(SecondValue);
 
-        // Releasing frees capacity and must begin a fresh drain, proving ownership was released.
+        // Releasing frees capacity and begins a fresh drain, so the delivery throws again.
         var second = Assert.Throws<InvalidOperationException>(signal.Release);
         await Assert.That(second).IsSameReferenceAs(failure);
         await Assert.That(deliveries).IsEqualTo(FirstDrainCount);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/R3BridgeGeneratorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/R3BridgeGeneratorTests.cs
index a53373cf..0594a688 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/R3BridgeGeneratorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/R3BridgeGeneratorTests.cs
@@ -25,7 +25,7 @@ public class R3BridgeGeneratorTests
     /// <summary>Generated metadata attribute key.</summary>
     private const string GeneratedMetadataKey = "ReactiveUI.Primitives.R3Bridge.Generator";
 
-    /// <summary>Legacy generated marker attribute type name.</summary>
+    /// <summary>The name of the marker attribute type the generator must not emit.</summary>
     private const string LegacyGeneratedMarkerName = "PrimitivesR3BridgeGeneratedAttribute";
 
     /// <summary>Compiler diagnostic raised when a source type conflicts with an imported type.</summary>
@@ -329,7 +329,7 @@ private static bool GeneratedMetadataExists(string[] generatedSources) => Array.
         generatedSources,
         static text => text.Contains($"AssemblyMetadata(\"{GeneratedMetadataKey}\"", StringComparison.Ordinal));
 
-    /// <summary>Checks whether generated source contains the removed custom marker attribute type.</summary>
+    /// <summary>Checks whether generated source contains the custom marker attribute type.</summary>
     /// <param name="generatedSources">Generated source text to inspect.</param>
     /// <returns><see langword="true"/> when the legacy generated marker type is emitted.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
index 55688d60..b609d5a3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
@@ -31,7 +31,7 @@ public class ReplaySignalTests
     /// <summary>The integer constant ten.</summary>
     private const int Ten = 10;
 
-    /// <summary>Constructors the argument checking.</summary>
+    /// <summary>Verifies the constructors reject negative buffer sizes, negative windows, and null sequencers.</summary>
     [Test]
     public void Constructor_ArgumentChecking()
     {
@@ -51,7 +51,6 @@ public void Constructor_ArgumentChecking()
         _ = Assert.Throws<ArgumentNullException>(static () => CreateAndDispose(static () => new(TimeSpan.Zero, null!)));
         _ = Assert.Throws<ArgumentNullException>(static () => CreateAndDispose(static () => new(0, TimeSpan.Zero, null!)));
 
-        // zero allowed
         CreateAndDispose(static () => new(0));
         CreateAndDispose(static () => new(TimeSpan.Zero));
         CreateAndDispose(static () => new(0, TimeSpan.Zero));
@@ -83,7 +82,7 @@ public async Task AZeroSizedBufferReplaysNothingToALateSubscriber()
         await Assert.That(replayed.SequenceEqual([Three])).IsTrue();
     }
 
-    /// <summary>Verifies a windowed buffer still drops the values that overflow its buffer size.</summary>
+    /// <summary>Verifies a windowed buffer drops the values that overflow its buffer size.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AWindowedBufferDropsValuesBeyondItsBufferSize()
@@ -113,7 +112,7 @@ public async Task DisposingAReplaySubscriptionTwiceIsIdempotent()
         await Assert.That(replayed.Count).IsEqualTo(0);
     }
 
-    /// <summary>Determines whether this instance has observers.</summary>
+    /// <summary>Verifies every replay buffer shape tracks observers as subscriptions are added and removed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers()
@@ -124,7 +123,7 @@ public async Task HasObservers()
         await HasObserversImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Determines whether [has observers dispose1].</summary>
+    /// <summary>Verifies every replay buffer shape drops its observers when the source is disposed first.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose1()
@@ -135,7 +134,7 @@ public async Task HasObservers_Dispose1()
         await HasObservers_Dispose1Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Determines whether [has observers dispose2].</summary>
+    /// <summary>Verifies every replay buffer shape drops its observers when the subscription is disposed first.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose2()
@@ -146,7 +145,7 @@ public async Task HasObservers_Dispose2()
         await HasObservers_Dispose2Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Determines whether [has observers dispose3].</summary>
+    /// <summary>Verifies every replay buffer shape reports disposal when it has no subscribers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_Dispose3()
@@ -157,7 +156,7 @@ public async Task HasObservers_Dispose3()
         await HasObservers_Dispose3Impl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Determines whether [has observers on completed].</summary>
+    /// <summary>Verifies completion drops the observers of every replay buffer shape.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnCompleted()
@@ -168,7 +167,7 @@ public async Task HasObservers_OnCompleted()
         await HasObservers_OnCompletedImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Determines whether [has observers on error].</summary>
+    /// <summary>Verifies an error drops the observers of every replay buffer shape.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HasObservers_OnError()
@@ -179,7 +178,7 @@ public async Task HasObservers_OnError()
         await HasObservers_OnErrorImpl(new(TimeSpan.FromSeconds(1), EmptySequencer.Instance));
     }
 
-    /// <summary>Called when [error argument checking].</summary>
+    /// <summary>Verifies a replay signal rejects a null error.</summary>
     [Test]
     public void OnError_ArgumentChecking()
     {
@@ -189,7 +188,7 @@ public void OnError_ArgumentChecking()
         _ = Assert.Throws<ArgumentNullException>(static () => new ReplaySignal<int>(EmptySequencer.Instance).OnError(null!));
     }
 
-    /// <summary>Subscribes the argument checking.</summary>
+    /// <summary>Verifies a replay signal rejects a null observer.</summary>
     [Test]
     public void Subscribe_ArgumentChecking()
     {
@@ -199,7 +198,7 @@ public void Subscribe_ArgumentChecking()
         _ = Assert.Throws<ArgumentNullException>(static () => new ReplaySignal<int>(EmptySequencer.Instance).Subscribe(null!));
     }
 
-    /// <summary>Verifies subjects, replay, behavior, state, and connectable aliases cover late terminal branches.</summary>
+    /// <summary>Verifies late subscribers receive the buffered values and the first terminal notification.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubjectsReplayBehaviorStateAndConnectableAliasesCoverLateTerminalBranches()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ResultTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ResultTests.cs
index 5bc455b5..d0ce0e0f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ResultTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ResultTests.cs
@@ -12,7 +12,7 @@ public class ResultTests
     /// <summary>Failure message used by result tests.</summary>
     private const string FailureMessage = "boom";
 
-    /// <summary>Covers the success result contract.</summary>
+    /// <summary>Verifies a success result reports success with no exception.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ResultSuccessReportsStatusAndString()
@@ -25,7 +25,7 @@ public async Task ResultSuccessReportsStatusAndString()
         await Assert.That(result.ToString()).IsEqualTo("Success");
     }
 
-    /// <summary>Covers the failure result contract.</summary>
+    /// <summary>Verifies a failure result reports failure and carries its exception.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ResultFailureReportsExceptionStatusAndString()
@@ -41,7 +41,7 @@ public async Task ResultFailureReportsExceptionStatusAndString()
         await Assert.That(created.Exception).IsSameReferenceAs(error);
     }
 
-    /// <summary>Covers failure result argument validation.</summary>
+    /// <summary>Verifies a result rejects a null exception.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void ResultRejectsNullException() =>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.AliasOverloads.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.AliasOverloads.cs
index 826bf483..76a95833 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.AliasOverloads.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.AliasOverloads.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the System.Reactive alias overloads that take only a subset of the observer callbacks, an explicit
-/// comparer, or an explicit gate — the shapes the data-driven parity rows do not reach.
-/// </summary>
+/// <summary>Verifies the System.Reactive alias overloads taking a callback subset, an explicit comparer, or a gate.</summary>
 public partial class RxNamesTests
 {
     /// <summary>Verifies the two-callback <c>Do</c> overloads run only the callbacks they were given.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
index d4c5c63a..6bfbf32d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Helpers.cs
@@ -17,10 +17,7 @@ public partial class RxNamesTests
     /// <summary>The narrowest generated multi-source <c>CombineLatest</c> overload.</summary>
     private const int MinMultiSourceArity = 4;
 
-    /// <summary>
-    /// The generated multi-source <c>CombineLatest</c> builders, ordered by arity from
-    /// <see cref="MinMultiSourceArity"/> upwards, so an arity selects its overload without a literal case label.
-    /// </summary>
+    /// <summary>The generated multi-source <c>CombineLatest</c> builders, ordered by arity from <see cref="MinMultiSourceArity"/> upwards.</summary>
     private static readonly Func<CombineLatestSources, IObservable<int>>[] _combineLatestBuilders =
     [
         CombineLatestOfFour,
@@ -127,7 +124,7 @@ private static bool RunStatefulThrow(Func<IObservable<int>, IObservable<int>> op
         return error is InvalidOperationException;
     }
 
-    /// <summary>A stateful projection that always throws (drives the sink catch path).</summary>
+    /// <summary>A stateful projection that always throws.</summary>
     /// <param name = "state">The unused state.</param>
     /// <param name = "value">The unused value.</param>
     /// <returns>Never returns; always throws.</returns>
@@ -135,7 +132,7 @@ private static bool RunStatefulThrow(Func<IObservable<int>, IObservable<int>> op
     [SuppressMessage("Maintainability", "SST1461:Remove unread private parameters", Justification = "The signature is fixed by the delegate this method is passed to as a method group.")]
     private static int ThrowProjection(int state, int value) => throw new InvalidOperationException(Boom);
 
-    /// <summary>A stateful predicate that always throws (drives the sink catch path).</summary>
+    /// <summary>A stateful predicate that always throws.</summary>
     /// <param name = "state">The unused state.</param>
     /// <param name = "value">The unused value.</param>
     /// <returns>Never returns; always throws.</returns>
@@ -159,7 +156,7 @@ private static List<int> RunSampling(Func<IObservable<int>, ISequencer, IObserva
         return values;
     }
 
-    /// <summary>Combines a source value with an inner value (result selector for the 3-arg SelectMany/FlatMap).</summary>
+    /// <summary>Combines a source value with an inner value.</summary>
     /// <param name = "source">The source value.</param>
     /// <param name = "inner">The inner value.</param>
     /// <returns>The combined value.</returns>
@@ -508,7 +505,7 @@ private static List<int> Collect(IObservable<int> source)
         return values;
     }
 
-    /// <summary>Builds a source of two int-range inner sources (exercises the synchronous Switch range fast path).</summary>
+    /// <summary>Builds a source of two int-range inner sources.</summary>
     /// <returns>An outer source of two range inners.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static IObservable<IObservable<int>> RangeInners() =>
@@ -534,16 +531,11 @@ private static bool RunStopGuards(Func<IObservable<int>, IObservable<int>> op)
         return completed == One && error is null;
     }
 
-    /// <summary>
-    /// The sources of the widest generated CombineLatest overload, named by argument position so every arity can
-    /// be built without indexing into an array.
-    /// </summary>
+    /// <summary>The sources of the widest generated CombineLatest overload, named by argument position.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2315:A type that owns a disposable should be disposable",
-        Justification =
-            "Test helper that holds the source subjects for a CombineLatest arity test. The subjects live for the "
-            + "duration of the test and the test process owns them; this helper is deliberately not IDisposable.")]
+        Justification = "The test process owns these subjects for the lifetime of the test.")]
     private sealed class CombineLatestSources
     {
         /// <summary>Initializes a new instance of the <see cref="CombineLatestSources"/> class.</summary>
@@ -649,7 +641,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         public void Complete() => _observer?.OnCompleted();
     }
 
-    /// <summary>A source that reports it requires current-thread subscription (drives the sink's propagation check).</summary>
+    /// <summary>A source that reports it requires current-thread subscription.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class CurrentThreadSource<T> : IRequireCurrentThread<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.SubscribeSafe.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.SubscribeSafe.cs
index 491506e3..74050125 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.SubscribeSafe.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.SubscribeSafe.cs
@@ -401,9 +401,9 @@ public async Task SubscribeSafePrimitivesDeliversTheSameNotificationsAsSubscribe
     }
 
     /// <summary>
-    /// Verifies the observer-taking <c>SubscribeSafe</c> is ambiguous once System.Reactive is in scope, and that
-    /// the explicit Primitives name resolves. System.Reactive declares its own observer overload in the
-    /// <c>System</c> namespace, which an implicit <c>using System;</c> always brings along.
+    /// Verifies the explicit Primitives name resolves where the observer-taking <c>SubscribeSafe</c> is ambiguous.
+    /// System.Reactive declares a competing observer overload in the <c>System</c> namespace, which an implicit
+    /// <c>using System;</c> brings along.
     /// </summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
index ec4fa688..5aa743f1 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
@@ -201,7 +201,7 @@ public static IEnumerable<BinaryCase> BinaryCases()
             _latched);
     }
 
-    /// <summary>Provides the generated multi-source CombineLatest arities not covered by the dedicated edge tests.</summary>
+    /// <summary>Provides the arities of the generated multi-source CombineLatest overloads.</summary>
     /// <returns>The CombineLatest arities from 4 through 15.</returns>
     public static IEnumerable<int> MultiSourceCombineLatestArities()
     {
@@ -656,7 +656,7 @@ public void RxNamesThrowOnNegativeArguments()
         _ = Assert.Throws<ArgumentOutOfRangeException>(() => source.Sample(TimeSpan.FromTicks(NegativeOne)));
     }
 
-    /// <summary>Verifies the stateful sinks forward a value and then an error (covers their error path).</summary>
+    /// <summary>Verifies the stateful sinks forward a value and then an error.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task StatefulSinksForwardValueThenError()
@@ -666,7 +666,7 @@ public async Task StatefulSinksForwardValueThenError()
         await Assert.That(RunStatefulError(static s => s.DoWith(Ten, IgnoreState))).IsTrue();
     }
 
-    /// <summary>Verifies the stateful projection sinks forward an exception thrown by the projection (covers their catch path).</summary>
+    /// <summary>Verifies the stateful projection sinks forward an exception thrown by the projection.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task StatefulProjectionForwardsThrownError()
@@ -721,7 +721,7 @@ public async Task ResumeDisposeStopsForwarding()
         await Assert.That(values.SequenceEqual(_tenOnly)).IsTrue();
     }
 
-    /// <summary>Verifies <c>Sample</c> mirrors <c>Probe</c> when sampled against an identical virtual clock drive.</summary>
+    /// <summary>Verifies <c>Sample</c> mirrors <c>Probe</c>.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SampleMatchesProbe()
@@ -764,7 +764,7 @@ public async Task RxNamesRangeFastPathsMatchCounterparts()
         await Assert.That(switched).IsEquivalentTo(switchedTo, EqualityComparer<int>.Default);
     }
 
-    /// <summary>Verifies <c>Retry</c> mirrors the source when no error occurs (covers the happy path).</summary>
+    /// <summary>Verifies <c>Retry</c> mirrors the source when no error occurs.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task RetryMirrorsSourceWhenNoError() =>
@@ -826,7 +826,7 @@ public void ResumeThrowsOnNullObserver() =>
             .Resume(Signal.FromEnumerable(_oneToThree))
             .Subscribe((IObserver<int>)null!));
 
-    /// <summary>Verifies Resume takes the scheduled subscription path when a current-thread sequencer is already active.</summary>
+    /// <summary>Verifies Resume schedules its subscription when a current-thread sequencer is active.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ResumeSchedulesWhenCurrentThreadSequencerActive()
@@ -855,7 +855,7 @@ await Assert.That(new ResumeSignal<int>(Signal.FromEnumerable(_oneToThree), Sign
     /// <returns>The new accumulated value.</returns>
     private static int Add(int accumulated, int value) => accumulated + value;
 
-    /// <summary>Returns the value unchanged (key selector).</summary>
+    /// <summary>Returns the value unchanged.</summary>
     /// <param name = "value">The source value.</param>
     /// <returns>The value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -873,11 +873,11 @@ await Assert.That(new ResumeSignal<int>(Signal.FromEnumerable(_oneToThree), Sign
     /// <returns><see langword="true"/> when the value is a multiple of the divisor.</returns>
     private static bool IsMultiple(int divisor, int value) => value % divisor == 0;
 
-    /// <summary>Consumes a value without effect (the side-effect under test is irrelevant to the output).</summary>
+    /// <summary>Consumes a value without effect.</summary>
     /// <param name = "_">The source value, which the side effect deliberately ignores.</param>
     private static void Ignore(int _)
     {
-        // Intentionally empty: Do/Tap forward values unchanged regardless of the side effect.
+        // Intentionally empty.
     }
 
     /// <summary>Consumes a state and value without effect.</summary>
@@ -886,7 +886,7 @@ private static void Ignore(int _)
     [SuppressMessage("Maintainability", "SST1461:Remove unread private parameters", Justification = "The signature is fixed by the delegate this method is passed to as a method group.")]
     private static void IgnoreState(int state, int value)
     {
-        // Intentionally empty: DoWith/TapWith forward values unchanged regardless of the side effect.
+        // Intentionally empty.
     }
 
     /// <summary>Projects a value to an inner sequence that emits it twice.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
index 652a9bea..e08b86dd 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SafeWitnessTests.cs
@@ -16,11 +16,7 @@ public class SafeWitnessTests
     /// <summary>A value pushed after the witness has terminated; it must never be delivered.</summary>
     private const int LateValue = 2;
 
-    /// <summary>
-    /// The cancel-owning wrapper forwards the first fault, disposes its cancellation resource once, and drops
-    /// every later notification. Faulting first (rather than completing first) is the path that leaves the
-    /// wrapped observer holding an error it must not see twice.
-    /// </summary>
+    /// <summary>The cancel-owning wrapper forwards the first fault, disposes its cancel resource once, then drops everything after.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CancelOwningSafeWitnessForwardsTheFirstFaultThenGoesQuiet()
@@ -42,10 +38,7 @@ public async Task CancelOwningSafeWitnessForwardsTheFirstFaultThenGoesQuiet()
         await Assert.That(cancelled).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// A delegate witness passed to <see cref="Witness.Safe{T}(IObserver{T})"/> is made safe in place rather
-    /// than wrapped. It must still forward the first fault exactly once and ignore everything after it.
-    /// </summary>
+    /// <summary>A delegate witness made safe by <see cref="Witness.Safe{T}(IObserver{T})"/> forwards the first fault exactly once, then ignores the rest.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DelegateWitnessMadeSafeForwardsTheFirstFaultThenGoesQuiet()
@@ -67,10 +60,7 @@ public async Task DelegateWitnessMadeSafeForwardsTheFirstFaultThenGoesQuiet()
         await Assert.That(values.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// When a safe delegate witness's value callback throws, the witness latches stopped: the exception
-    /// surfaces to the caller once, and the next value is dropped instead of re-entering the broken callback.
-    /// </summary>
+    /// <summary>A throwing value callback stops the safe delegate witness: the exception surfaces once and the next value is dropped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DelegateWitnessMadeSafeStopsAfterItsValueCallbackThrows()
@@ -91,10 +81,7 @@ public async Task DelegateWitnessMadeSafeStopsAfterItsValueCallbackThrows()
         await Assert.That(calls).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// The cancel-free wrapper (a plain observer made safe without a cancellation resource) forwards values,
-    /// completes exactly once, and drops notifications that arrive after the completion.
-    /// </summary>
+    /// <summary>The cancel-free wrapper forwards values, completes exactly once, and drops notifications after the completion.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CancelFreeSafeWitnessForwardsValuesThenCompletesExactlyOnce()
@@ -133,10 +120,7 @@ public async Task CancelFreeSafeWitnessForwardsTheFirstFaultThenGoesQuiet()
         await Assert.That(observer.Values.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// A throwing value callback stops the cancel-free wrapper: the exception surfaces once and the next value
-    /// is dropped rather than handed to the observer that already failed.
-    /// </summary>
+    /// <summary>A throwing observer stops the cancel-free wrapper: the exception surfaces once and the next value is dropped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CancelFreeSafeWitnessStopsAfterTheObserverThrows()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
index f869ddd0..799afeaf 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ScheduledSignalTests.cs
@@ -33,7 +33,7 @@ public sealed class ScheduledSignalTests
     /// <summary>The expected terminal exception message.</summary>
     private const string TerminalThrowMessage = "terminal";
 
-    /// <summary>The default observer receives the original terminal event and the restored replay.</summary>
+    /// <summary>The terminal notification count the default observer receives across completion and replay.</summary>
     private const int DefaultObserverTerminalReplayCount = 2;
 
     /// <summary>Constructor validates the scheduler argument.</summary>
@@ -160,7 +160,7 @@ await Assert.That(() => signal.OnError(new InvalidOperationException()))
             .ThrowsExactly<ObjectDisposedException>();
     }
 
-    /// <summary>The protected dispose path marks the signal disposed when managed cleanup is not requested.</summary>
+    /// <summary>The protected dispose overload marks the signal disposed when managed cleanup is not requested.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposeWithoutManagedCleanupMarksSignalDisposed()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
index f3c9b7a0..20c2760f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Pools.cs
@@ -258,7 +258,7 @@ public override void Post(SendOrPostCallback d, object? state)
         }
     }
 
-    /// <summary>Task scheduler that runs queued work inline and keeps the last task so a test can read its outcome.</summary>
+    /// <summary>Task scheduler that runs queued work inline and keeps the most recently queued task.</summary>
     private sealed class InlineTaskScheduler : TaskScheduler
     {
         /// <summary>Gets the most recently queued task.</summary>
@@ -278,7 +278,7 @@ protected override void QueueTask(Task task)
         protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
     }
 
-    /// <summary>Work item that always faults, so a sequencer's failure routing can be observed.</summary>
+    /// <summary>Work item that throws when executed.</summary>
     private sealed class ThrowingWorkItem : IWorkItem
     {
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
index b73c09bd..7b51d706 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.VirtualTime.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the virtual-time sequencers: the stateful scheduling overloads, the guards that stop the clock being
-/// re-entered while it is running, and a sequencer built on a clock type of the caller's choosing.
-/// </summary>
+/// <summary>Verifies virtual-time scheduling overloads, re-entrancy guards, and caller-supplied clock types.</summary>
 public partial class SequencerTests
 {
     /// <summary>Clock value a virtual sequencer starts at.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
index b55075fa..e387c2d7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
@@ -7,16 +7,13 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the work-item shapes the sequencers queue: the run-once handshake, cancellation before and after a run,
-/// and the delay conversion that decides when a due item runs.
-/// </summary>
+/// <summary>Verifies the queued work-item shapes: run-once execution, cancellation, and delay conversion.</summary>
 public partial class SequencerTests
 {
-    /// <summary>A monotonic timestamp delta used to drive the delay conversions.</summary>
+    /// <summary>A monotonic timestamp delta that drives the delay conversions.</summary>
     private const long DueTimestamp = 1000;
 
-    /// <summary>Verifies a monotonic delta that has already elapsed converts to no delay at all.</summary>
+    /// <summary>Verifies a monotonic delta at or before the current instant converts to no delay at all.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TimestampDeltaAtOrBeforeNowConvertsToZeroDelay()
@@ -105,7 +102,6 @@ public async Task ScheduledWorkItemReleasesItsActionResultOnCancellation()
         item.Dispose();
         await Assert.That(disposed).IsEqualTo(1);
 
-        // Disposal is a single transition: a second cancel must not dispose the action's result twice.
         item.Dispose();
         await Assert.That(disposed).IsEqualTo(1);
         await Assert.That(item.IsDisposed).IsTrue();
@@ -187,7 +183,6 @@ public async Task TimedWorkItemComparesByWorkItemIdentityAndDueTimestamp()
         await Assert.That(item.Equals(otherItem)).IsFalse();
         await Assert.That(item.Equals(otherDueTimestamp)).IsFalse();
 
-        // The boxed overload agrees with the strongly typed one, and rejects anything that is not an entry.
         await Assert.That(item.Equals((object)same)).IsTrue();
         await Assert.That(item.Equals((object)otherItem)).IsFalse();
         await Assert.That(item.Equals(new object())).IsFalse();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
index fafe8ba7..aaea38ed 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
@@ -76,11 +76,7 @@ public async Task CurrentThreadSequencerQueuesNestedWorkUntilCurrentActionComple
         await Assert.That(calls.SequenceEqual(expected)).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies nested current-thread work cancelled before the trampoline reaches it never runs. Scheduling from
-    /// inside a running action queues a cancellable work item and hands its handle back; disposing that handle must
-    /// leave the trampoline nothing to execute.
-    /// </summary>
+    /// <summary>Verifies nested current-thread work cancelled before the trampoline reaches it never runs.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CurrentThreadSequencerSkipsNestedWorkCancelledBeforeTheTrampolineRunsIt()
@@ -88,7 +84,7 @@ public async Task CurrentThreadSequencerSkipsNestedWorkCancelledBeforeTheTrampol
         var innerRan = false;
         _ = Sequencer.CurrentThread.Schedule(() =>
         {
-            // Re-entrant scheduling queues an ActionWorkItem and returns its cancellation handle.
+            // Re-entrant scheduling queues the work rather than running it inline.
             var handle = Sequencer.CurrentThread.Schedule(() => innerRan = true);
             handle.Dispose();
         });
@@ -179,7 +175,7 @@ static void CreateScheduledItem(
                 ScheduledItem.Create(scheduler, state, action, DateTimeOffset.UnixEpoch));
     }
 
-    /// <summary>Covers priority-queue ordering, shrink, peek, and removal branches.</summary>
+    /// <summary>Priority queues order by value, support peek and removal, shrink when drained, and reject a negative capacity.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task PriorityQueuesCoverOrderingShrinkAndRemovalBranches()
@@ -209,7 +205,7 @@ public async Task PriorityQueuesCoverOrderingShrinkAndRemovalBranches()
         _ = Assert.Throws<ArgumentOutOfRangeException>(CreateInvalidSequencerQueue);
     }
 
-    /// <summary>Covers scheduled-item comparison, invocation, disposal, and clock branches.</summary>
+    /// <summary>Scheduled items compare by due time, queue in due order, and repeat invocation and disposal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduledItemsCoverComparisonInvocationAndDisposalBranches()
@@ -261,7 +257,7 @@ public async Task ScheduledItemsCoverComparisonInvocationAndDisposalBranches()
         await AssertVirtualClockStartsAtItsInitialTime();
     }
 
-    /// <summary>Covers immediate and background sequencer argument validation and execution paths.</summary>
+    /// <summary>Immediate and background sequencers validate their arguments and run scheduled work.</summary>
     /// <returns>A task representing the asynchronous test operation.</returns>
     [Test]
     public async Task SequencersCoverValidationAndExecutionBranches()
@@ -276,7 +272,7 @@ public async Task SequencersCoverValidationAndExecutionBranches()
         await AssertSynchronizationContextSequencerValidatesAndRunsScheduledWork();
     }
 
-    /// <summary>Covers virtual-time extension validation and action scheduling.</summary>
+    /// <summary>Virtual-time extensions reject missing arguments and run relative and absolute actions.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task VirtualTimeSequencerExtensionsValidateAndRunActions()
@@ -303,7 +299,7 @@ public async Task VirtualTimeSequencerExtensionsValidateAndRunActions()
         await Assert.That(invoked).IsEqualTo(Three);
     }
 
-    /// <summary>Covers simple sequencer extension validation, delayed overloads, state overloads, and recursive scheduling.</summary>
+    /// <summary>Simple sequencer extensions reject missing arguments and run delayed, stateful, and recursive work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SimpleSequencerExtensionsCoverValidationAndRecursiveScheduling()
@@ -366,7 +362,7 @@ public async Task SimpleSequencerExtensionsCoverValidationAndRecursiveScheduling
         await Assert.That(recursiveCount).IsEqualTo(Three);
     }
 
-    /// <summary>Covers virtual-time service lookup, stopwatch, stop, sleep, and nested-run guard paths.</summary>
+    /// <summary>A virtual clock exposes its stopwatch provider, sleeps, stops, and refuses to be advanced from running work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task VirtualTimeSequencerBaseCoversServicesStopwatchAndRunGuards()
@@ -392,7 +388,7 @@ public async Task VirtualTimeSequencerBaseCoversServicesStopwatchAndRunGuards()
         await Assert.That(events.SequenceEqual(VirtualEventsExpected)).IsTrue();
     }
 
-    /// <summary>Covers timestamp scheduling work-item argument validation.</summary>
+    /// <summary>Timestamp scheduling rejects a missing work item.</summary>
     [Test]
     public void ScheduleWithTimestampValidatesWorkItem()
     {
@@ -400,7 +396,7 @@ public void ScheduleWithTimestampValidatesWorkItem()
         _ = Assert.Throws<ArgumentNullException>(() => sequencer.Schedule(null!, long.MaxValue));
     }
 
-    /// <summary>Covers timestamp scheduling executing due and past-due work items.</summary>
+    /// <summary>Timestamp scheduling runs due and past-due work items.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduleWithTimestampExecutesDueAndPastDueWork()
@@ -413,7 +409,7 @@ public async Task ScheduleWithTimestampExecutesDueAndPastDueWork()
         await Assert.That(workItem.ExecuteCount).IsEqualTo(Two);
     }
 
-    /// <summary>Covers scheduled-item probe comparison, equality, and invocation branches.</summary>
+    /// <summary>A scheduled item compares, equates, hashes, and disposes its invocation result when cancelled.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduledProbeComparisonAndInvocationCoverContracts()
@@ -431,11 +427,7 @@ public async Task ScheduledProbeComparisonAndInvocationCoverContracts()
         await Assert.That(scheduledDisposed).IsTrue();
     }
 
-    /// <summary>
-    /// The non-generic comparison is what a non-generic sorted collection reaches for. It must order by due time
-    /// just like the typed one, treat <see langword="null"/> as ordering first, and refuse anything that is not
-    /// a scheduled item rather than silently claiming equality.
-    /// </summary>
+    /// <summary>The non-generic comparison orders by due time, sorts <see langword="null"/> first, and rejects a non-item.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduledItemNonGenericComparisonOrdersByDueTime()
@@ -444,8 +436,7 @@ public async Task ScheduledItemNonGenericComparisonOrdersByDueTime()
         var late = ScheduledProbe.Create(Two, static () => EmptyDisposable.Instance);
         var sameDueTime = ScheduledProbe.Create(One, static () => EmptyDisposable.Instance);
 
-        // The casts are what force the non-generic IComparable.CompareTo(object) overload: an
-        // unqualified call would bind to the strongly typed CompareTo(ScheduledItem<int>) instead.
+        // The casts force the non-generic IComparable.CompareTo(object) overload.
         await Assert.That(((IComparable)early).CompareTo(null)).IsEqualTo(One);
         await Assert.That(((IComparable)early).CompareTo(late) < 0).IsTrue();
         await Assert.That(((IComparable)late).CompareTo(early) > 0).IsTrue();
@@ -622,7 +613,7 @@ private static void CreateSynchronizationContextSequencerWithoutContext()
         GC.KeepAlive(invalid);
     }
 
-    /// <summary>Completes a task completion source or throws when it was already completed.</summary>
+    /// <summary>Completes a task completion source, rejecting a second completion.</summary>
     /// <param name="completion">The completion source to update.</param>
     /// <param name="state">The value to set.</param>
     /// <exception cref="InvalidOperationException"><paramref name="completion"/> was already completed.</exception>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalCollectTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalCollectTests.cs
index da28f7ec..32759312 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalCollectTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalCollectTests.cs
@@ -13,10 +13,7 @@ public sealed class SignalCollectTests
     /// <summary>The buffer window used by the manually driven flush tests.</summary>
     private static readonly TimeSpan CollectWindow = TimeSpan.FromMilliseconds(50);
 
-    /// <summary>
-    /// Verifies a flush that fires with an empty window emits no batch, and that a source which completes
-    /// twice completes the buffered sequence once.
-    /// </summary>
+    /// <summary>A stale flush emits no batch, and a source that completes twice completes the batched sequence once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CollectIgnoresAStaleFlushAndASecondCompletion()
@@ -40,7 +37,7 @@ public async Task CollectIgnoresAStaleFlushAndASecondCompletion()
         await Assert.That(batches.Count).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the Collect method covers immediate, scheduled, terminal, and error paths.</summary>
+    /// <summary>Collect emits immediately with a zero window, batches on a clock, and forwards completion and errors.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CollectCoversImmediateScheduledCompletionErrorAndDisposePaths()
@@ -111,7 +108,6 @@ public async Task BufferEmitsTheWindowBatchOnceTheWindowElapses()
         source.OnNext(First);
         source.OnNext(Second);
 
-        // The window has not elapsed, so nothing may have been emitted yet.
         await Assert.That(batches.Count).IsEqualTo(0);
 
         clock.AdvanceBy(TimeSpan.FromTicks(Second));
@@ -119,7 +115,6 @@ public async Task BufferEmitsTheWindowBatchOnceTheWindowElapses()
         await Assert.That(batches.Count).IsEqualTo(1);
         await Assert.That(batches[0].SequenceEqual([First, Second])).IsTrue();
 
-        // A value in the next window opens a fresh batch rather than re-emitting the previous one.
         source.OnNext(Third);
         clock.AdvanceBy(TimeSpan.FromTicks(Second));
 
@@ -150,7 +145,7 @@ public async Task BufferForwardsASourceErrorAndAbandonsThePendingWindow()
         await Assert.That(observed.Count).IsEqualTo(1);
         await Assert.That(observed[0]).IsSameReferenceAs(expected);
 
-        // The buffer has stopped, so a late value must not be recorded and the scheduled flush must emit nothing.
+        // The source keeps pushing after its error, which the stopped buffer must drop.
         upstream.OnNext(Second);
         clock.AdvanceBy(TimeSpan.FromTicks(Second));
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
index 4f51298d..0db4e003 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs
@@ -31,7 +31,7 @@ public class SignalCreateTests
     /// <summary>Expected values for create-with-state tests.</summary>
     private static readonly int[] CreateWithStateExpected = [Third];
 
-    /// <summary>Creates the argument checking.</summary>
+    /// <summary>The create factory rejects a null subscribe callback and a null observer.</summary>
     [Test]
     public void Create_ArgumentChecking()
     {
@@ -40,7 +40,7 @@ public void Create_ArgumentChecking()
             Signal.Create((Func<IObserver<int>, IDisposable>)null!).Subscribe(null!));
     }
 
-    /// <summary>Creates the null coalescing action.</summary>
+    /// <summary>A create subscription disposes cleanly when its disposable carries no action.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task Create_NullCoalescingAction()
@@ -56,14 +56,14 @@ public async Task Create_NullCoalescingAction()
         await Assert.That(lst.SequenceEqual([CreatedValue])).IsTrue();
     }
 
-    /// <summary>Creates the exception.</summary>
+    /// <summary>A subscribe callback that throws surfaces at the subscribe call.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void Create_Exception() => Assert.Throws<InvalidOperationException>(static () => Signal.Create(
             new Func<IObserver<int>, IDisposable>(static _ => throw new InvalidOperationException()))
         .Subscribe());
 
-    /// <summary>Creates the observer throws.</summary>
+    /// <summary>An observer that throws from a notification surfaces the failure at the subscribe call.</summary>
     [Test]
     public void Create_ObserverThrows()
     {
@@ -84,7 +84,7 @@ public void Create_ObserverThrows()
         }).Subscribe(static x => { }, static ex => { }, static () => throw new InvalidOperationException()));
     }
 
-    /// <summary>Creates the with disposable argument checking.</summary>
+    /// <summary>The disposable-returning create overload rejects a null callback and a null observer.</summary>
     [Test]
     public void CreateWithDisposable_ArgumentChecking()
     {
@@ -98,7 +98,7 @@ public void CreateWithDisposable_ArgumentChecking()
         }).Subscribe(null!));
     }
 
-    /// <summary>Creates the with disposable null coalescing action.</summary>
+    /// <summary>The disposable-returning create overload tolerates a callback that returns no disposable.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CreateWithDisposable_NullCoalescingAction()
@@ -114,16 +114,14 @@ public async Task CreateWithDisposable_NullCoalescingAction()
         await Assert.That(lst.SequenceEqual([CreatedValue])).IsTrue();
     }
 
-    /// <summary>Creates the with disposable exception.</summary>
+    /// <summary>A throwing subscribe callback surfaces at the subscribe call of the disposable-returning overload.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
-            "A separate named regression test covering the disposable-returning Create overload's subscribe-time throw. "
-            + "It shares its assertion shape with Create_Exception but is kept as its own [Test] so the two entry points "
-            + "have independent, named coverage.")]
+            "The two tests subscribe through different Create overloads.")]
     public void CreateWithDisposable_Exception() => Assert.Throws<InvalidOperationException>(static () => Signal.Create(
             new Func<IObserver<int>, IDisposable>(static _ => throw new InvalidOperationException()))
         .Subscribe());
@@ -176,7 +174,7 @@ public async Task AnonymousSignal_ReturnsEmptyDisposableForNullDelegateResult()
         await Assert.That(disposable).IsSameReferenceAs(EmptyDisposable.Instance);
     }
 
-    /// <summary>Covers create-with-state overloads and null validation.</summary>
+    /// <summary>The create-with-state overloads invoke their stateful callback and reject null arguments.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CreateWithStateFactoriesInvokeStatefulSubscribeCallbacks()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalEmitIfQuietTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalEmitIfQuietTests.cs
index 94c3c958..66afbc3f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalEmitIfQuietTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalEmitIfQuietTests.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies <see cref="Signal"/> emit-if-quiet debounce contracts.</summary>
 public sealed class SignalEmitIfQuietTests
 {
-    /// <summary>
-    /// Verifies a source that completes twice, or errors after completing, is not forwarded twice: the quiet
-    /// observer keeps the Rx grammar even when the source breaks it.
-    /// </summary>
+    /// <summary>A second completion, or an error after completing, is dropped rather than forwarded.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EmitIfQuietDropsTerminalNotificationsAfterTheFirstOne()
@@ -32,7 +29,7 @@ public async Task EmitIfQuietDropsTerminalNotificationsAfterTheFirstOne()
         await Assert.That(witness.Values.Count).IsEqualTo(0);
     }
 
-    /// <summary>Verifies the EmitIfQuiet method covers immediate, scheduled, completion, stale emission, and error paths.</summary>
+    /// <summary>EmitIfQuiet emits immediately with a zero window, emits the last value after a quiet period, and forwards errors.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task EmitIfQuietCoversImmediateScheduledCompletionStaleAndErrorPaths()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
index b6978cfa..08e0754c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Behavior.cs
@@ -23,7 +23,7 @@ public partial class SignalFactoriesTests
     /// <summary>Expected single async value.</summary>
     private static readonly int[] ExpectedSingleAsyncValue = [1];
 
-    /// <summary>Exercises task, async-enumerable, and terminal task branches.</summary>
+    /// <summary>Task and async-enumerable factories forward cancellation and faults, and terminal tasks fault on an empty source.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task FactoriesTasksAndTerminalTasksCoverCancellationFaultAndEmptyBranches()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
index dd44f4e3..21431ff9 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
@@ -364,7 +364,7 @@ public async Task TimeFactoriesUseInjectedScheduler()
         await Assert.That(every.SequenceEqual(EveryExpected)).IsTrue();
     }
 
-    /// <summary>Verifies additional factory and unary operator parity helpers.</summary>
+    /// <summary>Sequence boundary, boolean terminal, and selection operators emit their expected values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AdditionalFactoriesAndUnaryOperatorsCoverCommonParitySurface()
@@ -374,7 +374,7 @@ public async Task AdditionalFactoriesAndUnaryOperatorsCoverCommonParitySurface()
         await VerifySelectionAndProjectionOperators();
     }
 
-    /// <summary>Verifies System.Reactive-style aliases intended to ease migration.</summary>
+    /// <summary>System.Reactive-named aliases prepend, tap, recover, and observe on a sequencer.</summary>
     /// <returns>A task that completes when the asynchronous assertions have run.</returns>
     [Test]
     public async Task SystemReactiveNamedAliasesCoverMigrationConvenienceSurface()
@@ -660,7 +660,7 @@ private static async Task VerifySequenceBoundaryOperators()
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The assertions target the synchronous IObservable operator overloads.")]
     private static async Task VerifyBooleanTerminalOperators()
     {
         List<int> count = [];
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
index 8387f54f..ee36c617 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
@@ -25,7 +25,7 @@ public async Task AnEmptySequenceCompletesWithoutEmitting()
         await Assert.That(completions).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the cancellable enumerable factory stops when its token is already cancelled.</summary>
+    /// <summary>The enumerable factory stops for a cancelled token and emits its whole sequence for an uncancellable one.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromEnumerableHonorsACancellableTokenAndIgnoresAnUncancellableOne()
@@ -72,8 +72,7 @@ public async Task StartWithoutASequencerRunsTheWorkOnTheDefaultSequencer()
         var actionRuns = 0;
         AwaitableWitness<RxVoid> actionWitness = new();
 
-        // A void method group is what selects Start(Action); a lambda over 'actionRuns++' is a
-        // Func<int> and would bind to the generic Start<T> overload instead.
+        // A void method group selects Start(Action); a lambda over 'actionRuns++' would bind to Start<T>.
         void RunAction() => actionRuns++;
 
         using var actionSubscription = Signal.Start(RunAction).Subscribe(actionWitness);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
index 78848d5c..8dff500b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
@@ -98,10 +98,7 @@ await Assert.That(static () => Signal.FromEventPattern<EventHandler<EventArgs>,
             null!)).Throws<ArgumentNullException>();
     }
 
-    /// <summary>
-    /// Verifies the handler-pair constructor attaches on the subscribing thread. The factories all supply a
-    /// sequencer argument now, so this is the shape only a caller constructing the signal directly reaches.
-    /// </summary>
+    /// <summary>Verifies the handler-pair constructor attaches on the subscribing thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromEventPatternSignalWithoutASequencerAttachesOnTheSubscribingThread()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
index dac4e5f5..e46811df 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
@@ -157,7 +157,6 @@ public async Task PeriodicAfterStopsReschedulingWhenTheSubscriptionIsDisposed()
         await Assert.That(witness.Values.SequenceEqual(ExpectedSingleZeroTick)).IsTrue();
         await Assert.That(witness.Completed).IsEqualTo(1);
 
-        // The downstream tore the timer down on its first tick, so no further tick may be scheduled.
         clock.AdvanceBy(SingleTick);
         clock.AdvanceBy(SingleTick);
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
index 762810ef..fe91ee53 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.cs
@@ -61,7 +61,7 @@ public partial class SignalFactoriesTests
     /// <summary>The expected repeated five values emitted by the bounded loop factory.</summary>
     private static readonly int[] ExpectedFiveFive = [Five, Five];
 
-    /// <summary>The expected single seven produced by the start and scheduled branches.</summary>
+    /// <summary>The expected single seven produced by the start and scheduled factories.</summary>
     private static readonly int[] ExpectedSingleSeven = [Seven];
 
     /// <summary>The expected error type names produced by the task factory continuations.</summary>
@@ -89,7 +89,7 @@ public partial class SignalFactoriesTests
     /// <summary>The expected values emitted by the direct task runner tests.</summary>
     private static readonly int[] ExpectedOneTwoThree = [One, Two, Three];
 
-    /// <summary>Covers scheduled return, throw, and empty signal implementations.</summary>
+    /// <summary>Scheduled emit, none, and fail factories deliver a value, a completion, and the original error.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduledScalarFactoriesUseNonImmediateSignalImplementations()
@@ -110,7 +110,7 @@ public async Task ScheduledScalarFactoriesUseNonImmediateSignalImplementations()
         await Assert.That(thrown[0]).IsSameReferenceAs(error);
     }
 
-    /// <summary>Covers factory scheduling, task continuations, and timer aliases with deterministic time.</summary>
+    /// <summary>Scheduled ranges, loops, task factories, and timer aliases emit their sequences on a virtual clock.</summary>
     /// <returns>A task that completes when asynchronous continuations are observed.</returns>
     [Test]
     public async Task FactoryAliasesScheduledRangesTasksAndTimersCoverRemainderBranches()
@@ -161,7 +161,7 @@ public async Task FactoryAliasesScheduledRangesTasksAndTimersCoverRemainderBranc
         AssertSchedulingFactoriesRejectInvalidArguments();
     }
 
-    /// <summary>Covers small value/factory/inline branches with public surface behavior.</summary>
+    /// <summary>Scheduled, looped, and paired signals validate their observers and emit through the inline surface.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ValueFactoryAndInlineBranchesCoverPublicEdgeBehavior()
@@ -211,7 +211,7 @@ public async Task ValueFactoryAndInlineBranchesCoverPublicEdgeBehavior()
         await Assert.That(mappedErrors.SequenceEqual(ExpectedMappedErrors)).IsTrue();
     }
 
-    /// <summary>Covers create-with-state, defer, and immediate-throw factory observer error paths.</summary>
+    /// <summary>Create-with-state, lazy, and fail factories forward their failures to the observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FactoryErrorPathsForwardObserverErrors()
@@ -280,7 +280,7 @@ public async Task FromAsyncCancellableFactoryDisposalSuppressesIgnoredCancellati
         await Assert.That(observer.Completions).IsEqualTo(0);
     }
 
-    /// <summary>Verifies that external token cancellation remains a source error while subscribed.</summary>
+    /// <summary>Verifies that external token cancellation surfaces as an observer error while the subscription is live.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromAsyncCancellableFactoryExternalCancellationForwardsObserverError()
@@ -374,7 +374,7 @@ public async Task FromAsyncCancellableFactorySynchronousFailuresForwardObserverE
         await Assert.That(nullTask.Completed).IsEqualTo(0);
     }
 
-    /// <summary>Verifies that already-canceled task factories forward cancellation as observer errors.</summary>
+    /// <summary>Verifies that a canceled task and a canceled external token forward cancellation as observer errors.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromAsyncCancellableFactoryCanceledTasksForwardObserverErrors()
@@ -528,10 +528,7 @@ public async Task RxFactoryAliasesRepeatGenerateUsingIfAndCase()
         AssertRxFactoryAliasesRejectInvalidArguments(cases);
     }
 
-    /// <summary>
-    /// Verifies an empty range completes immediately without touching the sequencer. There is nothing to emit, so the
-    /// factory hands back the shared empty signal rather than scheduling a walk over zero values.
-    /// </summary>
+    /// <summary>A sequence of no values completes immediately without scheduling anything.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SequenceOfNoValuesCompletesWithoutSchedulingAnything()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalGetAwaiterTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalGetAwaiterTests.cs
index 7d4d70ce..b8a4cc2c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalGetAwaiterTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalGetAwaiterTests.cs
@@ -18,7 +18,7 @@ public class SignalGetAwaiterTests
     /// <summary>Awaiter source values.</summary>
     private static readonly int[] AwaiterSource = [First, Second];
 
-    /// <summary>Covers signal awaiter completion, pre-cancellation, and registered cancellation paths.</summary>
+    /// <summary>An awaiter returns the last value, and a token cancelled before or after subscription throws.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task GetAwaiterCoversCompletionAndCancellationPaths()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
index 0819b57c..4ef51381 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs
@@ -40,10 +40,7 @@ public async Task MapAndKeepSignalsInheritTheCurrentThreadRequirementOfTheirSour
         await Assert.That(keptPlain.IsRequiredSubscribeOnCurrentThread()).IsFalse();
     }
 
-    /// <summary>
-    /// A source that keeps notifying after it has completed must not get a second bite at a Keep subscriber. The
-    /// filter must drop the late value before it even consults the predicate, and drop the late fault entirely.
-    /// </summary>
+    /// <summary>Keep drops the values and faults a source delivers after its completion, without consulting the predicate.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task KeepSignalDropsSourceNotificationsThatArriveAfterItsTerminal()
@@ -72,7 +69,7 @@ public async Task KeepSignalDropsSourceNotificationsThatArriveAfterItsTerminal()
         await Assert.That(predicateCalls).IsEqualTo(0);
     }
 
-    /// <summary>Verifies advanced map-indexed and enumerable blend direct paths.</summary>
+    /// <summary>Map-indexed signals report their source's thread requirement, and an unbounded blend forwards every value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AdvancedSignalsReportThreadRequirementsAndBlendUnboundedSources()
@@ -116,7 +113,7 @@ public async Task EnumerableBlendWithAConcurrencyBoundAdmitsSourcesInTurn()
         var bounded = sources.Blend(1);
         using var subscription = bounded.Subscribe(blended.Add, static ex => throw ex, () => completions++);
 
-        // The bound is one, so the second source must not be subscribed while the first is still running.
+        // The bound is one, so the second source stays unsubscribed while the first one runs.
         second.OnNext(UnobservedValue);
         first.OnNext(One);
         first.OnCompleted();
@@ -130,7 +127,7 @@ public async Task EnumerableBlendWithAConcurrencyBoundAdmitsSourcesInTurn()
         _ = Assert.Throws<ArgumentNullException>(() => bounded.Subscribe((IObserver<int>)null!));
     }
 
-    /// <summary>Verifies bounded blend drains enumerable sources and suppresses late terminals.</summary>
+    /// <summary>A bounded blend drains its sources, forwards only the first fault, and completes on a null enumerator.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task MaxConcurrentBlendCoordinatorDrainsAndSuppressesLateTerminals()
@@ -269,7 +266,7 @@ public async Task LatchAndExpireCoordinatorTerminalGuardsAreDeterministic()
         await Assert.That(expired.Errors[0]).IsTypeOf<TimeoutException>();
     }
 
-    /// <summary>Verifies take-until terminal guards and distinct set creation branches.</summary>
+    /// <summary>Take-until forwards the first terminal from either source, and distinct drops repeats with any comparer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TakeUntilAndDistinctTerminalBranchesAreCovered()
@@ -346,9 +343,7 @@ public void Schedule(IWorkItem item)
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "The relative and absolute Schedule overloads of this test-double sequencer intentionally behave the "
-                + "same way; both are required by the ISequencer contract and, as distinct interface overloads, cannot "
-                + "forward to one another.")]
+                "Both Schedule overloads are required by the ISequencer contract and cannot forward to one another.")]
         public void Schedule(IWorkItem item, long dueTimestamp)
         {
             item.Execute();
@@ -356,7 +351,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         }
     }
 
-    /// <summary>An enumerable that returns a null enumerator for defensive coordinator branches.</summary>
+    /// <summary>An enumerable that optionally returns a null enumerator.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     private sealed class NullEnumeratorEnumerable<T> : IEnumerable<IObservable<T>>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
index a51573d0..e29f9b33 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs
@@ -114,14 +114,14 @@ public async Task NullGuardsCoverPublicFactoryOperatorAndObserverContracts()
         await Task.CompletedTask;
     }
 
-    /// <summary>Exercises successful operator paths and early-termination branches.</summary>
+    /// <summary>Operator chains forward their values, and empty takes and exhausted skips complete without emitting.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     public async Task OperatorSurfaceCoversSuccessErrorAndEarlyTerminationBranches()
     {
         List<string> values = [];
@@ -174,7 +174,7 @@ public async Task OperatorSurfaceCoversSuccessErrorAndEarlyTerminationBranches()
         await Assert.That(flatMapValues.SequenceEqual(ExpectedFlatMapValues)).IsTrue();
     }
 
-    /// <summary>Exercises error materialization, recovery, resume, and retry branches.</summary>
+    /// <summary>Spark, unspark, rescue, resume, and reattempt carry a fault through to the final observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ErrorOperatorsMaterializeRecoverAndResumeDeterministically()
@@ -233,7 +233,7 @@ public async Task HigherOrderOperatorsHandleAsyncOrderingRacesSwitchingAndLatest
         await AssertPairAndForkJoinCompleteWithTheShorterSource();
     }
 
-    /// <summary>Exercises virtual-time operators and aliases.</summary>
+    /// <summary>Virtual-time operators emit only once their clock reaches the due time.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task VirtualTimeOperatorsCoverDelayTimeoutSampleTimerAndTimestampAliases()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
index 76e58c6a..22705449 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
@@ -59,7 +59,7 @@ public async Task ShiftRetainsTheDrainTimerArmedByAnInlineTick()
         await Assert.That(observer.Values.SequenceEqual([One])).IsTrue();
     }
 
-    /// <summary>Verifies that dispose waits for in-flight delivery and blocks queued notifications.</summary>
+    /// <summary>Disposing during delivery suppresses the queued notifications that follow it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ShiftDisposalClaimDuringDeliverySuppressesQueuedNotifications()
@@ -121,7 +121,7 @@ public async Task ShiftForwardsDelayedErrorAfterQueuedValues()
         await Assert.That(sequencer.ScheduledCount).IsEqualTo(0);
     }
 
-    /// <summary>Verifies notifications after a terminal one are dropped while the source is stopped.</summary>
+    /// <summary>Shift drops the notifications a source delivers after its terminal one.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ShiftDropsNotificationsAfterTerminalNotification()
@@ -205,9 +205,7 @@ private sealed class RecordingSequencer : ISequencer
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "The relative and absolute Schedule overloads of this test-double sequencer intentionally behave the "
-                + "same way; both are required by the ISequencer contract and, as distinct interface overloads, cannot "
-                + "forward to one another.")]
+                "Both Schedule overloads are required by the ISequencer contract and cannot forward to one another.")]
         public void Schedule(IWorkItem item, long dueTimestamp) => _items.Enqueue(item);
 
         /// <summary>Advances the scheduler clock without running queued work.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
index 48005413..ebc6c2fd 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Deterministic.cs
@@ -66,7 +66,7 @@ public partial class SignalOperatorMixinsTests
     /// <summary>Expected inner-subscribe error message.</summary>
     private static readonly string[] ExpectedInnerSubscribe = ["inner-subscribe"];
 
-    /// <summary>Verifies parity alias operators cover remaining lines.</summary>
+    /// <summary>Parity aliases forward prepended, fused, and chained values, and an ignoring recovery completes.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task ParityAliasOperatorsCoverRemainingLines()
@@ -96,13 +96,13 @@ public async Task ParityAliasOperatorsCoverRemainingLines()
         await Assert.That(ignoredCatchCompleted).IsEqualTo(1);
     }
 
-    /// <summary>Verifies range async fast paths and guard clauses cover remaining lines.</summary>
+    /// <summary>Sequence fast paths collect their values, and a pre-cancelled token cancels the task sink.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
-        Justification = "Synchronous CollectArray/CollectList operators are deliberately covered.")]
+        Justification = "The synchronous CollectArray and CollectList operators are the subject under test.")]
     public async Task RangeAsyncFastPathsAndNullGuardsCoverRemainingLines()
     {
         IEnumerable<IObservable<int>> blendSources = [Signal.Emit(One), Signal.Emit(Two)];
@@ -124,7 +124,7 @@ public async Task RangeAsyncFastPathsAndNullGuardsCoverRemainingLines()
         AssertOperatorGuardsRejectNullSourcesAndCallbacks();
     }
 
-    /// <summary>Verifies non-range task terminal sinks use the observer-backed async paths.</summary>
+    /// <summary>Count and any terminals await their results over a plain source, and cancel with a pre-cancelled token.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task NonRangeTaskTerminalsUseObserverBackedSinks()
@@ -144,7 +144,7 @@ await source.AnyAsync(static value => value == One, CancellationToken.None).Conf
         await Assert.That(source.CountAsync(canceledTerminal.Token).IsCanceled).IsTrue();
     }
 
-    /// <summary>Verifies remaining operator, factory, and observer failure branches are deterministic.</summary>
+    /// <summary>Scheduled factories, task signals, observer failures, and flat-map faults behave deterministically.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task RemainingOperatorFactoryAndObserverFailureBranchesAreDeterministic()
@@ -157,7 +157,7 @@ public async Task RemainingOperatorFactoryAndObserverFailureBranchesAreDetermini
         await VerifyFlatMapTerminalAndErrorBranches();
     }
 
-    /// <summary>Verifies optimized coordinator and async enumerable branches cover remaining gaps.</summary>
+    /// <summary>Async enumerable sources, race, switch, probe, calm, and fork-join coordinators gate their terminals.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task OptimizedCoordinatorAndAsyncEnumerableBranchesCoverRemainingGaps()
@@ -168,7 +168,7 @@ public async Task OptimizedCoordinatorAndAsyncEnumerableBranchesCoverRemainingGa
         await VerifyCalmAppendAndForkJoinBranches();
     }
 
-    /// <summary>Verifies range timing, queues, and thread pool cover remaining gaps.</summary>
+    /// <summary>Timestamp, time-interval, delay-start, and thread pool work items deliver on their sequencers.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
     public async Task RangeTimingQueuesAndThreadPoolCoverRemainingGaps()
@@ -315,7 +315,7 @@ await Assert.That(await Task.FromCanceled<int>(new(true)).HandleCancellation().C
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately verifies eager argument validation thrown synchronously, before the awaitable method returns its task.")]
+            "The guards under test throw synchronously, before the awaitable method returns its task.")]
     private static async Task VerifyAliasGuardsAndNullArgumentChecksAsync()
     {
         List<int> startWithAlias = [];
@@ -347,7 +347,7 @@ private static async Task VerifyAliasGuardsAndNullArgumentChecksAsync()
         await Assert.That(pendingTask.IsCanceled).IsTrue();
     }
 
-    /// <summary>Verifies immediate signal observer failure branches and the map late-notification branch.</summary>
+    /// <summary>A throwing observer propagates out of an immediate signal, and map drops notifications after its terminal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyObserverFailureBranchesAndMap()
     {
@@ -397,7 +397,7 @@ private static void VerifyMultiSubscriberOnErrorThrows()
         _ = Assert.Throws<InvalidOperationException>(() => signal.OnError(new InvalidOperationException("many")));
     }
 
-    /// <summary>Verifies FlatMap terminal completion, disposal, and the null-selector and inner-error branches.</summary>
+    /// <summary>FlatMap completes after its inners, stops on disposal, and faults on a null selector or failing inner.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyFlatMapTerminalAndErrorBranches()
     {
@@ -454,7 +454,7 @@ private static async Task VerifyFlatMapTerminalAndErrorBranches()
         await Assert.That(subscribeErrors.SequenceEqual(ExpectedInnerSubscribe)).IsTrue();
     }
 
-    /// <summary>Verifies async enumerable subscription, shift timing, and expire timeout branches.</summary>
+    /// <summary>Async enumerable sources drain to their subscriber, and shift and expire follow the virtual clock.</summary>
     /// <returns>A task representing the asynchronous verification.</returns>
     private static async Task VerifyAsyncEnumerableShiftAndExpireAsync()
     {
@@ -507,7 +507,7 @@ private static async Task VerifyAsyncEnumerableShiftAndExpireAsync()
         await Assert.That(expireError.Errors[0].Message).IsEqualTo("expire-error");
     }
 
-    /// <summary>Verifies the race, synchronized-latest, and switch coordinator branches.</summary>
+    /// <summary>Race, synchronized-latest, and switch coordinators gate every losing and stale inner.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyRaceSyncLatestAndSwitchBranches()
     {
@@ -615,7 +615,7 @@ private static async Task VerifySwitchToForwardsOnlyTheCurrentInner()
         await Assert.That(switched.Errors[0].Message).IsEqualTo("current-switch");
     }
 
-    /// <summary>Verifies switch outer-error, deferred-completion, and post-terminal gating branches.</summary>
+    /// <summary>Switch forwards one outer error, defers completion to its current inner, and gates what follows.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifySwitchTerminalGatingBranches()
     {
@@ -645,10 +645,7 @@ private static async Task VerifySwitchForwardsTheOuterErrorOnceAndGatesWhatFollo
         await Assert.That(outerErrored.Values.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies an outer completion waits for the current inner to finish, and that a superseded inner's
-    /// completion never completes the observer.
-    /// </summary>
+    /// <summary>Switch defers its completion to the current inner and ignores a superseded inner's completion.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifySwitchDefersCompletionUntilTheCurrentInnerFinishes()
     {
@@ -717,7 +714,7 @@ private static async Task VerifySwitchGatesEveryNotificationAfterAnInnerError()
         await Assert.That(innerErrorCompleted.Completed).IsEqualTo(0);
     }
 
-    /// <summary>Verifies the probe operator error, disposal, and completion branches.</summary>
+    /// <summary>Probe forwards a fault, stops after disposal, and completes without a sampled value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyProbeBranches()
     {
@@ -762,7 +759,7 @@ private static async Task VerifyProbeBranches()
         await Assert.That(currentThreadProbe.Completed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the calm debounce, append observer failure, and fork-join completion branches.</summary>
+    /// <summary>Calm emits only the quiet value, append surfaces observer faults, and fork-join waits for both sides.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyCalmAppendAndForkJoinBranches()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
index a7d3f97d..9668f59f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.PostTerminalGuards.cs
@@ -46,7 +46,7 @@ public async Task BlendStopsForwardingInnerValuesOnceTheSubscriptionIsDisposed()
         await Assert.That(inner.HasObservers).IsFalse();
     }
 
-    /// <summary>Verifies <c>Shift</c> drops values a source delivers after it has already completed.</summary>
+    /// <summary>Verifies <c>Shift</c> drops the values a source delivers after its completion.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ShiftDropsValuesDeliveredAfterTheSourceCompletes()
@@ -77,7 +77,7 @@ public async Task CalmOnTheCurrentThreadSequencerEmitsTheQuietValue()
         await Assert.That(values.SequenceEqual([One, Two])).IsTrue();
     }
 
-    /// <summary>Verifies a stale <c>Calm</c> timer tick does not re-emit the value it already delivered.</summary>
+    /// <summary>Verifies a stale <c>Calm</c> timer tick does not re-emit the value it delivered.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CalmIgnoresAStaleTimerTickAndPostTerminalNotifications()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
index be543818..98d01a84 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Scheduling.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Tests scheduled delivery and virtual-time operator behavior.</summary>
 public partial class SignalOperatorMixinsTests
 {
-    /// <summary>Verifies the timestamp operator immediate and clock-backed branches.</summary>
+    /// <summary>Timestamp stamps every value from its immediate or clock-backed sequencer and rejects null observers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyTimestampBranches()
     {
@@ -56,7 +56,7 @@ private static async Task VerifyTimestampBranches()
             immediateTimestampSignal.Subscribe((Action<Moment<int>>)null!, static _ => { }, static () => { }));
     }
 
-    /// <summary>Verifies the time-interval operator immediate and clock-backed branches.</summary>
+    /// <summary>Time-interval reports a zero gap for values its sequencer delivers without advancing the clock.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyTimeIntervalBranches()
     {
@@ -116,7 +116,7 @@ private static async Task VerifyTimeIntervalBranches()
             immediateIntervalSignal.Subscribe((Action<TimeInterval<int>>)null!, static _ => { }, static () => { }));
     }
 
-    /// <summary>Verifies delay-start signal branches, the sequencer work item, and queue guard clauses.</summary>
+    /// <summary>Verifies delay-start delivery, the sequencer work item, and the queue guard clauses.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task VerifyDelayStartAndWorkItemBranches()
     {
@@ -173,8 +173,6 @@ private static async Task VerifyDelayStartAndWorkItemBranches()
     /// <returns>A task representing the asynchronous verification.</returns>
     private static async Task VerifySequencerWorkItemDisposalBranches()
     {
-        // Invoke then dispose: the published disposable is released by Dispose exactly once,
-        // and a redundant second Dispose is a no-op.
         var invokeThenDisposeReleased = 0;
         SequencerWorkItem<ISequencer, int> invokeThenDispose = new(Sequencer.Immediate, One, (_, _) =>
             new ActionDisposable(() => Interlocked.Increment(ref invokeThenDisposeReleased)));
@@ -198,11 +196,10 @@ private static async Task VerifySequencerWorkItemDisposalBranches()
         await VerifySequencerWorkItemDisposeRaceInvariant();
     }
 
-    /// <summary>Verifies both compare-exchange outcomes of <c>SequencerWorkItem.Publish</c>.</summary>
+    /// <summary>Publish stores its disposable into an empty slot and releases it when the slot is claimed.</summary>
     /// <returns>A task representing the asynchronous verification.</returns>
     private static async Task VerifySequencerWorkItemPublishBranches()
     {
-        // Publish wins the empty slot: the disposable is stored and left alive for Dispose.
         var stored = 0;
         ActionDisposable storedDisposable = new(() => Interlocked.Increment(ref stored));
         IDisposable? winSlot = null;
@@ -210,7 +207,7 @@ private static async Task VerifySequencerWorkItemPublishBranches()
         await Assert.That(ReferenceEquals(winSlot, storedDisposable)).IsTrue();
         await Assert.That(stored).IsEqualTo(0);
 
-        // Publish loses to disposal (slot already claimed): the disposable is released immediately.
+        // A non-null slot means disposal claimed it first, so Publish releases the disposable.
         var loserDisposed = 0;
         ActionDisposable loser = new(() => Interlocked.Increment(ref loserDisposed));
         IDisposable? loseSlot = EmptyDisposable.Instance;
@@ -235,7 +232,7 @@ private static async Task VerifySequencerWorkItemDisposeRaceInvariant()
         await Assert.That(disposed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the thread pool absolute scheduling and scheduled work item disposal branches.</summary>
+    /// <summary>Verifies absolute thread pool scheduling and the disposal of a scheduled work item.</summary>
     /// <returns>A task representing the asynchronous verification.</returns>
     private static async Task VerifyThreadPoolWorkItemBranchesAsync()
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
index 680018c3..ca196fa6 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
@@ -54,25 +54,25 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The expected one-through-four sequence emitted by the four-element source.</summary>
     private static readonly int[] ExpectedOneToFour = [One, Two, Three, Four];
 
-    /// <summary>The expected single null produced by the default-if-empty branch.</summary>
+    /// <summary>The expected single null from default-if-empty.</summary>
     private static readonly int?[] ExpectedSingleNull = [null];
 
-    /// <summary>The expected one-and-two prefix retained by take-while and distinct branches.</summary>
+    /// <summary>The expected one-and-two prefix retained by take-while and distinct.</summary>
     private static readonly int[] ExpectedOneTwo = [One, Two];
 
-    /// <summary>The expected three-and-four suffix retained by skip-while and delay branches.</summary>
+    /// <summary>The expected three-and-four suffix retained by skip-while and delay.</summary>
     private static readonly int[] ExpectedThreeFour = [Three, Four];
 
-    /// <summary>The expected single nine produced by the fork-join sum branch.</summary>
+    /// <summary>The expected single nine produced by the fork-join sum.</summary>
     private static readonly int[] ExpectedSingleNine = [Nine];
 
-    /// <summary>The expected two-through-four prefix produced by the single prepend branch.</summary>
+    /// <summary>The expected two-through-four sequence produced by a single prepend.</summary>
     private static readonly int[] ExpectedTwoToFour = [Two, Three, Four];
 
-    /// <summary>The expected message from the single delayed-error branch.</summary>
+    /// <summary>The expected message from a delayed error.</summary>
     private static readonly string[] ExpectedDelayErrors = ["delay-error"];
 
-    /// <summary>The expected error type name from the expire-timeout branch.</summary>
+    /// <summary>The expected error type name from an expire timeout.</summary>
     private static readonly string[] ExpectedTimeoutErrors = [nameof(TimeoutException)];
 
     /// <summary>The expected single true value emitted by the true signal.</summary>
@@ -81,34 +81,34 @@ public partial class SignalOperatorMixinsTests
     /// <summary>The expected single false value emitted by the false signal.</summary>
     private static readonly bool[] ExpectedFalseValues = [false];
 
-    /// <summary>The expected single seven produced by the scheduled branch.</summary>
+    /// <summary>The expected single seven produced by scheduled work.</summary>
     private static readonly int[] ExpectedSingleSeven = [Seven];
 
-    /// <summary>The expected two-and-three sequence produced by the observer prepend branch.</summary>
+    /// <summary>The expected two-and-three sequence produced by an observer prepend.</summary>
     private static readonly int[] ExpectedTwoThree = [Two, Three];
 
-    /// <summary>The expected one-through-three sequence produced by the prepend/append branches.</summary>
+    /// <summary>The expected one-through-three sequence produced by prepend and append.</summary>
     private static readonly int[] ExpectedOneToThree = [One, Two, Three];
 
-    /// <summary>The expected three-and-five sequence produced by the combine-latest branch.</summary>
+    /// <summary>The expected three-and-five sequence produced by combine-latest.</summary>
     private static readonly int[] ExpectedThreeFive = [Three, Five];
 
-    /// <summary>The expected single two produced by the switch branch.</summary>
+    /// <summary>The expected single two produced by switching inners.</summary>
     private static readonly int[] ExpectedSingleTwo = [Two];
 
-    /// <summary>The expected single five produced by the typed catch branch.</summary>
+    /// <summary>The expected single five produced by a typed recovery.</summary>
     private static readonly int[] ExpectedSingleFive = [Five];
 
-    /// <summary>The expected message from the keep-predicate fault branch.</summary>
+    /// <summary>The expected message from a faulting keep predicate.</summary>
     private static readonly string[] ExpectedKeepErrors = ["keep-predicate"];
 
-    /// <summary>The expected message from the all-predicate fault branch.</summary>
+    /// <summary>The expected message from a faulting all predicate.</summary>
     private static readonly string[] ExpectedAllErrors = ["all-predicate"];
 
-    /// <summary>The expected messages from the recover handler-fault and unmatched branches.</summary>
+    /// <summary>The expected messages from a faulting recover handler and an unmatched error.</summary>
     private static readonly string[] ExpectedCatchErrors = ["handler-threw", "not-matched"];
 
-    /// <summary>Covers parity operator overloads, aliases, and argument guards that are not hit by scenario tests.</summary>
+    /// <summary>Parity operator aliases forward their values, report side effects, and reject null arguments.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ParityOperatorAliasesAndGuardsCoverRemainingBranches()
@@ -160,7 +160,7 @@ public async Task ParityOperatorAliasesAndGuardsCoverRemainingBranches()
         AssertAggregateAndTimingGuards(source);
     }
 
-    /// <summary>Covers prepend, observe-on, default-if-empty, and time-shift alias edge branches.</summary>
+    /// <summary>Prepend, observe-on, default-if-empty, and time-shift aliases return their shortcut results.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AliasAndTimeShiftBranchesCoverRemainingEdges()
@@ -192,7 +192,7 @@ public async Task AliasAndTimeShiftBranchesCoverRemainingEdges()
         await Assert.That(timeoutErrors.SequenceEqual(ExpectedTimeoutErrors)).IsTrue();
     }
 
-    /// <summary>Covers deterministic shortcut branches in primitive-vocabulary operator wrappers.</summary>
+    /// <summary>Primitive operator wrappers shortcut cancelable sources, empty takes, and pending tasks.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task PrimitiveShortcutBranchesCoverCancelableFallbackAndPendingTaskPaths()
@@ -242,7 +242,7 @@ public async Task PrimitiveShortcutBranchesCoverCancelableFallbackAndPendingTask
         await Assert.That(stringSwitch.SequenceEqual(ExpectedSingleValue)).IsTrue();
     }
 
-    /// <summary>Covers immutable boolean and rx-void return-signal inline subscription branches.</summary>
+    /// <summary>Immutable boolean and rx-void return signals deliver their value inline and complete.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ImmutableReturnSignalsCoverInlineBranches()
@@ -270,7 +270,7 @@ await Assert.That(((IRequireCurrentThread<RxVoid>)voidSignal).IsRequiredSubscrib
         await Assert.That(inlineCompleted).IsEqualTo(Three);
     }
 
-    /// <summary>Covers minimal virtual-clock scheduling guards and dispatch branches.</summary>
+    /// <summary>The minimal virtual clock rejects invalid advances and null actions, and dispatches due work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task MinimalVirtualClockSchedulingCoversGuardsAndDispatch()
@@ -296,7 +296,7 @@ public async Task MinimalVirtualClockSchedulingCoversGuardsAndDispatch()
         await Assert.That(scheduled.SequenceEqual(ExpectedSingleSeven)).IsTrue();
     }
 
-    /// <summary>Covers observer-based inline operator paths and private observer error cleanup paths.</summary>
+    /// <summary>Inline prepend and append operators reject null observers and propagate observer failures.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task InlineOperatorObserverAndErrorCleanupPathsCoverRemainingBranches()
@@ -339,7 +339,7 @@ public async Task InlineOperatorObserverAndErrorCleanupPathsCoverRemainingBranch
         await Assert.That(delegateErrors).IsEqualTo(1);
     }
 
-    /// <summary>Covers coordinator paths where later sources complete or error after another source has won.</summary>
+    /// <summary>Race, combine, and switch coordinators ignore sources that terminate after another has won.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task HigherOrderCoordinatorRaceCombineSwitchPathsCoverLateBranches()
@@ -395,7 +395,7 @@ public async Task HigherOrderCoordinatorRaceCombineSwitchPathsCoverLateBranches(
         await Assert.That(switched.Completed).IsEqualTo(1);
     }
 
-    /// <summary>Covers observer exception paths and typed catch/finally branches with deterministic synchronous sources.</summary>
+    /// <summary>Predicate faults, typed recovery, and cleanup handlers surface their errors once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ObserverExceptionCatchFinallyAndTerminalPredicateBranchesCoverRemainders()
@@ -451,7 +451,7 @@ public async Task ObserverExceptionCatchFinallyAndTerminalPredicateBranchesCover
         await Assert.That(finallyCalls).IsEqualTo(1);
     }
 
-    /// <summary>Covers fused prepend/default-if-empty/append and empty Prepend helpers.</summary>
+    /// <summary>Fused prepend, default-if-empty, and append preserve value ordering and the single terminal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task PrependAppendDefaultIfEmptyFusionPreservesOrderingAndTerminals()
@@ -508,7 +508,7 @@ public async Task IndexedMappingTaskChainAndTaskSignalAliasesCoverCompatibilityP
         _ = Assert.Throws<ArgumentNullException>(static () => ((IObservable<Task<int>>)null!).Chain());
     }
 
-    /// <summary>Verifies direct task-chain sequencing without the map adapter.</summary>
+    /// <summary>Task chaining emits pending task results in source order.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TaskChainDirectSignalKeepsPendingTasksInSourceOrder()
@@ -533,7 +533,7 @@ public async Task TaskChainDirectSignalKeepsPendingTasksInSourceOrder()
         await Assert.That(chained.Completions).IsEqualTo(One);
     }
 
-    /// <summary>Verifies direct task-chain terminal and disposal paths.</summary>
+    /// <summary>Task chaining forwards a source fault, a null task, and a task fault, and drops notifications after disposal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TaskChainDirectSignalHandlesErrorsAndDisposal()
@@ -585,7 +585,7 @@ public async Task TaskChainDirectSignalHandlesErrorsAndDisposal()
         await Assert.That(disposed.Completed).IsEqualTo(0);
     }
 
-    /// <summary>Covers default-if-empty behavior over hot sources for empty, non-empty, error, and observer-guard branches.</summary>
+    /// <summary>Default-if-empty substitutes its fallback only for an empty source and rejects a null observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DefaultIfEmptyCoversHotSourceEmptyNonEmptyErrorAndObserverGuard()
@@ -621,7 +621,7 @@ public async Task DefaultIfEmptyCoversHotSourceEmptyNonEmptyErrorAndObserverGuar
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task TelemetryBurstBuffersTerminalCountsAndSubscriberChurnAreDeterministic()
     {
@@ -743,7 +743,7 @@ private static async Task AssertTaskSignalAliasesForwardResultsCancellationAndFa
         await Assert.That(faultedTaskSignal.Errors[0]).IsSameReferenceAs(taskError);
     }
 
-    /// <summary>Covers the synchronous collect-list and collect-array operator branches.</summary>
+    /// <summary>Asserts collect-list and collect-array emit the entire source as a single value.</summary>
     /// <param name="source">A four-element integer source.</param>
     /// <exception cref="InvalidOperationException">A collect operator produced an unexpected sequence.</exception>
     private static void VerifyCollectOperators(IObservable<int> source)
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Aggregates.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Aggregates.cs
index 6dea0e6c..fa93a775 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Aggregates.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Aggregates.cs
@@ -98,13 +98,13 @@ public partial class SignalOperatorParityMixinsTests
     /// <summary>Expected result-selector FlatMap values.</summary>
     private static readonly int[] ResultFlatMapExpected = [First + FirstInner, Second + FirstInner];
 
-    /// <summary>Covers count, long-count, distinct fast count, and any helper branches.</summary>
+    /// <summary>The count, long-count, distinct-count, and any helpers report their aggregate.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task AggregateHelpersCoverPredicateDistinctAndAnyPaths()
     {
@@ -160,13 +160,13 @@ public async Task AggregateHelpersCoverPredicateDistinctAndAnyPaths()
         await Assert.That(rangeContainsFalse.SequenceEqual(FalseExpected)).IsTrue();
     }
 
-    /// <summary>Covers optimized aggregate observer error paths.</summary>
+    /// <summary>The optimized aggregate observers forward a source error unchanged.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task AggregateHelpersForwardSourceErrors()
     {
@@ -186,7 +186,7 @@ public async Task AggregateHelpersForwardSourceErrors()
         await Assert.That(observed[DistinctErrorIndex]).IsSameReferenceAs(distinctError);
     }
 
-    /// <summary>Covers predicate exceptions for aggregate boolean terminals.</summary>
+    /// <summary>The boolean aggregate terminals forward an exception thrown by the predicate.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AggregateBooleanTerminalsForwardPredicateErrors()
@@ -197,7 +197,7 @@ public async Task AggregateBooleanTerminalsForwardPredicateErrors()
         await Assert.That(observed[0]).IsSameReferenceAs(allError);
     }
 
-    /// <summary>Covers FlatMap queuing while an inner signal is active.</summary>
+    /// <summary>FlatMap queues a later inner signal until the active inner signal completes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FlatMapQueuesInnerSignalsUntilActiveInnerCompletes()
@@ -220,7 +220,7 @@ public async Task FlatMapQueuesInnerSignalsUntilActiveInnerCompletes()
         await Assert.That(completed).IsEqualTo(1);
     }
 
-    /// <summary>Covers the FlatMap overload with an outer and inner result selector.</summary>
+    /// <summary>The FlatMap result-selector overload projects each outer value with its inner value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FlatMapResultSelectorProjectsOuterAndInnerValues()
@@ -232,7 +232,7 @@ public async Task FlatMapResultSelectorProjectsOuterAndInnerValues()
         await Assert.That(values.SequenceEqual(ResultFlatMapExpected)).IsTrue();
     }
 
-    /// <summary>Covers FlatMap selector, inner, and outer error forwarding.</summary>
+    /// <summary>FlatMap forwards a selector, inner, and outer error to the observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FlatMapForwardsSelectorInnerAndOuterErrors()
@@ -320,7 +320,7 @@ public async Task RangeTerminalTasksFaultWhenThePredicateThrows()
         await Assert.That(countError!).IsSameReferenceAs(expected);
     }
 
-    /// <summary>The predicate terminals cancel up front when handed an already-cancelled token.</summary>
+    /// <summary>The predicate terminals cancel up front when handed a pre-cancelled token.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task PredicateTerminalTasksCancelUpFrontOnAnAlreadyCancelledToken()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Cancellation.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Cancellation.cs
index 89ae8bba..76a044c7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Cancellation.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.Cancellation.cs
@@ -64,7 +64,7 @@ public async Task ToTaskOnPendingTaskWithPreCanceledTokenIsCanceled()
         await Assert.That(task.IsCanceled).IsTrue();
     }
 
-    /// <summary>Verifies the issue #108 scenario: <c>FirstAsync().ToTask(token)</c> cancels when the token fires before a value arrives.</summary>
+    /// <summary>Verifies <c>FirstAsync().ToTask(token)</c> cancels when the token fires before a value arrives.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FirstAsyncToTaskCancelsWhenTokenFires()
@@ -80,7 +80,7 @@ public async Task FirstAsyncToTaskCancelsWhenTokenFires()
         await Assert.That(() => pending).Throws<TaskCanceledException>();
     }
 
-    /// <summary>Verifies the issue #108 scenario: <c>FirstAsync().ToTask(token)</c> yields the first matching value when it arrives before cancellation.</summary>
+    /// <summary>Verifies <c>FirstAsync().ToTask(token)</c> yields the first matching value when it arrives before cancellation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FirstAsyncToTaskYieldsFirstMatchingValue()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.RangeFastPaths.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.RangeFastPaths.cs
index 5a16ee79..8d3d22b6 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.RangeFastPaths.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.RangeFastPaths.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the range-backed fast paths of the aggregate operators: a sequence built from
-/// <see cref="Signal.Sequence(int, int)"/> is answered from its bounds instead of by enumerating it, and a
-/// predicate that throws while the bounds are being walked is still reported as an error to the observer.
-/// </summary>
+/// <summary>Verifies the range-backed fast paths of the aggregate operators.</summary>
 public partial class SignalOperatorParityMixinsTests
 {
     /// <summary>Verifies the aggregate operators answer a range source directly from its bounds.</summary>
@@ -20,7 +16,7 @@ public partial class SignalOperatorParityMixinsTests
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task RangeBackedAggregatesAreAnsweredFromTheRangeBounds()
     {
@@ -47,7 +43,7 @@ public async Task RangeBackedAggregatesAreAnsweredFromTheRangeBounds()
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task RangeBackedAggregatesReportAPredicateFailureAsAnError()
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs
index d020e9df..105c32c3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs
@@ -27,7 +27,7 @@ public partial class SignalOperatorParityMixinsTests
     /// <summary>The long constant two.</summary>
     private const long TwoLong = 2L;
 
-    /// <summary>The expected one-and-two prefix retained by distinct branches.</summary>
+    /// <summary>The expected one-and-two prefix from the distinct operators.</summary>
     private static readonly int[] ExpectedOneTwo = [One, Two];
 
     /// <summary>The expected single two produced by the distinct count alias.</summary>
@@ -39,13 +39,13 @@ public partial class SignalOperatorParityMixinsTests
     /// <summary>The expected single true value emitted by a true signal.</summary>
     private static readonly bool[] ExpectedTrueValues = [true];
 
-    /// <summary>Covers operator Subscribe(null) and current-thread propagation for internal optimized signal classes.</summary>
+    /// <summary>The optimized operator signals reject a null observer and do not require the current thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task InternalOptimizedOperatorSignalsValidateObserversAndThreadRequirements()
     {
@@ -98,13 +98,13 @@ public async Task InternalOptimizedOperatorSignalsValidateObserversAndThreadRequ
         }
     }
 
-    /// <summary>Covers optimized aggregate helper paths with custom comparers, selector exceptions, and range-backed count aliases.</summary>
+    /// <summary>The optimized aggregates honor custom comparers, surface selector faults, and count range sources.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task AggregateOptimizedSignalsCoverComparerAndExceptionPaths()
     {
@@ -145,13 +145,13 @@ public async Task AggregateOptimizedSignalsCoverComparerAndExceptionPaths()
         await Assert.That(containsRange.Values.SequenceEqual(ExpectedTrueValues)).IsTrue();
     }
 
-    /// <summary>Covers terminal observers that must ignore protocol violations after their first terminal signal.</summary>
+    /// <summary>Terminal observers ignore notifications after their first terminal signal and forward predicate failures.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [SuppressMessage(
         "Concurrency",
         "PSH1313:Call the async overload from an async method",
         Justification =
-            "This test deliberately exercises the synchronous IObservable operator overloads, not their awaitable terminal counterparts.")]
+            "The synchronous IObservable operator overloads are the subject under test.")]
     [Test]
     public async Task TerminalObserversIgnoreLateSignalsAndForwardPredicateFailures()
     {
@@ -194,7 +194,7 @@ public async Task TerminalObserversIgnoreLateSignalsAndForwardPredicateFailures(
         await Assert.That(values).Contains(true);
     }
 
-    /// <summary>Verifies scheduler-based ToObservable conversion and task conversion aliases.</summary>
+    /// <summary>The scheduler and task ToObservable aliases emit their values and honor cancellation.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ToObservableSchedulerAndTaskAliasesEmitAndHonorCancellation()
@@ -252,7 +252,7 @@ public async Task ToObservableSchedulerAndTaskAliasesEmitAndHonorCancellation()
         _ = Assert.Throws<ArgumentNullException>(static () => ((Task<int>)null!).ToObservable());
     }
 
-    /// <summary>Covers deterministic shortcut branches in System.Reactive-name parity operators.</summary>
+    /// <summary>The System.Reactive-named parity operators apply their default arguments and range fast paths.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ParityShortcutBranchesCoverDefaultsAndRangeFastPaths()
@@ -311,7 +311,7 @@ public async Task ParityShortcutBranchesCoverDefaultsAndRangeFastPaths()
         await Assert.That(fusedRanges.SequenceEqual(expectedLatest)).IsTrue();
     }
 
-    /// <summary>Creates a source that keeps signalling values and a completion after it has already errored.</summary>
+    /// <summary>Creates a source that signals a value and a completion after it has errored.</summary>
     /// <returns>The misbehaving source.</returns>
     private static ScriptedObservable<int> CreateSourceThatKeepsSignallingAfterItsError() =>
         new(static observer =>
@@ -322,7 +322,7 @@ private static ScriptedObservable<int> CreateSourceThatKeepsSignallingAfterItsEr
             observer.OnCompleted();
         });
 
-    /// <summary>Creates a source that keeps signalling values and an error after it has already completed.</summary>
+    /// <summary>Creates a source that signals an error and a value after it has completed.</summary>
     /// <returns>The misbehaving source.</returns>
     private static ScriptedObservable<int> CreateSourceThatKeepsSignallingAfterItsCompletion() =>
         new(static observer =>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
index 4a6c542d..524e4a4e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
@@ -24,7 +24,7 @@ public class SignalRecoverTests
     /// <summary>Expected values produced by the catch params overload.</summary>
     private static readonly int[] CatchRecoveryExpected = [First, Second];
 
-    /// <summary>Covers catch sequence recovery, final error, empty completion, null source, and enumerator failure branches.</summary>
+    /// <summary>A recover sequence falls through to the first source that succeeds, and reports a null or failing source.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CatchParamsFactoryCoversRecoveryAndFailureBranches()
@@ -123,7 +123,6 @@ public async Task DisposedRecoverSequenceIgnoresALateUpstreamError()
 
         upstream!.OnError(new InvalidOperationException(FirstMessage));
 
-        // The sequence was torn down, so the fallback source must never be subscribed and nothing may reach downstream.
         await Assert.That(witness.Values.Count).IsEqualTo(0);
         await Assert.That(witness.Errors.Count).IsEqualTo(0);
         await Assert.That(witness.Completed).IsEqualTo(0);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
index 4b7a741c..bad2caa7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.Aliases.cs
@@ -12,7 +12,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Tests Rx-style alias factories and empty-source shortcuts.</summary>
 public partial class SignalTests
 {
-    /// <summary>Verifies Rx factory aliases cover scheduled, empty, timeout, and switch range branches.</summary>
+    /// <summary>Rx-named aliases produce scheduled, empty, and timeout signals, and switch flattens range and non-range sources.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task RxFactoryAliasesCoverScheduledAndSwitchRangeBranches()
@@ -43,7 +43,7 @@ public async Task RxFactoryAliasesCoverScheduledAndSwitchRangeBranches()
         await Assert.That(nonRangeSwitch.SequenceEqual([Five])).IsTrue();
     }
 
-    /// <summary>Verifies parity aliases cover task terminal shortcut branches.</summary>
+    /// <summary>Task conversion forwards a completed result, a cancellation, a fault, and a pending result.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ParityAliasesCoverTaskObservableBranches()
@@ -69,7 +69,7 @@ public async Task ParityAliasesCoverTaskObservableBranches()
         await Assert.That(pendingWitness.Values.SequenceEqual([Two])).IsTrue();
     }
 
-    /// <summary>Verifies parity operators cover remaining public range and alias branches.</summary>
+    /// <summary>Range-backed aliases emit their values through default, unique, timestamp, concat, merge, and pair operators.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ParityOperatorsCoverRangeAndAliasBranches()
@@ -115,7 +115,7 @@ public async Task ParityOperatorsCoverRangeAndAliasBranches()
         await Assert.That(latestWithNonRangeRight.SequenceEqual([Two + Three, Two + Four])).IsTrue();
     }
 
-    /// <summary>Verifies direct from-async subscriptions cover constructor and synchronous completion paths.</summary>
+    /// <summary>A from-async subscription emits and completes synchronously, even when its factory disposes it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromAsyncSubscriptionsCoverConstructorAndSynchronousCompletionPaths()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
index c3a13602..6fcf32a8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
@@ -89,7 +89,7 @@ public partial class SignalTests
     /// <summary>Expected pair of RxVoid notifications.</summary>
     private static readonly RxVoid[] DoubleRxVoid = [RxVoid.Default, RxVoid.Default];
 
-    /// <summary>Called when [next].</summary>
+    /// <summary>A subscriber receives each value until its subscription is disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnNext()
@@ -106,7 +106,7 @@ public async Task OnNext()
         await Assert.That(value).IsEqualTo(PairCount);
     }
 
-    /// <summary>Called when [next disposed].</summary>
+    /// <summary>A disposed signal throws when a value is emitted.</summary>
     [Test]
     public void OnNextDisposed()
     {
@@ -115,7 +115,7 @@ public void OnNextDisposed()
         _ = Assert.Throws<ObjectDisposedException>(() => subject.OnNext(1));
     }
 
-    /// <summary>Called when [next disposed subscriber].</summary>
+    /// <summary>A disposed subscriber receives no further values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnNextDisposedSubscriber()
@@ -127,7 +127,7 @@ public async Task OnNextDisposedSubscriber()
         await Assert.That(value).IsEqualTo(0);
     }
 
-    /// <summary>Called when [completed].</summary>
+    /// <summary>A subscriber is notified when the signal completes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnCompleted()
@@ -141,7 +141,7 @@ public async Task OnCompleted()
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Called when [completed no op].</summary>
+    /// <summary>Completing a signal whose subscriber handles values only raises no error.</summary>
     [Test]
     public void OnCompleted_NoErrors()
     {
@@ -150,7 +150,7 @@ public void OnCompleted_NoErrors()
         subject.OnCompleted();
     }
 
-    /// <summary>Called when [completed once].</summary>
+    /// <summary>Only the first completion is forwarded.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnCompletedOnce()
@@ -166,7 +166,7 @@ public async Task OnCompletedOnce()
         await Assert.That(completed).IsEqualTo(1);
     }
 
-    /// <summary>Called when [completed disposed].</summary>
+    /// <summary>A disposed signal throws when it is completed.</summary>
     [Test]
     public void OnCompletedDisposed()
     {
@@ -175,7 +175,7 @@ public void OnCompletedDisposed()
         _ = Assert.Throws<ObjectDisposedException>(subject.OnCompleted);
     }
 
-    /// <summary>Called when [completed disposed subscriber].</summary>
+    /// <summary>A disposed subscriber is not notified of completion.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnCompletedDisposedSubscriber()
@@ -189,7 +189,7 @@ public async Task OnCompletedDisposedSubscriber()
         await Assert.That(completed).IsFalse();
     }
 
-    /// <summary>Called when [error].</summary>
+    /// <summary>An error reaches the subscriber's error handler.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnError()
@@ -203,7 +203,7 @@ public async Task OnError()
         await Assert.That(error).IsTrue();
     }
 
-    /// <summary>Called when [error once].</summary>
+    /// <summary>Only the first error is forwarded.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnErrorOnce()
@@ -219,7 +219,7 @@ public async Task OnErrorOnce()
         await Assert.That(errors).IsEqualTo(1);
     }
 
-    /// <summary>Called when [error disposed].</summary>
+    /// <summary>A disposed signal throws when an error is raised.</summary>
     [Test]
     public void OnErrorDisposed()
     {
@@ -228,7 +228,7 @@ public void OnErrorDisposed()
         _ = Assert.Throws<ObjectDisposedException>(() => subject.OnError(new InvalidOperationException()));
     }
 
-    /// <summary>Called when [error disposed subscriber].</summary>
+    /// <summary>A disposed subscriber is not notified of an error.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnErrorDisposedSubscriber()
@@ -266,7 +266,7 @@ public async Task SingleObserverSubscriptionReceivesLifecycleAndDetaches()
         await Assert.That(faulted.HasObservers).IsFalse();
     }
 
-    /// <summary>Called when [error rethrows by default].</summary>
+    /// <summary>An error raised with no error handler subscribed rethrows at the call site.</summary>
     [Test]
     public void OnErrorRethrowsByDefault()
     {
@@ -275,17 +275,17 @@ public void OnErrorRethrowsByDefault()
         _ = Assert.Throws<ArgumentException>(() => subject.OnError(new ArgumentException("subject error")));
     }
 
-    /// <summary>Called when [error null throws].</summary>
+    /// <summary>A null error is rejected.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void OnErrorNullThrows() => Assert.Throws<ArgumentNullException>(static () => new Signal<int>().OnError(null!));
 
-    /// <summary>Subscribes the null throws.</summary>
+    /// <summary>A null observer is rejected.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void SubscribeNullThrows() => Assert.Throws<ArgumentNullException>(static () => new Signal<int>().Subscribe(null!));
 
-    /// <summary>Subscribes the disposed throws.</summary>
+    /// <summary>Subscribing to a disposed signal throws.</summary>
     [Test]
     public void SubscribeDisposedThrows()
     {
@@ -294,7 +294,7 @@ public void SubscribeDisposedThrows()
         _ = Assert.Throws<ObjectDisposedException>(() => subject.Subscribe(static _ => { }));
     }
 
-    /// <summary>Subscribes the on completed.</summary>
+    /// <summary>A subscriber that arrives after completion is completed at once.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubscribeOnCompleted()
@@ -308,7 +308,7 @@ public async Task SubscribeOnCompleted()
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Subscribes the on error.</summary>
+    /// <summary>A subscriber that arrives after a fault receives that fault.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubscribeOnError()
@@ -322,7 +322,7 @@ public async Task SubscribeOnError()
         await Assert.That(error).IsTrue();
     }
 
-    /// <summary>Subscribes action observers, converts to multi-observer dispatch, and removes each observer independently.</summary>
+    /// <summary>Each action subscriber stops receiving values when its own subscription is disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubscribeActionObservers_DisposeIndependently()
@@ -348,7 +348,7 @@ public async Task SubscribeActionObservers_DisposeIndependently()
         await Assert.That(subject.HasObservers).IsFalse();
     }
 
-    /// <summary>Subjects the where.</summary>
+    /// <summary>A filtered signal forwards only the values its predicate accepts.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     [RequiresUnreferencedCode("Tests the action-based Subscribe overload that carries trimming annotations.")]
@@ -364,7 +364,7 @@ public async Task SubjectWhere()
         await Assert.That(values).IsEquivalentTo([ValueTwo]);
     }
 
-    /// <summary>Subjects the select.</summary>
+    /// <summary>A mapped signal forwards the projected value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     [RequiresUnreferencedCode("Tests the action-based Subscribe overload that carries trimming annotations.")]
@@ -378,7 +378,7 @@ public async Task SubjectSelect()
         await Assert.That(values).IsEquivalentTo([ValueFour]);
     }
 
-    /// <summary>Subjects the buffer.</summary>
+    /// <summary>A count-buffered signal emits each full batch of values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubjectBuffer()
@@ -398,7 +398,7 @@ public async Task SubjectBuffer()
         subject.Dispose();
     }
 
-    /// <summary>Subjects the buffer skip2.</summary>
+    /// <summary>A skipping buffer emits only the batches its window covers.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubjectBufferTake2Skip2()
@@ -421,7 +421,7 @@ public async Task SubjectBufferTake2Skip2()
         subject.Dispose();
     }
 
-    /// <summary>Subjects the rx void.</summary>
+    /// <summary>A unit-valued signal forwards each notification.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubjectRxVoid()
@@ -436,7 +436,7 @@ public async Task SubjectRxVoid()
         subject.Dispose();
     }
 
-    /// <summary>Verifies immediate core signals, range, zip, repeat, and observer failures cover remainders.</summary>
+    /// <summary>Immediate core signals, ranges, zips, and repeats forward their sequences and surface observer failures.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ImmediateCoreSignalsRangeZipRepeatAndObserverFailuresCoverRemainders()
@@ -468,7 +468,7 @@ await Assert.That(((IRequireCurrentThread<RxVoid>)Signal.EmitRxVoid()).IsRequire
         AssertObserverFailuresPropagateOutOfSubscribe();
     }
 
-    /// <summary>Covers signal subject subscriber churn, late subscriptions, disposal, and terminal no-op branches.</summary>
+    /// <summary>A signal keeps its subscribers through churn, replays terminals to late subscribers, and throws once disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SubjectsCoverMultipleSubscriberChurnLateTerminalsAndDisposalBranches()
@@ -523,7 +523,7 @@ public async Task SubjectsCoverMultipleSubscriberChurnLateTerminalsAndDisposalBr
         _ = Assert.Throws<ObjectDisposedException>(() => disposedSubject.OnNext(1));
     }
 
-    /// <summary>Disposal during dispatch preserves the captured observer delivery and reports disposal to the caller.</summary>
+    /// <summary>Disposing the signal from inside a dispatch delivers the value to its peers and reports the disposal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnNextReportsDisposalWhenASubscriberDisposesTheSignalMidDispatch()
@@ -531,8 +531,7 @@ public async Task OnNextReportsDisposalWhenASubscriberDisposesTheSignalMidDispat
         Signal<int> signal = new();
         RecordingWitness<int> survivor = new();
 
-        // Two subscribers put the signal on the multi-subscriber dispatch path rather than the single-observer
-        // fast path, which returns before the disposal is ever noticed.
+        // Two subscribers force the multi-subscriber dispatch path, the only one that notices the disposal.
         _ = signal.Subscribe(Witness.Create<int>(_ => signal.Dispose()));
         _ = signal.Subscribe(survivor);
 
@@ -542,10 +541,7 @@ public async Task OnNextReportsDisposalWhenASubscriberDisposesTheSignalMidDispat
         await Assert.That(survivor.Values.SequenceEqual([One])).IsTrue();
     }
 
-    /// <summary>
-    /// The finalizer path releases unmanaged resources only. It must leave the signal usable: a signal that
-    /// tore down its observers here would silently drop subscribers whenever a finalizer ran.
-    /// </summary>
+    /// <summary>The finalizer disposal path releases unmanaged resources only and leaves the signal usable.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UnmanagedOnlyDisposalLeavesTheSignalUsable()
@@ -561,11 +557,7 @@ public async Task UnmanagedOnlyDisposalLeavesTheSignalUsable()
         await Assert.That(observer.Values.SequenceEqual([One])).IsTrue();
     }
 
-    /// <summary>
-    /// Faults rethrow at the call site only to reach action subscribers, which have nowhere else to surface an
-    /// error. With observer subscribers alone — and enough of them to leave the single-subscriber fast path —
-    /// the error is delivered and <c>OnError</c> returns quietly.
-    /// </summary>
+    /// <summary>An error is delivered and <c>OnError</c> returns quietly when only observers are subscribed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnErrorDoesNotRethrowWhenOnlyObserversAreSubscribed()
@@ -584,10 +576,7 @@ public async Task OnErrorDoesNotRethrowWhenOnlyObserversAreSubscribed()
         await Assert.That(second.Errors[0]).IsSameReferenceAs(error);
     }
 
-    /// <summary>
-    /// The subscription array reuses the slot a departed subscriber vacated instead of growing. The newcomer
-    /// must be wired up properly in that recycled slot, and the departed subscriber must stay silent.
-    /// </summary>
+    /// <summary>A newly added subscriber receives values from the vacated slot, and the departed subscriber stays silent.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ASubscriberAddedAfterAnotherLeavesReusesTheVacatedSlot()
@@ -609,11 +598,7 @@ public async Task ASubscriberAddedAfterAnotherLeavesReusesTheVacatedSlot()
         await Assert.That(arrived.Values.SequenceEqual([One])).IsTrue();
     }
 
-    /// <summary>
-    /// Small integers come from a shared cache rather than a fresh allocation. Both subscription surfaces of a
-    /// cached signal must still replay the value they were built for, and values outside the cache must still
-    /// work.
-    /// </summary>
+    /// <summary>A cached small-integer signal replays its value to both subscription surfaces, as does an uncached one.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CachedInt32SignalsReplayTheirValueToObserversAndCallbacks()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
index ce772ee7..292806d1 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
@@ -443,10 +443,7 @@ public async Task TakeForwardsRequestedCount()
         await Assert.That(r.Completed).IsTrue();
     }
 
-    /// <summary>
-    /// A filtering sink that hands a value to a throwing observer must unsubscribe upstream before it rethrows.
-    /// Without that teardown the source keeps producing into an observer that has already failed.
-    /// </summary>
+    /// <summary>A filtering sink unsubscribes upstream before it rethrows the observer's failure.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FilteringSinksReleaseTheUpstreamWhenTheObserverThrows()
@@ -481,10 +478,7 @@ public async Task FilteringSinksReleaseTheUpstreamWhenTheObserverThrows()
         await AssertObserverFailureReleasesUpstream(uniqueBySink, uniqueBy);
     }
 
-    /// <summary>
-    /// The accumulating and counting sinks make the same promise: a throwing observer tears the sink down and
-    /// unsubscribes upstream rather than leaving a half-live pipeline behind.
-    /// </summary>
+    /// <summary>An accumulating or counting sink tears itself down and unsubscribes upstream when the observer throws.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AccumulatingAndCountingSinksReleaseTheUpstreamWhenTheObserverThrows()
@@ -506,10 +500,7 @@ public async Task AccumulatingAndCountingSinksReleaseTheUpstreamWhenTheObserverT
         await AssertObserverFailureReleasesUpstream(takeWhileSink, takeWhile);
     }
 
-    /// <summary>
-    /// A <see cref = "BufferWitness{T}"/> hands a window to the observer only when the window fills, so its
-    /// teardown-on-throw path is reached on the value that closes the window, not on the ones that fill it.
-    /// </summary>
+    /// <summary>A <see cref = "BufferWitness{T}"/> releases the upstream when the observer throws on the window it closes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task BufferSinkReleasesTheUpstreamWhenTheObserverThrowsOnACompletedWindow()
@@ -537,7 +528,7 @@ public async Task BufferSinkDropsValuesFromASourceThatKeepsPushingAfterTheObserv
         UnstoppableSource<int> source = new();
         using var subscription = source.Buffer(Two).Subscribe(observer);
 
-        // The window closes on the second value, so that is the first — and only — hand-off to the observer.
+        // The window closes on the second value, the only hand-off to the observer.
         source.Next(One);
         var thrown = Assert.Throws<InvalidOperationException>(() => source.Next(Two));
 
@@ -553,10 +544,7 @@ public async Task BufferSinkDropsValuesFromASourceThatKeepsPushingAfterTheObserv
         await Assert.That(observer.CompletedCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Every single-source sink forwards a fault to its observer exactly once and releases the upstream
-    /// subscription as it goes; none of them completes the observer as well.
-    /// </summary>
+    /// <summary>A filtering sink forwards a fault once, releases the upstream, and does not complete the observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FilteringSinksForwardFaultsAndReleaseTheUpstream()
@@ -603,7 +591,7 @@ await AssertFaultIsForwardedAndUpstreamReleased(
             });
     }
 
-    /// <summary>The accumulating and counting sinks forward a fault and release the upstream subscription too.</summary>
+    /// <summary>An accumulating or counting sink forwards a fault and releases the upstream subscription.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AccumulatingAndCountingSinksForwardFaultsAndReleaseTheUpstream()
@@ -641,10 +629,7 @@ await AssertFaultIsForwardedAndUpstreamReleased(
             });
     }
 
-    /// <summary>
-    /// The take sinks complete early, so a source that has not noticed yet can still push a fault at them. That
-    /// fault must be dropped: the observer has already been completed and must not then be told it failed.
-    /// </summary>
+    /// <summary>A fault that arrives after a take sink's terminal is dropped rather than forwarded to the observer.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TakeSinksDropFaultsThatArriveAfterTheirTerminal()
@@ -713,7 +698,7 @@ private static void Feed<T>(IObserver<T> sink, IEnumerable<T> values)
         }
     }
 
-    /// <summary>A user-defined accumulator that sums observed values, exercising the public <see cref = "IAggregator{T, TResult, TSelf}"/> contract.</summary>
+    /// <summary>A user-defined <see cref = "IAggregator{T, TResult, TSelf}"/> that sums observed values.</summary>
     private readonly record struct SumAggregator : IAggregator<int, int, SumAggregator>
     {
         /// <summary>Initializes a new instance of the <see cref = "SumAggregator"/> struct.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SinkTerminalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SinkTerminalTests.cs
index b8b282ef..c8bcfa21 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SinkTerminalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SinkTerminalTests.cs
@@ -55,7 +55,7 @@ public async Task CompleteWithoutValueCompletesAndDisposesTheSink()
         await Assert.That(sink.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The sink is disposed via the <c>finally</c> even when the downstream observer throws.</summary>
+    /// <summary>The sink is disposed even when the downstream observer throws.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FaultStillDisposesTheSinkWhenTheObserverThrows()
@@ -82,7 +82,7 @@ public async Task FaultWithLatchForwardsAndSetsTheLatchWhenNotDone()
         await Assert.That(sink.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The latched <c>Fault</c> overload does nothing once the latch is already set.</summary>
+    /// <summary>The latched <c>Fault</c> overload does nothing when the latch is set.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FaultWithLatchIsNoOpWhenAlreadyDone()
@@ -111,7 +111,7 @@ public async Task CompleteWithValueAndLatchEmitsAndSetsTheLatchWhenNotDone()
         await Assert.That(sink.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The latched value <c>Complete</c> overload does nothing once the latch is already set.</summary>
+    /// <summary>The latched value <c>Complete</c> overload does nothing when the latch is set.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CompleteWithValueAndLatchIsNoOpWhenAlreadyDone()
@@ -140,7 +140,7 @@ public async Task CompleteWithoutValueAndLatchCompletesAndSetsTheLatchWhenNotDon
         await Assert.That(sink.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The latched valueless <c>Complete</c> overload does nothing once the latch is already set.</summary>
+    /// <summary>The latched valueless <c>Complete</c> overload does nothing when the latch is set.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CompleteWithoutValueAndLatchIsNoOpWhenAlreadyDone()
@@ -180,7 +180,7 @@ private sealed class Recorder<T> : IObserver<T>
         public void OnNext(T value) => Values.Add(value);
     }
 
-    /// <summary>An observer whose <see cref = "OnError"/> throws, to exercise the helper's <c>finally</c> branch.</summary>
+    /// <summary>An observer whose <see cref = "OnError"/> throws when a fault is forwarded to it.</summary>
     /// <typeparam name = "T">The type of the observed values.</typeparam>
     private sealed class ThrowingObserver<T> : IObserver<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SparkTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SparkTests.cs
index 22f332af..f06d26ed 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SparkTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SparkTests.cs
@@ -39,7 +39,7 @@ public async Task CompletedSparksAreEqualPerValueType()
         await Assert.That(second).IsEqualTo(first);
     }
 
-    /// <summary>Exercises on-next spark value, equality, accept overloads, and observable conversion.</summary>
+    /// <summary>Verifies an on-next spark reports its value, compares by value, and dispatches every accept overload.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SparkOnNextCoversValueEqualityAndAcceptOverloads()
@@ -81,7 +81,7 @@ await Assert.That(next.Accept(static value => $"fn-next:{value}", static ex => e
         await Assert.That(observer.Events).Contains("next:42");
     }
 
-    /// <summary>Exercises on-error spark exception, equality, and accept overloads.</summary>
+    /// <summary>Verifies an on-error spark carries its exception, compares by value, and dispatches every accept overload.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SparkOnErrorCoversExceptionEqualityAndAcceptOverloads()
@@ -126,7 +126,7 @@ await Assert.That(
         await Assert.That(observer.Events).Contains("error:spark-error");
     }
 
-    /// <summary>Exercises on-completed spark equality, accept overloads, and observable validation.</summary>
+    /// <summary>Verifies an on-completed spark compares by value and dispatches every accept overload.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SparkOnCompletedCoversEqualityAndAcceptOverloads()
@@ -162,7 +162,7 @@ await Assert.That(completed.Accept(static value => value.ToString(), static ex =
         await Assert.That(observer.Events).Contains(CompletedText);
     }
 
-    /// <summary>Verifies a completed spark hashes without a value or an exception to reach for.</summary>
+    /// <summary>Verifies two completed sparks produce the same hash code.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CompletedSparksWithNoValueOrExceptionHashEqual()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
index 2559cff7..96974433 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Tests for <see cref="StartSignal{T}"/>'s current-thread requirement, which downstream current-thread
-/// operators query to decide whether they must enter the trampoline before subscribing to it.
-/// </summary>
+/// <summary>Verifies <see cref="StartSignal{T}"/> reports whether it must be subscribed on the current thread.</summary>
 public sealed class StartSignalTests
 {
     /// <summary>The value produced by the start function.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
index 46fd8dd2..3252fc17 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
@@ -34,7 +34,7 @@ public class StateSignalTests
     /// <summary>Expected projected read-only state values.</summary>
     private static readonly string[] ExpectedReadOnlyValues = ["v:10", "v:11", "v:11"];
 
-    /// <summary>Covers read-only projection error argument validation.</summary>
+    /// <summary>A read-only projection rejects a null error.</summary>
     [Test]
     public void ReadOnlyStateProjectionValidatesError()
     {
@@ -43,7 +43,7 @@ public void ReadOnlyStateProjectionValidatesError()
         _ = Assert.Throws<ArgumentNullException>(() => projection.OnError(null!));
     }
 
-    /// <summary>Covers read-only projection selector errors forwarded to current and late subscribers.</summary>
+    /// <summary>A selector error reaches both the current subscribers and later ones.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ReadOnlyStateProjectionForwardsSelectorErrorToLateSubscribers()
@@ -161,10 +161,7 @@ public async Task ReadOnlyStateProjectionSeedsItselfFromASourceThatHasAlreadyCom
         await Assert.That(late.Errors.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Once the projection has completed, a source that keeps notifying must not be able to move the projected
-    /// value, complete the subscribers twice, or turn a completed projection into a faulted one.
-    /// </summary>
+    /// <summary>A completed projection ignores later values, completions, and faults from its source.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ReadOnlyStateProjectionIgnoresSourceNotificationsAfterItsTerminal()
@@ -186,10 +183,7 @@ public async Task ReadOnlyStateProjectionIgnoresSourceNotificationsAfterItsTermi
         await Assert.That(observer.Errors.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Disposing a projection subscription detaches that observer and only that observer; disposing the same
-    /// handle again is a no-op rather than a second detach.
-    /// </summary>
+    /// <summary>Disposing a projection subscription detaches only that observer, and disposing it twice is a no-op.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ReadOnlyStateProjectionStopsFeedingADisposedSubscription()
@@ -210,10 +204,7 @@ public async Task ReadOnlyStateProjectionStopsFeedingADisposedSubscription()
         await Assert.That(attached.Values.SequenceEqual(["v:10", "v:11", "v:12"])).IsTrue();
     }
 
-    /// <summary>
-    /// A disposed projection has thrown its state away, so reading or subscribing to it must fail loudly rather
-    /// than hand back a stale value. Disposing twice must still be safe.
-    /// </summary>
+    /// <summary>A disposed projection rejects reads and subscriptions, and disposing it twice is safe.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposedReadOnlyStateProjectionRejectsReadsAndSubscriptions()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SubscribeExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SubscribeExtensionsTests.cs
index f5efa4ff..2a00db08 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SubscribeExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SubscribeExtensionsTests.cs
@@ -45,7 +45,7 @@ public static IDisposable SubscribeAll(
         }
         """;
 
-    /// <summary>A consumer that still uses the plain subscription name with both extension namespaces in scope.</summary>
+    /// <summary>A consumer that uses the plain subscription name with both extension namespaces in scope.</summary>
     private const string AmbiguousSubscribeConsumer = """
         global using System;
         global using ReactiveUI.Primitives;
@@ -132,7 +132,7 @@ public async Task SubscribePrimitivesCallbacksCompileWithSystemReactiveAndPrimit
         await Assert.That(symbol?.ContainingType.Name).IsEqualTo(nameof(SubscribeExtensions));
     }
 
-    /// <summary>Verifies the plain Subscribe name stays ambiguous, which is what the explicit name exists to avoid.</summary>
+    /// <summary>Verifies the plain Subscribe name stays ambiguous with System.Reactive in scope.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     [RequiresAssemblyFiles("Builds metadata references from loaded assembly locations.")]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchMapTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchMapTests.cs
index 8ffc7813..2a6afddc 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SwitchMapTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchMapTests.cs
@@ -61,10 +61,7 @@ public async Task SwitchMapMirrorsLatestInnerAndIgnoresStaleInner()
         await Assert.That(values.SequenceEqual(_tenThenTwenty)).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that a null source value switches onto whatever the selector returns for it, which detaches the
-    /// previous inner rather than leaving it attached.
-    /// </summary>
+    /// <summary>Verifies that a null source value switches onto the inner the selector returns for it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchMapSwitchesOnNullSourceValue()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
index 5cdfa309..f40f6119 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.Generation.cs
@@ -32,7 +32,6 @@ public async Task SwitchWitnessKeepsTheNewestGenerationWhenTheOuterIsReenteredWh
         // Pushing `first` subscribes it, which emits synchronously, which re-enters the outer with `second`.
         outer.OnNext(first);
 
-        // The replacement remains subscribed after the first subscription returns.
         second.Observer?.OnNext(SecondValue);
 
         using (Assert.Multiple())
@@ -102,7 +101,7 @@ private class RecordingObserver<T> : IObserver<T>
     /// <param name="replacement">The inner pushed on the first observed value.</param>
     private sealed class ReenteringObserver<T>(Signal<IObservable<T>> outer, IObservable<T> replacement) : RecordingObserver<T>
     {
-        /// <summary>Whether the re-entrant push has already happened.</summary>
+        /// <summary>Whether the re-entrant push has happened.</summary>
         private int _pushed;
 
         /// <inheritdoc/>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
index 9f0576fc..57298277 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
@@ -18,7 +18,7 @@ public sealed partial class SwitchWitnessTests
     /// <summary>The integer constant two.</summary>
     private const int Two = 2;
 
-    /// <summary>Verifies direct switch witness completion is emitted once.</summary>
+    /// <summary>A duplicate completion from the current inner source is suppressed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SwitchWitnessSuppressesDuplicateCompletionFromCurrentInner()
@@ -96,7 +96,6 @@ public async Task SwitchWitnessForwardsOnlyLatestInnerValues()
 
         outer.OnNext(second);
 
-        // The stale first inner is now superseded; its values must be dropped.
         first.Observer.OnNext(One);
         second.Observer!.OnNext(Two);
 
@@ -121,11 +120,9 @@ public async Task SwitchWitnessIgnoresStaleInnerCompletion()
         outer.OnNext(second);
         outer.OnCompleted();
 
-        // Stale inner completion (wrong version) must not complete the witness.
         staleFirst.OnCompleted();
         await Assert.That(observer.Completed).IsEqualTo(0);
 
-        // Current inner completion plus outer-complete completes once.
         second.Observer!.OnCompleted();
         await Assert.That(observer.Completed).IsEqualTo(One);
     }
@@ -143,7 +140,6 @@ public async Task SwitchWitnessDefersCompletionUntilActiveInnerCompletes()
         outer.OnNext(inner);
         outer.OnCompleted();
 
-        // Outer done but inner still active: no completion yet.
         await Assert.That(observer.Completed).IsEqualTo(0);
 
         inner.Observer!.OnCompleted();
@@ -181,7 +177,6 @@ public async Task SwitchWitnessForwardsOuterErrorAndGatesAfterwards()
         await Assert.That(observer.Errors).HasSingleItem();
         await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
 
-        // Everything is gated after the terminal error.
         inner.Observer!.OnNext(One);
         inner.Observer.OnCompleted();
         outer.OnNext(inner);
@@ -209,7 +204,6 @@ public async Task SwitchWitnessForwardsInnerErrorAndGatesAfterwards()
         await Assert.That(observer.Errors).HasSingleItem();
         await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
 
-        // Subsequent inner/outer notifications are gated.
         inner.Observer.OnNext(One);
         outer.OnCompleted();
 
@@ -233,7 +227,6 @@ public async Task SwitchWitnessDropsStaleInnerError()
         var staleFirst = first.Observer!;
         outer.OnNext(second);
 
-        // Error from the superseded inner is dropped, not forwarded.
         staleFirst.OnError(new InvalidOperationException("stale"));
 
         await Assert.That(observer.Errors).IsEmpty();
@@ -256,7 +249,6 @@ public async Task SwitchWitnessIgnoresSourceAfterTerminal()
         outer.OnCompleted();
         await Assert.That(observer.Completed).IsEqualTo(One);
 
-        // A late source must be ignored; its observer is never captured.
         outer.OnNext(inner);
         await Assert.That(inner.Observer).IsNull();
     }
@@ -274,11 +266,9 @@ public async Task SwitchWitnessGatesLateNotificationsAfterInnerError()
 
         outer.OnNext(first);
 
-        // An inner error makes the witness terminal without stopping the outer source.
         first.Observer!.OnError(new InvalidOperationException("boom"));
         await Assert.That(observer.Errors).HasSingleItem();
 
-        // Subsequent source switches and outer errors are gated: nothing more is forwarded.
         outer.OnNext(late);
         outer.OnError(new InvalidOperationException("late"));
 
@@ -303,7 +293,6 @@ public async Task SwitchWitnessDisposesActiveInnerOnDispose()
 
         subscription.Dispose();
 
-        // The inner subscription is disposed by the witness.
         await Assert.That(inner.Disposed).IsTrue();
     }
 
@@ -340,7 +329,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Observer that blocks its first value so any concurrent re-entry is detected with thread-safe state.</summary>
+    /// <summary>Observer that blocks inside its first value callback so concurrent re-entry is detected.</summary>
     private sealed class GatedObserver : IObserver<int>, IDisposable
     {
         /// <summary>Tracks how many threads are currently inside <see cref="OnNext"/>.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.WideArity.cs b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.WideArity.cs
index 3a658ee6..7ea891cb 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.WideArity.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.WideArity.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the wide-arity <c>SyncLatest</c> combinators for ten through sixteen sources: a result is
-/// withheld until every source has produced a value, each source lands in its own selector parameter, and a
-/// later value from any source replaces only that source's contribution.
-/// </summary>
+/// <summary>Verifies the ten- through sixteen-source <c>SyncLatest</c> combinators over their latest values.</summary>
 public partial class SyncLatestTests
 {
     /// <summary>The number of sources combined by the ten-source overload.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
index 9dd8fc69..d6ec3733 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SyncLatestTests.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>
-/// Verifies the multi-source <c>SyncLatest</c> combinators for three through nine sources: a result is
-/// withheld until every source has produced a value, each source lands in its own selector parameter, and a
-/// later value from any source replaces only that source's contribution.
-/// </summary>
+/// <summary>Verifies the three- through nine-source <c>SyncLatest</c> combinators over their latest values.</summary>
 public partial class SyncLatestTests
 {
     /// <summary>The number of sources combined by the three-source overload.</summary>
@@ -192,10 +188,7 @@ public async Task SyncLatestRejectsNullSourcesAndSelectors()
         await Assert.That(sources[0].HasObservers).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies the combined sequence ignores every notification a source delivers after the sequence has
-    /// terminated, and ignores a duplicate completion from a single source.
-    /// </summary>
+    /// <summary>Verifies the combined sequence ignores every notification a source delivers after it terminates.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SyncLatestIgnoresSourceNotificationsDeliveredAfterTheCombinedSequenceTerminates()
@@ -226,10 +219,7 @@ public async Task SyncLatestIgnoresSourceNotificationsDeliveredAfterTheCombinedS
         await Assert.That(witness.Errors.Count).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies a source that throws while being subscribed tears down the sources already subscribed and
-    /// surfaces the original failure to the caller.
-    /// </summary>
+    /// <summary>Verifies a source that throws on subscribe tears down the sources it has subscribed and rethrows.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SyncLatestUnsubscribesEarlierSourcesWhenALaterSourceThrowsOnSubscribe()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
index 60ad111a..2b79816e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.FromTask.cs
@@ -20,7 +20,7 @@ public partial class TaskSignalTests
     /// <summary>Exception message used by user exception tests.</summary>
     private const string BreakExecutionMessage = "break execution";
 
-    /// <summary>Covers from-task cancellation callback argument validation.</summary>
+    /// <summary>A null cancellation callback is rejected.</summary>
     [Test]
     public void FromTaskValidatesCancellationCallback()
     {
@@ -35,7 +35,7 @@ public void FromTaskValidatesCancellationCallback()
         }
     }
 
-    /// <summary>Covers from-task result emission and completion.</summary>
+    /// <summary>A from-task signal emits the task result and completes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FromTaskEmitsResult()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
index fbf96a62..ab301444 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskSignalTests.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies <see cref="TaskSignal{T}"/> cancellation and disposal contracts.</summary>
 public partial class TaskSignalTests
 {
-    /// <summary>Covers task-signal cancellation registration and disposal branches.</summary>
+    /// <summary>Disposing a task signal requests cancellation once, and a null factory is rejected.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TaskSignalCoversCancellationAndDisposeBranches()
@@ -49,7 +49,7 @@ public async Task TaskSignalCreateWithASchedulerBuildsASignalThatCancelsOnDispos
         await Assert.That(taskSignal.IsCancellationRequested).IsTrue();
     }
 
-    /// <summary>Disposal tolerates a token source that the completion path has already disposed.</summary>
+    /// <summary>Disposal tolerates a token source that the completion path has disposed.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TaskSignalDisposeToleratesAnAlreadyDisposedTokenSource()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalCompletionTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalCompletionTests.cs
index 31ba5334..c5b2f90e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalCompletionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalCompletionTests.cs
@@ -12,7 +12,7 @@ public class TaskTerminalCompletionTests
     /// <summary>Expected value used by terminal completion assertions.</summary>
     private const int ExpectedValue = 42;
 
-    /// <summary>Verifies that the terminal task is exposed and resolved with the supplied value.</summary>
+    /// <summary>The terminal task resolves with the supplied value.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task TaskReturnsResolvedResult()
@@ -56,7 +56,7 @@ public async Task AttachWithCanceledTokenDisposesSubscription()
         await Assert.That(subscription.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>Verifies that attaching with an already-canceled token cancels inline and releases the registration.</summary>
+    /// <summary>Attaching a subscription to a canceled token cancels inline and releases the registration.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AttachWithAlreadyCanceledTokenCancelsAndDisposesSubscription()
@@ -87,7 +87,7 @@ public async Task FailReleasesSubscriptionAndFaultsTask()
         await Assert.That(subscription.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the shared empty-source failure shape.</summary>
+    /// <summary>An empty-source failure faults the terminal task with the shared empty-source message.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task FailEmptyFaultsWithEmptySourceError()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalWitnessTests.cs
index 6c910e72..865b39ed 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskTerminalWitnessTests.cs
@@ -110,7 +110,7 @@ public async Task CountWitnessCancelsItsTaskWhenTheTokenIsCancelledWhileRunning(
         await Assert.That(upstream.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>A count witness built on an already-cancelled token cancels inline and drops a late subscription.</summary>
+    /// <summary>A count witness built on a cancelled token cancels inline and drops a late subscription.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CountWitnessOnAnAlreadyCancelledTokenCancelsInlineAndDropsTheSubscription()
@@ -145,7 +145,7 @@ public async Task CountWitnessIgnoresCompletionRaisedAfterItStopped()
         await Assert.That(upstream.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The any-witness keeps its result when a cancellation is signalled after it has already stopped.</summary>
+    /// <summary>The any-witness keeps its result when a cancellation is signalled after it stopped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task AnyWitnessIgnoresCancellationSignalledAfterItsResult()
@@ -163,7 +163,7 @@ public async Task AnyWitnessIgnoresCancellationSignalledAfterItsResult()
         await Assert.That(upstream.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>The count witness keeps its result when a cancellation is signalled after it has already stopped.</summary>
+    /// <summary>The count witness keeps its result when a cancellation is signalled after it stopped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task CountWitnessIgnoresCancellationSignalledAfterItStopped()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalTests.cs
index 41818de6..cdfa6bd7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalTests.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies <see cref="TimeInterval{T}"/> equality and hashing contracts.</summary>
 public class TimeIntervalTests
 {
-    /// <summary>An arbitrary non-zero interval; only its stability matters to the hashing contract.</summary>
+    /// <summary>A fixed non-zero interval shared by the time-interval tests.</summary>
     private static readonly TimeSpan SampleInterval = TimeSpan.FromMilliseconds(123);
 
     /// <summary>Verifies a time interval with a null value uses a deterministic null hash code.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/UnfoldSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/UnfoldSignalTests.cs
index acc432c9..f7a3d6e8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/UnfoldSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/UnfoldSignalTests.cs
@@ -17,7 +17,7 @@ public class UnfoldSignalTests
     /// <summary>The second expected value.</summary>
     private const int Second = 2;
 
-    /// <summary>Covers unfold subscribe argument validation.</summary>
+    /// <summary>Verifies an unfold rejects a null observer.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
     public void UnfoldValidatesObserver() => Assert.Throws<ArgumentNullException>(static () => Signal.Unfold(
@@ -27,7 +27,7 @@ public void UnfoldValidatesObserver() => Assert.Throws<ArgumentNullException>(st
             static value => value)
         .Subscribe(null!));
 
-    /// <summary>Covers unfold emission while the condition holds.</summary>
+    /// <summary>Verifies an unfold emits values while the condition holds and then completes.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UnfoldEmitsWhileConditionHolds()
@@ -40,10 +40,7 @@ public async Task UnfoldEmitsWhileConditionHolds()
         await Assert.That(unfoldCompleted).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// The observer surface must generate the same sequence as the callback surface: the unfold runs to
-    /// exhaustion on subscribe, and a condition that is false from the start yields nothing but a completion.
-    /// </summary>
+    /// <summary>Verifies an observer receives the generated sequence, or only a completion when the condition starts false.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UnfoldEmitsTheGeneratedSequenceToObservers()
@@ -65,7 +62,7 @@ public async Task UnfoldEmitsTheGeneratedSequenceToObservers()
         await Assert.That(exhausted.Completed).IsEqualTo(1);
     }
 
-    /// <summary>An unfold runs entirely inline on the subscriber's thread, so it never demands a particular one.</summary>
+    /// <summary>Verifies an unfold never requires subscription on the current thread.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UnfoldNeverRequiresCurrentThreadSubscription()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/UseSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/UseSignalTests.cs
index 7aaa3918..a920f1b8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/UseSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/UseSignalTests.cs
@@ -17,7 +17,7 @@ public class UseSignalTests
     /// <summary>A value pushed after the signal has terminated; it must never be delivered.</summary>
     private const int LateValue = 2;
 
-    /// <summary>Covers resource disposal when the subscription forwards a null error.</summary>
+    /// <summary>A null error from the scoped source is rejected and the resource is released.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UseValidatesSubscriptionError()
@@ -30,7 +30,7 @@ public async Task UseValidatesSubscriptionError()
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>Covers resource disposal when the inner subscription is null.</summary>
+    /// <summary>A null inner subscription is rejected and the resource is released.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UseDisposesResourceWhenSubscriptionIsNull()
@@ -42,10 +42,7 @@ public async Task UseDisposesResourceWhenSubscriptionIsNull()
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// A fault from the scoped source reaches the observer and releases the resource. The whole point of the
-    /// operator is that the resource does not outlive the sequence, whichever way the sequence ends.
-    /// </summary>
+    /// <summary>A fault from the scoped source reaches the observer and releases the resource.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UseForwardsSourceFaultsAndReleasesTheResource()
@@ -63,11 +60,7 @@ public async Task UseForwardsSourceFaultsAndReleasesTheResource()
         await Assert.That(resource.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// With a hot source, the subscription is handed to the sink while the sequence is still live: the resource
-    /// stays alive until completion, and every notification the source keeps sending afterwards is dropped
-    /// rather than re-delivered or re-releasing the resource.
-    /// </summary>
+    /// <summary>A hot source holds the resource until it completes, and notifications after the terminal are dropped.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UseHoldsTheResourceUntilTheHotSourceCompletesThenIgnoresLateSignals()
@@ -96,11 +89,7 @@ public async Task UseHoldsTheResourceUntilTheHotSourceCompletesThenIgnoresLateSi
         await Assert.That(source.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// When the observer throws from its value callback, the sink tears itself down — unsubscribing upstream
-    /// and releasing the resource — and rethrows. A second value must then be dropped, not fed back into the
-    /// observer that already failed.
-    /// </summary>
+    /// <summary>An observer that throws from its value callback releases the resource and receives no further values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UseReleasesTheResourceWhenTheObserverThrows()
@@ -113,7 +102,7 @@ public async Task UseReleasesTheResourceWhenTheObserverThrows()
 
         var thrown = Assert.Throws<InvalidOperationException>(() => sink.OnNext(FirstValue));
 
-        // The sink has stopped, so this must be a silent no-op rather than a second trip into the observer.
+        // The sink has stopped, so this is a silent no-op.
         sink.OnNext(LateValue);
 
         await Assert.That(thrown!.Message).IsEqualTo("observer-next");
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
index a24afd69..5442995f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Tests for <see cref="WasmSequencer"/>.</summary>
 public sealed class WasmSequencerTests
 {
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>Expected values produced by an immediate burst, in FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Verifies the shared instance is a singleton.</summary>
@@ -105,7 +105,7 @@ public async Task PastDueScheduleExecutes()
         await Assert.That(executed).IsTrue();
     }
 
-    /// <summary>Verifies a cancelled work item never executes while later work still runs.</summary>
+    /// <summary>Verifies a cancelled work item never executes while later work runs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task CancelledItemIsSkipped()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
index 4d2cf22d..cd60b818 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
@@ -42,7 +42,6 @@ public async Task DispatchDefersDeliveryToTheSequencer()
         source.OnNext(First);
         source.OnNext(Second);
 
-        // Nothing may be delivered until the sequencer runs the queued drain.
         await Assert.That(witness.Values.Count).IsEqualTo(0);
 
         clock.AdvanceBy(SingleTick);
@@ -76,7 +75,7 @@ public async Task DispatchForwardsSourceErrorsThroughTheSequencer()
         await Assert.That(witness.Errors[0]).IsSameReferenceAs(expected);
     }
 
-    /// <summary>A drain that is torn down mid-flight abandons the notifications still queued behind it.</summary>
+    /// <summary>A drain that is torn down mid-flight abandons the notifications queued behind it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DispatchAbandonsQueuedNotificationsWhenDisposedMidDrain()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
index 70f62b03..8c36b1a0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessTests.cs
@@ -95,7 +95,7 @@ public async Task SafeWitnessIgnoresSignalsAfterTerminalAndDisposesOnce()
         await Assert.That(disposed).IsEqualTo(1);
     }
 
-    /// <summary>Covers internal witness implementations and safe observer terminal behavior.</summary>
+    /// <summary>Disposed, throwing, and empty witnesses follow their contracts, and a safe witness stops at its terminal.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task WitnessesCoverDisposedThrowEmptyAndSafeBranches()
@@ -175,7 +175,7 @@ public async Task WitnessOnDefersNextAndCompletedUntilTheSequencerDrainsThem()
         await Assert.That(completed).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the witness routes a source failure through the same deferred sequencer drain.</summary>
+    /// <summary>A source failure is deferred until the sequencer drains it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task WitnessOnDefersAnErrorUntilTheSequencerDrainsIt()
@@ -195,7 +195,7 @@ public async Task WitnessOnDefersAnErrorUntilTheSequencerDrainsIt()
         await Assert.That(observed).IsSameReferenceAs(error);
     }
 
-    /// <summary>Covers callback, forwarding, and stateful witness contracts.</summary>
+    /// <summary>Callback, forwarding, stateful, and safe witnesses each forward notifications as their contract requires.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task WitnessImplementationsForwardNotificationsAndFallbackErrors()
@@ -207,7 +207,7 @@ public async Task WitnessImplementationsForwardNotificationsAndFallbackErrors()
         await AssertSafeWitnessIgnoresNotificationsAfterTheTerminal();
     }
 
-    /// <summary>Covers witness factory and safe-wrapper null-callback validation.</summary>
+    /// <summary>The witness factories and safe wrappers reject null callbacks and a null error.</summary>
     [Test]
     public void WitnessFactoriesValidateNullCallbacks()
     {
@@ -223,7 +223,7 @@ public void WitnessFactoriesValidateNullCallbacks()
             Witness.Create<int>(static _ => { }, static _ => { }, static () => { }).OnError(null!));
     }
 
-    /// <summary>Covers safe-witness error forwarding and post-terminal suppression branches.</summary>
+    /// <summary>A safe witness forwards a throwing observer's error, disposes its cancel resource, and drops later faults.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task SafeWitnessForwardsErrorAndIgnoresLateSignals()
@@ -932,10 +932,7 @@ public async Task RangeWithLatestSignalCombinesEachLeftValueWithFinalRightValue(
         _ = Assert.Throws<ArgumentNullException>(() => signal.Subscribe(null!));
     }
 
-    /// <summary>
-    /// Verifies removing an observer the list never held leaves the witness unchanged, so a stray unsubscribe
-    /// cannot drop a live observer or allocate a new snapshot.
-    /// </summary>
+    /// <summary>Removing an observer the list never held returns the same witness.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ListWitnessRemoveReturnsTheSameWitnessWhenTheObserverIsNotPresent()

From 2e3ea0d933d60a23c31b9e8a45da6856dce95567 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 21:54:51 +1000
Subject: [PATCH 04/11] further work

---
 .../Components/ReactiveComponentBase.cs       |   9 +-
 .../Internal/ScheduledDrainState.cs           |  12 +-
 .../Internal/SequencerPeriodicExtensions.cs   |   2 +-
 .../Operators/AsSignalObservable.cs           |   2 +-
 .../Operators/BufferUntilIdleObservable.cs    |   4 +-
 .../Operators/ConflateObservable.cs           |  14 +-
 .../Operators/DebounceImmediateObservable.cs  |   9 +-
 .../Operators/DebounceUntilObservable.cs      |  10 +-
 .../Operators/DetectStaleObservable.cs        |  12 +-
 .../Operators/ForEachObservable.cs            |   4 +-
 .../Operators/FromArrayObservable.cs          |   2 +-
 .../Operators/HeartbeatObservable.cs          |   9 +-
 .../Operators/ObserveOnIfObservable.cs        |  15 +-
 .../Operators/ObserveOnObservable.cs          |   7 +-
 .../Operators/RetryBackoffPolicy.cs           |   2 +-
 .../Operators/RetryWithBackoffObservable.cs   |  10 +-
 .../Operators/StartActionObservable.cs        |   5 +-
 .../Operators/StartFuncObservable.cs          |   5 +-
 .../Concurrency/AvaloniaScheduler.cs          |   3 +
 .../Concurrency/AvaloniaScheduler.cs          |   5 +-
 .../Concurrency/BlazorRendererSequencer.cs    |   3 +
 .../Concurrency/BlazorRendererSequencer.cs    |   6 +-
 .../FirstMatchFromCandidatesObservable.cs     |  26 +-
 .../Operators/LatestOrDefaultObservable.cs    |   6 +-
 .../Operators/WhereSelectObservable.cs        |   6 +-
 .../Concurrency/MauiDispatcherSequencer.cs    |   5 +
 .../Concurrency/MauiDispatcherSequencer.cs    |   2 +-
 .../OperatorTimeSchedulerBenchmarks.cs        |   4 +-
 ...ensionsComparisonBenchmarks.Competitors.cs | 144 ++++-----
 ...eExtensionsComparisonBenchmarks.Helpers.cs | 166 +++++-----
 ...mparisonBenchmarks.Library.Supplemental.cs | 306 +++++++++---------
 ...eExtensionsComparisonBenchmarks.Library.cs | 216 ++++++-------
 .../EventGeneratorDriverBenchmarks.cs         |   3 +-
 .../EventGeneratorGcProfileBenchmarks.cs      |   1 -
 .../GeneratorHarness.cs                       |   6 +-
 .../DisposableBagTests.cs                     |   2 +-
 .../DisposableSlotHelperTests.cs              |   2 +-
 .../ReactiveAsyncTests.cs                     |   4 +-
 .../SequencerSchedulingTests.cs               |   5 +-
 .../SequencerTests.cs                         |   2 +-
 ...mbineLatestOperatorTests.EnumerableRest.cs | 114 ++-----
 .../BlazorRendererSequencerTests.cs           |   2 +-
 .../CoalescingDispatchSchedulerTests.cs       |   2 +-
 .../BlazorRendererSequencerTests.cs           |   2 +-
 .../ReactiveComponentBaseTests.cs             |   9 +-
 .../ReactiveExtensionsTests.cs                |   2 +-
 .../SequencerSchedulingExtensionsTests.cs     |   5 +-
 .../AotSafeAssertionExtensions.cs             |   6 +-
 .../ContinuationTests.cs                      |  10 +-
 .../CurrentValueSubjectTests.MultiObserver.cs |  15 +-
 .../CurrentValueSubjectTests.cs               |   4 +-
 .../DisposableExtensionsTests.cs              |   6 +-
 .../Internal/ConcurrencyRaceHelpersTests.cs   |   5 +-
 .../Internal/FirstAsTaskHelperTests.cs        |  16 +-
 .../Internal/FirstAsValueTaskHelperTests.cs   |  18 +-
 .../Internal/ObserverArrayHelpersTests.cs     |   5 +-
 .../Internal/ReduceSinkStateTests.cs          |   6 +-
 .../Internal/TimerSinkStateTests.cs           |   9 +-
 ...ptionExtensionsTests.SchedulerOverloads.cs |   1 -
 .../ObservableSubscriptionExtensionsTests.cs  |  18 +-
 .../Operators/ConflateObservableTests.cs      |   4 +-
 .../DebounceImmediateObservableTests.cs       |   3 +-
 .../Operators/DetectStaleObservableTests.cs   |  11 +-
 .../FirstMatchFromCandidatesAsyncPathTests.cs |  43 +--
 .../FirstMatchFromCandidatesAsyncTests.cs     |   6 +-
 .../Operators/ForEachObservableTests.cs       |   3 +-
 .../Operators/HeartbeatObservableTests.cs     |   3 +-
 .../Operators/LogErrorsObservableTests.cs     |   3 +-
 .../Operators/MinMaxObservableTests.cs        |   4 +-
 .../Operators/ObserveOnIfObservableTests.cs   |  23 +-
 .../Operators/ObserveOnObservableTests.cs     |  22 +-
 .../MauiDispatcherSequencerTests.cs           |  12 +-
 .../MauiDispatcherSequencerTests.cs           |  14 +-
 .../ContainerDisposableTests.cs               |   2 +-
 .../LinqExtensionsTests.cs                    |   2 +-
 ...ncerSchedulingExtensionsTests.Overloads.cs |   5 +-
 .../SequencerTests.cs                         |   5 +-
 .../SignalTests.cs                            |   2 +-
 .../WasmSchedulerTests.cs                     |  32 +-
 .../BlendUniqueTests.cs                       |   2 +-
 .../ChooseSwitchSelectTests.cs                |   2 +-
 .../Common/ConsumerCompilation.cs             |   4 +-
 .../Common/MinimalVirtualClock.cs             |   2 +-
 .../GuardedWitnessTests.cs                    |   2 +-
 .../PrioritySemaphoreSignalTests.cs           |   2 +-
 .../ReplaySignalTests.cs                      |   4 +-
 .../RxNamesTests.Repeat.cs                    |   2 +-
 .../RxNamesTests.cs                           |   2 +-
 .../SequencerTests.cs                         |   2 +-
 .../SignalFactoriesTests.Composition.cs       |   2 +-
 .../SignalFactoriesTests.EventConversion.cs   |   2 +-
 .../SignalFactoriesTests.Scheduling.cs        |   2 +-
 .../SignalOperatorMixinsTests.cs              |   4 +-
 .../SignalRecoverTests.cs                     |   2 +-
 .../SignalTests.cs                            |   4 +-
 .../SinkObserverTests.cs                      |   2 +-
 .../WitnessOnSignalTests.cs                   |   2 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 .../CrossPlatformPlaceholderTests.cs          |   5 +-
 103 files changed, 705 insertions(+), 879 deletions(-)

diff --git a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
index 039ab19e..5bd07e31 100644
--- a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
+++ b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
@@ -12,6 +12,9 @@ namespace ReactiveUI.Primitives.Blazor.Components;
 #endif
 
 /// <summary>Base component that tracks reactive subscriptions and refreshes through Blazor's renderer dispatcher.</summary>
+/// <remarks>Every observed callback is marshalled onto the renderer dispatcher, so a handler can touch component state
+/// directly, and a callback that throws is dispatched to the enclosing error boundary instead of faulting a detached
+/// task. Disposing the component disposes every tracked subscription.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class ReactiveComponentBase : ComponentBase, IDisposable
 {
@@ -44,7 +47,7 @@ public void Dispose()
 
     /// <summary>Tracks a subscription so it is disposed when the component is disposed.</summary>
     /// <param name="subscription">The subscription to track.</param>
-    /// <returns>The supplied subscription, or <see cref="EmptyDisposable.Instance"/> when the component has already been disposed.</returns>
+    /// <returns>The supplied subscription, or <see cref="EmptyDisposable.Instance"/> when the component is disposed.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="subscription"/> is <see langword="null"/>.</exception>
     protected IDisposable Track(IDisposable subscription)
     {
@@ -136,7 +139,7 @@ protected IDisposable Observe<T>(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected Task InvalidateAsync() => InvokeAsync(StateHasChanged);
 
-    /// <summary>Handles an unhandled subscription error.</summary>
+    /// <summary>Handles a subscription error that no <c>onError</c> callback was given for.</summary>
     /// <param name="error">The observed error.</param>
     /// <exception cref="InvalidOperationException">Always thrown to surface the subscription error.</exception>
     protected virtual void OnObservedError(Exception error)
@@ -174,7 +177,7 @@ private async Task InvokeGuardedAsync(Action callback)
         }
     }
 
-    /// <summary>Refreshes the component when requested and when it is still active.</summary>
+    /// <summary>Refreshes the component when requested and the component is undisposed.</summary>
     /// <param name="shouldRefresh">A value indicating whether refresh is requested.</param>
     private void Refresh(bool shouldRefresh)
     {
diff --git a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
index c6dd7137..7f622e60 100644
--- a/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
+++ b/src/Primitives.Extensions.Shared/Internal/ScheduledDrainState.cs
@@ -36,17 +36,17 @@ internal sealed class ScheduledDrainState<T>(ISequencer scheduler, IDrainTarget
     /// <summary>Gets a value indicating whether the sink has reached a terminal state; read it inside the sink's gate.</summary>
     internal bool Done => _done;
 
-    /// <summary>Enqueues an OnNext notification and schedules a drain pass if one isn't already running.</summary>
+    /// <summary>Enqueues an OnNext notification and schedules a drain pass when none is in flight.</summary>
     /// <param name="value">The value to forward downstream.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void EnqueueNext(T value) => Enqueue(new(DrainNotificationKind.Next, value, null));
 
-    /// <summary>Enqueues an OnError notification and schedules a drain pass if one isn't already running.</summary>
+    /// <summary>Enqueues an OnError notification and schedules a drain pass when none is in flight.</summary>
     /// <param name="error">The error to forward downstream.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void EnqueueError(Exception error) => Enqueue(new(DrainNotificationKind.Error, default!, error));
 
-    /// <summary>Enqueues an OnCompleted notification and schedules a drain pass if one isn't already running.</summary>
+    /// <summary>Enqueues an OnCompleted notification and schedules a drain pass when none is in flight.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void EnqueueCompleted() => Enqueue(new(DrainNotificationKind.Completed, default!, null));
 
@@ -85,7 +85,7 @@ internal bool TryDequeue(out Notification notification)
         }
     }
 
-    /// <summary>Marks the sink done, clears queued notifications, and returns its upstream handle; the caller must hold the gate.</summary>
+    /// <summary>Marks the sink done and drops every queued notification, taking the gate itself.</summary>
     internal void Terminate()
     {
         lock (_gate)
@@ -95,7 +95,7 @@ internal void Terminate()
         }
     }
 
-    /// <summary>Marks the sink done, clears queued notifications, and returns its upstream handle; the caller must hold the gate.</summary>
+    /// <summary>Marks the sink done, leaving the queue untouched; the caller must hold the gate.</summary>
     internal void MarkDoneLocked() => _done = true;
 
     /// <summary>Begins disposal under the gate, returning the upstream subscription so the caller disposes it outside the gate, or <see langword="null"/> when the sink has terminated.</summary>
@@ -119,7 +119,7 @@ internal void Terminate()
         return subscription;
     }
 
-    /// <summary>Enqueues a notification; claims and schedules a single drain pass if one isn't running.</summary>
+    /// <summary>Enqueues a notification and claims the single drain pass when none is in flight.</summary>
     /// <param name="notification">The notification to forward to the drain loop.</param>
     private void Enqueue(in Notification notification)
     {
diff --git a/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs b/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
index e355ba5c..599ff3fb 100644
--- a/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
+++ b/src/Primitives.Extensions.Shared/Internal/SequencerPeriodicExtensions.cs
@@ -14,7 +14,7 @@ namespace ReactiveUI.Primitives.Extensions.Internal;
 /// <summary>Periodic scheduling helpers for <see cref="ISequencer"/>.</summary>
 internal static class SequencerPeriodicExtensions
 {
-    /// <summary>Periodic scheduling helpers for a sequencer.</summary>
+    /// <summary>Repeating schedule overloads hung off a sequencer instance.</summary>
     /// <param name="scheduler">The scheduler used for each tick.</param>
     extension(ISequencer scheduler)
     {
diff --git a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
index 405cadbb..d179f36d 100644
--- a/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/AsSignalObservable.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Projection operator that emits <see cref="RxVoid.Default"/> for every source element without allocating a projection closure.</summary>
+/// <summary>Replaces each source element with <see cref="RxVoid.Default"/>, leaving error and completion untouched.</summary>
 /// <typeparam name="T">The element type of the source observable (ignored).</typeparam>
 /// <param name="source">The source observable whose values are ignored.</param>
 internal sealed class AsSignalObservable<T>(IObservable<T> source) : IObservable<RxVoid>
diff --git a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
index 9277f051..9c31fd7d 100644
--- a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
@@ -44,7 +44,7 @@ private sealed class BufferUntilIdleSink(
         /// <summary>The gate protecting state transitions and downstream notification.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Shared timer / done-flag plumbing.</summary>
+        /// <summary>The timer slot and terminal-state flag shared with the operator's handlers.</summary>
         private readonly TimerSinkState<IList<T>> _state = new(downstream);
 
         /// <summary>The current buffer of elements.</summary>
@@ -94,7 +94,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Schedules a flush after the idle period.</summary>
+        /// <summary>Replaces any pending flush with one scheduled a further idle period ahead.</summary>
         private void ScheduleFlush() => _state.Timer.Disposable = scheduler.Schedule(idleTime, Flush);
 
         /// <summary>Flushes the current buffer to the downstream observer.</summary>
diff --git a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
index 088a5359..c21bc9f8 100644
--- a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
@@ -11,7 +11,12 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Conflates an observable stream by delaying updates that occur within a minimum period.</summary>
+/// <summary>
+/// Delivers notifications on <paramref name="scheduler"/> and keeps emissions at least
+/// <paramref name="minimumUpdatePeriod"/> apart: a value arriving inside that window is deferred to the end of it and a
+/// newer value takes the deferred one's place. Completion waits for a deferred value to land, while an error is
+/// forwarded at once and discards it.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="minimumUpdatePeriod">The minimum period between emissions.</param>
@@ -48,7 +53,7 @@ internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
         /// <summary>The gate protecting the queue, throttle window, and downstream notification.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Shared queue / scheduled-drain machinery.</summary>
+        /// <summary>The notification queue and scheduled-drain bookkeeping shared with the drain loop.</summary>
         private readonly ScheduledDrainState<T> _state;
 
         /// <summary>The disposable tracking a scheduled deferred emission.</summary>
@@ -57,7 +62,7 @@ internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
         /// <summary>Wall-clock timestamp of the last emission forwarded downstream.</summary>
         private DateTimeOffset _lastUpdateTime = DateTimeOffset.MinValue;
 
-        /// <summary>Set to <see langword="true"/> when an upstream OnCompleted is queued but a deferred emission is still pending; the completion fires after that emission lands.</summary>
+        /// <summary>Set when an upstream OnCompleted arrives while a deferred emission is pending, so the completion fires once that emission lands.</summary>
         private bool _completionRequested;
 
         /// <summary>Initializes a new instance of the <see cref="ConflateSink"/> class.</summary>
@@ -128,8 +133,7 @@ void IDrainTarget.Drain()
 
                     default:
                         {
-                            // DrainNotificationKind has only three values; the discard arm absorbs
-                            // Completed so the compiler sees an exhaustive switch.
+                            // Completed is the only remaining kind; this arm keeps the switch exhaustive.
                             ForwardCompleted();
                             return;
                         }
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
index 63703687..aa3b2dce 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
@@ -10,7 +10,10 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Debounces a sequence but emits the first value immediately.</summary>
+/// <summary>
+/// Emits the first source value inline, then holds each later value for <paramref name="dueTime"/> and emits only the
+/// most recent one. A terminal notification flushes a pending value before it is forwarded.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="dueTime">The debounce duration.</param>
@@ -44,7 +47,7 @@ private sealed class DebounceImmediateSink(
         /// <summary>The gate for thread safety.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>The timer for debouncing.</summary>
+        /// <summary>The pending debounce timer, replaced whenever a newer value arrives.</summary>
         private readonly SwapDisposable _timer = new();
 
         /// <summary>Whether the first value has been emitted.</summary>
@@ -126,7 +129,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Emits the last value if any.</summary>
+        /// <summary>Emits the waiting value, if there is one, and clears it.</summary>
         private void Emit()
         {
             T? toEmit;
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
index e92e72d6..e7507d5f 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
@@ -10,7 +10,11 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Debounces a sequence until a condition becomes true for an element.</summary>
+/// <summary>
+/// Forwards a value inline when <paramref name="condition"/> holds for it, cancelling any pending emission, and
+/// otherwise emits it once <paramref name="debounce"/> elapses with no newer value. An error or completion drops a
+/// pending value.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="debounce">The debounce duration.</param>
@@ -49,7 +53,7 @@ private sealed class DebounceUntilSink(
         /// <summary>The gate protecting state transitions and downstream notification.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Shared timer / done-flag plumbing.</summary>
+        /// <summary>The timer slot and terminal-state flag shared with the operator's handlers.</summary>
         private readonly TimerSinkState<T> _state = new(downstream);
 
         /// <inheritdoc/>
@@ -104,7 +108,7 @@ public void Dispose()
             }
         }
 
-        /// <summary>Emits a debounced value when the sink is still active.</summary>
+        /// <summary>Emits the debounced value unless the sink has terminated.</summary>
         /// <param name="value">The debounced value.</param>
         private void EmitDebounced(T value)
         {
diff --git a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
index bb69cb0d..c68c354c 100644
--- a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
@@ -11,7 +11,11 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Detects when a sequence becomes stale (no emissions for a specified period).</summary>
+/// <summary>
+/// Wraps each source value as an update and emits a staleness marker when <paramref name="stalenessPeriod"/> passes
+/// without one, measured from subscription. The window re-arms on every value, so a single quiet stretch yields one
+/// marker.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="stalenessPeriod">The period after which the sequence is considered stale.</param>
@@ -46,7 +50,7 @@ private sealed class DetectStaleSink(
         /// <summary>The gate protecting state transitions and downstream notification.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Shared timer / done-flag plumbing.</summary>
+        /// <summary>The timer slot and terminal-state flag shared with the operator's handlers.</summary>
         private readonly TimerSinkState<Stale<T>> _state = new(downstream);
 
         /// <summary>Upstream subscription handle, set once via <see cref="AttachSourceSubscription"/> and disposed with the sink.</summary>
@@ -68,7 +72,7 @@ public void AttachSourceSubscription(IDisposable subscription)
             }
         }
 
-        /// <summary>Initializes the staleness timer.</summary>
+        /// <summary>Arms the first staleness window, which the caller does at subscribe time.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Initialize() => ScheduleStale();
 
@@ -116,7 +120,7 @@ public void Dispose()
             Interlocked.Exchange(ref _sourceSubscription, null)?.Dispose();
         }
 
-        /// <summary>Arms the staleness timer, which re-arms on every upstream emission without allocating a per-arm closure.</summary>
+        /// <summary>Arms the staleness timer, replacing any window that is counting down.</summary>
         private void ScheduleStale() =>
             _state.Timer.Disposable =
                 scheduler.Schedule(this, stalenessPeriod, static (_, self) => self.OnStaleTimer());
diff --git a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
index 3e6cf57e..04866ed4 100644
--- a/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ForEachObservable.cs
@@ -10,10 +10,10 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Flattening operator that subscribes to an upstream sequence of <see cref="IEnumerable{T}"/> batches and emits each contained element individually.</summary>
+/// <summary>Emits each element of every <see cref="IEnumerable{T}"/> the source produces, in order, ignoring a null batch.</summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source observable of enumerables.</param>
-/// <param name="scheduler">An optional scheduler used to marshal source notifications onto.</param>
+/// <param name="scheduler">An optional scheduler that source notifications are marshalled onto.</param>
 internal sealed class ForEachObservable<T>(
     IObservable<IEnumerable<T>> source,
     ISequencer? scheduler) : IObservable<T>
diff --git a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
index c41cbcbf..9b155fa5 100644
--- a/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/FromArrayObservable.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <summary>Factory operator that emits each element of an <see cref="IEnumerable{T}"/> to a single subscriber and then completes, optionally marshalling the emission through a scheduler.</summary>
 /// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
 /// <param name="source">The source enumerable whose elements are pumped on subscription.</param>
-/// <param name="scheduler">An optional scheduler used to dispatch the pump.</param>
+/// <param name="scheduler">An optional scheduler that dispatches the pump.</param>
 internal sealed class FromArrayObservable<T>(
     IEnumerable<T> source,
     ISequencer? scheduler) : IObservable<T>
diff --git a/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs b/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
index 3c73db56..baaf1589 100644
--- a/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/HeartbeatObservable.cs
@@ -11,7 +11,10 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Injects heartbeat values into the sequence when the source remains quiet for a specified period.</summary>
+/// <summary>
+/// Wraps each source value as an update and emits a heartbeat every <paramref name="heartbeatPeriod"/> that the source
+/// stays quiet, restarting the timer on each value.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="heartbeatPeriod">The period between heartbeats.</param>
@@ -71,7 +74,7 @@ public void AttachSourceSubscription(IDisposable subscription)
             }
         }
 
-        /// <summary>Initializes the heartbeat timer.</summary>
+        /// <summary>Starts the heartbeat timer, which the caller does at subscribe time.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Initialize() => ScheduleHeartbeats();
 
@@ -137,7 +140,7 @@ public void Dispose()
             subscription?.Dispose();
         }
 
-        /// <summary>Schedules the next heartbeat.</summary>
+        /// <summary>Restarts the periodic heartbeat timer, dropping the one it replaces.</summary>
         private void ScheduleHeartbeats()
         {
             lock (_gate)
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
index 574dc407..8ec4147d 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
@@ -11,7 +11,12 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Conditionally switches between two schedulers based on a reactive condition.</summary>
+/// <summary>
+/// Schedules each source value onto <paramref name="trueScheduler"/> or <paramref name="falseScheduler"/> according to
+/// the latest value from <paramref name="condition"/>, using the false scheduler until the condition first emits. Error
+/// and completion are forwarded on the producer's thread, so a terminal notification can overtake scheduled values, and
+/// the condition's own error or completion is ignored.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="condition">The reactive condition observable.</param>
@@ -67,7 +72,7 @@ private sealed class ObserveOnIfSink(
         /// <summary>The scheduler to use when condition is false.</summary>
         private readonly ISequencer _falseScheduler = InvalidOperationExceptionHelper.Check(falseScheduler);
 
-        /// <summary>The current scheduler.</summary>
+        /// <summary>The scheduler chosen by the latest condition value.</summary>
         private ISequencer _currentScheduler = falseScheduler;
 
         /// <summary>The last condition value.</summary>
@@ -79,7 +84,7 @@ private sealed class ObserveOnIfSink(
         /// <summary>Whether the sequence is done.</summary>
         private bool _done;
 
-        /// <summary>Gets the condition observer.</summary>
+        /// <summary>Gets a new observer that feeds condition values into this sink.</summary>
         public IObserver<bool> ConditionObserver => new ConditionObserverImpl(this);
 
         /// <inheritdoc/>
@@ -157,7 +162,7 @@ private void UpdateCondition(bool conditionValue)
             }
         }
 
-        /// <summary>Forwards a scheduled value to the downstream observer if the sink is still active.</summary>
+        /// <summary>Forwards a scheduled value downstream unless the sink has terminated.</summary>
         /// <param name="value">The value to forward.</param>
         private void ForwardNext(T value)
         {
@@ -172,7 +177,7 @@ private void ForwardNext(T value)
             _downstream.OnNext(value);
         }
 
-        /// <summary>Observer for condition updates.</summary>
+        /// <summary>Observer that pushes condition values into the sink and ignores the condition's terminal notifications.</summary>
         /// <param name="sink">The owning sink.</param>
         private sealed class ConditionObserverImpl(ObserveOnIfSink sink) : IObserver<bool>
         {
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
index e274fa86..0c8eae16 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
@@ -23,8 +23,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        // The immediate scheduler runs scheduled work inline on the calling thread, so the
-        // queue-and-drain machinery would be pure overhead: forward straight through.
+        // The immediate sequencer runs scheduled work inline, so queue-and-drain would change nothing.
         if (ReferenceEquals(scheduler, Sequencer.Immediate))
         {
             return source.Subscribe(observer);
@@ -44,7 +43,7 @@ private sealed class ObserveOnSink : IObserver<T>, IDisposable, IDrainTarget
         /// <summary>The gate protecting the queue and terminal state.</summary>
         private readonly Lock _gate = new();
 
-        /// <summary>Shared queue / scheduled-drain machinery.</summary>
+        /// <summary>The notification queue and scheduled-drain bookkeeping shared with the drain loop.</summary>
         private readonly ScheduledDrainState<T> _state;
 
         /// <summary>Initializes a new instance of the <see cref="ObserveOnSink"/> class.</summary>
@@ -104,7 +103,7 @@ void IDrainTarget.Drain()
 
                     default:
                         {
-                            // DrainNotificationKind has only three values; the discard arm absorbs Completed.
+                            // Completed is the only remaining kind; this arm keeps the switch exhaustive.
                             _state.Terminate();
                             _downstream.OnCompleted();
                             return;
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
index c10ff22d..28d00ff7 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryBackoffPolicy.cs
@@ -13,7 +13,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="InitialDelay">Delay before the first retry.</param>
 /// <param name="BackoffFactor">Multiplier applied to the delay per retry attempt.</param>
 /// <param name="MaxDelay">Cap on the computed delay, or <see langword="null"/> for no cap.</param>
-/// <param name="Scheduler">Scheduler used to schedule each delay.</param>
+/// <param name="Scheduler">Scheduler that times each retry delay.</param>
 /// <param name="OnError">Optional callback invoked on every upstream error.</param>
 internal readonly record struct RetryBackoffPolicy(
     int MaxRetries,
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs b/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
index e05170f4..3443f43b 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
@@ -11,7 +11,11 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Retries the source observable sequence upon error, with optional delay, retry count, and backoff.</summary>
+/// <summary>
+/// Re-subscribes the source after an error, waiting the policy's initial delay scaled by its backoff factor for each
+/// attempt and capped by its maximum, then forwards the error once the retry budget is spent. Every error reaches the
+/// policy's callback, and values forwarded before a retry are not retracted.
+/// </summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="policy">The retry / backoff configuration.</param>
@@ -46,13 +50,13 @@ private sealed class RetryWithBackoffSink(
         /// <summary>The subscription to the source sequence.</summary>
         private readonly MutableDisposable _subscription = new();
 
-        /// <summary>The number of retries already attempted.</summary>
+        /// <summary>The number of retries attempted so far.</summary>
         private int _retries;
 
         /// <summary>Whether the sink has been disposed.</summary>
         private bool _disposed;
 
-        /// <summary>Starts the retry process.</summary>
+        /// <summary>Subscribes the source for the first attempt.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Run() => SubscribeToSource();
 
diff --git a/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs b/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
index 17ed6a77..88f5a838 100644
--- a/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
@@ -10,7 +10,10 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Operator that runs an action and completes immediately.</summary>
+/// <summary>
+/// Runs the action once per subscription, inline or on <paramref name="scheduler"/>, then emits
+/// <see cref="RxVoid.Default"/> and completes. An exception from the action is forwarded as an error instead.
+/// </summary>
 /// <param name="action">The action to run.</param>
 /// <param name="scheduler">An optional scheduler; <c>null</c> runs the action synchronously inline.</param>
 internal sealed class StartActionObservable(Action action, ISequencer? scheduler) : IObservable<RxVoid>
diff --git a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
index 031020ca..315e0336 100644
--- a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
@@ -10,7 +10,10 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Runs the function once — inline when no scheduler is supplied, otherwise on the scheduler — emits the result, then completes.</summary>
+/// <summary>
+/// Runs the function once per subscription, inline or on <paramref name="scheduler"/>, then emits the result and
+/// completes. An exception from the function is forwarded as an error instead.
+/// </summary>
 /// <typeparam name="TResult">Result type.</typeparam>
 /// <param name="function">Function to run.</param>
 /// <param name="scheduler">Optional scheduler; null runs inline.</param>
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
index 658b70e2..0288932d 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
@@ -8,6 +8,9 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>Avalonia UI-thread scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
+/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/> and delayed work fires on a
+/// <see cref="DispatcherTimer"/>, so disposing the returned subscription stops that timer as well as suppressing work
+/// that has not started.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("AvaloniaScheduler: Dispatcher = {Dispatcher}, Priority = {Priority}")]
 public sealed class AvaloniaScheduler : CoalescingDispatchScheduler
diff --git a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
index 3dd23c31..4a556500 100644
--- a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
@@ -9,6 +9,9 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Avalonia UI-thread scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
+/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/>, one batch per posted drain; scheduling from
+/// that thread queues the item for the next drain rather than running it inline. Delayed work fires on a
+/// <see cref="DispatcherTimer"/>, and an item cancelled before its drain reaches it is skipped.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class AvaloniaScheduler : ISequencer
@@ -89,7 +92,7 @@ private void ScheduleDelayed(IWorkItem item, long dueTimestamp)
         timer.Start();
     }
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs b/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
index cdb1339c..97069fa7 100644
--- a/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
+++ b/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
@@ -9,6 +9,9 @@
 namespace ReactiveUI.Primitives.Blazor.Reactive.Concurrency;
 
 /// <summary>Scheduler that coalesces scheduled work through a Blazor renderer dispatcher delegate.</summary>
+/// <remarks>Work runs on the renderer's dispatcher, and delayed work waits on a background scheduler that marshals it
+/// back through the renderer when due. A renderer task that faults reaches
+/// <see cref="UnhandledExceptionHandler"/>.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("BlazorRendererSequencer: InvokeAsync = {_invokeAsync}, UnhandledExceptionHandler = {UnhandledExceptionHandler}")]
 public sealed class BlazorRendererSequencer : CoalescingDispatchScheduler
diff --git a/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs b/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
index 83fe39c5..0f6434bb 100644
--- a/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
+++ b/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
@@ -11,6 +11,10 @@
 namespace ReactiveUI.Primitives.Blazor.Concurrency;
 
 /// <summary>Sequencer that coalesces scheduled work through a Blazor renderer dispatcher delegate.</summary>
+/// <remarks>Work runs on the renderer's dispatcher, one batch per posted drain; scheduling from that thread queues the
+/// item for the next drain rather than running it inline. Delayed work waits on a shared timer that marshals it back
+/// through the renderer when due, and a renderer task that faults reaches
+/// <see cref="UnhandledExceptionHandler"/>.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class BlazorRendererSequencer : ISequencer
@@ -105,7 +109,7 @@ private void HandleFault(Exception exception)
             ExceptionDispatchInfo.Capture(exception));
     }
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
index eaac15fc..2e3d981a 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
@@ -19,7 +19,7 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="transform">Synchronous transform applied to each raw value to produce the result.</param>
 /// <param name="predicate">Returns <see langword="true"/> when a transformed value is a match.</param>
 /// <param name="fallback">Value emitted when no candidate matches.</param>
-/// <remarks>Synchronous projections run on the caller's thread. Asynchronous projections retain their state until callbacks complete.</remarks>
+/// <remarks>A projection that completes synchronously runs on the subscribing thread; one that does not keeps the walk alive until its callbacks arrive.</remarks>
 public sealed class FirstMatchFromCandidatesObservable<TKey, TRaw, TResult>(
     IReadOnlyList<TKey> candidates,
     Func<TKey, IObservable<TRaw>> project,
@@ -46,12 +46,11 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return TrySyncLoop(observer);
     }
 
-    /// <summary>Tries a synchronous fast-path: each candidate's projected observable is.</summary>
+    /// <summary>Walks the candidates inline, handing over to an asynchronous sink at the first projection that does not complete synchronously.</summary>
     /// <param name="observer">The downstream observer.</param>
     /// <returns>The subscription disposable.</returns>
     internal IDisposable TrySyncLoop(IObserver<TResult> observer)
     {
-        // The thread-local probe is reset between subscriptions.
         var probe = SyncProbe.RentForCurrentThread();
 
         for (var i = 0; i < candidates.Count; i++)
@@ -104,15 +103,11 @@ internal IDisposable TrySyncLoop(IObserver<TResult> observer)
         return EmptyDisposable.Instance;
     }
 
-    /// <summary>
-    /// Lightweight observer used by the synchronous fast-path to capture the result
-    /// of a one-shot projection. Cheaper than <see cref="AsyncSink"/> because it
-    /// carries no downstream observer, candidate list, or delegate references.
-    /// </summary>
+    /// <summary>Observer that records one candidate projection's synchronous outcome — value, error and termination — for the inline walk.</summary>
     [System.Diagnostics.DebuggerDisplay("SyncProbe: Completed = {Completed}, HasValue = {HasValue}, Value = {Value}")]
     public sealed class SyncProbe : IObserver<TRaw>
     {
-        /// <summary>Per-thread cached instance; rented on entry to <c>TrySyncLoop</c> and returned on exit. Eliminates the per-subscribe allocation on the fast path.</summary>
+        /// <summary>Per-thread cached instance, rented on entry to the inline walk and returned on exit.</summary>
         [ThreadStatic]
         private static SyncProbe? _cached;
 
@@ -174,7 +169,7 @@ internal void Reset()
         }
     }
 
-    /// <summary>Heap-allocated observer used when a projection does not complete synchronously. Walks the remaining candidates via async callbacks.</summary>
+    /// <summary>Observer that walks the remaining candidates through asynchronous callbacks once a projection defers.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="candidates">The candidate list.</param>
     /// <param name="project">The projection delegate.</param>
@@ -200,7 +195,7 @@ private sealed class AsyncSink(
         /// <summary>One once the sink has reached a terminal state; otherwise zero.</summary>
         private int _done;
 
-        /// <summary>Whether the sink is currently looping through candidates.</summary>
+        /// <summary>Set while <see cref="TryNext"/> walks candidates, so a terminal callback from the inline subscription does not advance the walk re-entrantly.</summary>
         private bool _looping;
 
         /// <inheritdoc/>
@@ -245,7 +240,7 @@ public void OnError(Exception error)
 
             if (_looping)
             {
-                // Sync-completion is captured by the probe in TryNext; nothing more to do here.
+                // The walk in TryNext reads this terminal notification off the probe instead.
                 return;
             }
 
@@ -257,10 +252,7 @@ public void OnError(Exception error)
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "A candidate that completes and a candidate that errors both mean the same thing to this operator: that "
-                + "candidate produced no match, so advance to the next one. OnError and OnCompleted are distinct "
-                + "IObserver<T> channels that deliberately share this advance logic; collapsing them would lose the "
-                + "ability to give candidate errors their own policy later.")]
+                "A candidate that errors and a candidate that completes both mean no match, so both channels advance the walk.")]
         public void OnCompleted()
         {
             if (Volatile.Read(ref _done) != 0)
@@ -270,7 +262,7 @@ public void OnCompleted()
 
             if (_looping)
             {
-                // Sync-completion is captured by the probe in TryNext; nothing more to do here.
+                // The walk in TryNext reads this terminal notification off the probe instead.
                 return;
             }
 
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
index 114dc5f1..7084e744 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/LatestOrDefaultObservable.cs
@@ -6,13 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits <paramref name="defaultValue"/> on subscribe, then each source value that differs from the one emitted before
-/// it under <see cref="EqualityComparer{T}.Default"/>.
-/// </summary>
+/// <summary>Emits the default value on subscribe, then each source value that differs from the one before it.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="defaultValue">The value to emit initially.</param>
+/// <remarks>Equality is decided by <see cref="EqualityComparer{T}.Default"/>.</remarks>
 public sealed class LatestOrDefaultObservable<T>(
     IObservable<T> source,
     T defaultValue) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
index 36e48a61..2ca33a4b 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WhereSelectObservable.cs
@@ -6,15 +6,13 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits <paramref name="selector"/> applied to each source element that <paramref name="predicate"/> accepts. An
-/// exception from either delegate terminates the sequence.
-/// </summary>
+/// <summary>Emits each source element the predicate accepts, projected by the selector.</summary>
 /// <typeparam name="TIn">The source element type.</typeparam>
 /// <typeparam name="TOut">The projected element type after applying the selector.</typeparam>
 /// <param name="source">The source observable to filter and project.</param>
 /// <param name="predicate">Predicate applied to each source element; only elements returning <see langword="true"/> are forwarded through <paramref name="selector"/>.</param>
 /// <param name="selector">Projection applied to elements that pass <paramref name="predicate"/>.</param>
+/// <remarks>An exception from either delegate terminates the sequence.</remarks>
 public sealed class WhereSelectObservable<TIn, TOut>(
     IObservable<TIn> source,
     Func<TIn, bool> predicate,
diff --git a/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs b/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
index 702aa790..c159f795 100644
--- a/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
@@ -8,6 +8,9 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>MAUI dispatcher scheduler that coalesces scheduled work through an <see cref="IDispatcher"/>.</summary>
+/// <remarks>Work runs on the dispatcher's thread. Delayed work goes to the dispatcher's own delayed dispatch, which
+/// cannot be called off once armed, so disposing the returned subscription suppresses the action without cancelling
+/// the delay.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("MauiDispatcherSequencer: Dispatcher = {Dispatcher}")]
 public sealed class MauiDispatcherSequencer : CoalescingDispatchScheduler
@@ -28,6 +31,8 @@ public MauiDispatcherSequencer(IDispatcher dispatcher) =>
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         _ = Dispatcher.DispatchDelayed(dueTime, work);
+
+        // The dispatcher hands back no handle for an armed delay, so there is nothing to stop here.
         return Disposable.Empty;
     }
 }
diff --git a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
index 182a0c42..ee33076d 100644
--- a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
@@ -64,7 +64,7 @@ private void ScheduleDelayed(IWorkItem item, long dueTimestamp) =>
             DispatchSequencerState.DelayUntil(dueTimestamp),
             () => DispatchSequencerState.RunIfActive(item));
 
-    /// <summary>Forwards the cached drain callback to the engine.</summary>
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTimeSchedulerBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTimeSchedulerBenchmarks.cs
index 3a6e277a..3d09fb42 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTimeSchedulerBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/OperatorTimeSchedulerBenchmarks.cs
@@ -362,9 +362,7 @@ private sealed class ImmediateSynchronizationContext : SynchronizationContext, I
             "Design",
             "SST2318:Members should not have identical bodies",
             Justification =
-                "Post and Send are distinct SynchronizationContext overrides that this immediate context deliberately "
-                + "implements the same way: run the callback inline. They are separate base-class overrides and cannot "
-                + "be collapsed.")]
+                "Post and Send are distinct SynchronizationContext overrides and cannot be collapsed into one.")]
         public override void Send(SendOrPostCallback d, object? state) => d(state);
 
         /// <summary>Releases the resources used by the synchronization context.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Competitors.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Competitors.cs
index c0e9a000..0181c496 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Competitors.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Competitors.cs
@@ -13,32 +13,32 @@ namespace ReactiveUI.Primitives.Benchmarks;
 /// <summary>Benchmarks the complete synchronous ReactiveUI.Primitives.Extensions public helper surface.</summary>
 public partial class ReactiveExtensionsComparisonBenchmarks
 {
-    /// <summary>Executes the <c>SystemReactiveAsSignal</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveAsSignal</c> result.</returns>
+    /// <summary>Projects the System.Reactive range to unit values and drains it.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveAsSignal() =>
         DrainPrimitiveUnit(RxObservable.Select(RxObservable.Range(0, Count), static _ => RxVoid.Default));
 
-    /// <summary>Executes the <c>SystemReactiveCatchAndReturn</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveCatchAndReturn</c> result.</returns>
+    /// <summary>Substitutes a fallback value for a System.Reactive failure.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveCatchAndReturn() =>
         DrainInt(RxObservable.Throw<int>(Boom).Catch(RxObservable.Return(Fallback)));
 
-    /// <summary>Executes the <c>SystemReactiveCatchIgnore</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveCatchIgnore</c> result.</returns>
+    /// <summary>Swallows a System.Reactive failure and completes empty.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveCatchIgnore() =>
         DrainInt(RxObservable.Throw<int>(Boom).Catch(RxObservable.Empty<int>()));
 
-    /// <summary>Executes the <c>SystemReactiveCombineLatestValuesAreAllFalse</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveCombineLatestValuesAreAllFalse</c> result.</returns>
+    /// <summary>Combines two false System.Reactive sources and tests that every value is false.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveCombineLatestValuesAreAllFalse() =>
         DrainBool(BoolSources(ExtensionsLibrary.ReactiveUIExtensions, false).CombineLatest(ValuesAreAllFalse));
 
-    /// <summary>Executes the <c>SystemReactiveCombineLatestValuesAreAllTrue</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveCombineLatestValuesAreAllTrue</c> result.</returns>
+    /// <summary>Combines two true System.Reactive sources and tests that every value is true.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveCombineLatestValuesAreAllTrue() =>
         DrainBool(BoolSources(ExtensionsLibrary.ReactiveUIExtensions, true).CombineLatest(ValuesAreAllTrue));
@@ -75,28 +75,28 @@ private static bool ValuesAreAllTrue(IList<bool> values)
         return true;
     }
 
-    /// <summary>Executes the <c>SystemReactiveFilter</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveFilter</c> result.</returns>
+    /// <summary>Filters the System.Reactive string source by the even-digit regex.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int SystemReactiveFilter()
     {
         var regex = EvenRegex();
         return DrainString(RxObservable.Where(RxObservable.ToObservable(StringValues), value => regex.IsMatch(value)));
     }
 
-    /// <summary>Executes the <c>SystemReactiveForEach</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveForEach</c> result.</returns>
+    /// <summary>Flattens a single batch of values through System.Reactive.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveForEach() =>
         DrainInt(RxObservable.Return(Values.AsEnumerable()).SelectMany(static values => values));
 
-    /// <summary>Executes the <c>SystemReactiveFromArray</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveFromArray</c> result.</returns>
+    /// <summary>Drains the shared int array through System.Reactive.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveFromArray() =>
         DrainInt(RxObservable.ToObservable(Values));
 
-    /// <summary>Executes the <c>SystemReactiveGetMax</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveGetMax</c> result.</returns>
+    /// <summary>Combines two System.Reactive scalars into their maximum.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveGetMax() =>
         DrainInt(RxObservable.CombineLatest(
@@ -104,8 +104,8 @@ private static int SystemReactiveGetMax() =>
             RxObservable.Return(SecondValue),
             Math.Max));
 
-    /// <summary>Executes the <c>SystemReactiveGetMin</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveGetMin</c> result.</returns>
+    /// <summary>Combines two System.Reactive scalars into their minimum.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveGetMin() =>
         DrainInt(RxObservable.CombineLatest(
@@ -113,14 +113,14 @@ private static int SystemReactiveGetMin() =>
             RxObservable.Return(SecondValue),
             Math.Min));
 
-    /// <summary>Executes the <c>SystemReactiveNot</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveNot</c> result.</returns>
+    /// <summary>Negates each boolean emitted by the System.Reactive source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveNot() =>
         DrainBool(RxObservable.Select(RxObservable.ToObservable(BooleanValues), static value => !value));
 
-    /// <summary>Executes the <c>SystemReactivePairwise</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactivePairwise</c> result.</returns>
+    /// <summary>Rebuilds pairwise semantics from a System.Reactive sliding buffer.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int SystemReactivePairwise()
     {
         PairWitness observer = new();
@@ -133,96 +133,96 @@ private static int SystemReactivePairwise()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>SystemReactiveReturn</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveReturn</c> result.</returns>
+    /// <summary>Drains a single-value System.Reactive source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveReturn() =>
         DrainInt(RxObservable.Return(Value));
 
-    /// <summary>Executes the <c>SystemReactiveScanWithInitial</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveScanWithInitial</c> result.</returns>
+    /// <summary>Accumulates the System.Reactive range from a seed value.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveScanWithInitial() =>
         DrainInt(RxObservable.Scan(RxObservable.Range(0, Count), 0, static (acc, value) => acc + value));
 
-    /// <summary>Executes the <c>SystemReactiveSelectAsyncScenario</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveSelectAsyncScenario</c> result.</returns>
+    /// <summary>Projects each System.Reactive value through a completed task.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveSelectAsyncScenario() =>
         DrainInt(RxObservable.SelectMany(
             RxObservable.Range(0, Count),
             static value => RxObservable.FromAsync(() => Task.FromResult(value + 1))));
 
-    /// <summary>Executes the <c>SystemReactiveSelectConstant</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveSelectConstant</c> result.</returns>
+    /// <summary>Replaces every value in the System.Reactive range with a constant.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveSelectConstant() =>
         DrainInt(RxObservable.Select(RxObservable.Range(0, Count), static _ => Value));
 
-    /// <summary>Executes the <c>SystemReactiveSelectManyThen</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveSelectManyThen</c> result.</returns>
+    /// <summary>Chains two sequential System.Reactive projections.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveSelectManyThen() =>
         DrainInt(RxObservable.SelectMany(
             RxObservable.SelectMany(RxObservable.Return(Value), static value => RxObservable.Return(value + 1)),
             static value => RxObservable.Return(value + 1)));
 
-    /// <summary>Executes the <c>SystemReactiveSkipWhileNull</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveSkipWhileNull</c> result.</returns>
+    /// <summary>Skips the leading nulls of the System.Reactive string source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveSkipWhileNull() =>
         DrainString(RxObservable.Select(
             RxObservable.ToObservable(NullableStrings).SkipWhile(static value => value is null),
             static value => value!));
 
-    /// <summary>Executes the <c>SystemReactiveTakeUntil</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveTakeUntil</c> result.</returns>
+    /// <summary>Truncates the System.Reactive range at the match threshold.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveTakeUntil() =>
         DrainInt(RxObservable.Range(0, Count).TakeWhile(static value => value <= Match));
 
-    /// <summary>Executes the <c>SystemReactiveToHotTask</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveToHotTask</c> result.</returns>
+    /// <summary>Converts a single-value System.Reactive source to a task and waits for it.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveToHotTask() =>
         GetCompletedResult(System.Reactive.Threading.Tasks.TaskObservableExtensions.ToTask(RxObservable.Return(Value)));
 
-    /// <summary>Executes the <c>SystemReactiveWaitUntil</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveWaitUntil</c> result.</returns>
+    /// <summary>Takes the first System.Reactive value that matches the threshold.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveWaitUntil() =>
         DrainInt(RxObservable.Range(0, Count).FirstAsync(static value => value == Match));
 
-    /// <summary>Executes the <c>SystemReactiveWhereFalse</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveWhereFalse</c> result.</returns>
+    /// <summary>Keeps only the false values of the System.Reactive boolean source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveWhereFalse() =>
         DrainBool(RxObservable.Where(RxObservable.ToObservable(BooleanValues), static value => !value));
 
-    /// <summary>Executes the <c>SystemReactiveWhereIsNotNull</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveWhereIsNotNull</c> result.</returns>
+    /// <summary>Keeps only the non-null values of the System.Reactive string source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveWhereIsNotNull() =>
         DrainString(RxObservable.Select(
             RxObservable.Where(RxObservable.ToObservable(NullableStrings), static value => value is not null),
             static value => value!));
 
-    /// <summary>Executes the <c>SystemReactiveWhereSelect</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveWhereSelect</c> result.</returns>
+    /// <summary>Filters the System.Reactive range to even values and scales them.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveWhereSelect() =>
         DrainInt(RxObservable.Select(
             RxObservable.Where(RxObservable.Range(0, Count), static value => (value & 1) == 0),
             static value => value * ResultMultiplier));
 
-    /// <summary>Executes the <c>SystemReactiveWhereTrue</c> benchmark helper.</summary>
-    /// <returns>The <c>SystemReactiveWhereTrue</c> result.</returns>
+    /// <summary>Keeps only the true values of the System.Reactive boolean source.</summary>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SystemReactiveWhereTrue() =>
         DrainBool(RxObservable.Where(RxObservable.ToObservable(BooleanValues), static value => value));
 
-    /// <summary>Executes the <c>R3AsSignal</c> benchmark helper.</summary>
-    /// <returns>The <c>R3AsSignal</c> result.</returns>
+    /// <summary>Projects the R3 range to a constant and drains it.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3AsSignal()
     {
         IntR3Witness observer = new();
@@ -231,8 +231,8 @@ private static int R3AsSignal()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3CatchAndReturn</c> benchmark helper.</summary>
-    /// <returns>The <c>R3CatchAndReturn</c> result.</returns>
+    /// <summary>Substitutes a fallback value for an R3 failure.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3CatchAndReturn()
     {
         IntR3Witness observer = new();
@@ -243,8 +243,8 @@ private static int R3CatchAndReturn()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3CatchIgnore</c> benchmark helper.</summary>
-    /// <returns>The <c>R3CatchIgnore</c> result.</returns>
+    /// <summary>Swallows an R3 failure and completes empty.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3CatchIgnore()
     {
         IntR3Witness observer = new();
@@ -255,8 +255,8 @@ private static int R3CatchIgnore()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3FromArray</c> benchmark helper.</summary>
-    /// <returns>The <c>R3FromArray</c> result.</returns>
+    /// <summary>Drains the shared int array through R3.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3FromArray()
     {
         IntR3Witness observer = new();
@@ -264,8 +264,8 @@ private static int R3FromArray()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3Not</c> benchmark helper.</summary>
-    /// <returns>The <c>R3Not</c> result.</returns>
+    /// <summary>Negates each boolean emitted by the R3 source.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3Not()
     {
         R3BoolWitness observer = new();
@@ -276,8 +276,8 @@ private static int R3Not()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3Return</c> benchmark helper.</summary>
-    /// <returns>The <c>R3Return</c> result.</returns>
+    /// <summary>Drains a single-value R3 source.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3Return()
     {
         IntR3Witness observer = new();
@@ -285,8 +285,8 @@ private static int R3Return()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3SelectConstant</c> benchmark helper.</summary>
-    /// <returns>The <c>R3SelectConstant</c> result.</returns>
+    /// <summary>Replaces every value in the R3 range with a constant.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3SelectConstant()
     {
         IntR3Witness observer = new();
@@ -295,8 +295,8 @@ private static int R3SelectConstant()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3WhereFalse</c> benchmark helper.</summary>
-    /// <returns>The <c>R3WhereFalse</c> result.</returns>
+    /// <summary>Keeps only the false values of the R3 boolean source.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3WhereFalse()
     {
         R3BoolWitness observer = new();
@@ -307,8 +307,8 @@ private static int R3WhereFalse()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3WhereIsNotNull</c> benchmark helper.</summary>
-    /// <returns>The <c>R3WhereIsNotNull</c> result.</returns>
+    /// <summary>Keeps only the non-null values of the R3 string source.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3WhereIsNotNull()
     {
         R3CountingWitness<string> observer = new();
@@ -318,8 +318,8 @@ private static int R3WhereIsNotNull()
         return observer.ItemCount;
     }
 
-    /// <summary>Executes the <c>R3WhereSelect</c> benchmark helper.</summary>
-    /// <returns>The <c>R3WhereSelect</c> result.</returns>
+    /// <summary>Filters the R3 range to even values and scales them.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3WhereSelect()
     {
         IntR3Witness observer = new();
@@ -330,8 +330,8 @@ private static int R3WhereSelect()
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>R3WhereTrue</c> benchmark helper.</summary>
-    /// <returns>The <c>R3WhereTrue</c> result.</returns>
+    /// <summary>Keeps only the true values of the R3 boolean source.</summary>
+    /// <returns>The scenario checksum.</returns>
     private static int R3WhereTrue()
     {
         R3BoolWitness observer = new();
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
index e123f901..1a25710e 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Helpers.cs
@@ -18,24 +18,24 @@ namespace ReactiveUI.Primitives.Benchmarks;
 /// <summary>Benchmarks the complete synchronous ReactiveUI.Primitives.Extensions public helper surface.</summary>
 public partial class ReactiveExtensionsComparisonBenchmarks
 {
-    /// <summary>Executes the <c>ArraySource</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>ArraySource</c> result.</returns>
+    /// <summary>Creates an int source over the shared array from the selected library.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>An observable over <see cref="Values"/>.</returns>
     private static IObservable<int> ArraySource(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.FromArray(Values)
             : PackageExtensions.FromArray(Values);
 
-    /// <summary>Executes the <c>BoolSource</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>BoolSource</c> result.</returns>
+    /// <summary>Creates a bool source over the shared boolean array from the selected library.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>An observable over <see cref="BooleanValues"/>.</returns>
     private static IObservable<bool> BoolSource(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.FromArray(BooleanValues)
             : PackageExtensions.FromArray(BooleanValues);
 
-    /// <summary>Executes the <c>EnsureCompleted</c> benchmark helper.</summary>
-    /// <param name="task">The <c>task</c> value.</param>
+    /// <summary>Spin-waits for the operation, rethrowing cancellation or failure.</summary>
+    /// <param name="task">The operation to wait on.</param>
     /// <exception cref="TaskCanceledException"><paramref name="task"/> completed in the canceled state.</exception>
     /// <exception cref="InvalidOperationException"><paramref name="task"/> completed in the faulted state.</exception>
     private static void EnsureCompleted(Task task)
@@ -58,8 +58,8 @@ private static void EnsureCompleted(Task task)
         throw new InvalidOperationException("The benchmark task should complete successfully.", task.Exception);
     }
 
-    /// <summary>Executes the <c>EnsureCompleted</c> benchmark helper.</summary>
-    /// <param name="task">The <c>task</c> value.</param>
+    /// <summary>Spin-waits for the operation, rethrowing cancellation or failure.</summary>
+    /// <param name="task">The operation to wait on.</param>
     private static void EnsureCompleted(ValueTask task)
     {
         if (task.IsCompletedSuccessfully)
@@ -70,18 +70,18 @@ private static void EnsureCompleted(ValueTask task)
         EnsureCompleted(task.AsTask());
     }
 
-    /// <summary>Executes the <c>GetCompletedResult</c> benchmark helper.</summary>
-    /// <param name="task">The <c>task</c> value.</param>
-    /// <returns>The <c>GetCompletedResult</c> result.</returns>
+    /// <summary>Waits for the operation to finish and returns the scenario checksum.</summary>
+    /// <param name="task">The operation to wait on.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int GetCompletedResult(Task<int> task)
     {
         EnsureCompleted(task);
         return Value;
     }
 
-    /// <summary>Executes the <c>GetCompletedResult</c> benchmark helper.</summary>
-    /// <param name="task">The <c>task</c> value.</param>
-    /// <returns>The <c>GetCompletedResult</c> result.</returns>
+    /// <summary>Waits for the operation to finish and returns the scenario checksum.</summary>
+    /// <param name="task">The operation to wait on.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int GetCompletedResult(ValueTask<int> task)
     {
         if (!task.IsCompletedSuccessfully)
@@ -92,10 +92,10 @@ private static int GetCompletedResult(ValueTask<int> task)
         return Value;
     }
 
-    /// <summary>Executes the <c>BoolSources</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <param name="value">The <c>value</c> value.</param>
-    /// <returns>The <c>BoolSources</c> result.</returns>
+    /// <summary>Yields two single-value bool sources from the selected library.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <param name="value">The boolean each source emits.</param>
+    /// <returns>Two observables that each emit <paramref name="value"/>.</returns>
     private static IEnumerable<IObservable<bool>> BoolSources(ExtensionsLibrary library, bool value)
     {
         yield return library == ExtensionsLibrary.Primitives
@@ -106,8 +106,8 @@ private static IEnumerable<IObservable<bool>> BoolSources(ExtensionsLibrary libr
             : PackageObservables.Return(value);
     }
 
-    /// <summary>Executes the <c>CompletedTasks</c> benchmark helper.</summary>
-    /// <returns>The <c>CompletedTasks</c> result.</returns>
+    /// <summary>Yields pre-completed tasks carrying ascending values.</summary>
+    /// <returns>A lazy sequence of <see cref="Count"/> completed tasks.</returns>
     private static IEnumerable<Task<int>> CompletedTasks()
     {
         for (var i = 0; i < Count; i++)
@@ -116,8 +116,8 @@ private static IEnumerable<Task<int>> CompletedTasks()
         }
     }
 
-    /// <summary>Executes the <c>CreateValues</c> benchmark helper.</summary>
-    /// <returns>The <c>CreateValues</c> result.</returns>
+    /// <summary>Builds the shared int payload as ascending values from zero.</summary>
+    /// <returns>An array of <see cref="Count"/> ascending values.</returns>
     private static int[] CreateValues()
     {
         var values = new int[Count];
@@ -129,9 +129,9 @@ private static int[] CreateValues()
         return values;
     }
 
-    /// <summary>Executes the <c>DrainArray</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainArray</c> result.</returns>
+    /// <summary>Subscribes to the source and sums the length of every emitted array.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The summed array lengths.</returns>
     private static int DrainArray(IObservable<int[]> source)
     {
         ArrayWitness observer = new();
@@ -139,9 +139,9 @@ private static int DrainArray(IObservable<int[]> source)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>DrainBool</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainBool</c> result.</returns>
+    /// <summary>Subscribes to the source and folds the emitted booleans into a checksum.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The true-value count plus the emission count.</returns>
     private static int DrainBool(IObservable<bool> source)
     {
         BoolSignalWitness observer = new();
@@ -149,9 +149,9 @@ private static int DrainBool(IObservable<bool> source)
         return observer.Total + observer.NextCount;
     }
 
-    /// <summary>Executes the <c>DrainInt</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainInt</c> result.</returns>
+    /// <summary>Subscribes to the source and folds the emitted integers into a checksum.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The value total plus the emission count.</returns>
     private static int DrainInt(IObservable<int> source)
     {
         IntSignalWitness observer = new();
@@ -159,9 +159,9 @@ private static int DrainInt(IObservable<int> source)
         return observer.Total + observer.NextCount;
     }
 
-    /// <summary>Executes the <c>DrainList</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainList</c> result.</returns>
+    /// <summary>Subscribes to the source and sums the size of every emitted list.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The summed list sizes.</returns>
     private static int DrainList(IObservable<IList<int>> source)
     {
         ListWitness observer = new();
@@ -169,9 +169,9 @@ private static int DrainList(IObservable<IList<int>> source)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>DrainPackageUnit</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainPackageUnit</c> result.</returns>
+    /// <summary>Subscribes to the source and counts the System.Reactive unit notifications.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The emission count plus the completion count.</returns>
     private static int DrainPackageUnit(IObservable<RxUnit> source)
     {
         CountingSignalWitness<RxUnit> observer = new();
@@ -179,9 +179,9 @@ private static int DrainPackageUnit(IObservable<RxUnit> source)
         return observer.Count + observer.CompletionCount;
     }
 
-    /// <summary>Executes the <c>DrainPrimitiveUnit</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainPrimitiveUnit</c> result.</returns>
+    /// <summary>Subscribes to the source and counts the primitives void notifications.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The emission count plus the completion count.</returns>
     private static int DrainPrimitiveUnit(IObservable<RxVoid> source)
     {
         CountingSignalWitness<RxVoid> observer = new();
@@ -189,9 +189,9 @@ private static int DrainPrimitiveUnit(IObservable<RxVoid> source)
         return observer.Count + observer.CompletionCount;
     }
 
-    /// <summary>Executes the <c>DrainString</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainString</c> result.</returns>
+    /// <summary>Subscribes to the source and folds emitted string lengths into a checksum, counting null as zero.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The total string length plus the emission count.</returns>
     private static int DrainString(IObservable<string?> source)
     {
         NullableStringLengthWitness observer = new();
@@ -199,9 +199,9 @@ private static int DrainString(IObservable<string?> source)
         return observer.TotalLength + observer.ItemCount;
     }
 
-    /// <summary>Executes the <c>DrainSyncTuple</c> benchmark helper.</summary>
-    /// <param name="source">The <c>source</c> value.</param>
-    /// <returns>The <c>DrainSyncTuple</c> result.</returns>
+    /// <summary>Subscribes to the source, summing each value and disposing its synchronization handle.</summary>
+    /// <param name="source">The sequence to drain.</param>
+    /// <returns>The summed values.</returns>
     private static int DrainSyncTuple(IObservable<(int Value, IDisposable Sync)> source)
     {
         SyncTupleWitness observer = new();
@@ -209,29 +209,29 @@ private static int DrainSyncTuple(IObservable<(int Value, IDisposable Sync)> sou
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>Range</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>Range</c> result.</returns>
+    /// <summary>Creates the shared ascending range from the selected library.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>An observable over <see cref="Count"/> ascending values from zero.</returns>
     private static IObservable<int> Range(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? Signal.Sequence(0, Count)
             : RxObservable.Range(0, Count);
 
-    /// <summary>Executes the <c>ThrowInt</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>ThrowInt</c> result.</returns>
+    /// <summary>Creates an immediately failing int source from the selected library.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>An observable that fails with <see cref="Boom"/>.</returns>
     private static IObservable<int> ThrowInt(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? Signal.Fail<int>(Boom)
             : RxObservable.Throw<int>(Boom);
 
-    /// <summary>Executes the <c>ThrowPackageUnit</c> benchmark helper.</summary>
-    /// <returns>The <c>ThrowPackageUnit</c> result.</returns>
+    /// <summary>Creates a System.Reactive unit source that fails immediately.</summary>
+    /// <returns>An observable that fails with <see cref="Boom"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static IObservable<RxUnit> ThrowPackageUnit() => RxObservable.Throw<RxUnit>(Boom);
 
-    /// <summary>Executes the <c>ThrowPrimitiveUnit</c> benchmark helper.</summary>
-    /// <returns>The <c>ThrowPrimitiveUnit</c> result.</returns>
+    /// <summary>Creates a primitives void source that fails immediately.</summary>
+    /// <returns>An observable that fails with <see cref="Boom"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static IObservable<RxVoid> ThrowPrimitiveUnit() => Signal.Fail<RxVoid>(Boom);
 
@@ -246,10 +246,10 @@ private static IObservable<int> ThrowInt(ExtensionsLibrary library) =>
     [System.Diagnostics.DebuggerDisplay("ExtensionScenario: Name = {_name}")]
     public sealed class ExtensionScenario(string name, Func<int> run)
     {
-        /// <summary>Stores the scenario name.</summary>
+        /// <summary>The scenario name reported by BenchmarkDotNet.</summary>
         private readonly string _name = name;
 
-        /// <summary>Stores the scenario delegate.</summary>
+        /// <summary>The delegate invoked for each benchmark operation.</summary>
         private readonly Func<int> _run = run;
 
         /// <summary>Runs the scenario delegate.</summary>
@@ -261,10 +261,10 @@ public sealed class ExtensionScenario(string name, Func<int> run)
         public override string ToString() => _name;
     }
 
-    /// <summary>Provides the <c>ArrayWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that accumulates the length of every emitted array.</summary>
     private sealed class ArrayWitness : IObserver<int[]>
     {
-        /// <summary>Gets the <c>Total</c> benchmark helper value.</summary>
+        /// <summary>Gets the summed length of the arrays observed.</summary>
         public int Total { get; private set; }
 
         /// <inheritdoc/>
@@ -281,10 +281,10 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Provides the <c>DummyResource</c> benchmark helper type.</summary>
+    /// <summary>Disposable resource used by the resource-scoping scenarios.</summary>
     private sealed class DummyResource : IDisposable
     {
-        /// <summary>Gets or sets the <c>TouchCount</c> benchmark helper value.</summary>
+        /// <summary>Gets or sets the number of times the resource has been touched.</summary>
         private int TouchCount { get; set; }
 
         /// <inheritdoc/>
@@ -292,14 +292,14 @@ public void Dispose()
         {
         }
 
-        /// <summary>Executes the <c>Touch</c> benchmark helper.</summary>
+        /// <summary>Records one use of the resource.</summary>
         public void Touch() => TouchCount++;
     }
 
-    /// <summary>Provides the <c>ListWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that accumulates the size of every emitted list.</summary>
     private sealed class ListWitness : IObserver<IList<int>>
     {
-        /// <summary>Gets the <c>Total</c> benchmark helper value.</summary>
+        /// <summary>Gets the summed size of the lists observed.</summary>
         public int Total { get; private set; }
 
         /// <inheritdoc/>
@@ -316,13 +316,13 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Provides the <c>NullableStringLengthWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that counts emissions and accumulates string length, counting null as zero.</summary>
     private sealed class NullableStringLengthWitness : IObserver<string?>
     {
-        /// <summary>Gets the <c>ItemCount</c> benchmark helper value.</summary>
+        /// <summary>Gets the number of values observed.</summary>
         public int ItemCount { get; private set; }
 
-        /// <summary>Gets the <c>TotalLength</c> benchmark helper value.</summary>
+        /// <summary>Gets the summed length of the strings observed.</summary>
         public int TotalLength { get; private set; }
 
         /// <inheritdoc/>
@@ -343,10 +343,10 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Provides the <c>PairWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that sums both halves of every emitted pair.</summary>
     private sealed class PairWitness : IObserver<(int Previous, int Current)>
     {
-        /// <summary>Gets the <c>Total</c> benchmark helper value.</summary>
+        /// <summary>Gets the summed pair values.</summary>
         public int Total { get; private set; }
 
         /// <inheritdoc/>
@@ -363,13 +363,13 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Provides the <c>PropertySource</c> benchmark helper type.</summary>
+    /// <summary>Property holder that raises a change notification on every assignment.</summary>
     private sealed class PropertySource : INotifyPropertyChanged
     {
-        /// <summary>Occurs when the <c>PropertyChanged</c> benchmark helper event is raised.</summary>
+        /// <summary>Occurs when <see cref="CurrentValue"/> is assigned.</summary>
         public event PropertyChangedEventHandler? PropertyChanged;
 
-        /// <summary>Gets or sets the <c>CurrentValue</c> benchmark helper value.</summary>
+        /// <summary>Gets or sets the value whose assignment raises the change notification.</summary>
         public int CurrentValue
         {
             get;
@@ -381,10 +381,10 @@ public int CurrentValue
         }
     }
 
-    /// <summary>Provides the <c>R3BoolWitness</c> benchmark helper type.</summary>
+    /// <summary>R3 observer that counts the true values observed.</summary>
     private sealed class R3BoolWitness : R3.Observer<bool>
     {
-        /// <summary>Gets the <c>Total</c> benchmark helper value.</summary>
+        /// <summary>Gets the number of true values observed.</summary>
         public int Total { get; private set; }
 
         /// <inheritdoc/>
@@ -409,11 +409,11 @@ protected override void OnCompletedCore(R3.Result result)
         }
     }
 
-    /// <summary>Provides the <c>R3CountingWitness</c> benchmark helper type.</summary>
+    /// <summary>R3 observer that counts the values observed.</summary>
     /// <typeparam name="T">The observed value type.</typeparam>
     private sealed class R3CountingWitness<T> : R3.Observer<T>
     {
-        /// <summary>Gets the <c>ItemCount</c> benchmark helper value.</summary>
+        /// <summary>Gets the number of values observed.</summary>
         public int ItemCount { get; private set; }
 
         /// <inheritdoc/>
@@ -430,10 +430,10 @@ protected override void OnCompletedCore(R3.Result result)
         }
     }
 
-    /// <summary>Provides the <c>SyncTupleWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that sums each value and disposes its paired synchronization handle.</summary>
     private sealed class SyncTupleWitness : IObserver<(int Value, IDisposable Sync)>
     {
-        /// <summary>Gets the <c>Total</c> benchmark helper value.</summary>
+        /// <summary>Gets the summed values.</summary>
         public int Total { get; private set; }
 
         /// <inheritdoc/>
@@ -454,11 +454,11 @@ public void OnCompleted()
         }
     }
 
-    /// <summary>Provides the <c>TupleWitness</c> benchmark helper type.</summary>
+    /// <summary>Observer that counts each value and disposes its paired synchronization handle.</summary>
     /// <typeparam name="T">The observed value type.</typeparam>
     private sealed class TupleWitness<T> : IObserver<(T Value, IDisposable Sync)>
     {
-        /// <summary>Gets the <c>ItemCount</c> benchmark helper value.</summary>
+        /// <summary>Gets the number of values observed.</summary>
         public int ItemCount { get; private set; }
 
         /// <inheritdoc/>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.Supplemental.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.Supplemental.cs
index 936d713e..8c1a2d26 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.Supplemental.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.Supplemental.cs
@@ -21,9 +21,9 @@ namespace ReactiveUI.Primitives.Benchmarks;
 /// <summary>Benchmarks the complete synchronous ReactiveUI.Primitives.Extensions public helper surface.</summary>
 public partial class ReactiveExtensionsComparisonBenchmarks
 {
-    /// <summary>Executes the <c>RunPartition</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunPartition</c> result.</returns>
+    /// <summary>Splits the array source into even and odd halves and drains both.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunPartition(ExtensionsLibrary library)
     {
         IntSignalWitness observer = new();
@@ -43,27 +43,27 @@ private static int RunPartition(ExtensionsLibrary library)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>RunReplayLastOnSubscribe</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunReplayLastOnSubscribe</c> result.</returns>
+    /// <summary>Replays the last value of the array source to a late subscriber.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunReplayLastOnSubscribe(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ReplayLastOnSubscribe(ArraySource(library), Fallback)
             : PackageExtensions.ReplayLastOnSubscribe(ArraySource(library), Fallback));
 
-    /// <summary>Executes the <c>RunRetryForeverWithDelay</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunRetryForeverWithDelay</c> result.</returns>
+    /// <summary>Retries the array source indefinitely with no delay between attempts.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunRetryForeverWithDelay(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.RetryForeverWithDelay(ArraySource(library), TimeSpan.Zero)
             : PackageExtensions.RetryForeverWithDelay(ArraySource(library), TimeSpan.Zero));
 
-    /// <summary>Executes the <c>RunRetryWithBackoff</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunRetryWithBackoff</c> result.</returns>
+    /// <summary>Retries the array source once with a zero-length backoff.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunRetryWithBackoff(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -82,44 +82,44 @@ private static int RunRetryWithBackoff(ExtensionsLibrary library) =>
                 TimeSpan.Zero,
                 ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunRetryWithDelay</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunRetryWithDelay</c> result.</returns>
+    /// <summary>Retries the array source once with a computed zero delay.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunRetryWithDelay(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.RetryWithDelay(ArraySource(library), 1, static _ => TimeSpan.Zero)
             : PackageExtensions.RetryWithDelay(ArraySource(library), 1, static _ => TimeSpan.Zero));
 
-    /// <summary>Executes the <c>RunRetryWithFixedDelay</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunRetryWithFixedDelay</c> result.</returns>
+    /// <summary>Retries the array source once with a fixed zero delay.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunRetryWithFixedDelay(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.RetryWithFixedDelay(ArraySource(library), 1, TimeSpan.Zero)
             : PackageExtensions.RetryWithFixedDelay(ArraySource(library), 1, TimeSpan.Zero));
 
-    /// <summary>Executes the <c>RunReturn</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunReturn</c> result.</returns>
+    /// <summary>Drains a single-value source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunReturn(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesObservables.Return(Value)
             : PackageObservables.Return(Value));
 
-    /// <summary>Executes the <c>RunRunAll</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunRunAll</c> result.</returns>
+    /// <summary>Runs a single unit source to completion through RunAll.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunRunAll(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainPrimitiveUnit(PrimitivesExtensions.RunAll([PrimitivesObservables.Return(RxVoid.Default)]))
             : DrainPackageUnit(PackageExtensions.RunAll([PackageObservables.Return(RxUnit.Default)]));
 
-    /// <summary>Executes the <c>RunSampleLatest</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSampleLatest</c> result.</returns>
+    /// <summary>Samples the latest array value on each sampler notification.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSampleLatest(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -130,27 +130,27 @@ private static int RunSampleLatest(ExtensionsLibrary library) =>
                 ArraySource(library),
                 PackageExtensions.SelectConstant(ArraySource(library), new object())));
 
-    /// <summary>Executes the <c>RunScanWithInitial</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunScanWithInitial</c> result.</returns>
+    /// <summary>Accumulates the array source from a seed value.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunScanWithInitial(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ScanWithInitial(ArraySource(library), 0, static (acc, value) => acc + value)
             : PackageExtensions.ScanWithInitial(ArraySource(library), 0, static (acc, value) => acc + value));
 
-    /// <summary>Executes the <c>RunSchedule</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSchedule</c> result.</returns>
+    /// <summary>Schedules a projection of one value on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSchedule(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.Schedule(Value, Sequencer.Immediate, static value => value + 1)
             : PackageExtensions.Schedule(Value, ImmediateScheduler.Instance, static value => value + 1));
 
-    /// <summary>Executes the <c>RunScheduleSafe</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunScheduleSafe</c> result.</returns>
+    /// <summary>Schedules an error-isolated callback on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunScheduleSafe(ExtensionsLibrary library)
     {
         var count = 0;
@@ -160,18 +160,18 @@ private static int RunScheduleSafe(ExtensionsLibrary library)
         return count;
     }
 
-    /// <summary>Executes the <c>RunSelectAsyncScenario</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectAsyncScenario</c> result.</returns>
+    /// <summary>Projects each array value through a completed task.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectAsyncScenario(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SelectAsync(ArraySource(library), static value => Task.FromResult(value + 1))
             : PackageExtensions.SelectAsync(ArraySource(library), static value => Task.FromResult(value + 1)));
 
-    /// <summary>Executes the <c>RunSelectAsyncConcurrent</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectAsyncConcurrent</c> result.</returns>
+    /// <summary>Projects each array value through a completed task under a concurrency cap.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectAsyncConcurrent(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -184,9 +184,9 @@ private static int RunSelectAsyncConcurrent(ExtensionsLibrary library) =>
                 static value => Task.FromResult(value + 1),
                 MaxConcurrency));
 
-    /// <summary>Executes the <c>RunSelectAsyncSequential</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectAsyncSequential</c> result.</returns>
+    /// <summary>Projects each array value through a completed task, one at a time.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectAsyncSequential(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -197,27 +197,27 @@ private static int RunSelectAsyncSequential(ExtensionsLibrary library) =>
                 ArraySource(library),
                 static value => Task.FromResult(value + 1)));
 
-    /// <summary>Executes the <c>RunSelectConstant</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectConstant</c> result.</returns>
+    /// <summary>Replaces every array value with a constant.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectConstant(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SelectConstant(ArraySource(library), Value)
             : PackageExtensions.SelectConstant(ArraySource(library), Value));
 
-    /// <summary>Executes the <c>RunSelectLatestAsyncScenario</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectLatestAsyncScenario</c> result.</returns>
+    /// <summary>Projects array values through a completed task, keeping only the latest.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectLatestAsyncScenario(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SelectLatestAsync(ArraySource(library), static value => Task.FromResult(value + 1))
             : PackageExtensions.SelectLatestAsync(ArraySource(library), static value => Task.FromResult(value + 1)));
 
-    /// <summary>Executes the <c>RunSelectManyThen</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSelectManyThen</c> result.</returns>
+    /// <summary>Chains two sequential projections from a single value.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSelectManyThen(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -230,35 +230,35 @@ private static int RunSelectManyThen(ExtensionsLibrary library) =>
                 static value => PackageObservables.Return(value + 1),
                 static value => PackageObservables.Return(value + 1)));
 
-    /// <summary>Executes the <c>RunShuffle</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunShuffle</c> result.</returns>
+    /// <summary>Shuffles a single emitted array.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunShuffle(ExtensionsLibrary library) =>
         DrainArray(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.Shuffle(PrimitivesObservables.Return(Values))
             : PackageExtensions.Shuffle(PackageObservables.Return(Values)));
 
-    /// <summary>Executes the <c>RunSkipWhileNull</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSkipWhileNull</c> result.</returns>
+    /// <summary>Skips the leading nulls of the string source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSkipWhileNull(ExtensionsLibrary library) =>
         DrainString(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SkipWhileNull(PrimitivesExtensions.FromArray(SkipStrings))
             : PackageExtensions.SkipWhileNull(PackageExtensions.FromArray(SkipStrings)));
 
-    /// <summary>Executes the <c>RunStart</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunStart</c> result.</returns>
+    /// <summary>Starts a void action on an immediate scheduler and drains its unit notification.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunStart(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainPrimitiveUnit(PrimitivesExtensions.Start(static () => { }, Sequencer.Immediate))
             : DrainPackageUnit(PackageExtensions.Start(static () => { }, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunSubscribeAndComplete</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSubscribeAndComplete</c> result.</returns>
+    /// <summary>Subscribes to a single-value unit source and waits for completion.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSubscribeAndComplete(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -273,9 +273,9 @@ private static int RunSubscribeAndComplete(ExtensionsLibrary library)
         return 1;
     }
 
-    /// <summary>Executes the <c>RunSubscribeAsyncScenario</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSubscribeAsyncScenario</c> result.</returns>
+    /// <summary>Sums the array source through an asynchronous subscription callback.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSubscribeAsyncScenario(ExtensionsLibrary library)
     {
         var total = 0;
@@ -293,9 +293,9 @@ private static int RunSubscribeAsyncScenario(ExtensionsLibrary library)
         return total;
     }
 
-    /// <summary>Executes the <c>RunSubscribeGetError</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSubscribeGetError</c> result.</returns>
+    /// <summary>Subscribes to a failing source and reports whether an error surfaced.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSubscribeGetError(ExtensionsLibrary library)
     {
         var error = library == ExtensionsLibrary.Primitives
@@ -305,17 +305,17 @@ private static int RunSubscribeGetError(ExtensionsLibrary library)
         return error is null ? 0 : 1;
     }
 
-    /// <summary>Executes the <c>RunSubscribeGetValue</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSubscribeGetValue</c> result.</returns>
+    /// <summary>Subscribes to the array source and reads the single returned value.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSubscribeGetValue(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? PrimitivesSubscriptionExtensions.SubscribeGetValue(ArraySource(library))
             : PackageSubscriptionExtensions.SubscribeGetValue(ArraySource(library));
 
-    /// <summary>Executes the <c>RunSubscribeSynchronous</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSubscribeSynchronous</c> result.</returns>
+    /// <summary>Sums the array source through a synchronous subscription callback.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSubscribeSynchronous(ExtensionsLibrary library)
     {
         var total = 0;
@@ -333,18 +333,18 @@ private static int RunSubscribeSynchronous(ExtensionsLibrary library)
         return total;
     }
 
-    /// <summary>Executes the <c>RunSwitchIfEmpty</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSwitchIfEmpty</c> result.</returns>
+    /// <summary>Substitutes a single-value source when the source completes empty.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSwitchIfEmpty(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SwitchIfEmpty(Signal.None<int>(), PrimitivesObservables.Return(Value))
             : PackageExtensions.SwitchIfEmpty(RxObservable.Empty<int>(), PackageObservables.Return(Value)));
 
-    /// <summary>Executes the <c>RunSyncTimer</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSyncTimer</c> result.</returns>
+    /// <summary>Advances virtual time once over a wall-clock timer.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunSyncTimer(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -363,63 +363,63 @@ private static int RunSyncTimer(ExtensionsLibrary library)
         return packageObserver.Count + packageObserver.CompletionCount;
     }
 
-    /// <summary>Executes the <c>RunSynchronizeAsyncScenario</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSynchronizeAsyncScenario</c> result.</returns>
+    /// <summary>Pairs each array value with an asynchronously acquired synchronization handle.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSynchronizeAsyncScenario(ExtensionsLibrary library) =>
         DrainSyncTuple(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SynchronizeAsync(ArraySource(library))
             : PackageExtensions.SynchronizeAsync(ArraySource(library)));
 
-    /// <summary>Executes the <c>RunSynchronizeSynchronous</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunSynchronizeSynchronous</c> result.</returns>
+    /// <summary>Pairs each array value with a synchronously acquired synchronization handle.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunSynchronizeSynchronous(ExtensionsLibrary library) =>
         DrainSyncTuple(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.SynchronizeSynchronous(ArraySource(library))
             : PackageExtensions.SynchronizeSynchronous(ArraySource(library)));
 
-    /// <summary>Executes the <c>RunTakeUntil</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunTakeUntil</c> result.</returns>
+    /// <summary>Truncates the array source at the match threshold.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunTakeUntil(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.TakeUntil(ArraySource(library), static value => value == Match)
             : PackageExtensions.TakeUntil(ArraySource(library), static value => value == Match));
 
-    /// <summary>Executes the <c>RunThrottleDistinct</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunThrottleDistinct</c> result.</returns>
+    /// <summary>Throttles the array source, suppressing repeats inside the window.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunThrottleDistinct(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ThrottleDistinct(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate)
             : PackageExtensions.ThrottleDistinct(ArraySource(library), TimeSpan.Zero, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunThrottleFirst</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunThrottleFirst</c> result.</returns>
+    /// <summary>Throttles the array source, keeping the leading value of each window.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunThrottleFirst(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ThrottleFirst(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate)
             : PackageExtensions.ThrottleFirst(ArraySource(library), TimeSpan.Zero, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunThrottleOnScheduler</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunThrottleOnScheduler</c> result.</returns>
+    /// <summary>Throttles the array source on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunThrottleOnScheduler(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ThrottleOnScheduler(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate)
             : PackageExtensions.ThrottleOnScheduler(ArraySource(library), TimeSpan.Zero, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunThrottleUntilTrue</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunThrottleUntilTrue</c> result.</returns>
+    /// <summary>Throttles the array source until a value clears the match threshold.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunThrottleUntilTrue(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -432,25 +432,25 @@ private static int RunThrottleUntilTrue(ExtensionsLibrary library) =>
                 TimeSpan.Zero,
                 static value => value >= Match));
 
-    /// <summary>Executes the <c>RunToHotTask</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunToHotTask</c> result.</returns>
+    /// <summary>Converts a single-value source to an eagerly started task and waits for it.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunToHotTask(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? GetCompletedResult(PrimitivesExtensions.ToHotTask(PrimitivesObservables.Return(Value)))
             : GetCompletedResult(PackageExtensions.ToHotTask(PackageObservables.Return(Value)));
 
-    /// <summary>Executes the <c>RunToHotValueTask</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunToHotValueTask</c> result.</returns>
+    /// <summary>Converts a single-value source to an eagerly started value task and waits for it.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunToHotValueTask(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? GetCompletedResult(PrimitivesExtensions.ToHotValueTask(PrimitivesObservables.Return(Value)))
             : GetCompletedResult(PackageExtensions.ToHotValueTask(PackageObservables.Return(Value)));
 
-    /// <summary>Executes the <c>RunToPropertyObservable</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunToPropertyObservable</c> result.</returns>
+    /// <summary>Bridges a property-changed notification into an observable.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunToPropertyObservable(ExtensionsLibrary library)
     {
         PropertySource source = new();
@@ -464,9 +464,9 @@ private static int RunToPropertyObservable(ExtensionsLibrary library)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>RunToReadOnlyBehavior</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunToReadOnlyBehavior</c> result.</returns>
+    /// <summary>Pushes a value through a read-only behavior and its paired sink.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunToReadOnlyBehavior(ExtensionsLibrary library)
     {
         IntSignalWitness observer = new();
@@ -486,9 +486,9 @@ private static int RunToReadOnlyBehavior(ExtensionsLibrary library)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>RunTrySelect</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunTrySelect</c> result.</returns>
+    /// <summary>Projects even array values to strings and drops the rest.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunTrySelect(ExtensionsLibrary library) =>
         DrainString(library == ExtensionsLibrary.Primitives
@@ -499,17 +499,17 @@ private static int RunTrySelect(ExtensionsLibrary library) =>
                 ArraySource(library),
                 static value => value % EvenDivisor == 0 ? value.ToString(CultureInfo.InvariantCulture) : null));
 
-    /// <summary>Executes the <c>RunUsing</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunUsing</c> result.</returns>
+    /// <summary>Scopes a disposable resource around a unit source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunUsing(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainPrimitiveUnit(PrimitivesExtensions.Using(new DummyResource(), static resource => resource.Touch()))
             : DrainPackageUnit(PackageExtensions.Using(new DummyResource(), static resource => resource.Touch()));
 
-    /// <summary>Executes the <c>RunWaitForCompletion</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWaitForCompletion</c> result.</returns>
+    /// <summary>Blocks on a single-value unit source until it completes.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunWaitForCompletion(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -526,9 +526,9 @@ private static int RunWaitForCompletion(ExtensionsLibrary library)
         return 1;
     }
 
-    /// <summary>Executes the <c>RunWaitForError</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWaitForError</c> result.</returns>
+    /// <summary>Blocks on a failing source and reports whether an error surfaced.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunWaitForError(ExtensionsLibrary library)
     {
         var error = library == ExtensionsLibrary.Primitives
@@ -538,44 +538,44 @@ private static int RunWaitForError(ExtensionsLibrary library)
         return error is null ? 0 : 1;
     }
 
-    /// <summary>Executes the <c>RunWaitForValue</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWaitForValue</c> result.</returns>
+    /// <summary>Blocks on the array source until its first value arrives.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunWaitForValue(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? PrimitivesSubscriptionExtensions.WaitForValue(ArraySource(library), WaitTimeout)
             : PackageSubscriptionExtensions.WaitForValue(ArraySource(library), WaitTimeout);
 
-    /// <summary>Executes the <c>RunWaitUntil</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWaitUntil</c> result.</returns>
+    /// <summary>Waits for the first array value that matches the threshold.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWaitUntil(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.WaitUntil(ArraySource(library), static value => value == Match)
             : PackageExtensions.WaitUntil(ArraySource(library), static value => value == Match));
 
-    /// <summary>Executes the <c>RunWhereFalse</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWhereFalse</c> result.</returns>
+    /// <summary>Keeps only the false values of the boolean source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWhereFalse(ExtensionsLibrary library) =>
         DrainBool(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.WhereFalse(BoolSource(library))
             : PackageExtensions.WhereFalse(BoolSource(library)));
 
-    /// <summary>Executes the <c>RunWhereIsNotNull</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWhereIsNotNull</c> result.</returns>
+    /// <summary>Keeps only the non-null values of the string source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWhereIsNotNull(ExtensionsLibrary library) =>
         DrainString(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.WhereIsNotNull(PrimitivesExtensions.FromArray(NullableStrings))
             : PackageExtensions.WhereIsNotNull(PackageExtensions.FromArray(NullableStrings)));
 
-    /// <summary>Executes the <c>RunWhereSelect</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWhereSelect</c> result.</returns>
+    /// <summary>Filters the array source to even values and scales them.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWhereSelect(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -588,18 +588,18 @@ private static int RunWhereSelect(ExtensionsLibrary library) =>
                 static value => (value & 1) == 0,
                 static value => value * ResultMultiplier));
 
-    /// <summary>Executes the <c>RunWhereTrue</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWhereTrue</c> result.</returns>
+    /// <summary>Keeps only the true values of the boolean source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWhereTrue(ExtensionsLibrary library) =>
         DrainBool(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.WhereTrue(BoolSource(library))
             : PackageExtensions.WhereTrue(BoolSource(library)));
 
-    /// <summary>Executes the <c>RunWhile</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWhile</c> result.</returns>
+    /// <summary>Repeats a unit action while a counter remains positive.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunWhile(ExtensionsLibrary library)
     {
         var remaining = Count;
@@ -619,9 +619,9 @@ bool ShouldContinue()
             : DrainPackageUnit(PackageExtensions.While(ShouldContinue, RecordIteration)) + total;
     }
 
-    /// <summary>Executes the <c>RunWithLimitedConcurrency</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunWithLimitedConcurrency</c> result.</returns>
+    /// <summary>Awaits pre-completed tasks under a concurrency cap.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunWithLimitedConcurrency(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.cs
index 9ab16ea9..fcca7abc 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.Library.cs
@@ -22,25 +22,25 @@ namespace ReactiveUI.Primitives.Benchmarks;
 /// <summary>Benchmarks the complete synchronous ReactiveUI.Primitives.Extensions public helper surface.</summary>
 public partial class ReactiveExtensionsComparisonBenchmarks
 {
-    /// <summary>Executes the <c>RunAsSignal</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunAsSignal</c> result.</returns>
+    /// <summary>Projects the selected library's range to unit values through AsSignal.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunAsSignal(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainPrimitiveUnit(PrimitivesExtensions.AsSignal(Range(library)))
             : DrainPackageUnit(PackageExtensions.AsSignal(Range(library)));
 
-    /// <summary>Executes the <c>RunBufferUntil</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunBufferUntil</c> result.</returns>
+    /// <summary>Buffers the character source between bracket delimiters.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunBufferUntil(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainString(PrimitivesExtensions.BufferUntil(PrimitivesExtensions.FromArray(BufferCharacters), '[', ']'))
             : DrainString(PackageExtensions.BufferUntil(PackageExtensions.FromArray(BufferCharacters), '[', ']'));
 
-    /// <summary>Executes the <c>RunBufferUntilIdle</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunBufferUntilIdle</c> result.</returns>
+    /// <summary>Buffers the array source until it falls idle, on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunBufferUntilIdle(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainList(PrimitivesExtensions.BufferUntilIdle(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate))
@@ -49,9 +49,9 @@ private static int RunBufferUntilIdle(ExtensionsLibrary library) =>
                 TimeSpan.Zero,
                 ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunBufferUntilInactive</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunBufferUntilInactive</c> result.</returns>
+    /// <summary>Buffers the array source until it falls inactive, on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunBufferUntilInactive(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainList(
@@ -61,9 +61,9 @@ private static int RunBufferUntilInactive(ExtensionsLibrary library) =>
                 TimeSpan.Zero,
                 ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunCatchAndReturn</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCatchAndReturn</c> result.</returns>
+    /// <summary>Substitutes a computed fallback for a typed failure through CatchAndReturn.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunCatchAndReturn(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -74,62 +74,62 @@ private static int RunCatchAndReturn(ExtensionsLibrary library) =>
                 ThrowInt(library),
                 static _ => Fallback));
 
-    /// <summary>Executes the <c>RunCatchIgnore</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCatchIgnore</c> result.</returns>
+    /// <summary>Swallows a typed failure through CatchIgnore.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunCatchIgnore(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.CatchIgnore<int, InvalidOperationException>(ThrowInt(library), static _ => { })
             : PackageExtensions.CatchIgnore<int, InvalidOperationException>(ThrowInt(library), static _ => { }));
 
-    /// <summary>Executes the <c>RunCatchReturn</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCatchReturn</c> result.</returns>
+    /// <summary>Substitutes a constant fallback for a failure through CatchReturn.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunCatchReturn(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.CatchReturn(ThrowInt(library), Fallback)
             : PackageExtensions.CatchReturn(ThrowInt(library), Fallback));
 
-    /// <summary>Executes the <c>RunCatchReturnUnit</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCatchReturnUnit</c> result.</returns>
+    /// <summary>Substitutes a unit value for a failing unit source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunCatchReturnUnit(ExtensionsLibrary library) =>
         library == ExtensionsLibrary.Primitives
             ? DrainPrimitiveUnit(PrimitivesExtensions.CatchReturnUnit(ThrowPrimitiveUnit()))
             : DrainPackageUnit(PackageExtensions.CatchReturnUnit(ThrowPackageUnit()));
 
-    /// <summary>Executes the <c>RunCombineLatestValuesAreAllFalse</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCombineLatestValuesAreAllFalse</c> result.</returns>
+    /// <summary>Combines two false sources and tests that every value is false.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunCombineLatestValuesAreAllFalse(ExtensionsLibrary library) =>
         DrainBool(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.CombineLatestValuesAreAllFalse(BoolSources(library, false))
             : PackageExtensions.CombineLatestValuesAreAllFalse(BoolSources(library, false)));
 
-    /// <summary>Executes the <c>RunCombineLatestValuesAreAllTrue</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunCombineLatestValuesAreAllTrue</c> result.</returns>
+    /// <summary>Combines two true sources and tests that every value is true.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunCombineLatestValuesAreAllTrue(ExtensionsLibrary library) =>
         DrainBool(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.CombineLatestValuesAreAllTrue(BoolSources(library, true))
             : PackageExtensions.CombineLatestValuesAreAllTrue(BoolSources(library, true)));
 
-    /// <summary>Executes the <c>RunConflate</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunConflate</c> result.</returns>
+    /// <summary>Conflates the array source over a zero window on an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunConflate(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.Conflate(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate)
             : PackageExtensions.Conflate(ArraySource(library), TimeSpan.Zero, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunContinuationDispose</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunContinuationDispose</c> result.</returns>
+    /// <summary>Constructs and disposes a continuation, reading its completed phase count.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunContinuationDispose(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -142,9 +142,9 @@ private static int RunContinuationDispose(ExtensionsLibrary library)
         return (int)packageContinuation.CompletedPhases;
     }
 
-    /// <summary>Executes the <c>RunContinuationLock</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunContinuationLock</c> result.</returns>
+    /// <summary>Acquires a continuation lock and observes the task-based handle.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunContinuationLock(ExtensionsLibrary library)
     {
         TupleWitness<int> observer = new();
@@ -162,9 +162,9 @@ private static int RunContinuationLock(ExtensionsLibrary library)
         return observer.ItemCount;
     }
 
-    /// <summary>Executes the <c>RunContinuationLockValueTask</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunContinuationLockValueTask</c> result.</returns>
+    /// <summary>Acquires a continuation lock and observes the value-task handle.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunContinuationLockValueTask(ExtensionsLibrary library)
     {
         TupleWitness<int> observer = new();
@@ -182,18 +182,18 @@ private static int RunContinuationLockValueTask(ExtensionsLibrary library)
         return observer.ItemCount;
     }
 
-    /// <summary>Executes the <c>RunDebounceImmediate</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDebounceImmediate</c> result.</returns>
+    /// <summary>Debounces the array source, emitting the leading value of each window.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunDebounceImmediate(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.DebounceImmediate(ArraySource(library), TimeSpan.Zero, Sequencer.Immediate)
             : PackageExtensions.DebounceImmediate(ArraySource(library), TimeSpan.Zero, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunDebounceUntil</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDebounceUntil</c> result.</returns>
+    /// <summary>Debounces the array source until a value clears the match threshold.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunDebounceUntil(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -208,9 +208,9 @@ private static int RunDebounceUntil(ExtensionsLibrary library) =>
                 static value => value >= Match,
                 ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunDetectStale</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDetectStale</c> result.</returns>
+    /// <summary>Advances virtual time over a silent source to emit a stale marker.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunDetectStale(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -231,9 +231,9 @@ private static int RunDetectStale(ExtensionsLibrary library)
         return packageObserver.Count + packageObserver.CompletionCount;
     }
 
-    /// <summary>Executes the <c>RunDoOnDispose</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDoOnDispose</c> result.</returns>
+    /// <summary>Counts the dispose callback raised when the subscription is released.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunDoOnDispose(ExtensionsLibrary library)
     {
         var count = 0;
@@ -245,9 +245,9 @@ private static int RunDoOnDispose(ExtensionsLibrary library)
         return count;
     }
 
-    /// <summary>Executes the <c>RunDoOnSubscribe</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDoOnSubscribe</c> result.</returns>
+    /// <summary>Counts the subscribe callback raised when the source is subscribed.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunDoOnSubscribe(ExtensionsLibrary library)
     {
         var count = 0;
@@ -257,18 +257,18 @@ private static int RunDoOnSubscribe(ExtensionsLibrary library)
         return total + count;
     }
 
-    /// <summary>Executes the <c>RunDropIfBusy</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunDropIfBusy</c> result.</returns>
+    /// <summary>Drops values from the array source while the handler is busy.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunDropIfBusy(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.DropIfBusy(ArraySource(library), static _ => default)
             : PackageExtensions.DropIfBusy(ArraySource(library), static _ => default));
 
-    /// <summary>Executes the <c>RunFastForEach</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunFastForEach</c> result.</returns>
+    /// <summary>Pushes the shared array into an observer through FastForEach.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunFastForEach(ExtensionsLibrary library)
     {
         IntSignalWitness observer = new();
@@ -284,18 +284,18 @@ private static int RunFastForEach(ExtensionsLibrary library)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>RunFilter</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunFilter</c> result.</returns>
+    /// <summary>Filters the string source by the even-digit regex.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunFilter(ExtensionsLibrary library) =>
         DrainString(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.Filter(PrimitivesExtensions.FromArray(StringValues), EvenRegex())
             : PackageExtensions.Filter(PackageExtensions.FromArray(StringValues), EvenRegex()));
 
-    /// <summary>Executes the <c>RunFirstMatchFromCandidates</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunFirstMatchFromCandidates</c> result.</returns>
+    /// <summary>Probes candidate values and takes the first that clears the match threshold.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunFirstMatchFromCandidates(ExtensionsLibrary library)
     {
         var candidates = Values;
@@ -314,9 +314,9 @@ private static int RunFirstMatchFromCandidates(ExtensionsLibrary library)
                 Fallback));
     }
 
-    /// <summary>Executes the <c>RunForEach</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunForEach</c> result.</returns>
+    /// <summary>Flattens a single batch of values through ForEach.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunForEach(ExtensionsLibrary library)
     {
         int[][] batches = [Values];
@@ -325,15 +325,15 @@ private static int RunForEach(ExtensionsLibrary library)
             : PackageExtensions.ForEach(PackageExtensions.FromArray<IEnumerable<int>>(batches), null));
     }
 
-    /// <summary>Executes the <c>RunFromArray</c> benchmark helper.</summary>
-    /// <param name="library)">The <c>library)</c> value.</param>
-    /// <returns>The <c>RunFromArray</c> result.</returns>
+    /// <summary>Drains the shared int array through the library's FromArray.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunFromArray(ExtensionsLibrary library) => DrainInt(ArraySource(library));
 
-    /// <summary>Executes the <c>RunGetMax</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunGetMax</c> result.</returns>
+    /// <summary>Combines two scalar sources into their maximum.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunGetMax(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -344,9 +344,9 @@ private static int RunGetMax(ExtensionsLibrary library) =>
                 PackageObservables.Return(FirstValue),
                 PackageObservables.Return(SecondValue)));
 
-    /// <summary>Executes the <c>RunGetMin</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunGetMin</c> result.</returns>
+    /// <summary>Combines two scalar sources into their minimum.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunGetMin(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -357,9 +357,9 @@ private static int RunGetMin(ExtensionsLibrary library) =>
                 PackageObservables.Return(FirstValue),
                 PackageObservables.Return(SecondValue)));
 
-    /// <summary>Executes the <c>RunHeartbeat</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunHeartbeat</c> result.</returns>
+    /// <summary>Advances virtual time over a silent source to emit a heartbeat.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunHeartbeat(ExtensionsLibrary library)
     {
         if (library == ExtensionsLibrary.Primitives)
@@ -380,18 +380,18 @@ private static int RunHeartbeat(ExtensionsLibrary library)
         return packageObserver.Count + packageObserver.CompletionCount;
     }
 
-    /// <summary>Executes the <c>RunLatestOrDefault</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunLatestOrDefault</c> result.</returns>
+    /// <summary>Reads the latest value of the array source, falling back when it has none.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunLatestOrDefault(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.LatestOrDefault(ArraySource(library), Fallback)
             : PackageExtensions.LatestOrDefault(ArraySource(library), Fallback));
 
-    /// <summary>Executes the <c>RunLogErrors</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunLogErrors</c> result.</returns>
+    /// <summary>Wraps the array source in the error-logging operator and drains it.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunLogErrors(ExtensionsLibrary library)
     {
         var errors = 0;
@@ -401,36 +401,36 @@ private static int RunLogErrors(ExtensionsLibrary library)
         return total + errors;
     }
 
-    /// <summary>Executes the <c>RunNot</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunNot</c> result.</returns>
+    /// <summary>Negates each boolean emitted by the boolean source.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunNot(ExtensionsLibrary library) =>
         DrainBool(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.Not(BoolSource(library))
             : PackageExtensions.Not(BoolSource(library)));
 
-    /// <summary>Executes the <c>RunObserveOnIf</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunObserveOnIf</c> result.</returns>
+    /// <summary>Conditionally reschedules the array source onto an immediate scheduler.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunObserveOnIf(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ObserveOnIf(ArraySource(library), true, Sequencer.Immediate)
             : PackageExtensions.ObserveOnIf(ArraySource(library), true, ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunObserveOnSafe</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunObserveOnSafe</c> result.</returns>
+    /// <summary>Reschedules the array source onto an immediate scheduler with error isolation.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunObserveOnSafe(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
             ? PrimitivesExtensions.ObserveOnSafe(ArraySource(library), Sequencer.Immediate)
             : PackageExtensions.ObserveOnSafe(ArraySource(library), ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunOnErrorRetry</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunOnErrorRetry</c> result.</returns>
+    /// <summary>Retries the array source once on a typed failure with no delay.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int RunOnErrorRetry(ExtensionsLibrary library) =>
         DrainInt(library == ExtensionsLibrary.Primitives
@@ -447,9 +447,9 @@ private static int RunOnErrorRetry(ExtensionsLibrary library) =>
                 TimeSpan.Zero,
                 ImmediateScheduler.Instance));
 
-    /// <summary>Executes the <c>RunOnNext</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunOnNext</c> result.</returns>
+    /// <summary>Pushes the shared array into an observer one value at a time.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunOnNext(ExtensionsLibrary library)
     {
         IntSignalWitness observer = new();
@@ -465,9 +465,9 @@ private static int RunOnNext(ExtensionsLibrary library)
         return observer.Total;
     }
 
-    /// <summary>Executes the <c>RunPairwise</c> benchmark helper.</summary>
-    /// <param name="library">The <c>library</c> value.</param>
-    /// <returns>The <c>RunPairwise</c> result.</returns>
+    /// <summary>Pairs each value of the array source with its predecessor.</summary>
+    /// <param name="library">The library implementation to exercise.</param>
+    /// <returns>The scenario checksum.</returns>
     private static int RunPairwise(ExtensionsLibrary library)
     {
         PairWitness observer = new();
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
index e89003d2..837bff4d 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorDriverBenchmarks.cs
@@ -10,8 +10,7 @@
 
 namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 
-/// <summary>What the observable-event generator itself costs on a build and on a keystroke.</summary>
-/// <remarks>Measures generator execution for cold, unchanged, unrelated-edit, and event-edit inputs, excluding compilation updates.</remarks>
+/// <summary>Generator execution for cold, unchanged, unrelated-edit, and event-edit inputs, excluding compilation updates.</summary>
 [System.Diagnostics.DebuggerDisplay("EventGeneratorDriverBenchmarks: {Size}")]
 [SimpleJob(warmupCount: 5, iterationCount: 15)]
 [EventPipeProfiler(EventPipeProfile.CpuSampling)]
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
index 860acf58..e17f17a8 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/EventGeneratorGcProfileBenchmarks.cs
@@ -14,7 +14,6 @@ namespace ReactiveUI.Primitives.ObservableEvents.Benchmarks;
 /// Allocation baselines for the generator's cold and incremental runs, with a GC-verbose trace naming the frames
 /// the allocations come from. Opt in with <c>--filter "*GcProfile*"</c>.
 /// </summary>
-/// <remarks>Profiles allocation call stacks for the largest event corpus.</remarks>
 [ShortRunJob]
 [EventPipeProfiler(EventPipeProfile.GcVerbose)]
 [System.Diagnostics.DebuggerDisplay("EventGeneratorGcProfileBenchmarks: {nameof(EventGeneratorGcProfileBenchmarks),nq}")]
diff --git a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
index 9bc12082..52ec1eed 100644
--- a/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.ObservableEvents.Benchmarks/GeneratorHarness.cs
@@ -36,14 +36,14 @@ internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateCo
 
     /// <summary>Runs the generator with unchanged inputs to measure cache reuse.</summary>
     /// <param name="size">The corpus size.</param>
-    /// <returns>The unchanged compilation and a driver that has already generated once.</returns>
+    /// <returns>The unchanged compilation and the primed driver.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUnchangedState(CorpusSize size) =>
         RunOnce(size);
 
     /// <summary>Runs the generator after editing a file unrelated to event activation.</summary>
     /// <param name="size">The corpus size.</param>
-    /// <returns>The edited compilation and a driver that has already generated once.</returns>
+    /// <returns>The edited compilation and the primed driver.</returns>
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUnrelatedEditState(CorpusSize size)
     {
         var primed = RunOnce(size);
@@ -54,7 +54,7 @@ internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateUn
 
     /// <summary>Runs the generator after changing one host's event declarations.</summary>
     /// <param name="size">The corpus size.</param>
-    /// <returns>The edited compilation and a driver that has already generated once.</returns>
+    /// <returns>The edited compilation and the primed driver.</returns>
     internal static (Compilation Compilation, CSharpGeneratorDriver Driver) CreateEventEditState(CorpusSize size)
     {
         var primed = RunOnce(size);
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
index 8a49dcb4..9e4f2578 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableBagTests.cs
@@ -108,7 +108,7 @@ public async Task WhenAddAfterDispose_ThenSuppliedDisposableDisposedImmediately(
         await Assert.That(late.DisposeCount).IsEqualTo(1);
     }
 
-    /// <summary>Tracking disposable used to count dispose invocations.</summary>
+    /// <summary>Tracking disposable that counts its dispose invocations.</summary>
     private sealed class CountedDisposable : IDisposable
     {
         /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
diff --git a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
index 21593a7d..5f4dccdf 100644
--- a/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
+++ b/src/tests/ReactiveUI.Disposables.Tests/DisposableSlotHelperTests.cs
@@ -134,7 +134,7 @@ public async Task WhenAssignmentCompletesBeforeDisposal_ThenRetainsStoredValue()
         await Assert.That(incoming.DisposeCount).IsEqualTo(0);
     }
 
-    /// <summary>Disposable used to verify dispose counts.</summary>
+    /// <summary>Disposable that records its dispose count.</summary>
     private sealed class CountingDisposable : IDisposable
     {
         /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/ReactiveAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/ReactiveAsyncTests.cs
index 5f7c0cdc..89a50c7d 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/ReactiveAsyncTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/ReactiveAsyncTests.cs
@@ -7,13 +7,13 @@
 
 namespace ReactiveUI.Primitives.Async.Reactive.Tests;
 
-/// <summary>Smoke tests confirming the Reactive async leaf's recompiled shared source behaves correctly.</summary>
+/// <summary>Smoke tests for the shared async source as recompiled into the Reactive async leaf.</summary>
 public class ReactiveAsyncTests
 {
     /// <summary>Sentinel value used by the tests.</summary>
     private const int Sentinel = 42;
 
-    /// <summary>The Core engine compiled into the leaf still emits values through the async subscribe path.</summary>
+    /// <summary>The Core engine compiled into the leaf emits values through the async subscribe path.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task Return_EmitsValueAndCompletes()
diff --git a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
index ea249eb9..75d08830 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerSchedulingTests.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Reactive.Tests;
 
-/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
+/// <summary>Tests the scheduling overloads the seam adds to a System.Reactive scheduler.</summary>
 public class SequencerSchedulingTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -15,11 +15,12 @@ public class SequencerSchedulingTests
     /// <summary>How many times the recursive overload reschedules itself before it stops.</summary>
     private const int ExpectedRecursiveRuns = 3;
 
+    // Fully qualified: an unqualified IScheduler makes the seam's overloads ambiguous with System.Reactive's own.
     /// <summary>The scheduler the seam forwards to, typed as the interface the seam extends.</summary>
     private static readonly System.Reactive.Concurrency.IScheduler InlineScheduler =
         System.Reactive.Concurrency.ImmediateScheduler.Instance;
 
-    /// <summary>A due time that has already passed, so absolute scheduling runs inline.</summary>
+    /// <summary>A due time in the past, so absolute scheduling runs inline.</summary>
     private static readonly DateTimeOffset ElapsedDueTime = DateTimeOffset.UnixEpoch;
 
     /// <summary>Verifies the plain action overload runs the action on the scheduler.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerTests.cs b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerTests.cs
index a5ebfc8b..db937fd1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Reactive.Tests/SequencerTests.cs
@@ -6,7 +6,7 @@
 
 namespace ReactiveUI.Primitives.Async.Reactive.Tests;
 
-/// <summary>Verifies sequencers.</summary>
+/// <summary>Verifies each built-in sequencer maps onto its System.Reactive scheduler and that interval normalization forwards.</summary>
 public class SequencerTests
 {
     /// <summary>A negative interval, which normalization clamps to zero.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
index 848021d7..185a5880 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
@@ -8,13 +8,10 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>Tests for CombineLatestOperatorTests.</summary>
+/// <summary>Tests the enumerable <c>CombineLatest</c> overload's disposal and completion guards.</summary>
 public partial class CombineLatestOperatorTests
 {
-    /// <summary>
-    /// Tests CombineLatest enumerable returns early from SubscribeAsync when disposed during subscribe,
-    /// exercising the early return path in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that emitting after an immediate dispose completes without error.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableDisposedDuringSubscribe_ThenReturnsEarly()
@@ -26,17 +23,12 @@ public async Task WhenCombineLatestEnumerableDisposedDuringSubscribe_ThenReturns
             static (_, _) => default,
             null);
 
-        // Dispose immediately, before any values
         await sub.DisposeAsync();
 
-        // Emit after dispose - should be ignored
         await signal.OnNextAsync(1, CancellationToken.None);
     }
 
-    /// <summary>
-    /// Tests CombineLatest enumerable OnNextAsync returns early when disposed,
-    /// exercising the OnNextAsync disposed guard in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that values pushed by either source after disposal are not forwarded.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenIgnored()
@@ -58,17 +50,13 @@ public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenIgnored()
 
         await sub.DisposeAsync();
 
-        // These should be ignored
         await signal1.OnNextAsync(1, CancellationToken.None);
         await signal2.OnNextAsync(SecondSignalValue, CancellationToken.None);
 
         await Assert.That(items).IsEmpty();
     }
 
-    /// <summary>
-    /// Tests CombineLatest enumerable OnErrorResumeAsync returns early when disposed,
-    /// exercising the OnErrorResumeAsync disposed guard in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that an error resumed after disposal is not forwarded.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenIgnored()
@@ -88,16 +76,12 @@ public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenIgnor
 
         await sub.DisposeAsync();
 
-        // Error after dispose should be ignored
         await signal.OnErrorResumeAsync(new InvalidOperationException("err"), CancellationToken.None);
 
         await Assert.That(errors).IsEmpty();
     }
 
-    /// <summary>
-    /// Tests CombineLatest enumerable OnCompletedAsync returns early when already completed for same index,
-    /// exercising the already-completed guard in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that a source completing after disposal forwards no completion.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableAlreadyDisposed_ThenOnCompletedIgnored()
@@ -117,20 +101,14 @@ public async Task WhenCombineLatestEnumerableAlreadyDisposed_ThenOnCompletedIgno
                 return default;
             });
 
-        // Dispose first
         await sub.DisposeAsync();
 
-        // Complete after dispose - should be ignored
         await signal1.OnCompletedAsync(Result.Success);
 
-        // No extra completion should have been forwarded since we disposed
         await Assert.That(completion).IsNull();
     }
 
-    /// <summary>
-    /// Tests CombineLatest enumerable completes when a source completes without emitting a value,
-    /// exercising the shouldComplete path in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that an empty source completes the combined sequence during subscription.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCompletes()
@@ -156,10 +134,7 @@ public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCom
         await Assert.That(completion!.Value.IsSuccess).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that CombineLatestEnumerable OnNextAsync returns early when disposed.
-    /// Uses the blocking-OnCompletedAsync technique to keep the gate alive while _disposed is set.
-    /// </summary>
+    /// <summary>Verifies that a value arriving while the subscription tears down is dropped.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenReturnsEarly()
@@ -185,15 +160,13 @@ public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenReturnsEarly
                     await allowCompletion.Task;
                 });
 
-        // Set up initial values
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
 
-        // Trigger failure on src1 → FinishAsync → _disposed=1 → blocks on OnCompletedAsync
+        // Blocking inside the completion handler parks the subscription mid-teardown.
         var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
-        // _disposed is 1, gate still alive → OnNextAsync should hit the guard
         await src2.EmitNext(SentinelValue);
 
         await Assert.That(items).Count().IsEqualTo(1);
@@ -202,7 +175,7 @@ public async Task WhenCombineLatestEnumerableOnNextAfterDispose_ThenReturnsEarly
         await failTask;
     }
 
-    /// <summary>Verifies that CombineLatestEnumerable OnErrorResumeAsync returns early when disposed.</summary>
+    /// <summary>Verifies that an error arriving while the subscription tears down is dropped.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenReturnsEarly()
@@ -231,10 +204,10 @@ public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenRetur
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
 
+        // Blocking inside the completion handler parks the subscription mid-teardown.
         var failTask = src1.Complete(Result.Failure(new InvalidOperationException("test")));
         await completionBlocked.Task;
 
-        // _disposed is 1, gate still alive → OnErrorResumeAsync should hit the guard
         await src2.EmitError(new InvalidOperationException("post-dispose error"));
 
         await Assert.That(errors).IsEmpty();
@@ -243,7 +216,7 @@ public async Task WhenCombineLatestEnumerableOnErrorResumeAfterDispose_ThenRetur
         await failTask;
     }
 
-    /// <summary>Verifies that CombineLatestEnumerable OnCompleted returns early for an already-completed index.</summary>
+    /// <summary>Verifies that completing a source twice yields a single overall completion.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableDoubleComplete_ThenSecondIsIgnored()
@@ -266,19 +239,14 @@ public async Task WhenCombineLatestEnumerableDoubleComplete_ThenSecondIsIgnored(
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
 
-        // Complete src1 (has emitted, src2 still active → no overall completion)
         await src1.Complete(Result.Success);
-
-        // Complete src1 again - already completed[0] = true, returns early
         await src1.Complete(Result.Success);
-
-        // Now complete src2 → overall completion
         await src2.Complete(Result.Success);
 
         await Assert.That(completionCount).IsEqualTo(1);
     }
 
-    /// <summary>Verifies that CombineLatestEnumerable completes when a source completes without emitting.</summary>
+    /// <summary>Verifies that a source completing without a value completes the sequence at once.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCompletesImmediately()
@@ -298,14 +266,13 @@ public async Task WhenCombineLatestEnumerableSourceCompletesWithoutValue_ThenCom
                     return default;
                 });
 
-        // src1 completes without ever emitting, so shouldComplete = !_values[0].HasValue = true
         await src1.Complete(Result.Success);
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
 
-    /// <summary>Verifies that CombineLatestEnumerable returns early when disposed during subscribe loop.</summary>
+    /// <summary>Verifies that cancelling mid-subscribe throws and leaves later sources unsubscribed.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableDisposedDuringSubscribeLoop_ThenReturnsEarly()
@@ -335,27 +302,19 @@ public async Task WhenCombineLatestEnumerableDisposedDuringSubscribeLoop_ThenRet
         await Assert.That(normalSubscribed).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies that SubscribeAsync bails out of the source subscription loop when an
-    /// earlier source completes without emitting (triggering overall completion and
-    /// cancelling the dispose CTS) before remaining sources are subscribed,
-    /// covering the early-return guard in CombineLatestEnumerable.SubscribeAsync.
-    /// </summary>
+    /// <summary>Verifies that a first source completing during subscribe skips subscribing the rest.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableFirstSourceCompletesImmediately_ThenSkipsRemainingSubscriptions()
     {
         var secondSourceSubscribed = false;
 
-        // Second source records whether it was ever subscribed.
         var trackingSource = AsyncObs.Create<int>((_, _) =>
         {
             secondSourceSubscribed = true;
             return new(DisposableAsync.Empty);
         });
 
-        // Empty completes immediately during subscribe, triggering overall completion
-        // before the loop reaches the second source.
         IObservableAsync<int>[] sources = [AsyncObs.Empty<int>(), trackingSource];
 
         await using var sub = await sources.CombineLatest()
@@ -364,11 +323,7 @@ public async Task WhenCombineLatestEnumerableFirstSourceCompletesImmediately_The
         await Assert.That(secondSourceSubscribed).IsFalse();
     }
 
-    /// <summary>
-    /// Verifies that OnCompletedAsync returns early when the same source index completes
-    /// a second time while the subscription is still active (the _completed[index] guard),
-    /// covering line 268 in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that a repeated completion from one of three sources is not counted twice.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableSameSourceCompletedTwice_ThenSecondCompletionIsIgnored()
@@ -389,31 +344,22 @@ public async Task WhenCombineLatestEnumerableSameSourceCompletedTwice_ThenSecond
                     return default;
                 });
 
-        // All sources emit so _values[i].HasValue is true for all.
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
         await src3.EmitNext(Source2Value);
 
-        // src1 completes: _completed[0]=true, completedCount=1 (not 3), shouldComplete=false.
         await src1.Complete(Result.Success);
-
-        // src1 completes again: _completed[0] is already true, returns early (line 268).
         await src1.Complete(Result.Success);
 
         await Assert.That(completionCount).IsEqualTo(0);
 
-        // Finish: complete remaining sources so the subscription terminates cleanly.
         await src2.Complete(Result.Success);
         await src3.Complete(Result.Success);
 
         await Assert.That(completionCount).IsEqualTo(1);
     }
 
-    /// <summary>
-    /// Verifies that OnCompletedAsync takes the non-completing path (shouldComplete=false)
-    /// when a source that has already emitted a value completes while other sources remain active,
-    /// covering line 277 in CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that a completed source that had emitted keeps the sequence open while others run.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableSourceWithValueCompletes_ThenDoesNotCompleteUntilAllDone()
@@ -442,37 +388,29 @@ public async Task WhenCombineLatestEnumerableSourceWithValueCompletes_ThenDoesNo
                     return default;
                 });
 
-        // Both emit so _values[i].HasValue is true for both.
         await src1.EmitNext(Src1FirstValue);
         await src2.EmitNext(Src2FirstValue);
 
         await Assert.That(emissions).Count().IsEqualTo(1);
 
-        // src1 completes: _values[0].HasValue=true, completedCount=1 (not 2) → shouldComplete=false (line 277).
         await src1.Complete(Result.Success);
 
-        // Subscription is still active because shouldComplete was false.
         await Assert.That(completionResult).IsNull();
 
-        // src2 can still emit and combine with src1's last value.
+        // src2 combines against the last value of the completed src1.
         await src2.EmitNext(Src2SecondValue);
 
         await Assert.That(emissions).Count().IsEqualTo(ExpectedEmissions);
         await Assert.That(emissions[1][0]).IsEqualTo(Src1FirstValue);
         await Assert.That(emissions[1][1]).IsEqualTo(Src2SecondValue);
 
-        // Complete src2 → all sources completed, shouldComplete=true.
         await src2.Complete(Result.Success);
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that OnCompletedAsync returns early without incrementing the completed count
-    /// when the same source index has already completed, exercising the _completed[index] guard
-    /// on line 268 of CombineLatestEnumerable with a single additional source still active.
-    /// </summary>
+    /// <summary>Verifies that a repeated completion leaves the remaining source free to emit.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task
@@ -500,42 +438,32 @@ public async Task
                     return default;
                 });
 
-        // Both sources emit so all _values have values.
         await src1.EmitNext(1);
         await src2.EmitNext(Source1Value);
 
         await Assert.That(emissions).Count().IsEqualTo(1);
 
-        // src1 completes: _completed[0]=true, completedCount=1, shouldComplete=false.
         await src1.Complete(Result.Success);
 
         await Assert.That(completionResult).IsNull();
 
-        // Duplicate completion for index 0: _completed[0] is already true, returns default (line 268).
         await src1.Complete(Result.Success);
 
-        // Still no overall completion because src2 hasn't completed.
         await Assert.That(completionResult).IsNull();
 
-        // src2 can still emit; the duplicate completion did not corrupt state.
         await src2.EmitNext(Src2LateValue);
 
         await Assert.That(emissions).Count().IsEqualTo(ExpectedEmissions);
         await Assert.That(emissions[1][0]).IsEqualTo(1);
         await Assert.That(emissions[1][1]).IsEqualTo(Src2LateValue);
 
-        // Clean termination.
         await src2.Complete(Result.Success);
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
     }
 
-    /// <summary>
-    /// Verifies that when one source in a three-source CombineLatest completes without ever
-    /// emitting a value, the shouldComplete path triggers immediate completion and the remaining
-    /// sources are torn down, exercising line 277 of CombineLatestEnumerable.
-    /// </summary>
+    /// <summary>Verifies that a middle source completing without a value completes the sequence with no snapshot.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCombineLatestEnumerableMiddleSourceCompletesWithoutEmitting_ThenCompletesImmediately()
@@ -563,20 +491,16 @@ public async Task WhenCombineLatestEnumerableMiddleSourceCompletesWithoutEmittin
                     return default;
                 });
 
-        // src1 and src3 emit, but src2 never emits.
         await src1.EmitNext(Src1Value);
         await src3.EmitNext(Src3Value);
 
-        // No snapshot yet because src2 has not emitted.
         await Assert.That(emissions).IsEmpty();
 
-        // src2 completes without emitting: !_values[1].HasValue is true → shouldComplete=true (line 277).
         await src2.Complete(Result.Success);
 
         await Assert.That(completionResult).IsNotNull();
         await Assert.That(completionResult!.Value.IsSuccess).IsTrue();
 
-        // No snapshots were ever emitted because not all sources had values.
         await Assert.That(emissions).IsEmpty();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
index f6bf6180..10f17454 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
@@ -14,7 +14,7 @@ namespace ReactiveUI.Primitives.Blazor.Reactive.Tests;
 /// <summary>Tests for <see cref="BlazorRendererSequencer"/> as an <see cref="IScheduler"/> driven through a fake renderer delegate.</summary>
 public sealed class BlazorRendererSequencerTests
 {
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Verifies the constructor rejects a null renderer delegate.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
index 75b30157..73accb15 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/CoalescingDispatchSchedulerTests.cs
@@ -122,7 +122,7 @@ public async Task RequestingADrainWithNothingQueuedPostsNothing()
         await Assert.That(scheduler.PostCount).IsEqualTo(0);
     }
 
-    /// <summary>A second schedule coalesces onto the drain already posted for the first.</summary>
+    /// <summary>A second schedule coalesces onto the drain posted for the first.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ASecondScheduleCoalescesOntoThePendingDrain()
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
index d3efac81..5918118b 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
@@ -14,7 +14,7 @@ namespace ReactiveUI.Primitives.Blazor.Tests;
 /// <summary>Tests for <see cref="BlazorRendererSequencer"/> driven through a fake renderer delegate.</summary>
 public sealed class BlazorRendererSequencerTests
 {
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Verifies the constructor rejects a null renderer delegate.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
index 96d266ab..beb81f7f 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
@@ -11,12 +11,7 @@
 
 namespace ReactiveUI.Primitives.Blazor.Tests;
 
-/// <summary>
-/// Tests for <see cref="ReactiveComponentBase"/>'s observation, refresh, and disposal behaviour. Each test
-/// attaches the component to an <see cref="HtmlRenderer"/> so its renderer-dispatcher-bound work (the guarded
-/// invoke and <c>StateHasChanged</c>) actually runs, and drives the source on the dispatcher so the
-/// notifications complete synchronously.
-/// </summary>
+/// <summary>Tests <see cref="ReactiveComponentBase"/> observation, refresh, and disposal against a component attached to an <see cref="HtmlRenderer"/>.</summary>
 public sealed class ReactiveComponentBaseTests
 {
     /// <summary>The first value pushed to a source.</summary>
@@ -99,7 +94,7 @@ await harness.Dispatcher.InvokeAsync(() =>
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies suppressing the refresh still delivers the value.</summary>
+    /// <summary>Verifies an observation with the refresh suppressed delivers the value to the callback.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ObservationWithoutRefreshStillDeliversTheValue()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/ReactiveExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/ReactiveExtensionsTests.cs
index 1cc313d7..e8866e14 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/ReactiveExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/ReactiveExtensionsTests.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Reactive.Tests;
 
-/// <summary>Smoke tests confirming the Reactive Extensions leaf's recompiled shared operators behave correctly.</summary>
+/// <summary>Smoke tests for the shared operators as recompiled into the Reactive Extensions leaf.</summary>
 public class ReactiveExtensionsTests
 {
     /// <summary>Value pushed through the signal conversion; only its type is asserted.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
index 2307fcc2..1e715cac 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/SequencerSchedulingExtensionsTests.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Reactive.Tests;
 
-/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
+/// <summary>Tests the scheduling overloads the seam adds to a System.Reactive scheduler.</summary>
 public class SequencerSchedulingExtensionsTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -19,11 +19,12 @@ public class SequencerSchedulingExtensionsTests
     /// <summary>How many times the recursive overload reschedules itself before it stops.</summary>
     private const int ExpectedRecursiveRuns = 3;
 
+    // Fully qualified: an unqualified IScheduler makes the seam's overloads ambiguous with System.Reactive's own.
     /// <summary>The scheduler the seam forwards to, typed as the interface the seam extends.</summary>
     private static readonly System.Reactive.Concurrency.IScheduler InlineScheduler =
         System.Reactive.Concurrency.ImmediateScheduler.Instance;
 
-    /// <summary>A due time that has already passed, so absolute scheduling runs inline.</summary>
+    /// <summary>A due time in the past, so absolute scheduling runs inline.</summary>
     private static readonly DateTimeOffset ElapsedDueTime = DateTimeOffset.UnixEpoch;
 
     /// <summary>The state both stateful overloads must hand back, once each.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs
index 89feb006..e5be3ec6 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs
@@ -20,10 +20,8 @@ internal static class AotSafeAssertionExtensions
         where TCollection : IEnumerable<TItem>
     {
         /// <summary>
-        /// Asserts the collection is equivalent to <paramref name="expected"/>
-        /// using the element type's default <see cref="EqualityComparer{T}"/>
-        /// (order-insensitive, mirroring <c>IsEquivalentTo</c>'s default
-        /// <see cref="CollectionOrdering.Any"/>).
+        /// Asserts the collection is equivalent to <paramref name="expected"/>, order-insensitively
+        /// (<see cref="CollectionOrdering.Any"/>), using the element type's default <see cref="EqualityComparer{T}"/>.
         /// </summary>
         /// <param name="expected">The expected element sequence.</param>
         /// <returns>The chained collection-equivalency assertion.</returns>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
index 16fc6902..58a3cf80 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
@@ -6,12 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
-/// <summary>Tests for <see cref="Continuation"/> — the phase-barrier lock used to serialise emissions,
-/// covering both the <see cref="Continuation.Lock{T}"/> (Task) and <see cref="Continuation.LockValueTask{T}"/>
-/// (ValueTask) entry points plus the already-locked short-circuit.</summary>
+/// <summary>Tests for <see cref="Continuation"/>, the phase-barrier lock that serialises emissions.</summary>
 public class ContinuationTests
 {
-    /// <summary>Item pushed while the continuation is already locked; the barrier is expected to drop it.</summary>
+    /// <summary>Item pushed while the continuation holds the lock, which the barrier drops.</summary>
     private const int DroppedItem = 2;
 
     /// <summary>Verifies <see cref="Continuation.LockValueTask{T}"/> pushes the item downstream, locks, and completes once the phase is signalled by an unlock.</summary>
@@ -34,7 +32,7 @@ public async Task WhenLockValueTaskNotLocked_ThenEmitsAndCompletesOnUnlock()
         await Assert.That(continuation.CompletedPhases).IsGreaterThanOrEqualTo(1);
     }
 
-    /// <summary>Verifies a second <see cref="Continuation.LockValueTask{T}"/> while already locked returns a completed default value task and does not push the item downstream.</summary>
+    /// <summary>Verifies a second <see cref="Continuation.LockValueTask{T}"/> taken under the lock returns a completed default value task and drops the item.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenLockValueTaskAlreadyLocked_ThenReturnsDefaultAndDropsItem()
@@ -75,7 +73,7 @@ public async Task WhenLockNotLocked_ThenEmitsAndCompletesOnUnlock()
         await Assert.That(values.Count).IsEqualTo(1);
     }
 
-    /// <summary>Verifies a second <see cref="Continuation.Lock{T}"/> while already locked returns a completed task and drops the item.</summary>
+    /// <summary>Verifies a second <see cref="Continuation.Lock{T}"/> taken under the lock returns a completed task and drops the item.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenLockAlreadyLocked_ThenReturnsCompletedAndDropsItem()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
index 2c0d3058..f9b36e89 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
@@ -49,8 +49,7 @@ public async Task WhenMiddleObserverDisposed_ThenOthersStillReceive()
         await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
     }
 
-    /// <summary>Verifies that going from two observers back to one collapses to the
-    /// single-observer fast path while still broadcasting correctly.</summary>
+    /// <summary>Verifies the surviving observer keeps receiving after the second of two is disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSecondObserverDisposedFromPair_ThenSingleObserverStillReceives()
@@ -67,9 +66,7 @@ public async Task WhenSecondObserverDisposedFromPair_ThenSingleObserverStillRece
         await Assert.That(b).IsCollectionEqualTo([MultiInitialValue]);
     }
 
-    /// <summary>Disposing the first observer of a 2-observer subject exercises Unsubscribe's
-    /// <c>index == 0 ? existing[1] : existing[0]</c> ternary on the true branch — the surviving
-    /// observer collapses back to the single-observer fast path.</summary>
+    /// <summary>Verifies the surviving observer keeps receiving after the first of two is disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenFirstObserverOfPairDisposed_ThenSingleSurvivorReceives()
@@ -81,16 +78,13 @@ public async Task WhenFirstObserverOfPairDisposed_ThenSingleSurvivorReceives()
         var subA = subject.Subscribe(a.Add);
         using var subB = subject.Subscribe(b.Add);
 
-        // Dispose subA from the two-observer array; Unsubscribe's `index == 0 ? existing[1] : existing[0]`
-        // ternary picks the true branch, collapsing _observer to subB.
         subA.Dispose();
         subject.OnNext(Update);
         await Assert.That(a).IsCollectionEqualTo([MultiInitialValue]);
         await Assert.That(b).IsCollectionEqualTo([MultiInitialValue, Update]);
     }
 
-    /// <summary>Verifies that disposing the first observer of a 3-observer subject works
-    /// (collapse exercises the index==0 branch of the shrink path).</summary>
+    /// <summary>Verifies the remaining two observers keep receiving after the first of three is disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenFirstObserverDisposed_ThenOthersStillReceive()
@@ -110,8 +104,7 @@ public async Task WhenFirstObserverDisposed_ThenOthersStillReceive()
         await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
     }
 
-    /// <summary>Verifies that disposing the last observer of a 3-observer subject works
-    /// (collapse exercises the tail-only branch of the shrink path).</summary>
+    /// <summary>Verifies the remaining two observers keep receiving after the last of three is disposed.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenLastObserverDisposed_ThenOthersStillReceive()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs
index d524226b..ebe71ba8 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs
@@ -101,7 +101,7 @@ public async Task WhenOnCompleted_ThenObserversReceiveCompletion()
         await Assert.That(completedFirst).IsTrue();
         await Assert.That(completedLate).IsTrue();
 
-        // Late subscriber still sees the replayed value before completion.
+        // A late subscriber receives the replayed value ahead of the completion.
         await Assert.That(lateValues).IsCollectionEqualTo([InitialValue]);
     }
 
@@ -152,7 +152,7 @@ public async Task WhenSubscribeAfterDispose_ThenObjectDisposedExceptionDelivered
         await Assert.That(error).IsTypeOf<ObjectDisposedException>();
     }
 
-    /// <summary>Verifies that AsObservable returns a hide-the-observer view that still delivers values.</summary>
+    /// <summary>Verifies that AsObservable returns a hide-the-observer view that delivers values.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsObservable_ThenDeliversValuesButHidesObserverApi()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs
index 0021d708..296cefe0 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Tests;
 /// <summary>Tests disposable extensions.</summary>
 public class DisposableExtensionsTests
 {
-    /// <summary>Tests DisposeWith returns a disposable.</summary>
+    /// <summary>Verifies <c>DisposeWith</c> throws when the composite it is handed is null.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task GivenNull_WhenDisposeWith_ThenExceptionThrown()
@@ -26,7 +26,7 @@ public async Task GivenNull_WhenDisposeWith_ThenExceptionThrown()
         await Assert.That(result).IsTypeOf<ArgumentNullException>();
     }
 
-    /// <summary>Tests DisposeWith disposes the underlying disposable.</summary>
+    /// <summary>Verifies disposing the composite disposes everything added to it with <c>DisposeWith</c>.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task GivenDisposable_WhenDisposeWith_ThenDisposed()
@@ -43,7 +43,7 @@ public async Task GivenDisposable_WhenDisposeWith_ThenDisposed()
         await Assert.That(sut.IsDisposed).IsTrue();
     }
 
-    /// <summary>Tests DisposeWith returns the original disposable.</summary>
+    /// <summary>Verifies <c>DisposeWith</c> returns the disposable it was called on.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task GivenDisposable_WhenDisposeWith_ThenReturnsDisposable()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs
index 66ff1004..11f55862 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs
@@ -6,8 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
 
-/// <summary>Direct RxVoid tests for <see cref="ConcurrencyRaceHelpers"/> — both race-claim
-/// primitives are pure functions over their inputs and every branch is exercised here.</summary>
+/// <summary>Tests for <see cref="ConcurrencyRaceHelpers"/>, the race-claim primitives.</summary>
 public class ConcurrencyRaceHelpersTests
 {
     /// <summary>Sentinel for the "not yet claimed" state in the tests.</summary>
@@ -29,7 +28,7 @@ public async Task WhenTryClaimOpen_ThenReturnsTrueAndTransitions()
         await Assert.That(state).IsEqualTo(Claimed);
     }
 
-    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryClaim"/> returns false when the state is already claimed and does not mutate it further.</summary>
+    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryClaim"/> returns false against a claimed state and leaves it unchanged.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenTryClaimAlreadyClaimed_ThenReturnsFalse()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs
index 8a8df817..1571fcb6 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs
@@ -9,7 +9,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
 
-/// <summary>Tests for <see cref = "FirstAsTaskHelper"/> covering the error and empty-completion paths that <c>ToHotTask</c> does not otherwise exercise.</summary>
+/// <summary>Tests for <see cref = "FirstAsTaskHelper"/>, the first-value task bridge.</summary>
 public class FirstAsTaskHelperTests
 {
     /// <summary>Message of an error the helper is expected to drop.</summary>
@@ -60,11 +60,7 @@ public async Task WhenSourceEmitsMultiple_ThenTaskCompletesWithFirst()
     public void WhenSourceNull_ThenThrowsArgumentNullException() =>
         Assert.Throws<ArgumentNullException>(static () => FirstAsTaskHelper.FirstAsTask<int>(null!));
 
-    /// <summary>Exercises the <c>Subscription?.Dispose()</c> null-conditional branch on
-    /// <c>FirstWitness.OnNext</c> — a source that synchronously emits during <c>Subscribe</c>
-    /// (such as <see cref = "Observable.Return{T}(T)"/>) fires <c>OnNext</c> before
-    /// <c>FirstAsTask</c> can assign the <c>Subscription</c> property, so the latch-and-cleanup
-    /// path sees <c>Subscription == null</c> and the conditional dispose becomes a no-op.</summary>
+    /// <summary>Verifies a source that emits during <c>Subscribe</c>, before the subscription handle exists, completes the task with that value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
@@ -74,7 +70,7 @@ public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
         await Assert.That(await task).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies emissions arriving after the task has already settled are silently ignored.</summary>
+    /// <summary>Verifies emissions arriving after the task settles are silently ignored.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSubjectErrorsThenLaterEvents_ThenLaterEventsIgnored()
@@ -89,8 +85,7 @@ public async Task WhenSubjectErrorsThenLaterEvents_ThenLaterEventsIgnored()
         await Assert.That(ex).IsSameReferenceAs(expected);
     }
 
-    /// <summary>Verifies that a second <c>OnNext</c> arriving via a non-cooperative source
-    /// (one that does not stop emitting after the first value) is dropped by the latch.</summary>
+    /// <summary>Verifies a second <c>OnNext</c> from a source that keeps emitting is dropped by the latch.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSecondOnNextAfterFirstSettled_ThenIgnored()
@@ -132,8 +127,7 @@ public async Task WhenSecondOnCompletedAfterFirstSettled_ThenIgnored()
         await Assert.That(() => task).ThrowsExactly<InvalidOperationException>();
     }
 
-    /// <summary>Test observable that captures its subscriber so tests can directly invoke
-    /// non-cooperative double-terminal sequences against <c>FirstAsTaskHelper</c>'s observer.</summary>
+    /// <summary>Observable that captures its subscriber so a test can notify it directly.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class InvasiveObservable<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
index 59c0b401..2cf85928 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
@@ -8,9 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
 
-/// <summary>Tests for <see cref = "FirstAsValueTaskHelper{T}"/> covering the value, error, and
-/// empty-completion paths the pooled <c>ToHotValueTask</c> source exposes, plus the pool reuse and
-/// post-settle drop branches.</summary>
+/// <summary>Tests for <see cref = "FirstAsValueTaskHelper{T}"/>, the pooled first-value task bridge.</summary>
 public class FirstAsValueTaskHelperTests
 {
     /// <summary>Message of an error the helper is expected to drop.</summary>
@@ -62,8 +60,7 @@ public async Task WhenSourceNull_ThenThrowsArgumentNullException() => await Asse
         .That(static async () => await FirstAsValueTaskHelper<int>.FirstAsValueTask(null!))
         .ThrowsExactly<ArgumentNullException>();
 
-    /// <summary>Exercises the <c>Subscription?.Dispose()</c> null-conditional branch when a source
-    /// synchronously emits during <c>Subscribe</c> before the subscription field is assigned.</summary>
+    /// <summary>Verifies a source that emits during <c>Subscribe</c>, before the subscription handle exists, yields that value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
@@ -73,8 +70,7 @@ public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
         await Assert.That(value).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies the pooled source is reused across sequential calls — a second call after the
-    /// first has settled returns to the pool and resolves correctly.</summary>
+    /// <summary>Verifies a second sequential call resolves correctly against the recycled pooled source.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenCalledSequentially_ThenPooledSourceReused()
@@ -85,8 +81,7 @@ public async Task WhenCalledSequentially_ThenPooledSourceReused()
         await Assert.That(second).IsEqualTo(SecondValue);
     }
 
-    /// <summary>Verifies awaiting the value task before the source emits registers a continuation on the
-    /// pooled source (the incomplete-await path) and resolves once the value later arrives.</summary>
+    /// <summary>Verifies a value task awaited before the source emits resolves when the value arrives.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAwaitedBeforeEmission_ThenCompletesOnLaterValue()
@@ -98,7 +93,7 @@ public async Task WhenAwaitedBeforeEmission_ThenCompletesOnLaterValue()
         await Assert.That(result).IsEqualTo(FirstValue);
     }
 
-    /// <summary>Verifies emissions arriving after the value task has already settled are silently ignored.</summary>
+    /// <summary>Verifies emissions arriving after the value task settles are silently ignored.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSecondTerminalAfterSettled_ThenIgnored()
@@ -140,8 +135,7 @@ public async Task WhenSecondOnCompletedAfterSettled_ThenIgnored()
         await Assert.That(async () => await task).ThrowsExactly<InvalidOperationException>();
     }
 
-    /// <summary>Test observable that captures its subscriber so tests can directly invoke
-    /// non-cooperative double-terminal sequences against the pooled first-value observer.</summary>
+    /// <summary>Observable that captures its subscriber so a test can notify it directly.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class InvasiveObservable<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs
index a047d258..6d92000d 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
 
-/// <summary>Direct RxVoid tests for <see cref="ObserverArrayHelpers"/> — both the broadcast
-/// loop and the remove-or-null short-circuit paths. The helpers are pure functions over
-/// their inputs, so each branch is exercised by passing synthesized arrays rather than
-/// relying on operator-level scheduler races.</summary>
+/// <summary>Tests for <see cref="ObserverArrayHelpers"/>, the broadcast and remove-or-null helpers.</summary>
 public class ObserverArrayHelpersTests
 {
     /// <summary>Sentinel value broadcast through the helper.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs
index db0bbdc5..17fa9b2e 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs
@@ -59,7 +59,7 @@ public async Task WhenHandleError_ThenForwardsAndIsTerminal()
         InvalidOperationException error = new("boom");
 
         state.HandleError(error);
-        state.HandleError(new InvalidOperationException("second")); // should be no-op
+        state.HandleError(new InvalidOperationException("second"));
 
         await Assert.That(state.IsDone).IsTrue();
         await Assert.That(observer.Errors).Count().IsEqualTo(1);
@@ -77,7 +77,7 @@ public async Task WhenAllSourcesComplete_ThenDownstreamCompletes()
         CaptureWitness<int> observer = new();
         ReduceSinkState<int, int> state = new(observer, PairedSourceCount);
 
-        // Seed both values so completion-without-value path isn't triggered.
+        // Both slots must hold a value, or completion takes the completed-without-value path instead.
         state.Values[0] = SeedValue1;
         state.Values[1] = SeedValue2;
         state.HasValueCount = SeededValueCount;
@@ -119,7 +119,7 @@ public async Task WhenSameSourceCompletesTwice_ThenSecondCallIgnored()
         ReduceSinkState<int, int> state = new(observer, PairedSourceCount);
 
         state.HandleCompleted(0);
-        state.HandleCompleted(0); // same index — should be no-op
+        state.HandleCompleted(0);
 
         await Assert.That(state.CompletedCount).IsEqualTo(1);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs
index 41697b91..deeaf28d 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs
@@ -6,8 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
 
-/// <summary>Direct RxVoid tests for <see cref="TimerSinkState{T}"/> — covers the terminal
-/// idempotency guards across <c>HandleErrorLocked</c>, <c>HandleCompletedLocked</c>, and <c>HandleDisposeLocked</c>.</summary>
+/// <summary>Tests for <see cref="TimerSinkState{T}"/>, the shared timer sink state.</summary>
 public class TimerSinkStateTests
 {
     /// <summary>Verifies <c>HandleErrorLocked</c> forwards the error then marks the state done.</summary>
@@ -40,8 +39,7 @@ public async Task WhenHandleCompletedLocked_ThenForwardsAndMarksDone()
         await Assert.That(observer.Completions).IsEqualTo(1);
     }
 
-    /// <summary>Exercises the <c>HandleCompletedLocked</c> idempotency guard — once the state is
-    /// already terminal, a second call returns without re-forwarding to the downstream.</summary>
+    /// <summary>Verifies <c>HandleCompletedLocked</c> forwards nothing once the state is terminal.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenHandleCompletedLockedAfterError_ThenNoOp()
@@ -56,8 +54,7 @@ public async Task WhenHandleCompletedLockedAfterError_ThenNoOp()
         await Assert.That(observer.Errors).Count().IsEqualTo(1);
     }
 
-    /// <summary>Exercises the <c>HandleErrorLocked</c> idempotency guard — once the state is
-    /// already terminal, a second call returns without re-forwarding.</summary>
+    /// <summary>Verifies <c>HandleErrorLocked</c> forwards nothing once the state is terminal.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenHandleErrorLockedAfterCompleted_ThenNoOp()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
index 505e9ce7..e1cd54e0 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
@@ -50,7 +50,6 @@ public async Task WhenWaitForCompletionWithSchedulerOnly_ThenReturnsAfterTermina
     {
         Observable.Return(RxVoid.Default).WaitForCompletion(ImmediateSequencer.Instance);
 
-        // Sentinel follow-up to give TUnit a real assertion.
         var sentinel = Observable.Return(SchedulerSentinelValue).SubscribeGetValue();
         await Assert.That(sentinel).IsEqualTo(SchedulerSentinelValue);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
index c84123ae..155466a7 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
@@ -41,8 +41,7 @@ public async Task WhenSubscribeGetValueEmpty_ThenReturnsDefault()
     [Test]
     public async Task WhenSubscribeAndComplete_ThenSwallowsUnitAndReturns()
     {
-        // Helper is fire-and-forget; verify a follow-up call on a different sequence still
-        // returns the expected value, proving SubscribeAndComplete didn't leave state behind.
+        // The helper returns nothing, so the follow-up call is what shows it left no state behind.
         Observable.Return(RxVoid.Default).SubscribeAndComplete();
         var followUp = Observable.Return(RxVoid.Default).SubscribeGetValue();
         await Assert.That(followUp).IsEqualTo(RxVoid.Default);
@@ -175,16 +174,13 @@ public async Task WhenWaitForErrorTimesOut_ThenTimeoutException()
         await Assert.That(ex).IsNotNull();
     }
 
-    /// <summary>Verifies the single-arg <c>WaitForCompletion(IObservable&lt;RxVoid&gt;)</c> overload —
-    /// pass-through to the scheduler-aware core with default timeout.</summary>
+    /// <summary>Verifies the single-argument <c>WaitForCompletion</c> overload returns on completion.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenWaitForCompletionUnitDefault_ThenReturnsOnCompletion() =>
         await Assert.That(static () => Observable.Return(RxVoid.Default).WaitForCompletion()).ThrowsNothing();
 
-    /// <summary>Exercises the no-op <c>OnError</c> body of <c>ValueCaptureWitness</c> —
-    /// <c>SubscribeGetValue</c> on an erroring source still returns the last captured value
-    /// (default) and the error is silently swallowed by the observer.</summary>
+    /// <summary>Verifies <c>SubscribeGetValue</c> swallows a source error and returns the default value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSubscribeGetValueSourceErrors_ThenErrorSwallowed()
@@ -195,9 +191,7 @@ public async Task WhenSubscribeGetValueSourceErrors_ThenErrorSwallowed()
         await Assert.That(value).IsEqualTo(0);
     }
 
-    /// <summary>Exercises the no-op <c>OnNext</c> and <c>OnCompleted</c> bodies of
-    /// <c>ErrorCaptureWitness</c> — <c>SubscribeGetError</c> on a completing source ignores
-    /// the value and the completion, returning a null error.</summary>
+    /// <summary>Verifies <c>SubscribeGetError</c> returns a null error for a source that completes.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSubscribeGetErrorSourceCompletesWithValue_ThenReturnsNull()
@@ -207,9 +201,7 @@ public async Task WhenSubscribeGetErrorSourceCompletesWithValue_ThenReturnsNull(
         await Assert.That(error).IsNull();
     }
 
-    /// <summary>Exercises the <c>OnError</c> path of <c>BlockingValueWitness</c> —
-    /// <c>WaitForValue</c> on an erroring source returns the default value once the gate
-    /// is signalled by the error.</summary>
+    /// <summary>Verifies a source error releases <c>WaitForValue</c>, which returns the default value.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenWaitForValueSourceErrors_ThenGateSignalledAndDefaultReturned()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
index 5656de05..b89078a0 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
@@ -24,7 +24,7 @@ public class ConflateObservableTests
     /// <summary>Half of the update-period window.</summary>
     private const int HalfWindowTicks = 50;
 
-    /// <summary>Sentinel values.</summary>
+    /// <summary>First sentinel value.</summary>
     private const int First = 1;
 
     /// <summary>Second sentinel value.</summary>
@@ -166,7 +166,7 @@ public async Task WhenOnCompletedAfterError_ThenDropped()
         await Assert.That(completed).IsFalse();
     }
 
-    /// <summary>Verifies disposal suppresses queued notifications and callbacks already removed from the queue.</summary>
+    /// <summary>Verifies disposal suppresses both queued notifications and callbacks taken off the queue.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSinkEnqueuedAfterDispose_ThenSilentlyDropped()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs
index 1bea307f..cc2616a6 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs
@@ -6,8 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <c>DebounceImmediateObservable</c> covering the after-terminal guards
-/// on the sink that fire only when an upstream pushes events past its own completion.</summary>
+/// <summary>Tests for <c>DebounceImmediateObservable</c> under an upstream that notifies past its terminal.</summary>
 public class DebounceImmediateObservableTests
 {
     /// <summary>Tick window for the debounce.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
index 0093facf..a443c06e 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
@@ -16,8 +16,7 @@ public class DetectStaleObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Verifies that a source erroring synchronously during subscribe forwards the error and
-    /// disposes the upstream handle through the attach-after-terminated branch.</summary>
+    /// <summary>Verifies a source erroring during subscribe forwards the error and disposes the upstream handle.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubscription()
@@ -33,17 +32,13 @@ public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubs
         await Assert.That(source.Subscription.IsDisposed).IsTrue();
     }
 
-    /// <summary>Observable that synchronously errors during <c>Subscribe</c> and exposes the subscription
-    /// handle it returned so tests can assert it was disposed.</summary>
+    /// <summary>Observable that errors during <c>Subscribe</c> and exposes the handle it returned.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     /// <param name = "error">The exception to emit synchronously.</param>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2315:A type that owns a disposable should be disposable",
-        Justification =
-            "Test double that returns and exposes the BooleanDisposable subscription handle so the test can assert the "
-            + "operator under test disposed it. The operator owns disposal; making this double IDisposable would "
-            + "misattribute ownership, and the object's lifetime is the test's.")]
+        Justification = "The operator under test owns disposal of the exposed handle; this double only hands it back.")]
     private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
     {
         /// <summary>Gets the subscription handle returned from the most recent subscribe.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
index e0bd4599..6db420ee 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
@@ -43,8 +43,7 @@ public async Task WhenCandidatesEmpty_ThenEmitsFallbackAndCompletes()
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies that an async projection whose value matches the predicate emits the
-    /// matching value and completes — exercises the <c>AsyncSink.OnNext</c> match path.</summary>
+    /// <summary>Verifies an async projection whose value matches the predicate emits it and completes.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncProjectionMatches_ThenEmitsMatch()
@@ -66,8 +65,7 @@ public async Task WhenAsyncProjectionMatches_ThenEmitsMatch()
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
-    /// <summary>Verifies that an async projection that never matches falls through to the
-    /// fallback when its source completes — exercises the async <c>OnCompleted</c> path.</summary>
+    /// <summary>Verifies an async projection that completes without a match falls through to the fallback.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncProjectionNeverMatches_ThenFallback()
@@ -88,8 +86,7 @@ public async Task WhenAsyncProjectionNeverMatches_ThenFallback()
         await Assert.That(results).IsCollectionEqualTo([Fallback]);
     }
 
-    /// <summary>Verifies that an async projection error is swallowed and the walk continues
-    /// to the next candidate — exercises the async <c>OnError</c> path.</summary>
+    /// <summary>Verifies an async projection error is swallowed and the walk moves to the next candidate.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncProjectionErrors_ThenSkipsToNextCandidate()
@@ -133,8 +130,7 @@ public async Task WhenDisposedDuringAsyncWalk_ThenStops()
         await Assert.That(completed).IsFalse();
     }
 
-    /// <summary>Verifies that when the synchronous transform throws for one candidate the next
-    /// candidate is tried — exercises the <c>catch { continue; }</c> path in the sync fast path.</summary>
+    /// <summary>Verifies a synchronous transform that throws for one candidate lets the next be tried.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSyncTransformThrows_ThenContinuesToNextCandidate()
@@ -151,10 +147,7 @@ public async Task WhenSyncTransformThrows_ThenContinuesToNextCandidate()
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies that a candidate whose projected observable synchronously calls
-    /// <c>OnError</c> on the sink during its <c>Subscribe</c> call hits the
-    /// <c>if (_looping) return;</c> re-entrancy guard in <c>AsyncSink.OnError</c> and
-    /// proceeds to the next candidate.</summary>
+    /// <summary>Verifies a candidate that errors from inside its own <c>Subscribe</c> gives way to the next.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncCandidateProjectionSyncErrors_ThenLoopingGuardSkipsToNextCandidate()
@@ -176,10 +169,7 @@ public async Task WhenAsyncCandidateProjectionSyncErrors_ThenLoopingGuardSkipsTo
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies that a candidate whose projected observable synchronously calls
-    /// <c>OnCompleted</c> on the sink during its <c>Subscribe</c> call hits the
-    /// <c>if (_looping) return;</c> re-entrancy guard in <c>AsyncSink.OnCompleted</c> and
-    /// proceeds to the next candidate.</summary>
+    /// <summary>Verifies a candidate that completes from inside its own <c>Subscribe</c> gives way to the next.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncCandidateProjectionSyncCompletes_ThenLoopingGuardSkipsToNextCandidate()
@@ -197,8 +187,7 @@ public async Task WhenAsyncCandidateProjectionSyncCompletes_ThenLoopingGuardSkip
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies that a second async candidate emission arriving after a match has already
-    /// fired is silently dropped via the <c>_done</c> guard in <c>AsyncSink.OnNext</c>.</summary>
+    /// <summary>Verifies candidate notifications arriving after the match has fired are silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncCandidateEmitsAfterMatch_ThenDroppedByDoneGuard()
@@ -218,14 +207,11 @@ public async Task WhenAsyncCandidateEmitsAfterMatch_ThenDroppedByDoneGuard()
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
-    /// <summary>Drives <c>AsyncSink.TryNext</c> through a candidate whose projection
-    /// synchronously errors — that path enters <c>AsyncSink.OnError</c> while <c>_looping == true</c>
-    /// (inside <c>TryNext</c>), exercising the <c>if (_looping) return;</c> guard.</summary>
+    /// <summary>Verifies a mid-walk candidate that errors from inside <c>Subscribe</c> lets the walk reach the match.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncSinkWalkHitsSyncErroringCandidate_ThenLoopingGuardSkipsAhead()
     {
-        // The second candidate errors synchronously after the first asynchronous candidate completes.
         string[] keys = [AsyncKey, SyncErrorKey, HitKey];
         Subject<string> asyncSubject = new();
         List<string> results = [];
@@ -241,15 +227,13 @@ public async Task WhenAsyncSinkWalkHitsSyncErroringCandidate_ThenLoopingGuardSki
             static value => value == HitKey,
             Fallback).Subscribe(results.Add, () => completed.TrySetResult());
 
-        // Completing the first candidate starts the synchronously failing candidate.
+        // Completing the first candidate is what advances the walk onto the re-entrant one.
         asyncSubject.OnCompleted();
         await completed.Task;
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
-    /// <summary>Same shape as the looping-error case but the intermediate candidate
-    /// synchronously completes instead of erroring, exercising
-    /// <c>AsyncSink.OnCompleted</c>'s <c>_looping</c> guard.</summary>
+    /// <summary>Verifies a mid-walk candidate that completes from inside <c>Subscribe</c> lets the walk reach the match.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenAsyncSinkWalkHitsSyncCompletingCandidate_ThenLoopingGuardSkipsAhead()
@@ -273,8 +257,7 @@ public async Task WhenAsyncSinkWalkHitsSyncCompletingCandidate_ThenLoopingGuardS
         await Assert.That(results).IsCollectionEqualTo([HitKey]);
     }
 
-    /// <summary>Observable that synchronously calls <c>OnError</c> on the subscriber from inside
-    /// its <c>Subscribe</c> method — used to exercise the re-entrancy <c>_looping</c> guard.</summary>
+    /// <summary>Observable that calls <c>OnError</c> on its subscriber from inside <c>Subscribe</c>.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     /// <param name = "error">The exception to deliver to the subscriber.</param>
     private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
@@ -287,9 +270,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Observable that synchronously calls <c>OnCompleted</c> on the subscriber from
-    /// inside its <c>Subscribe</c> method — used to exercise the re-entrancy <c>_looping</c>
-    /// guard.</summary>
+    /// <summary>Observable that calls <c>OnCompleted</c> on its subscriber from inside <c>Subscribe</c>.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     private sealed class SyncCompletingObservable<T> : IObservable<T>
     {
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs
index 96961932..ca6fb407 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs
@@ -7,9 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests covering the async-sink path of
-/// <c>FirstMatchFromCandidates</c> (when projections do not complete synchronously)
-/// and edge cases not exercised by the sync fast-path tests.</summary>
+/// <summary>Tests <c>FirstMatchFromCandidates</c> where the candidate projections do not complete synchronously.</summary>
 public class FirstMatchFromCandidatesAsyncTests
 {
     /// <summary>Transformed result produced from the matching raw value.</summary>
@@ -156,7 +154,7 @@ public async Task WhenAsyncProjectionFactoryThrows_ThenSkipsAndContinues()
             static t => t == MatchResult,
             Fallback).Subscribe(results.Add);
 
-        // Trigger async sink: complete the first projection so AsyncSink.TryNext walks the rest.
+        // Completing the first projection is what advances the walk onto the remaining candidates.
         asyncFirst.OnCompleted();
         await Assert.That(results).IsCollectionEqualTo([MatchResult]);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
index fd4d54ec..c822cb95 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
@@ -8,8 +8,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <see cref = "ForEachObservable{T}"/> — null-batch ignore semantics, the
-/// scheduler-marshalled delivery path, error forwarding, and the null-observer subscribe guard.</summary>
+/// <summary>Tests for <see cref = "ForEachObservable{T}"/> — null batches, scheduled delivery, and error forwarding.</summary>
 public class ForEachObservableTests
 {
     /// <summary>Sentinel batch element.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
index 9c87ba86..c3c3d1de 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
@@ -91,8 +91,7 @@ public async Task WhenHeartbeatSourceEmits_ThenForwardsValueUpdate()
         await Assert.That(updates).IsCollectionEqualTo([Value]);
     }
 
-    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
-    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <summary>Verifies notifications arriving after the source completes are silently dropped.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenEventsAfterCompleted_ThenDropped()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs
index 20315947..41fd67a7 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs
@@ -7,8 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
 
-/// <summary>Tests for <see cref = "LogErrorsObservable{T}"/> — verifies the logger is tapped on
-/// the error path, never on the success path, and that the null-observer subscribe guard fires.</summary>
+/// <summary>Tests for <see cref = "LogErrorsObservable{T}"/> — when the logger is tapped, and the null-observer guard.</summary>
 public class LogErrorsObservableTests
 {
     /// <summary>Sentinel value flowing through the success path.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
index 74161728..7bb1b746 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
@@ -82,7 +82,7 @@ public async Task WhenGetMaxSourceErrors_ThenForwardsError()
         await Assert.That(caught).IsSameReferenceAs(expected);
     }
 
-    /// <summary>Verifies <c>GetMax</c> with no additional sources still emits the source's own values verbatim.</summary>
+    /// <summary>Verifies <c>GetMax</c> with no additional sources emits the source's own values verbatim.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenGetMaxSingleSource_ThenEmitsSourceValues()
@@ -96,7 +96,7 @@ public async Task WhenGetMaxSingleSource_ThenEmitsSourceValues()
         await Assert.That(results).IsCollectionEqualTo([LowValue, MidValue, HighValue]);
     }
 
-    /// <summary>Verifies <c>GetMin</c> with no additional sources still emits the source's own values verbatim.</summary>
+    /// <summary>Verifies <c>GetMin</c> with no additional sources emits the source's own values verbatim.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenGetMinSingleSource_ThenEmitsSourceValues()
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
index bc56ce74..da73dc42 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
@@ -84,8 +84,7 @@ public async Task WhenObserveOnIfSourceCompletes_ThenForwardsCompletion()
         await Assert.That(completed).IsTrue();
     }
 
-    /// <summary>Verifies that the single-scheduler overload defaults the false branch to
-    /// <see cref = "Sequencer.Immediate"/> by emitting synchronously when the condition is false.</summary>
+    /// <summary>Verifies the single-scheduler overload emits synchronously while the condition is false.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenObserveOnIfSingleSchedulerConditionFalse_ThenImmediate()
@@ -123,10 +122,7 @@ public async Task WhenOnNextAfterCompleted_ThenDropped()
         await Assert.That(values).IsEmpty();
     }
 
-    /// <summary>Exercises the <c>_done</c> guard inside the scheduled callback —
-    /// when the source completes between <c>OnNext</c>'s schedule call and the scheduler firing
-    /// the queued callback, the callback observes <c>_done == true</c> and returns without
-    /// forwarding to downstream.</summary>
+    /// <summary>Verifies a queued emission is dropped when the source completes before the callback fires.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenScheduledCallbackFiresAfterSourceCompleted_ThenDroppedByDoneGuard()
@@ -139,22 +135,16 @@ public async Task WhenScheduledCallbackFiresAfterSourceCompleted_ThenDroppedByDo
         using var sub = source.ObserveOnIf(condition, scheduler, scheduler)
             .Subscribe(values.Add, () => completedCount++);
 
-        // First emission queues the forward-to-downstream callback on the VirtualClock.
+        // The emission is queued on the clock, so the completion below lands ahead of it.
         source.Observer.OnNext(1);
-
-        // Source completes synchronously, flipping _done = true before the queued callback runs.
         source.Observer.OnCompleted();
 
-        // Advance the scheduler so the queued callback fires; it observes _done == true and
-        // returns at the in-callback guard rather than calling downstream.OnNext.
         scheduler.AdvanceBy(1);
         await Assert.That(completedCount).IsEqualTo(1);
         await Assert.That(values).IsEmpty();
     }
 
-    /// <summary>Verifies the condition observer's duplicate-value short-circuit — emitting the
-    /// same condition value twice in a row hits the <c>_hasCondition &amp; &amp; _lastCondition == c</c>
-    /// guard and returns silently without re-assigning the current scheduler.</summary>
+    /// <summary>Verifies a repeated condition value is ignored and leaves the selected scheduler in place.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenObserveOnIfConditionDuplicate_ThenSilentlyShortCircuits()
@@ -166,15 +156,10 @@ public async Task WhenObserveOnIfConditionDuplicate_ThenSilentlyShortCircuits()
         List<int> values = [];
         using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler).Subscribe(values.Add);
 
-        // First emission seeds the gate (_hasCondition transitions from false to true).
         condition.OnNext(true);
-
-        // Second identical emission hits the duplicate-value guard and returns early.
         condition.OnNext(true);
         source.OnNext(1);
 
-        // Sanity: subsequent value still routes through the true-scheduler (the duplicate did
-        // not corrupt the captured state).
         await Assert.That(values).IsCollectionEqualTo([1]);
     }
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
index e00a6485..5b3e4a93 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
@@ -15,11 +15,10 @@ public class ObserveOnObservableTests
     /// <summary>Synthetic error message attached to source errors.</summary>
     private const string SourceErrorMessage = "source error";
 
-    /// <summary>Second sentinel value (kept as a constant to satisfy the no-magic-number rule).</summary>
+    /// <summary>Second sentinel value.</summary>
     private const int SecondValue = 2;
 
-    /// <summary>Verifies the immediate scheduler is special-cased to forward straight through the source
-    /// subscription without the queue-and-drain machinery.</summary>
+    /// <summary>Verifies the immediate scheduler forwards straight through, without queue-and-drain.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenImmediateScheduler_ThenForwardsDirectly()
@@ -103,9 +102,7 @@ public async Task WhenDisposedBeforeDrain_ThenTearsDownAndDropsQueued()
         await Assert.That(values).IsEmpty();
     }
 
-    /// <summary>Verifies the upstream subscription is disposed when the source terminates synchronously during
-    /// subscribe — the drain runs inline (terminating the sink) before <c>AttachSourceSubscription</c> records
-    /// the handle, so the late attach disposes it instead.</summary>
+    /// <summary>Verifies the upstream handle is disposed when the source terminates during subscribe, before the sink records it.</summary>
     /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubscription()
@@ -120,17 +117,13 @@ public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubs
         await Assert.That(source.Subscription.IsDisposed).IsTrue();
     }
 
-    /// <summary>Observable that synchronously errors during <c>Subscribe</c> and exposes the subscription
-    /// handle it returned so tests can assert it was disposed.</summary>
+    /// <summary>Observable that errors during <c>Subscribe</c> and exposes the handle it returned.</summary>
     /// <typeparam name = "T">The element type.</typeparam>
     /// <param name = "error">The exception to emit synchronously.</param>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Design",
         "SST2315:A type that owns a disposable should be disposable",
-        Justification =
-            "Test double that returns and exposes the BooleanDisposable subscription handle so the test can assert the "
-            + "operator under test disposed it. The operator owns disposal; making this double IDisposable would "
-            + "misattribute ownership, and the object's lifetime is the test's.")]
+        Justification = "The operator under test owns disposal of the exposed handle; this double only hands it back.")]
     private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
     {
         /// <summary>Gets the subscription handle returned from the most recent subscribe.</summary>
@@ -162,10 +155,7 @@ private sealed class InlineScheduler : ISequencer
         [System.Diagnostics.CodeAnalysis.SuppressMessage(
             "Design",
             "SST2318:Members should not have identical bodies",
-            Justification =
-                "The relative and absolute Schedule overloads of this test-double sequencer intentionally behave the "
-                + "same way; both are required by the ISequencer contract and, as distinct interface overloads, cannot "
-                + "forward to one another.")]
+            Justification = "Both ISequencer Schedule overloads must exist and run inline; neither can forward to the other.")]
         public void Schedule(IWorkItem item, long dueTimestamp) => item.Execute();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
index e89e69ff..68c8cc03 100644
--- a/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Maui.Reactive.Tests/MauiDispatcherSequencerTests.cs
@@ -9,13 +9,10 @@
 
 namespace ReactiveUI.Primitives.Maui.Reactive.Tests;
 
-/// <summary>
-/// Tests for <see cref="MauiDispatcherSequencer"/> as an <see cref="IScheduler"/>, exercised through a fake
-/// <see cref="IDispatcher"/> so the immediate and time-based dispatch paths run deterministically on any platform.
-/// </summary>
+/// <summary>Tests <see cref="MauiDispatcherSequencer"/> as an <see cref="IScheduler"/> through a fake <see cref="IDispatcher"/>.</summary>
 public sealed class MauiDispatcherSequencerTests
 {
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
@@ -54,10 +51,7 @@ public async Task ImmediateScheduleDispatchesAndExecutes()
         await Assert.That(dispatcher.DispatchDelayedCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies work due in the future routes through <see cref="IDispatcher.DispatchDelayed(TimeSpan, Action)"/>
-    /// with a positive delay, and runs on the dispatcher without the shared-timer marshal hop.
-    /// </summary>
+    /// <summary>Verifies future work routes through <see cref="IDispatcher.DispatchDelayed(TimeSpan, Action)"/> with a positive delay.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayedScheduleUsesDispatchDelayed()
diff --git a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
index d92168d1..bea3957c 100644
--- a/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Maui.Tests/MauiDispatcherSequencerTests.cs
@@ -8,13 +8,10 @@
 
 namespace ReactiveUI.Primitives.Maui.Tests;
 
-/// <summary>
-/// Tests for <see cref="MauiDispatcherSequencer"/>, exercised through a fake <see cref="IDispatcher"/>
-/// so the immediate and time-based dispatch paths run deterministically on any platform.
-/// </summary>
+/// <summary>Tests <see cref="MauiDispatcherSequencer"/>'s immediate and time-based dispatch paths through a fake <see cref="IDispatcher"/>.</summary>
 public sealed class MauiDispatcherSequencerTests
 {
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
@@ -53,10 +50,7 @@ public async Task ImmediateScheduleDispatchesAndExecutes()
         await Assert.That(dispatcher.DispatchDelayedCount).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies work due in the future routes through <see cref="IDispatcher.DispatchDelayed(TimeSpan, Action)"/>
-    /// with a positive delay, and runs on the dispatcher without the thread-pool marshal hop.
-    /// </summary>
+    /// <summary>Verifies future work routes through <see cref="IDispatcher.DispatchDelayed(TimeSpan, Action)"/> with a positive delay.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DelayedScheduleUsesDispatchDelayed()
@@ -72,7 +66,7 @@ public async Task DelayedScheduleUsesDispatchDelayed()
         await Assert.That(dispatcher.LastDelay).IsGreaterThan(TimeSpan.Zero);
     }
 
-    /// <summary>Verifies a due timestamp at or before now takes the immediate path rather than the delayed timer.</summary>
+    /// <summary>Verifies a due timestamp that is not in the future takes the immediate path rather than the delayed timer.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task PastDueTimestampUsesImmediatePath()
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/ContainerDisposableTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/ContainerDisposableTests.cs
index 95c74fea..cebf443e 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/ContainerDisposableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/ContainerDisposableTests.cs
@@ -109,7 +109,7 @@ public async Task ConversionThrowsForNullContainer()
         await Assert.That(exception.ParamName).IsEqualTo("container");
     }
 
-    /// <summary>Verifies the container still behaves as a group of disposables in its own right.</summary>
+    /// <summary>Verifies the container behaves as a group of disposables in its own right.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task ContainerTracksItsOwnRegistrationsAlongsideTheComposite()
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
index 6b02aa07..6b9bbe98 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/LinqExtensionsTests.cs
@@ -94,7 +94,7 @@ public async Task DisposeWithThrowsForNullContainerDisposable()
         await Assert.That(exception.ParamName).IsEqualTo("disposables");
     }
 
-    /// <summary>Verifies a container converted to a composite still disposes what System.Reactive registered on it.</summary>
+    /// <summary>Verifies a container converted to a composite disposes what System.Reactive registered on it.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposeWithComposedFromAContainerDisposesWithTheContainer()
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
index a3705caf..f011f15f 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerSchedulingExtensionsTests.Overloads.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>Tests scheduling overloads. Fully qualified scheduler names avoid ambiguous System.Reactive extension methods.</summary>
+/// <summary>Tests the scheduling overloads the seam adds to a System.Reactive scheduler.</summary>
 public partial class SequencerSchedulingExtensionsTests
 {
     /// <summary>State threaded through the closure-free stateful overloads.</summary>
@@ -19,11 +19,12 @@ public partial class SequencerSchedulingExtensionsTests
     /// <summary>How many times the recursive overload reschedules itself before it stops.</summary>
     private const int ExpectedRecursiveRuns = 3;
 
+    // Fully qualified: an unqualified IScheduler makes the seam's overloads ambiguous with System.Reactive's own.
     /// <summary>The scheduler the seam forwards to, typed as the interface the seam extends.</summary>
     private static readonly System.Reactive.Concurrency.IScheduler InlineScheduler =
         System.Reactive.Concurrency.ImmediateScheduler.Instance;
 
-    /// <summary>A due time that has already passed, so absolute scheduling runs inline.</summary>
+    /// <summary>A due time in the past, so absolute scheduling runs inline.</summary>
     private static readonly DateTimeOffset ElapsedDueTime = DateTimeOffset.UnixEpoch;
 
     /// <summary>The state both stateful overloads must hand back, once each.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerTests.cs
index afaacbfd..3c8e26e0 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerTests.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>
-/// Verifies <see cref="Sequencer"/> maps each built-in sequencer onto the matching System.Reactive
-/// scheduler singleton, and that time normalization forwards to System.Reactive.
-/// </summary>
+/// <summary>Verifies <see cref="Sequencer"/> maps each built-in sequencer onto its System.Reactive scheduler and forwards interval normalization.</summary>
 public class SequencerTests
 {
     /// <summary>A negative interval, which normalization clamps to zero.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SignalTests.cs
index 8de58bd1..8c179e1d 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SignalTests.cs
@@ -8,7 +8,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Tests;
 
-/// <summary>Smoke tests confirming the Reactive leaf's recompiled shared signals behave correctly.</summary>
+/// <summary>Smoke tests for the shared signal surface as recompiled into the Reactive leaf.</summary>
 public class SignalTests
 {
     /// <summary>The values replayed by <c>Signal.FromEnumerable</c>.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
index 67215fb5..04b3d0f5 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
@@ -11,7 +11,7 @@ namespace ReactiveUI.Primitives.Reactive.Tests;
 /// <summary>Tests for <see cref="WasmScheduler"/>.</summary>
 public sealed class WasmSchedulerTests
 {
-    /// <summary>State payload used to verify state threading.</summary>
+    /// <summary>State payload threaded through the scheduled action.</summary>
     private const int StatePayload = 42;
 
     /// <summary>Periodic ticks a test drives before disposing; more than one, so threaded state is observable.</summary>
@@ -23,7 +23,7 @@ public sealed class WasmSchedulerTests
     /// <summary>Sentinel <see cref="Array.FindIndex{T}(T[], Predicate{T})"/> returns when no element matches.</summary>
     private const int NoMatch = -1;
 
-    /// <summary>Expected values produced by an immediate burst, used to verify FIFO order.</summary>
+    /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
     /// <summary>Due time of a work item that is expected to run after its delay elapses.</summary>
@@ -119,7 +119,7 @@ public async Task ImmediateBurstExecutesInOrder()
         await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies an item disposed while it waits in the ready queue is skipped while later work still runs.</summary>
+    /// <summary>Verifies an item disposed while it waits in the ready queue is skipped and later work runs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposedImmediateItemIsSkipped()
@@ -194,7 +194,7 @@ public async Task DisposedDelayedItemDoesNotRun()
 
         subscription.Dispose();
 
-        // The due time never elapses on its own, so this is the run a timer callback already in flight would deliver.
+        // The due time never elapses on its own, so this stands in for a timer callback in flight.
         subscription.Run();
 
         await Assert.That(subscription.IsDisposed).IsTrue();
@@ -294,7 +294,7 @@ public async Task DisposedPeriodicItemDisposeIsIdempotent()
         await Assert.That(subscription.Dispose).ThrowsNothing();
     }
 
-    /// <summary>Verifies an action that cancels its own item before returning still has its returned disposable released.</summary>
+    /// <summary>Verifies an action that cancels its own item before returning has its returned disposable released.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task SelfCancellingImmediateActionDisposesReturnedDisposable()
@@ -321,27 +321,27 @@ public async Task SelfCancellingImmediateActionDisposesReturnedDisposable()
         await Assert.That(returned.IsDisposed).IsTrue();
     }
 
-    /// <summary>Verifies that scheduling with a null action returns proper exception.</summary>
+    /// <summary>Verifies the shared scheduler's immediate overload rejects a null action.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduleWithNullActionThrows() =>
         await Assert.That(static () => WasmScheduler.Default.Schedule(0, null!)).Throws<ArgumentNullException>();
 
-    /// <summary>Verifies that scheduling delayed with a null action returns proper exception.</summary>
+    /// <summary>Verifies the shared scheduler's delayed overload rejects a null action.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task ScheduleDelayedWithNullActionThrows() => await Assert
         .That(static () => WasmScheduler.Default.Schedule(0, ValidInterval, null!))
         .Throws<ArgumentNullException>();
 
-    /// <summary>Verifies that scheduling periodic with negative period throws.</summary>
+    /// <summary>Verifies the shared scheduler's periodic overload rejects a negative period.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task SchedulePeriodicWithNegativePeriodThrows() => await Assert
         .That(static () => WasmScheduler.Default.SchedulePeriodic(0, TimeSpan.FromMilliseconds(-1), static s => s))
         .Throws<ArgumentOutOfRangeException>();
 
-    /// <summary>Verifies that scheduling periodic with null action returns proper exception.</summary>
+    /// <summary>Verifies the shared scheduler's periodic overload rejects a null action.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task SchedulePeriodicWithNullActionThrows() => await Assert
@@ -379,10 +379,7 @@ await Assert.That(() => scheduler.SchedulePeriodic(0, UnreachablePeriod, state =
         await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies disposing the scheduler cancels work still waiting in the ready queue while a drain is in flight:
-    /// the queued item is released, not left for the resuming drain to run against a scheduler that is already gone.
-    /// </summary>
+    /// <summary>Verifies disposing the scheduler releases a queued item rather than leaving it for a resuming drain to run.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DisposeCancelsWorkTheInFlightDrainHasNotReachedYet()
@@ -395,7 +392,7 @@ public async Task DisposeCancelsWorkTheInFlightDrainHasNotReachedYet()
             return Disposable.Empty;
         });
 
-        // Queue without arming a drain, so the item is provably still waiting when the disposal runs.
+        // Queue without arming a drain, so the item sits unclaimed in the queue when the disposal runs.
         scheduler.QueueReady(queued);
 
         scheduler.Dispose();
@@ -474,7 +471,7 @@ public async Task EnqueueThatLosesTheRaceToDisposeReleasesTheItemItQueued()
 
         scheduler.Dispose();
 
-        // The enqueue that was already past Schedule's disposed check when the disposal drained the ready queue.
+        // Models an enqueue that passed Schedule's disposed check before the disposal drained the ready queue.
         scheduler.Enqueue(item);
 
         await Assert.That(item.IsDisposed).IsTrue();
@@ -485,10 +482,7 @@ public async Task EnqueueThatLosesTheRaceToDisposeReleasesTheItemItQueued()
         await Assert.That(ran).IsEqualTo(0);
     }
 
-    /// <summary>
-    /// Verifies a drain pass dispatches every queued item exactly once: an item the batch skips would be stranded,
-    /// and one it claims twice would run its action twice.
-    /// </summary>
+    /// <summary>Verifies a drain pass dispatches every queued item exactly once.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
     public async Task DrainDispatchesEveryQueuedItemExactlyOnce()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
index d8f19a47..65399ba8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BlendUniqueTests.cs
@@ -68,7 +68,7 @@ public async Task EmptySourcesCompletesImmediately()
         await Assert.That(completed).IsEqualTo(Once);
     }
 
-    /// <summary>Verifies that a custom comparer is used to suppress duplicates.</summary>
+    /// <summary>Verifies that a custom comparer decides which values count as duplicates.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task UsesSuppliedComparer()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
index 63efd95b..82600ca7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ChooseSwitchSelectTests.cs
@@ -20,7 +20,7 @@ public class ChooseSwitchSelectTests
     /// <summary>The value twenty.</summary>
     private const int Twenty = 20;
 
-    /// <summary>The divisor used to select even values in the Choose test.</summary>
+    /// <summary>The divisor that selects even values in the Choose test.</summary>
     private const int Two = 2;
 
     /// <summary>The expected single-occurrence count.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
index cb79a139..c781cc58 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ConsumerCompilation.cs
@@ -10,8 +10,8 @@
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>
-/// Compiles consumer code against the shipped Primitives assemblies to assert what a downstream compiler resolves.
-/// Overload resolution against a referenced assembly binds through metadata, not through this assembly's source.
+/// Compiles consumer code against the shipped Primitives assemblies, so overload resolution binds through metadata
+/// the way a downstream project sees it rather than through this assembly's source.
 /// </summary>
 public static class ConsumerCompilation
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
index 505dabf5..28072af4 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/MinimalVirtualClock.cs
@@ -25,7 +25,7 @@ internal static class MinimalVirtualClock
     internal static VirtualTimeSequencer<long, long> Create() => Create(Comparer<long>.Default);
 
     /// <summary>Creates a tick-based virtual sequencer ordered by the supplied comparer.</summary>
-    /// <param name="comparer">The comparer used to order scheduled times.</param>
+    /// <param name="comparer">The comparer that orders scheduled times.</param>
     /// <returns>The virtual sequencer.</returns>
     internal static VirtualTimeSequencer<long, long> Create(IComparer<long> comparer) =>
         new(0L, comparer, Adder, ToDateTimeOffset, ToRelative);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/GuardedWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/GuardedWitnessTests.cs
index 93d04dfe..eb16657c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/GuardedWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/GuardedWitnessTests.cs
@@ -13,7 +13,7 @@ public sealed class GuardedWitnessTests
     /// <summary>Value forwarded through the guard.</summary>
     private const int One = 1;
 
-    /// <summary>Second value used to verify forwarding continues after a value.</summary>
+    /// <summary>The second value, which shows forwarding continues after the first.</summary>
     private const int Two = 2;
 
     /// <summary>Verifies the constructor rejects null arguments.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
index 802da0c3..14a96867 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
@@ -39,7 +39,7 @@ public sealed class PrioritySemaphoreSignalTests
     /// <summary>The number of values queued before draining.</summary>
     private const int SeededValueCount = 12;
 
-    /// <summary>The initial capacity used to drain queued values.</summary>
+    /// <summary>The initial capacity that governs how many queued values drain.</summary>
     private const int InitialDrainCapacity = 3;
 
     /// <summary>The amount added during alternating capacity updates.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
index b609d5a3..b34455d1 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReplaySignalTests.cs
@@ -303,7 +303,7 @@ private static async Task AssertWindowedReplayDropsValuesOlderThanTheWindow()
     }
 
     /// <summary>Checks gate ownership and ordered handover from replay to live delivery.</summary>
-    /// <param name = "factory">Factory used to create the replay signal under test.</param>
+    /// <param name = "factory">Factory that creates the replay signal under test.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task AssertReplayAndLiveDeliveryHoldTheGate(Func<ReplaySignal<int>> factory)
     {
@@ -327,7 +327,7 @@ private static async Task AssertReplayAndLiveDeliveryHoldTheGate(Func<ReplaySign
     }
 
     /// <summary>Creates a replay signal and disposes it immediately.</summary>
-    /// <param name = "factory">Factory used to create the signal.</param>
+    /// <param name = "factory">Factory that creates the signal.</param>
     private static void CreateAndDispose(Func<ReplaySignal<int>> factory)
     {
         using var signal = factory();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Repeat.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Repeat.cs
index b240d957..4d7a650b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Repeat.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Repeat.cs
@@ -12,7 +12,7 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Repeat operator parity tests for System.Reactive-compatible names.</summary>
 public partial class RxNamesTests
 {
-    /// <summary>The value four, used to bound the infinite repeat test.</summary>
+    /// <summary>The value four, which bounds the infinite repeat test.</summary>
     private const int Four = 4;
 
     /// <summary>The expected values when a two-value source is repeated twice.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
index 5aa743f1..96a7d6ea 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
@@ -17,7 +17,7 @@ public partial class RxNamesTests
     /// <summary>The multiplier/state used by projection cases.</summary>
     private const int Ten = 10;
 
-    /// <summary>The divisor used to select even values.</summary>
+    /// <summary>The divisor that selects even values.</summary>
     private const int Two = 2;
 
     /// <summary>The fold/aggregate seed.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
index aaea38ed..389c6e3b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.cs
@@ -616,7 +616,7 @@ private static void CreateSynchronizationContextSequencerWithoutContext()
     /// <summary>Completes a task completion source, rejecting a second completion.</summary>
     /// <param name="completion">The completion source to update.</param>
     /// <param name="state">The value to set.</param>
-    /// <exception cref="InvalidOperationException"><paramref name="completion"/> was already completed.</exception>
+    /// <exception cref="InvalidOperationException"><paramref name="completion"/> has completed.</exception>
     private static void SetCompletion(TaskCompletionSource<int> completion, int state)
     {
         if (completion.TrySetResult(state))
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
index 21431ff9..14889e18 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Composition.cs
@@ -54,7 +54,7 @@ public partial class SignalFactoriesTests
     /// <summary>The fourth projected value after applying the projection multiplier.</summary>
     private const int ProjectedFourthValue = 21;
 
-    /// <summary>A peer value used to verify distinct-by bucketing.</summary>
+    /// <summary>A peer value that shares a distinct-by bucket.</summary>
     private const int ProjectedSecondBucketPeerValue = 12;
 
     /// <summary>The zip result expected from the first pair.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
index 8dff500b..b0b0ce59 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.EventConversion.cs
@@ -269,7 +269,7 @@ await Assert.That(static () => Signal.FromEventPattern<EventHandler<EventArgs>,
             static _ => { })).Throws<ArgumentNullException>();
     }
 
-    /// <summary>A sender used to check the typed-sender event pattern keeps its static type.</summary>
+    /// <summary>A sender whose static type the typed-sender event pattern must preserve.</summary>
     [System.Diagnostics.DebuggerDisplay("EventBroadcaster: Id = {Id}")]
     public sealed class EventBroadcaster
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
index e46811df..241dceb9 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.Scheduling.cs
@@ -181,7 +181,7 @@ await Assert.That(((IRequireCurrentThread<int>)Signal.Loop(Seven)).IsRequiredSub
         await Assert.That(witness.Completed).IsEqualTo(1);
     }
 
-    /// <summary>A loop subscription that is already torn down never emits.</summary>
+    /// <summary>A loop subscription torn down before the loop runs never emits.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task LoopEmitsNothingWhenTheSubscriptionIsDisposedBeforeItRuns()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
index ca196fa6..8d755230 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs
@@ -768,7 +768,7 @@ private static void VerifyCollectOperators(IObservable<int> source)
     }
 
     /// <summary>Asserts the prepend, observe-on, subscribe-on, and tap argument guards.</summary>
-    /// <param name="source">A non-null source used to exercise instance guards.</param>
+    /// <param name="source">A non-null source for the instance overloads.</param>
     private static void AssertPrependObserveTapGuards(IObservable<int> source)
     {
         _ = Assert.Throws<ArgumentNullException>(static () => LinqExtensions.Prepend(null!, One, Two));
@@ -786,7 +786,7 @@ private static void AssertPrependObserveTapGuards(IObservable<int> source)
     }
 
     /// <summary>Asserts the aggregate, flat-map, and timing operator argument guards.</summary>
-    /// <param name="source">A non-null source used to exercise instance guards.</param>
+    /// <param name="source">A non-null source for the instance overloads.</param>
     private static void AssertAggregateAndTimingGuards(IObservable<int> source)
     {
         _ = Assert.Throws<ArgumentNullException>(static () => LinqExtensions.IgnoreValues<int>(null!));
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
index 524e4a4e..431903c4 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalRecoverTests.cs
@@ -77,7 +77,7 @@ public async Task RecoverAndCleanupOperatorsRequireCurrentThreadSubscription()
         await Assert.That(((IRequireCurrentThread<int>)cleanup).IsRequiredSubscribeOnCurrentThread()).IsTrue();
     }
 
-    /// <summary>A cleanup action runs even when subscribing to the source throws, and the failure still surfaces.</summary>
+    /// <summary>A cleanup action runs when subscribing to the source throws, and the failure surfaces.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
     public async Task OnCleanupRunsTheActionWhenSubscribingToTheSourceThrows()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
index 6fcf32a8..20678a05 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
@@ -698,7 +698,7 @@ private static void AssertObserverFailuresPropagateOutOfSubscribe()
                 .Subscribe((IObserver<int>)null!));
     }
 
-    /// <summary>A minimal <see cref="IRequireCurrentThread{T}"/> probe used to exercise the subscription routing.</summary>
+    /// <summary>A minimal <see cref="IRequireCurrentThread{T}"/> probe that reports how a subscription was routed.</summary>
     /// <typeparam name="T">The type of the signal sequence elements.</typeparam>
     private sealed class SignalsBaseProbe<T> : IRequireCurrentThread<T>
     {
@@ -723,7 +723,7 @@ public IDisposable Subscribe(IObserver<T> observer) =>
 
         /// <summary>Performs the core subscription by returning an empty disposable.</summary>
         /// <param name="observer">The observer to subscribe.</param>
-        /// <param name="cancel">The disposable used to cancel the subscription.</param>
+        /// <param name="cancel">The disposable that cancels the subscription.</param>
         /// <returns>An empty disposable.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage("Maintainability", "SST1461:Remove unread private parameters", Justification = "The signature is fixed by the delegate SignalSubscription.Subscribe expects.")]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
index 292806d1..bbd62191 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SinkObserverTests.cs
@@ -655,7 +655,7 @@ public async Task TakeSinksDropFaultsThatArriveAfterTheirTerminal()
     }
 
     /// <summary>Asserts a sink rethrows the observer's failure and releases its upstream subscription.</summary>
-    /// <param name = "sink">The sink under test, already holding <paramref name = "subscription"/>.</param>
+    /// <param name = "sink">The sink under test, holding <paramref name = "subscription"/>.</param>
     /// <param name = "subscription">The upstream subscription the sink must release.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     private static async Task AssertObserverFailureReleasesUpstream(
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
index cd60b818..203307d0 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessOnSignalTests.cs
@@ -20,7 +20,7 @@ public sealed class WitnessOnSignalTests
     /// <summary>The second value pushed through the dispatch queue.</summary>
     private const int Second = 2;
 
-    /// <summary>A single virtual tick used to drain the sequencer queue.</summary>
+    /// <summary>A single virtual tick, enough to drain the sequencer queue.</summary>
     private static readonly TimeSpan SingleTick = TimeSpan.FromTicks(1);
 
     /// <summary>The values expected when only the first queued notification is delivered.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/CrossPlatformPlaceholderTests.cs
index 40a58044..62662fe4 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.WinForms.Reactive.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real Windows Forms control tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the Windows Forms control tests are absent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Tests/CrossPlatformPlaceholderTests.cs
index 5f03ea03..70df6fd8 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.WinForms.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real WinForms control tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the WinForms control tests are absent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/CrossPlatformPlaceholderTests.cs
index 1a6a4d16..b7cc58a7 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.WinUI.Reactive.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real WinUI dispatcher tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the WinUI dispatcher tests are absent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Tests/CrossPlatformPlaceholderTests.cs
index ce7194cc..7c0fca2d 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.WinUI.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real WinUI dispatcher tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the WinUI dispatcher tests are absent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/CrossPlatformPlaceholderTests.cs
index ef5a66bc..7ead6de6 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Wpf.Reactive.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real WPF dispatcher tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the WPF dispatcher tests are absent.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Tests/CrossPlatformPlaceholderTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Tests/CrossPlatformPlaceholderTests.cs
index 535a09b8..46affbe6 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Tests/CrossPlatformPlaceholderTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Tests/CrossPlatformPlaceholderTests.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Wpf.Tests;
 
-/// <summary>
-/// Placeholder so the cross-platform test host runs a test and does not report a zero-test run.
-/// The real WPF dispatcher tests compile and run on Windows only (see the csproj).
-/// </summary>
+/// <summary>Placeholder keeping the non-Windows test host from reporting a zero-test run.</summary>
 public sealed class CrossPlatformPlaceholderTests
 {
     /// <summary>Verifies this build leg is the cross-platform one, where the WPF dispatcher tests are absent.</summary>

From d01b2b2ae977647687418c1120ea82e35fda0692 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 22:02:37 +1000
Subject: [PATCH 05/11] docs: state what non-public members do, not why

- Reduce internal operator and helper summaries to a single line of behaviour.
- Drop allocation and deadlock rationale from field and method summaries.
- Keep remarks for public contracts a caller cannot infer from the signature.
---
 .../Operators/ConflateObservable.cs                  |  7 +------
 .../Operators/DebounceImmediateObservable.cs         |  5 +----
 .../Operators/DebounceUntilObservable.cs             |  6 +-----
 .../Operators/DetectStaleObservable.cs               |  6 +-----
 .../Operators/ObserveOnIfObservable.cs               |  7 +------
 .../Operators/RetryWithBackoffObservable.cs          |  6 +-----
 .../Operators/StartActionObservable.cs               |  5 +----
 .../Operators/StartFuncObservable.cs                 |  5 +----
 .../Operators/WhileObservable.cs                     |  6 +-----
 .../Advanced/SubscriptionScheduling.cs               |  5 +----
 .../Advanced/TaskSignalSubscription{T}.cs            |  4 +---
 .../Disposables/MultipleDisposableAsync.cs           |  5 +----
 .../Operators/Blend.cs                               | 12 ++----------
 13 files changed, 14 insertions(+), 65 deletions(-)

diff --git a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
index c21bc9f8..b0cbd66b 100644
--- a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
@@ -11,12 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Delivers notifications on <paramref name="scheduler"/> and keeps emissions at least
-/// <paramref name="minimumUpdatePeriod"/> apart: a value arriving inside that window is deferred to the end of it and a
-/// newer value takes the deferred one's place. Completion waits for a deferred value to land, while an error is
-/// forwarded at once and discards it.
-/// </summary>
+/// <summary>Keeps emissions at least <paramref name="minimumUpdatePeriod"/> apart on <paramref name="scheduler"/>; completion waits for a deferred value, an error discards it.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="minimumUpdatePeriod">The minimum period between emissions.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
index aa3b2dce..6eb5d64d 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceImmediateObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Emits the first source value inline, then holds each later value for <paramref name="dueTime"/> and emits only the
-/// most recent one. A terminal notification flushes a pending value before it is forwarded.
-/// </summary>
+/// <summary>Emits the first value inline, then the most recent value after <paramref name="dueTime"/> of quiet.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="dueTime">The debounce duration.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
index e7507d5f..47772429 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
@@ -10,11 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Forwards a value inline when <paramref name="condition"/> holds for it, cancelling any pending emission, and
-/// otherwise emits it once <paramref name="debounce"/> elapses with no newer value. An error or completion drops a
-/// pending value.
-/// </summary>
+/// <summary>Emits a value inline when <paramref name="condition"/> holds for it, otherwise after <paramref name="debounce"/> of quiet.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="debounce">The debounce duration.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
index c68c354c..5aadf57f 100644
--- a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
@@ -11,11 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Wraps each source value as an update and emits a staleness marker when <paramref name="stalenessPeriod"/> passes
-/// without one, measured from subscription. The window re-arms on every value, so a single quiet stretch yields one
-/// marker.
-/// </summary>
+/// <summary>Wraps each value as an update and emits one staleness marker per quiet stretch of <paramref name="stalenessPeriod"/>.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="stalenessPeriod">The period after which the sequence is considered stale.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
index 8ec4147d..0fad6fe9 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnIfObservable.cs
@@ -11,12 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Schedules each source value onto <paramref name="trueScheduler"/> or <paramref name="falseScheduler"/> according to
-/// the latest value from <paramref name="condition"/>, using the false scheduler until the condition first emits. Error
-/// and completion are forwarded on the producer's thread, so a terminal notification can overtake scheduled values, and
-/// the condition's own error or completion is ignored.
-/// </summary>
+/// <summary>Schedules values per the latest <paramref name="condition"/> value; terminal notifications bypass scheduling.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="condition">The reactive condition observable.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs b/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
index 3443f43b..e16f3a43 100644
--- a/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RetryWithBackoffObservable.cs
@@ -11,11 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Re-subscribes the source after an error, waiting the policy's initial delay scaled by its backoff factor for each
-/// attempt and capped by its maximum, then forwards the error once the retry budget is spent. Every error reaches the
-/// policy's callback, and values forwarded before a retry are not retracted.
-/// </summary>
+/// <summary>Re-subscribes after an error using the policy's backoff delays, forwarding the error once its budget is spent.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="policy">The retry / backoff configuration.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs b/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
index 88f5a838..d0b1ad5a 100644
--- a/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/StartActionObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Runs the action once per subscription, inline or on <paramref name="scheduler"/>, then emits
-/// <see cref="RxVoid.Default"/> and completes. An exception from the action is forwarded as an error instead.
-/// </summary>
+/// <summary>Runs the action once per subscription, then emits <see cref="RxVoid.Default"/> and completes.</summary>
 /// <param name="action">The action to run.</param>
 /// <param name="scheduler">An optional scheduler; <c>null</c> runs the action synchronously inline.</param>
 internal sealed class StartActionObservable(Action action, ISequencer? scheduler) : IObservable<RxVoid>
diff --git a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
index 315e0336..35b0e263 100644
--- a/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/StartFuncObservable.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Runs the function once per subscription, inline or on <paramref name="scheduler"/>, then emits the result and
-/// completes. An exception from the function is forwarded as an error instead.
-/// </summary>
+/// <summary>Runs the function once per subscription, then emits its result and completes.</summary>
 /// <typeparam name="TResult">Result type.</typeparam>
 /// <param name="function">Function to run.</param>
 /// <param name="scheduler">Optional scheduler; null runs inline.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
index c22f6a14..2de29667 100644
--- a/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/WhileObservable.cs
@@ -11,11 +11,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>
-/// Loops the supplied <see cref="Action"/> on the supplied <see cref="ISequencer"/>, or inline when no scheduler is
-/// provided, emitting <see cref="RxVoid.Default"/> after each iteration for as long as
-/// <paramref name="condition"/> returns <c>true</c>.
-/// </summary>
+/// <summary>Invokes the action and emits <see cref="RxVoid.Default"/> per iteration while <paramref name="condition"/> returns <see langword="true"/>.</summary>
 /// <param name="condition">The loop predicate. Evaluated before each iteration.</param>
 /// <param name="action">The action to invoke per iteration.</param>
 /// <param name="scheduler">An optional scheduler; <c>null</c> runs every iteration inline.</param>
diff --git a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
index 7d7f808d..98b6c117 100644
--- a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
+++ b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
@@ -34,10 +34,7 @@ internal static IDisposable OnCurrentThread<TState>(TState state, Func<TState, I
         return subscription;
     }
 
-    /// <summary>
-    /// Runs <paramref name="run"/> on <paramref name="sequencer"/>: inline for the immediate sequencer, and
-    /// queued behind the current-thread sequencer when that one is the target and is draining work.
-    /// </summary>
+    /// <summary>Runs <paramref name="run"/> inline on the immediate sequencer, otherwise schedules it on <paramref name="sequencer"/>.</summary>
     /// <typeparam name="TState">The type of the state passed to the scheduled work.</typeparam>
     /// <param name="sequencer">The sequencer that runs the work.</param>
     /// <param name="state">The state carried to <paramref name="run"/>.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
index 1d93ba50..4a5d7a63 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
@@ -18,9 +18,7 @@ public abstract class TaskSignalSubscription<T>(IObserverAsync<T> observer) : IA
     /// <summary>The cancellation token source that cancels the subscription's job on disposal.</summary>
     private readonly CancellationTokenSource _cts = new();
 
-    /// <summary>Flows through the job's notification chain across thread hops, so a reentrant
-    /// <see cref="DisposeAsync"/> issued from inside the job skips the self-join on <see cref="_tcs"/>
-    /// that would otherwise deadlock.</summary>
+    /// <summary>Set while the job runs, so a reentrant <see cref="DisposeAsync"/> from inside it skips the self-join.</summary>
     private readonly AsyncLocal<bool> _executing = new();
 
     /// <summary>Set on the first disposal so later calls are no-ops.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
index 6400f71b..17b7c488 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
@@ -30,10 +30,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>The synchronization gate protecting all mutable state in this collection.</summary>
     private readonly Lock _gate = new();
 
-    /// <summary>
-    /// Backing array, <see langword="null"/> until something is added. A removal zeroes its slot rather than shifting
-    /// elements, so <see cref="_length"/> is the high-water mark and <see cref="_count"/> the non-null slots.
-    /// </summary>
+    /// <summary>Backing array; a removal zeroes its slot, so <see cref="_length"/> is the high-water mark and <see cref="_count"/> the non-null slots.</summary>
     private IAsyncDisposable?[]? _items;
 
     /// <summary>High-water mark of used slots in <see cref="_items"/>. Includes slots zeroed by Remove.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
index 81174018..dcbd4006 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
@@ -191,11 +191,7 @@ internal async ValueTask SubscribeSourcesAsync(
             await _outerDisposable.SetDisposableAsync(outerSubscription).ConfigureAwait(false);
         }
 
-        /// <summary>
-        /// Links the original subscribe-time cancellation token into this subscription's dispose chain so
-        /// later per-emission methods can rely on <see cref="DisposedCancellationToken"/> instead of
-        /// allocating a per-emission linked CTS.
-        /// </summary>
+        /// <summary>Links the subscribe-time token into this subscription's dispose chain, surfacing it as <see cref="DisposedCancellationToken"/>.</summary>
         /// <param name="external">The subscribe-time token.</param>
         internal void LinkExternalCancellation(CancellationToken external)
         {
@@ -559,11 +555,7 @@ internal void BeginSubscribing() => FireAndForgetHelper.Run(async () =>
                 }
             });
 
-            /// <summary>
-            /// Links the original subscribe-time cancellation token into this subscription's dispose chain so
-            /// later per-emission methods can rely on <see cref="_disposedCancellationToken"/> instead of
-            /// allocating a per-emission linked CTS.
-            /// </summary>
+            /// <summary>Links the subscribe-time token into this subscription's dispose chain, surfacing it as <see cref="_disposedCancellationToken"/>.</summary>
             /// <param name="external">The subscribe-time token.</param>
             internal void LinkExternalCancellation(CancellationToken external)
             {

From 697d6d40eb25860d17c22d2d987285f2bffc4fc9 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sat, 12 Sep 2026 23:30:43 +1000
Subject: [PATCH 06/11] Further

---
 src/Directory.Packages.props                  |   1 -
 src/Polyfills/TaskPolyfillExtensions.cs       |   9 +-
 .../Advanced/StartSubscription.cs             |  20 +-
 src/Primitives.Async.Shared/AsyncContext.cs   |  48 ++-
 .../Components/ReactiveComponentBase.cs       |   7 +-
 .../Internal/ScheduledWait.cs                 |  41 +++
 .../ObservableSubscriptionExtensions.cs       |  18 +-
 .../Operators/BufferUntilIdleObservable.cs    |   2 +-
 .../Operators/ConflateObservable.cs           |   1 -
 .../Operators/ObserveOnObservable.cs          |   2 -
 .../Operators/RunAllObservable.cs             |   5 +-
 .../Operators/ScheduledSourceObservable.cs    |   4 +-
 .../Operators/SyncTimerObservable.cs          |   3 -
 .../Operators/ThrottleDistinctObservable.cs   |   1 -
 .../Operators/UsingActionObservable.cs        |   2 +-
 .../Operators/UsingFuncObservable.cs          |   2 +-
 .../ReactiveExtensions.cs                     |  76 ++---
 .../CoalescingDispatchScheduler.cs            |   9 +-
 .../DispatchWorkItemBase.cs                   |   8 +-
 .../Advanced/AsyncSubscriptionLifetime.cs     |   2 +-
 .../Advanced/AutoConnectSignal{T}.cs          |   2 -
 .../Advanced/AutoShareSignal{T}.cs            |   5 +-
 .../Advanced/CatchSignal{T}.cs                |   2 +-
 .../Advanced/CreateSink{T}.cs                 |   7 +-
 src/Primitives.Shared/Advanced/EverySignal.cs |   3 +-
 .../Advanced/FromAsyncSubscription{T}.cs      |  11 +-
 .../Advanced/FromAsyncTaskObservation{T}.cs   |   2 +-
 ...Signal{TEventHandler,TCallback,TResult}.cs |   6 +-
 .../Advanced/IsEmptySignal{T}.cs              |   1 -
 .../MaxConcurrentBlendCoordinator{T}.cs       |   4 +-
 .../Advanced/MergeCoordinator{T}.cs           |   1 -
 .../Advanced/RaceWitness{T}.cs                |   2 +-
 .../Advanced/RecoverSignal{T,TException}.cs   |   7 +-
 .../Advanced/ResumeSignal{T}.cs               |   2 +-
 src/Primitives.Shared/Advanced/StartSignal.cs |   8 +-
 .../Advanced/StartSignal{T}.cs                |   8 +-
 .../Advanced/SwitchWitness{T}.cs              |   2 +-
 .../Advanced/TaskFaultObservation.cs          |  25 ++
 .../Advanced/WitnessOnSignal{T}.cs            |   2 +-
 .../ConnectableSignalRxNameExtensions.cs      |  10 +-
 src/Primitives.Shared/Core/Spark{T}.cs        |   8 +-
 .../SignalOperatorMixins.BlendUnique.cs       |  14 +-
 ...SignalOperatorMixins.ChooseSwitchSelect.cs |  11 +-
 .../SignalOperatorMixins.CollectionSignals.cs |   4 +-
 .../SignalOperatorMixins.CombineLatest.cs     |   3 +-
 .../SignalOperatorMixins.Coordinators.cs      |   2 +-
 .../SignalOperatorMixins.SchedulerSignals.cs  | 194 ++++++-----
 .../SignalOperatorMixins.StatefulSignals.cs   |   3 -
 .../SignalOperatorMixins.Switch.cs            |  47 ++-
 ...alOperatorParityMixins.AggregateHelpers.cs |   2 -
 ...OperatorParityMixins.AwaitableTerminals.cs |   6 +-
 ...atorParityMixins.BooleanTerminalHelpers.cs |   2 -
 .../SignalOperatorParityMixins.FlatMap.cs     |   1 -
 .../SignalOperatorParityMixins.Helpers.cs     |   2 -
 .../SignalOperatorParityMixins.Probe.cs       |   4 +-
 ...ixins.RxNames.CombineLatest.Collections.cs |   7 +-
 .../SignalOperatorParityMixins.RxNames.cs     | 115 +++----
 .../SignalOperatorParityMixins.cs             |  12 +-
 .../Signals/PrioritySemaphoreSignal{T}.cs     |  32 +-
 .../Signals/ReplaySignal{T}.cs                |   1 -
 .../Signals/SignalExtensions{Create}.cs       |   8 +-
 .../Signals/SignalExtensions{FromTask}.cs     |  25 +-
 .../Signals/SignalExtensions{GetAwaiter}.cs   |  10 +-
 .../Signals/Signal{Create}.cs                 |  14 +-
 .../Signals/Signal{Factories}.cs              |   2 +-
 .../Signals/Signal{FromTask}.cs               |   2 +-
 .../Signals/TaskSignal{T}.cs                  |   2 +-
 .../Signals/TaskTerminalCompletion{T}.cs      |   3 -
 .../Disposables/CancellationDisposable.cs     |   2 +-
 .../Disposables/EmptyDisposable.cs            |   2 +-
 .../Disposables/MultipleDisposable.cs         |   9 +-
 .../Disposables/MutableDisposable.cs          |   8 +-
 .../Disposables/OnceDisposable.cs             |  12 +-
 .../Disposables/SingleDisposable.cs           |   3 +-
 .../SingleReplaceableDisposable.cs            |  59 ++--
 .../Disposables/SwapDisposable.cs             |  10 +-
 .../Advanced/AsyncSerialGate.cs               |   6 +-
 .../Advanced/BackgroundJobSignal{T}.cs        |   4 +-
 .../Advanced/CallbackWitnessAsync.cs          |   3 +-
 .../Advanced/FlatMapCoordinator{TResult}.cs   |  12 +-
 .../Advanced/ForwardingWitnessAsync.cs        |   5 +-
 .../Advanced/IntervalSignal.cs                |   3 +-
 .../Advanced/IntervalSubscription.cs          |   2 +-
 .../Advanced/LeadSubscription{T}.cs           |   2 +-
 .../Advanced/PooledDelaySource.cs             |  21 +-
 .../Advanced/ReattemptSubscription{T}.cs      |   2 +-
 .../Advanced/SequenceSubscription.cs          |   1 -
 .../Advanced/StartSubscription{TResult}.cs    |  20 +-
 .../Advanced/SyncLatestCoordinatorBase.cs     |   2 +-
 ...tEnumerableCoordinator{TSource,TResult}.cs |   4 +-
 .../Advanced/SyncLatestIndexedWitness.cs      |   7 +-
 .../Advanced/SyncLatestLifecycle.cs           |  11 +-
 .../Advanced/TakeUntilLifecycle.cs            |  12 +-
 .../Advanced/TaskSignalSubscription{T}.cs     |   8 +-
 .../ConnectableSignalAsyncHelper.cs           |  22 +-
 .../Disposables/DisposableAsync.cs            |   6 +-
 .../Disposables/DisposableAsyncSlot.cs        |  20 +-
 .../Disposables/MultipleDisposableAsync.cs    |  16 +-
 .../SingleReplaceableDisposableAsync.cs       |   4 +-
 .../Helpers/FireAndForgetHelper.cs            |   2 +-
 .../IObserverAsync.cs                         |   6 +-
 .../Observables/Create.cs                     |   2 -
 .../Observables/Empty.cs                      |   1 -
 .../Observables/Never.cs                      |   1 -
 .../Observables/Return.cs                     |   3 +-
 .../Observables/ToAsyncSignal.cs              |   7 +-
 .../Operators/Blend.cs                        |   7 +-
 .../Operators/Chain.cs                        |   3 +-
 .../Operators/ChainEnumerableSignal{T}.cs     |   4 +-
 .../Operators/ChainSignalSourcesSignal{T}.cs  |   4 +-
 .../Operators/Expire.cs                       |   7 +-
 .../Operators/Fold.cs                         |  10 +-
 .../Operators/Keep.cs                         |   4 -
 .../Operators/Map.cs                          |   4 -
 .../Operators/Multicast.cs                    |   5 +-
 .../Operators/Pair.cs                         |   4 +-
 .../Operators/ParityHelpers.FilterFusions.cs  |   2 -
 .../ParityHelpers.OperatorFusions.cs          |   4 +-
 .../Operators/ParityHelpers.Partition.cs      |   1 -
 .../Operators/ParityHelpers.cs                |   8 +-
 .../Operators/Recover.cs                      |   2 -
 .../Operators/RefCount.cs                     |   1 -
 .../Operators/Shift.cs                        |   2 +-
 .../SignalAsyncExtensions.Delay.Rx.cs         |   4 +-
 .../SignalAsyncExtensions.Timeout.Rx.cs       |  20 +-
 .../Operators/StartWith.cs                    |   4 +-
 .../Operators/SubscribeAsync.cs               |   2 +-
 .../Operators/SwitchToSignal.cs               |   2 +-
 .../Operators/SyncLatest2.cs                  |   7 +-
 .../Operators/SyncLatestEnumerable.cs         |   1 -
 .../Operators/TakeUntil.cs                    |  20 +-
 .../Operators/Throttle.cs                     |  20 +-
 .../Operators/Unique.cs                       |  13 +-
 ...yLatestSignalAsyncStateObserverLease{T}.cs |   4 +-
 ...yLatestSignalAsyncStateObserverLease{T}.cs |   4 +-
 ...currentStatelessReplayLatestSignalAsync.cs |   2 +-
 .../UnhandledExceptionHandler.cs              |   9 +-
 .../WitnessAsync.cs                           |  19 +-
 .../Concurrency/AvaloniaScheduler.cs          |  46 ++-
 .../Concurrency/AvaloniaScheduler.cs          |  22 +-
 .../ReactiveUI.Primitives.Avalonia.csproj     |   4 +
 .../Concurrency/BlazorRendererSequencer.cs    |  69 ++--
 .../Concurrency/BlazorRendererSequencer.cs    |  72 ++--
 .../ReactiveUI.Primitives.Blazor.csproj       |   4 +
 .../Advanced/AggregateWitness.cs              |   6 +-
 .../Advanced/AsyncEnumerableSignal{T}.cs      |   8 +-
 .../Advanced/BufferWitness.cs                 |   5 +-
 .../Advanced/IAggregator.cs                   |   7 +-
 .../Advanced/SinkSubscription.cs              |   6 +-
 .../Advanced/SinkTerminal.cs                  |   6 +-
 .../Advanced/SubscriptionSlots.cs             |   5 +-
 .../Advanced/SynchronizeWitness.cs            |   6 +-
 .../Advanced/UseSignal{TResource,T}.cs        |   6 +-
 .../Advanced/WitnessTeardown.cs               |   2 +-
 .../Concurrency/ScheduledItem.cs              |  18 +-
 .../ConnectableSignal{T}.cs                   |   3 +-
 .../Core/TimeInterval{T}.cs                   |   5 +-
 src/ReactiveUI.Primitives.Core/Optional.cs    |   5 +-
 .../Signals/AsyncSignal.cs                    |   1 -
 .../Signals/AwaitWitness.cs                   |  10 +-
 .../Signals/BehaviorSignalState{T}.cs         |   2 +-
 .../Signals/Broadcaster{T}.cs                 | 120 ++++---
 .../Signals/CommandSignal{TResult}.cs         |   5 +-
 .../Signals/DelayableNotificationSignal{T}.cs |   6 +-
 .../Signals/DelegateWitness{T}.cs             |   7 +-
 .../MapWithSignal{TSource,TState,TResult}.cs  |   5 +-
 .../Signals/Signal{T}.cs                      |   4 +-
 .../Signals/StateSignal{T}.cs                 |   2 +-
 .../Signals/TapWithSignal{T,TState}.cs        |   5 +-
 .../ConcurrencyLimiter.cs                     |  41 ++-
 .../Continuation.cs                           | 186 ++++++----
 .../CurrentValueSubject.cs                    |   3 +-
 .../FirstAsValueTaskHelper.cs                 |   6 +-
 .../Heartbeat.cs                              |   7 +-
 .../Internal/ReduceSinkState.cs               |   4 +-
 .../Operators/BinaryMinMaxObservable.cs       |   9 +-
 .../Operators/BooleanReduceObservable.cs      |  10 +-
 .../Operators/BufferUntilObservable.cs        |   6 +-
 .../CatchAndReturnWithFactoryObservable.cs    |   7 +-
 .../Operators/CatchIgnoreObservable.cs        |   6 +-
 .../Operators/DropIfBusyObservable.cs         |   6 +-
 .../Operators/FilterRegexObservable.cs        |   5 +-
 .../FirstMatchFromCandidatesObservable.cs     |  11 +-
 .../Operators/MinMaxObservable.cs             |  10 +-
 .../Operators/PartitionObservable.cs          |   9 +-
 .../ReplayLastOnSubscribeObservable.cs        |   5 +-
 .../Operators/SampleLatestObservable.cs       |   7 +-
 .../Operators/ScanWithInitialObservable.cs    |   5 +-
 .../SelectAsyncConcurrentObservable.cs        |   7 +-
 .../SelectAsyncSequentialObservable.cs        |   7 +-
 .../Operators/SelectConstantObservable.cs     |   2 +-
 .../Operators/SelectLatestAsyncObservable.cs  |  17 +-
 .../Operators/SelectManyThenObservable.cs     |   7 +-
 .../Operators/ShuffleObservable.cs            |  33 +-
 .../Operators/SubscribeAsyncObservable.cs     |   9 +-
 .../Operators/SwitchIfEmptyObservable.cs      |   6 +-
 .../Operators/SynchronizeAsyncObservable.cs   |   8 +-
 .../Operators/TakeUntilInclusiveObservable.cs |   7 +-
 .../Operators/TrySelectObservable.cs          |   2 +-
 .../Operators/WaitUntilObservable.cs          |   4 +-
 .../Stale.cs                                  |  10 +-
 .../TimerSinkState.cs                         |   6 +-
 .../Concurrency/MauiDispatcherSequencer.cs    |   6 +-
 .../Concurrency/MauiDispatcherSequencer.cs    |   7 +-
 .../ActivationExtensionsEmitter.cs            |   1 -
 .../CodeGeneration/GeneratedNames.cs          |   3 +-
 .../CodeGeneration/PooledStringBuilder.cs     |   1 -
 .../EventGenerator.cs                         |   4 +-
 .../Helpers/InstanceTargetExtractor.cs        |   2 +-
 .../Helpers/SymbolHelpers.cs                  |   3 +-
 .../Helpers/TargetCollections.cs              |   1 -
 .../Concurrency/WasmScheduler.cs              |  71 ++--
 .../Disposables/ContainerDisposable.cs        |  10 +-
 .../LinqExtensions.ContainerDisposable.cs     |   2 +-
 .../Platforms/android/HandlerSequencer.cs     |  27 +-
 .../Platforms/apple/NSRunloopSequencer.cs     |  26 +-
 .../Concurrency/ControlSequencer.cs           |  51 ++-
 .../Concurrency/ControlSequencer.cs           |  66 ++--
 .../Properties/AssemblyInfo.cs                |   7 +
 .../Concurrency/DispatcherQueueSequencer.cs   |  44 ++-
 .../Concurrency/DispatcherQueueSequencer.cs   |  31 +-
 .../Concurrency/DispatcherSequencer.cs        |  47 ++-
 .../Concurrency/DispatcherSequencer.cs        |  22 +-
 .../Advanced/DispatchSequencerState.cs        |   6 +-
 .../Concurrency/CurrentThreadSequencer.cs     |   6 +-
 .../Concurrency/Sequencer.Simple.cs           |  11 +-
 .../Concurrency/Sequencer.cs                  |   2 +
 .../SynchronizationContextSequencer.cs        |  14 +-
 .../Concurrency/TaskPoolSequencer.cs          |  24 +-
 .../Concurrency/ThreadPoolSequencer.cs        |  22 +-
 .../VirtualTimeSequencerExtensions.cs         |   1 -
 ...rtualTimeSequencer{TAbsolute,TRelative}.cs |   6 +-
 .../VirtualTimeState{TAbsolute,TRelative}.cs  |   1 -
 .../Concurrency/WasmSequencer.cs              |  28 +-
 .../Platforms/android/HandlerSequencer.cs     |  16 +-
 .../Platforms/apple/NSRunloopSequencer.cs     |  15 +-
 src/ReactiveUI.Primitives/RxVoid.cs           |   4 +-
 .../BooleanSignalWitness.cs                   |   2 +-
 .../IntR3ActionWitness.cs                     |   2 +-
 .../SingleReplaceableDisposableTests.cs       |  73 ++++
 .../AsyncRenameCoverageTests.cs               |   4 +-
 .../CancellationStopCoordinatorTests.cs       |  50 +++
 .../ContextSwitchSignalAsyncTests.cs          | 263 ++++++++++++++
 .../CustomTaskScheduler.cs                    |  63 +++-
 .../ErrorHandlingOperatorTests.cs             |  10 +-
 .../FactorySignalTests.cs                     |   2 +-
 .../IntervalSubscriptionTests.cs              |  72 ++++
 .../ManualTaskScheduler.cs                    |  27 ++
 .../ObserveOnAsyncSignalTests.cs              | 322 ------------------
 .../ObserveOnIfOperatorTests.cs               |  20 +-
 .../ObserveOnSafeOperatorTests.cs             |  24 +-
 .../StartSubscriptionTests.cs                 | 105 ++++++
 .../TransformationOperatorTests.cs            |  62 +---
 .../AvaloniaSchedulerTests.cs                 | 200 ++++++-----
 .../AvaloniaTestSession.cs                    |  21 --
 ....Primitives.Avalonia.Reactive.Tests.csproj |   1 -
 .../AvaloniaSchedulerTests.cs                 | 200 ++++++++---
 .../AvaloniaTestSession.cs                    |  21 --
 ...eactiveUI.Primitives.Avalonia.Tests.csproj |   1 -
 .../BlazorRendererSequencerTests.cs           | 117 ++++++-
 .../BlazorRendererSequencerTests.cs           | 117 ++++++-
 .../ContinuationTests.cs                      | 287 ++++++++++++----
 .../Internal/ScheduledWaitTests.cs            |  37 ++
 .../WasmSchedulerTests.cs                     |  28 ++
 .../BroadcasterTests.cs                       |  85 +++++
 .../PrioritySemaphoreSignalTests.cs           |  33 ++
 .../RxNamesTests.Scheduling.cs                | 128 ++++---
 .../RxNamesTests.cs                           |   2 +-
 .../ScheduledItemTests.cs                     |  40 +++
 .../SequencerTests.Cancellation.cs            |  19 +-
 .../SignalFactoriesTests.DefaultSequencer.cs  |  24 +-
 .../SignalTests.cs                            |   2 +-
 .../StartSignalTests.cs                       |  79 ++++-
 .../SwitchCoordinatorTests.cs                 | 178 ++++++++++
 .../SwitchWitnessTests.cs                     | 105 ------
 .../TaskPoolSequencerTests.cs                 |  40 +++
 .../ControlSequencerTests.cs                  | 227 +++++++++---
 .../ControlSequencerTests.cs                  | 210 +++++++++---
 .../DispatcherQueueSequencerTests.cs          | 185 +++++++---
 ...eUI.Primitives.WinUI.Reactive.Tests.csproj |  13 +-
 .../DispatcherQueueSequencerTests.cs          | 197 +++++++----
 .../ReactiveUI.Primitives.WinUI.Tests.csproj  |  13 +-
 .../DispatcherSequencerTests.cs               | 156 ++++++---
 .../DispatcherSequencerTests.cs               | 176 ++++++----
 284 files changed, 4414 insertions(+), 2587 deletions(-)
 create mode 100644 src/Primitives.Extensions.Shared/Internal/ScheduledWait.cs
 create mode 100644 src/Primitives.Shared/Advanced/TaskFaultObservation.cs
 create mode 100644 src/ReactiveUI.Primitives.WinForms/Properties/AssemblyInfo.cs
 create mode 100644 src/tests/ReactiveUI.Disposables.Tests/SingleReplaceableDisposableTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/CancellationStopCoordinatorTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ContextSwitchSignalAsyncTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ManualTaskScheduler.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/StartSubscriptionTests.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaTestSession.cs
 delete mode 100644 src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaTestSession.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ScheduledWaitTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/ScheduledItemTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SwitchCoordinatorTests.cs

diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
index 26e11fed..92c03c56 100644
--- a/src/Directory.Packages.props
+++ b/src/Directory.Packages.props
@@ -33,7 +33,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageVersion Include="Avalonia" Version="$(AvaloniaVersion)"/>
-    <PackageVersion Include="Avalonia.Headless" Version="$(AvaloniaVersion)"/>
     <PackageVersion Include="Microsoft.AspNetCore.Components" Version="8.0.31" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0')) AND !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))"/>
     <PackageVersion Include="Microsoft.AspNetCore.Components" Version="9.0.20" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0')) AND !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0'))"/>
     <PackageVersion Include="Microsoft.AspNetCore.Components" Version="10.0.12" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0')) AND !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net11.0'))"/>
diff --git a/src/Polyfills/TaskPolyfillExtensions.cs b/src/Polyfills/TaskPolyfillExtensions.cs
index c753f8cf..ce028c0d 100644
--- a/src/Polyfills/TaskPolyfillExtensions.cs
+++ b/src/Polyfills/TaskPolyfillExtensions.cs
@@ -58,7 +58,7 @@ private static async Task WaitForCompletionAsync(Task task, TimeSpan timeout, Ca
         using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
         if (timeout != Timeout.InfiniteTimeSpan)
         {
-            linked.CancelAfter(timeout);
+            ScheduleTimeout(linked, timeout);
         }
 
         using (linked.Token.Register(static state => ((TaskCompletionSource<bool>)state).TrySetResult(true), signal))
@@ -71,5 +71,12 @@ private static async Task WaitForCompletionAsync(Task task, TimeSpan timeout, Ca
             }
         }
     }
+
+    /// <summary>Schedules cancellation when the timeout elapses.</summary>
+    /// <param name="source">The cancellation source.</param>
+    /// <param name="timeout">The timeout duration.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private static void ScheduleTimeout(CancellationTokenSource source, TimeSpan timeout) => source.CancelAfter(timeout);
 }
 #endif
diff --git a/src/Primitives.Async.Shared/Advanced/StartSubscription.cs b/src/Primitives.Async.Shared/Advanced/StartSubscription.cs
index 88b5c2f5..02bcb33b 100644
--- a/src/Primitives.Async.Shared/Advanced/StartSubscription.cs
+++ b/src/Primitives.Async.Shared/Advanced/StartSubscription.cs
@@ -46,7 +46,21 @@ protected override async ValueTask ExecuteAsyncCore(
             return;
         }
 
-        await Task.Factory.StartNew(
+        await ExecuteOnSchedulerAsync(observer, taskScheduler, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>Starts the action through the supplied scheduler.</summary>
+    /// <param name="observer">The observer receiving the signal notification.</param>
+    /// <param name="taskScheduler">The scheduler that starts the action.</param>
+    /// <param name="cancellationToken">Cancellation for the scheduled task and notifications.</param>
+    /// <returns>The scheduled action and notification operation.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private Task ExecuteOnSchedulerAsync(
+        IObserverAsync<RxVoid> observer,
+        TaskScheduler taskScheduler,
+        CancellationToken cancellationToken) =>
+        Task.Factory.StartNew(
                 static s =>
                 {
                     var (self, observer, cancellationToken) =
@@ -57,9 +71,7 @@ await Task.Factory.StartNew(
                 cancellationToken,
                 TaskCreationOptions.DenyChildAttach,
                 taskScheduler)
-            .Unwrap()
-            .ConfigureAwait(false);
-    }
+            .Unwrap();
 
     /// <summary>Runs the action and forwards the completion signal.</summary>
     /// <param name="observer">The observer receiving the signal notification.</param>
diff --git a/src/Primitives.Async.Shared/AsyncContext.cs b/src/Primitives.Async.Shared/AsyncContext.cs
index b95d9352..f9dd4046 100644
--- a/src/Primitives.Async.Shared/AsyncContext.cs
+++ b/src/Primitives.Async.Shared/AsyncContext.cs
@@ -26,7 +26,7 @@ private AsyncContext()
     public static AsyncContext Default { get; } = new();
 
     /// <summary>Gets the synchronization context to use for marshaling callbacks and continuations.</summary>
-    /// <remarks>A specified synchronization context receives posted continuations; otherwise the task scheduler determines execution.</remarks>
+    /// <remarks>A synchronization context takes precedence over the task scheduler and sequencer.</remarks>
     public SynchronizationContext? SynchronizationContext { get; init; }
 
     /// <summary>Gets the task scheduler to use for scheduling tasks, or null to use the default scheduler.</summary>
@@ -67,8 +67,7 @@ public static AsyncContext From(TaskScheduler taskScheduler)
     /// <param name="scheduler">The sequencer to use for configuring the AsyncContext.</param>
     /// <returns>An AsyncContext instance configured with the provided scheduler.</returns>
     /// <exception cref="ArgumentNullException">Thrown if scheduler is null.</exception>
-    /// <remarks>If the provided sequencer directly implements <see cref="SynchronizationContext"/>, that instance is used
-    /// directly. Otherwise, continuations are scheduled as direct <see cref="IWorkItem"/> instances on the sequencer.</remarks>
+    /// <remarks>A sequencer that is also a synchronization context receives posted continuations.</remarks>
     public static AsyncContext From(ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
@@ -122,7 +121,7 @@ public readonly record struct AsyncContextSwitcherAwaitable(
 
         /// <summary>Schedules the specified continuation action to be invoked when the operation has completed.</summary>
         /// <param name="continuation">The action to execute when the operation is complete. Cannot be null.</param>
-        /// <remarks>Continuations use the synchronization context or task scheduler; cancellation invokes them immediately on the current thread.</remarks>
+        /// <remarks>An already cancelled token invokes the continuation immediately on the caller's thread.</remarks>
         public void OnCompleted(Action continuation)
         {
             ArgumentExceptionHelper.ThrowIfNull(continuation);
@@ -136,18 +135,14 @@ public void OnCompleted(Action continuation)
             var sc = AsyncContext.SynchronizationContext;
             if (sc is not null)
             {
-                sc.Post(static c => ((Action)c!).Invoke(), continuation);
+                PostContinuation(sc, continuation);
                 return;
             }
 
             var ts = AsyncContext.TaskScheduler;
             if (ts is not null && ts != TaskScheduler.Default)
             {
-                _ = Task.Factory.StartNew(
-                    continuation,
-                    CancellationToken.None,
-                    TaskCreationOptions.DenyChildAttach,
-                    ts);
+                ScheduleContinuation(ts, continuation);
                 return;
             }
 
@@ -158,13 +153,36 @@ public void OnCompleted(Action continuation)
                 return;
             }
 
-            // Queue directly to avoid allocating a Task for each continuation.
-            if (ts is null || ts == TaskScheduler.Default)
-            {
-                _ = ThreadPool.UnsafeQueueUserWorkItem(static c => ((Action)c!).Invoke(), continuation);
-            }
+            QueueContinuation(continuation);
         }
 
+        /// <summary>Posts a continuation to the supplied synchronization context.</summary>
+        /// <param name="context">The context receiving the continuation.</param>
+        /// <param name="continuation">The continuation to invoke.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void PostContinuation(SynchronizationContext context, Action continuation) =>
+            context.Post(static c => ((Action)c!).Invoke(), continuation);
+
+        /// <summary>Schedules a continuation through the supplied task scheduler.</summary>
+        /// <param name="scheduler">The scheduler receiving the continuation.</param>
+        /// <param name="continuation">The continuation to invoke.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ScheduleContinuation(TaskScheduler scheduler, Action continuation) =>
+            _ = Task.Factory.StartNew(
+                continuation,
+                CancellationToken.None,
+                TaskCreationOptions.DenyChildAttach,
+                scheduler);
+
+        /// <summary>Queues a continuation on the thread pool without capturing execution context.</summary>
+        /// <param name="continuation">The continuation to invoke.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void QueueContinuation(Action continuation) =>
+            _ = ThreadPool.UnsafeQueueUserWorkItem(static c => ((Action)c!).Invoke(), continuation);
+
         /// <summary>Work item used to schedule context-switch continuations directly on an <see cref="ISequencer"/>.</summary>
         /// <param name="continuation">The continuation to invoke.</param>
         private sealed class ContinuationWorkItem(Action continuation) : IWorkItem
diff --git a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
index 5bd07e31..83b409fa 100644
--- a/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
+++ b/src/Primitives.Blazor.Shared/Components/ReactiveComponentBase.cs
@@ -12,9 +12,10 @@ namespace ReactiveUI.Primitives.Blazor.Components;
 #endif
 
 /// <summary>Base component that tracks reactive subscriptions and refreshes through Blazor's renderer dispatcher.</summary>
-/// <remarks>Every observed callback is marshalled onto the renderer dispatcher, so a handler can touch component state
-/// directly, and a callback that throws is dispatched to the enclosing error boundary instead of faulting a detached
-/// task. Disposing the component disposes every tracked subscription.</remarks>
+/// <remarks>
+/// Callbacks run on the renderer dispatcher; callback exceptions reach the enclosing error boundary. Component disposal releases tracked
+/// subscriptions.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class ReactiveComponentBase : ComponentBase, IDisposable
 {
diff --git a/src/Primitives.Extensions.Shared/Internal/ScheduledWait.cs b/src/Primitives.Extensions.Shared/Internal/ScheduledWait.cs
new file mode 100644
index 00000000..a968843c
--- /dev/null
+++ b/src/Primitives.Extensions.Shared/Internal/ScheduledWait.cs
@@ -0,0 +1,41 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+#if REACTIVE_SHIM
+namespace ReactiveUI.Primitives.Extensions.Reactive.Internal;
+#else
+namespace ReactiveUI.Primitives.Extensions.Internal;
+#endif
+
+/// <summary>Runs an action after a synchronous wait.</summary>
+internal static class ScheduledWait
+{
+    /// <summary>Runs an action after the specified delay.</summary>
+    /// <param name="dueTime">The delay.</param>
+    /// <param name="action">The action to invoke.</param>
+    /// <returns>An empty disposable after the action returns.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static IDisposable Run(TimeSpan dueTime, Action action) => Run(dueTime, action, Wait);
+
+    /// <summary>Invokes an action after the supplied wait completes.</summary>
+    /// <param name="dueTime">The delay passed to the wait operation.</param>
+    /// <param name="action">The action to invoke.</param>
+    /// <param name="wait">The wait operation; a failure prevents the action.</param>
+    /// <returns>An empty disposable after the action returns.</returns>
+    internal static IDisposable Run(TimeSpan dueTime, Action action, Action<TimeSpan> wait)
+    {
+        wait(dueTime);
+        action();
+        return EmptyDisposable.Instance;
+    }
+
+    /// <summary>Blocks the current thread for the requested delay.</summary>
+    /// <param name="dueTime">The delay.</param>
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Wait(TimeSpan dueTime) => Thread.Sleep(dueTime);
+}
diff --git a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
index 071cfb63..c4689aaf 100644
--- a/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ObservableSubscriptionExtensions.cs
@@ -21,7 +21,7 @@ public static class ObservableSubscriptionExtensions
     /// <param name="source">The observable to subscribe to.</param>
     extension(IObservable<RxVoid> source)
     {
-        /// <summary>Subscribes to a <see cref="RxVoid"/>-producing observable, discarding the value. Safe only when the sequence terminates synchronously.</summary>
+        /// <summary>Subscribes to a synchronously terminating sequence and discards its value.</summary>
         public void SubscribeAndComplete()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -127,7 +127,7 @@ public void WaitForCompletion(ISequencer scheduler, TimeSpan timeout) =>
         public T? WaitForValue(ISequencer scheduler, TimeSpan timeout) =>
             WaitForValueCore(source, scheduler, timeout);
 
-        /// <summary>Blocks until the source terminates; returns any captured error (does NOT rethrow). Default 30s timeout.</summary>
+        /// <summary>Blocks until the source terminates or the timeout expires, returning any captured error without throwing it.</summary>
         /// <returns>The captured error, or <see langword="null"/> if completion was normal.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Exception? WaitForError() =>
@@ -175,7 +175,7 @@ public void WaitForCompletion(ISequencer scheduler, TimeSpan timeout) =>
         BlockingValueWitness<T> sink = new(done);
         using var subscription = ScheduledSubscribe(source, sink, scheduler);
 
-        if (!done.Wait(timeout))
+        if (!WaitForTerminal(done, timeout))
         {
             throw new TimeoutException(
                 $"WaitForValue timed out after {timeout.TotalSeconds}s.");
@@ -197,7 +197,7 @@ private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer
         BlockingTerminalWitness<RxVoid> sink = new(done);
         using var subscription = ScheduledSubscribe(source, sink, scheduler);
 
-        if (!done.Wait(timeout))
+        if (!WaitForTerminal(done, timeout))
         {
             throw new TimeoutException(
                 $"WaitForCompletion timed out after {timeout.TotalSeconds}s.");
@@ -226,7 +226,7 @@ private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer
         BlockingTerminalWitness<T> sink = new(done);
         using var subscription = ScheduledSubscribe(source, sink, scheduler);
 
-        if (!done.Wait(timeout))
+        if (!WaitForTerminal(done, timeout))
         {
             throw new TimeoutException(
                 $"WaitForError timed out after {timeout.TotalSeconds}s.");
@@ -235,6 +235,14 @@ private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer
         return sink.Error;
     }
 
+    /// <summary>Blocks until a terminal signal arrives or the timeout expires.</summary>
+    /// <param name="done">The terminal signal.</param>
+    /// <param name="timeout">The maximum wait duration.</param>
+    /// <returns>True when the signal arrives; false on timeout.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool WaitForTerminal(ManualResetEventSlim done, TimeSpan timeout) => done.Wait(timeout);
+
     /// <summary>Subscribes <paramref name="observer"/> to <paramref name="source"/> on <paramref name="scheduler"/>, or inline when no scheduler is supplied.</summary>
     /// <typeparam name="T">The type of the elements in <paramref name="source"/>.</typeparam>
     /// <param name="source">The observable to subscribe to.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
index 9c31fd7d..e0f494f1 100644
--- a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Buffers elements and emits them when the stream has been idle for a specified duration. Backs both the <c>BufferUntilIdle</c> and <c>BufferUntilInactive</c> public operators.</summary>
+/// <summary>Buffers elements until the source has been idle for the specified duration.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="idleTime">The duration of inactivity required to flush the buffer.</param>
diff --git a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
index b0cbd66b..666bb875 100644
--- a/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ConflateObservable.cs
@@ -128,7 +128,6 @@ void IDrainTarget.Drain()
 
                     default:
                         {
-                            // Completed is the only remaining kind; this arm keeps the switch exhaustive.
                             ForwardCompleted();
                             return;
                         }
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
index 0c8eae16..6045ef6d 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
@@ -23,7 +23,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        // The immediate sequencer runs scheduled work inline, so queue-and-drain would change nothing.
         if (ReferenceEquals(scheduler, Sequencer.Immediate))
         {
             return source.Subscribe(observer);
@@ -103,7 +102,6 @@ void IDrainTarget.Drain()
 
                     default:
                         {
-                            // Completed is the only remaining kind; this arm keeps the switch exhaustive.
                             _state.Terminate();
                             _downstream.OnCompleted();
                             return;
diff --git a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
index e7b05b55..461eb0cb 100644
--- a/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/RunAllObservable.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Extensions.Reactive.Operators;
 namespace ReactiveUI.Primitives.Extensions.Operators;
 #endif
 
-/// <summary>Runs sources sequentially, ignores their values, and emits RxVoid on completion. Empty input completes immediately; source errors propagate.</summary>
+/// <summary>Runs sources sequentially and emits RxVoid on completion, propagating source errors and completing immediately for empty input.</summary>
 /// <param name="sources">The list of one-shot observables to run in order.</param>
 internal sealed class RunAllObservable(IReadOnlyList<IObservable<RxVoid>> sources) : IObservable<RxVoid>
 {
@@ -56,7 +56,7 @@ internal sealed class Sink(
         /// <inheritdoc/>
         public void OnNext(RxVoid value)
         {
-            // Ignore — we only care about completion.
+            // Values are ignored; completion advances to the next source.
         }
 
         /// <inheritdoc/>
@@ -80,7 +80,6 @@ public void OnCompleted()
 
             if (_looping)
             {
-                // Inside the loop the surrounding RunNext reads _iterationTerminated; no recursion.
                 Volatile.Write(ref _iterationTerminated, 1);
                 return;
             }
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
index 48edde8c..8c0a4e12 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduledSourceObservable.cs
@@ -108,13 +108,13 @@ public void OnNext(T value)
         /// <inheritdoc/>
         public void OnError(Exception error)
         {
-            // Not forwarded: this operator is next-only by contract.
+            // Terminal notifications are not forwarded.
         }
 
         /// <inheritdoc/>
         public void OnCompleted()
         {
-            // Not forwarded: this operator is next-only by contract.
+            // Terminal notifications are not forwarded.
         }
     }
 }
diff --git a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
index 4681e65b..41a531a6 100644
--- a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
@@ -85,14 +85,11 @@ private void Remove(IObserver<DateTime> observer)
         {
             lock (_gate)
             {
-                // Never null: Dispose's Interlocked guard admits one Remove per subscription, and the
-                // observer was added under this same lock before the disposable was handed out.
                 var updated = ObserverArrayHelpers.RemoveOrNull(_observers, observer, _emptyObservers)!;
 
                 Volatile.Write(ref _observers, updated);
                 if (ReferenceEquals(updated, _emptyObservers))
                 {
-                    // Never null: reaching an empty set means Subscribe ran, which arms the timer.
                     _timerSubscription!.Dispose();
                     _timerSubscription = null;
                 }
diff --git a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
index 17a3ee90..f74fb9a6 100644
--- a/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ThrottleDistinctObservable.cs
@@ -27,7 +27,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        // Equivalent to DistinctUntilChanged().Throttle(throttle, scheduler).DistinctUntilChanged(), fused into one sink.
         ThrottleDistinctSink sink = new(observer, throttle, scheduler);
         var subscription = source.Subscribe(sink);
         return new DisposableBag(subscription, sink);
diff --git a/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs b/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
index cdc2e1e2..b19c2a43 100644
--- a/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/UsingActionObservable.cs
@@ -67,7 +67,7 @@ private static void Run(IObserver<RxVoid> observer, T resource, Action<T>? actio
             }
             catch
             {
-                // Swallow secondary dispose failure; the primary exception is what callers care about.
+                // Secondary disposal errors do not replace the original failure.
             }
 
             observer.OnError(error);
diff --git a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
index 3f752c7e..fd6cc45c 100644
--- a/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/UsingFuncObservable.cs
@@ -70,7 +70,7 @@ private static void Run(IObserver<TResult> observer, T resource, Func<T, TResult
             }
             catch
             {
-                // Swallow secondary dispose failure; the primary exception is what callers care about.
+                // Secondary disposal errors do not replace the original failure.
             }
 
             observer.OnError(error);
diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
index 208caa36..b33e1289 100644
--- a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
@@ -145,13 +145,13 @@ public IObservable<RxVoid> CatchReturnUnit() =>
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Returns only values that are not null. Converts the nullability.</summary>
+        /// <summary>Filters out null values and returns a sequence with a non-nullable element type.</summary>
         /// <returns>A non nullable version of the observable that only emits valid values.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> WhereIsNotNull() =>
             new WhereIsNotNullObservable<T>(source);
 
-        /// <summary>Change the source observable type to <see cref="RxVoid"/>. This allows us to be notified when the observable emits a value.</summary>
+        /// <summary>Replaces each source value with RxVoid.</summary>
         /// <returns>The signal.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<RxVoid> AsSignal() =>
@@ -189,11 +189,7 @@ public IObservable<T> CatchIgnore<TException>(Action<TException> errorAction)
         public IObservable<Stale<T>> DetectStale(TimeSpan stalenessPeriod, ISequencer scheduler) =>
             new DetectStaleObservable<T>(source, stalenessPeriod, scheduler);
 
-        /// <summary>
-        /// Applies a conflation algorithm to an observable stream. Anytime the stream OnNext twice
-        /// below minimumUpdatePeriod, the second update gets delayed to respect the
-        /// minimumUpdatePeriod. If more than 2 updates happen, only the last update is pushed.
-        /// </summary>
+        /// <summary>Emits updates at least minimumUpdatePeriod apart, retaining only the latest pending update.</summary>
         /// <param name="minimumUpdatePeriod">Minimum delay between two updates.</param>
         /// <param name="scheduler">Scheduler to publish updates.</param>
         /// <returns>The conflated stream.</returns>
@@ -216,7 +212,7 @@ public IObservable<Heartbeat<T>> Heartbeat(TimeSpan heartbeatPeriod, ISequencer
         public IObservable<T> LatestOrDefault(T defaultValue) =>
             new LatestOrDefaultObservable<T>(source, defaultValue);
 
-        /// <summary>Logs the errors. Inline error logging without terminating the stream.</summary>
+        /// <summary>Logs errors without terminating the sequence.</summary>
         /// <param name="logger">The logger.</param>
         /// <returns>A sequence that logs errors.</returns>
         public IObservable<T> LogErrors(Action<Exception> logger)
@@ -398,11 +394,7 @@ public IDisposable SubscribeSynchronous(Func<T, ValueTask> onNext) =>
         public IObservable<T> SwitchIfEmpty(IObservable<T> fallback) =>
             new SwitchIfEmptyObservable<T>(source, fallback);
 
-        /// <summary>
-        /// Synchronizes the asynchronous operations in downstream operations.
-        /// Use SubscribeSynchronus instead for a simpler version.
-        /// Call Sync.Dispose() to release the lock in the downstream methods.
-        /// </summary>
+        /// <summary>Pairs each value with a disposable acknowledgement that releases its downstream wait.</summary>
         /// <returns>An Observable of T and a release mechanism.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<(T Value, IDisposable Sync)> SynchronizeAsync() =>
@@ -531,13 +523,7 @@ public IObservable<T> ThrottleOnScheduler(TimeSpan timeSpan, ISequencer schedule
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Task<T> ToHotTask() => FirstAsTaskHelper.FirstAsTask(source);
 
-        /// <summary>
-        /// Convert an observable to a <see cref="ValueTask{T}"/> that starts immediately. Backed by a
-        /// pooled <see cref="System.Threading.Tasks.Sources.IValueTaskSource{T}"/> implementation, so
-        /// steady-state callers pay no allocations after the per-type pool warms up. Prefer this over
-        /// <see cref="ToHotTask{T}"/> when the call site can consume a <see cref="ValueTask{T}"/>
-        /// (single await, no caching, no <c>WhenAll</c>).
-        /// </summary>
+        /// <summary>Subscribes immediately and returns a ValueTask for the first value that must be consumed exactly once.</summary>
         /// <returns>A <see cref="ValueTask{T}"/> that completes with the first value, faults on source error, or faults on empty completion.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask<T> ToHotValueTask() =>
@@ -692,11 +678,7 @@ public IObservable<T> DoOnSubscribe(Action action) =>
         public IObservable<T> DoOnDispose(Action disposeAction) =>
             new DoOnDisposeObservable<T>(source, disposeAction);
 
-        /// <summary>
-        /// Fused <c>Where(predicate).Select(selector)</c>. Allocates a single observer
-        /// per subscription instead of two, eliminating the intermediate operator that
-        /// the equivalent Rx chain would build.
-        /// </summary>
+        /// <summary>Projects source values that satisfy the predicate.</summary>
         /// <typeparam name="TOut">The projected element type.</typeparam>
         /// <param name="predicate">Filter applied to each source element.</param>
         /// <param name="selector">Projection applied to elements that pass <paramref name="predicate"/>.</param>
@@ -712,7 +694,7 @@ public IObservable<TOut> WhereSelect<TOut>(Func<T, bool> predicate, Func<T, TOut
         public IObservable<T> CatchReturn(T fallback) =>
             new CatchReturnObservable<T>(source, fallback);
 
-        /// <summary>Projects every source element to a stored constant, avoiding the closure allocation of <c>.Select(_ =&gt; value)</c>. Common in fire-then-return-value chains.</summary>
+        /// <summary>Replaces each source value with the supplied constant.</summary>
         /// <typeparam name="TResult">The result element type.</typeparam>
         /// <param name="constant">The constant value emitted for each source element.</param>
         /// <returns>An observable that emits <paramref name="constant"/> for each source element.</returns>
@@ -720,11 +702,7 @@ public IObservable<T> CatchReturn(T fallback) =>
         public IObservable<TResult> SelectConstant<TResult>(TResult constant) =>
             new SelectConstantObservable<T, TResult>(source, constant);
 
-        /// <summary>
-        /// Applies <paramref name="selector"/> and emits only non-null results.
-        /// Replaces <c>.Select(f).Where(x =&gt; x is not null).Select(x =&gt; x!)</c>
-        /// with a single operator allocation.
-        /// </summary>
+        /// <summary>Projects source values and forwards only non-null results.</summary>
         /// <typeparam name="TOut">The projected element type.</typeparam>
         /// <param name="selector">Projection that may return <see langword="null"/>.</param>
         /// <returns>An observable that emits only non-null projected values.</returns>
@@ -732,7 +710,7 @@ public IObservable<TResult> SelectConstant<TResult>(TResult constant) =>
         public IObservable<TOut> TrySelect<TOut>(Func<T, TOut?> selector) =>
             new TrySelectObservable<T, TOut>(source, selector);
 
-        /// <summary>Chains two one-shot <c>SelectMany</c> projections into a single operator. Replaces <c>.SelectMany(a).SelectMany(b)</c> (2 operator allocations) with 1.</summary>
+        /// <summary>Projects each source value through two successive observable selectors.</summary>
         /// <typeparam name="TMid">The intermediate element type.</typeparam>
         /// <typeparam name="TResult">The final result type.</typeparam>
         /// <param name="first">First projection: source → intermediate observable.</param>
@@ -795,8 +773,8 @@ public IObservable<T> GetMin(params IObservable<T>[] sources)
     }
 
     /// <summary>Null-skipping operators for an observable source sequence of reference types.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="source">The source.</param>
+    /// <typeparam name="T">The reference type of the source elements.</typeparam>
+    /// <param name="source">The source observable.</param>
     extension<T>(IObservable<T> source)
         where T : class
     {
@@ -904,12 +882,7 @@ public void OnNext(params T[] events)
     /// <param name="sources">The observables to run in order.</param>
     extension(IReadOnlyList<IObservable<RxVoid>> sources)
     {
-        /// <summary>
-        /// Runs a list of one-shot <see cref="IObservable{RxVoid}"/> sequentially and emits
-        /// a single <see cref="RxVoid.Default"/> when all have completed. Replaces
-        /// <c>.Concat().LastOrDefaultAsync()</c> with a single operator that avoids stack
-        /// overflow on inline-completing sources.
-        /// </summary>
+        /// <summary>Runs sources sequentially and emits RxVoid after all complete.</summary>
         /// <returns>A one-shot observable that completes after all sources.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<RxVoid> RunAll() =>
@@ -922,11 +895,7 @@ public IObservable<RxVoid> RunAll() =>
     extension<TKey>(IReadOnlyList<TKey> candidates)
     {
         /// <summary>
-        /// Walks a list of candidate keys sequentially, projects each into a one-shot
-        /// observable, transforms the raw value, and emits the first transformed value
-        /// that satisfies <paramref name="predicate"/>. Errors from individual projections
-        /// are swallowed (the candidate is skipped). If no candidate matches, emits
-        /// <paramref name="fallback"/>.
+        /// Projects candidates sequentially, skipping projection errors, and emits the first matching transformed value or the fallback.
         /// </summary>
         /// <typeparam name="TRaw">The raw element type emitted by the projection.</typeparam>
         /// <typeparam name="TResult">The transformed result type.</typeparam>
@@ -977,14 +946,9 @@ public IDisposable ScheduleSafe(TimeSpan dueTime, Action action)
         {
             ArgumentExceptionHelper.ThrowIfNull(action);
 
-            if (scheduler is null)
-            {
-                Thread.Sleep(dueTime);
-                action();
-                return EmptyDisposable.Instance;
-            }
-
-            return scheduler.Schedule(dueTime, action);
+            return scheduler is null
+                ? ScheduledWait.Run(dueTime, action)
+                : scheduler.Schedule(dueTime, action);
         }
     }
 
@@ -1054,8 +1018,8 @@ public IObservable<TProperty> ToPropertyObservable<TProperty>(
     }
 
     /// <summary>Scheduling operators for a single value.</summary>
-    /// <typeparam name="T">The type.</typeparam>
-    /// <param name="value">The value.</param>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="value">The value to schedule.</param>
     extension<T>(T value)
     {
         /// <summary>Schedules a single value after a delay.</summary>
@@ -1138,7 +1102,7 @@ public static IObservable<TResult> Start<TResult>(Func<TResult> function, ISeque
         new StartFuncObservable<TResult>(function, scheduler);
 
     /// <summary>Builds a current-value subject pair: a read-only observable and the push-side observer.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The value type carried by the subject.</typeparam>
     /// <param name="initialValue">The initial value.</param>
     /// <returns>A tuple of IObservable and IObserver.</returns>
     public static (IObservable<T> Observable, IObserver<T> Observer) ToReadOnlyBehavior<T>(T initialValue)
diff --git a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
index 43fd7b74..dcb51949 100644
--- a/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
+++ b/src/Primitives.Platform.Reactive.Shared/CoalescingDispatchScheduler.cs
@@ -10,11 +10,10 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>Base <see cref="IScheduler"/> for UI-thread dispatchers that drains queued work one batch per dispatcher post.</summary>
-/// <remarks>Work runs on the dispatcher thread; scheduling from that thread queues the item for the next posted batch
-/// rather than running it inline, so a scheduled action never re-enters the caller. The disposable a
-/// <c>Schedule</c> overload returns suppresses work that has not started and disposes what a started action
-/// returned. A platform scheduler supplies <see cref="Post"/> and may replace the delayed path by overriding
-/// <see cref="ScheduleOnDispatcher"/>.</remarks>
+/// <remarks>
+/// Work runs in posted dispatcher batches without inline reentrancy. Disposing a scheduled action suppresses unstarted work and disposes the
+/// resource returned by an action that has started.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("CoalescingDispatchScheduler: ReadyCount = {_readyCount}, DrainPosted = {_drainPosted}")]
 public abstract class CoalescingDispatchScheduler : LocalScheduler
 {
diff --git a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
index 5fb7f74c..0e881841 100644
--- a/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
+++ b/src/Primitives.Platform.Reactive.Shared/DispatchWorkItemBase.cs
@@ -60,12 +60,18 @@ public void Run()
             return;
         }
 
+        ReleaseCanceledResult();
+    }
+
+    /// <summary>Releases the published result if the work item is cancelled.</summary>
+    internal void ReleaseCanceledResult()
+    {
         if (!IsDisposed)
         {
             return;
         }
 
-        disposable.Dispose();
+        ReleaseStartedWork();
     }
 
     /// <summary>Atomically claims the single cancellation transition for this work item.</summary>
diff --git a/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
index 020b85ba..3e169c0b 100644
--- a/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
+++ b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs
@@ -100,7 +100,7 @@ private static void CancelIgnoringDisposed(CancellationTokenSource cts)
         }
         catch (ObjectDisposedException)
         {
-            // Completion can release the CTS concurrently; disposal continues with the inner subscription.
+            // Concurrent completion does not prevent subscription disposal.
         }
     }
 }
diff --git a/src/Primitives.Shared/Advanced/AutoConnectSignal{T}.cs b/src/Primitives.Shared/Advanced/AutoConnectSignal{T}.cs
index db73a391..e0281569 100644
--- a/src/Primitives.Shared/Advanced/AutoConnectSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/AutoConnectSignal{T}.cs
@@ -60,8 +60,6 @@ public IDisposable Subscribe(IObserver<T> observer)
 
         var subscription = Source.Subscribe(observer);
 
-        // Auto-connect only ever counts up and connects once, so no lock is needed: a single
-        // CompareExchange latches the connect once the threshold is reached.
         var count = Interlocked.Increment(ref _count);
         if (count >= SubscriberCount && Interlocked.CompareExchange(ref _connected, 1, 0) == 0)
         {
diff --git a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
index cef1b153..38e83db0 100644
--- a/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/AutoShareSignal{T}.cs
@@ -102,8 +102,6 @@ private void ConnectOutsideGate(IDisposable subscription)
         {
             _isConnecting = false;
 
-            // _connection is null here: _isConnecting gated every other subscriber out of Connect, and
-            // Release only ever nulls _connection. Publish the connection while subscribers remain.
             if (_count != 0)
             {
                 _connection = connection;
@@ -111,8 +109,7 @@ private void ConnectOutsideGate(IDisposable subscription)
             }
         }
 
-        // A re-entrant or concurrent Release drained the count while connecting, so the connection is
-        // orphaned and disposed here.
+        // A connection completed after the last unsubscription is disposed.
         connection.Dispose();
     }
 
diff --git a/src/Primitives.Shared/Advanced/CatchSignal{T}.cs b/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
index 66e650ed..740569a6 100644
--- a/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/CatchSignal{T}.cs
@@ -171,7 +171,7 @@ private void RecursiveRun(Action self)
             }
         }
 
-        /// <summary>Advances the enumerator to the next source. Call while holding <see cref="_gate"/>.</summary>
+        /// <summary>Advances the enumerator to the next source while the caller holds the gate.</summary>
         /// <param name="next">The next source, or <see langword="null"/> once the sequence is exhausted.</param>
         /// <param name="error">The exception the sequence raised, when it raised one.</param>
         /// <returns><see langword="true"/> when the sequence advanced without raising.</returns>
diff --git a/src/Primitives.Shared/Advanced/CreateSink{T}.cs b/src/Primitives.Shared/Advanced/CreateSink{T}.cs
index 234c4735..ca68e7fb 100644
--- a/src/Primitives.Shared/Advanced/CreateSink{T}.cs
+++ b/src/Primitives.Shared/Advanced/CreateSink{T}.cs
@@ -10,12 +10,9 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// The observer handed to create-style subscription factories. It forwards notifications until terminated and owns
-/// the cancel resource the factory returns; when constructed with <c>disposeOnNextThrow</c> it also releases that
-/// resource before rethrowing if a downstream <c>OnNext</c> throws.
-/// </summary>
+/// <summary>Forwards notifications until termination and owns the resource returned by the subscription factory.</summary>
 /// <typeparam name="T">The value type.</typeparam>
+/// <remarks>When disposeOnNextThrow is enabled, a downstream OnNext failure disposes the resource before rethrowing.</remarks>
 [System.Diagnostics.DebuggerDisplay("CreateSink: Stopped = {_stopped}, Observer = {_observer}")]
 public sealed class CreateSink<T> : IDisposable, IObserver<T>
 {
diff --git a/src/Primitives.Shared/Advanced/EverySignal.cs b/src/Primitives.Shared/Advanced/EverySignal.cs
index 458ea6ca..a958d980 100644
--- a/src/Primitives.Shared/Advanced/EverySignal.cs
+++ b/src/Primitives.Shared/Advanced/EverySignal.cs
@@ -99,7 +99,6 @@ internal EveryCoordinator Run()
         /// <summary>Emits the current tick and reschedules unless cancelled.</summary>
         private void Tick()
         {
-            // The sequencer checks cancellation before invoking this item, not before the observer is called.
             if (_slot.IsDisposed)
             {
                 return;
@@ -109,7 +108,7 @@ private void Tick()
             _tick++;
             _observer.OnNext(tick);
 
-            // An observer that disposes from inside OnNext must stop the schedule rather than re-arm it.
+            // Disposal from OnNext stops future notifications.
             if (_slot.IsDisposed)
             {
                 return;
diff --git a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
index 8bf1e500..5ac15f6f 100644
--- a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
+++ b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
@@ -101,14 +101,21 @@ internal IDisposable Start()
         }
 
         FromAsyncTaskObservation<T> observation = new(Observer, Lifetime, ExternalCancellation, linkedSource);
+        RegisterObservation(task, observation);
+        return this;
+    }
+
+    /// <summary>Registers the callback that receives a pending task's terminal state.</summary>
+    /// <param name="task">The pending task.</param>
+    /// <param name="observation">The terminal-state observer.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void RegisterObservation(Task<T> task, FromAsyncTaskObservation<T> observation) =>
         _ = task.ContinueWith(
             static (completedTask, state) => ((FromAsyncTaskObservation<T>)state!).Observe(completedTask),
             observation,
             CancellationToken.None,
             TaskContinuationOptions.ExecuteSynchronously,
             TaskScheduler.Default);
-        return this;
-    }
 
     /// <summary>Forwards a task that has reached a terminal state.</summary>
     /// <param name="task">The task to observe.</param>
diff --git a/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs b/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
index 2c8e4644..b58d328e 100644
--- a/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
+++ b/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
@@ -57,7 +57,7 @@ internal void Observe(Task<T> task)
         }
         catch (Exception) when (Lifetime.IsCancellationRequested)
         {
-            // Subscription disposal owns this cancellation path and must stay silent downstream.
+            // Subscription cancellation does not send a terminal notification.
         }
         catch (Exception error)
         {
diff --git a/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs b/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
index fb04d930..e63f8b20 100644
--- a/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
+++ b/src/Primitives.Shared/Advanced/FromEventConversionSignal{TEventHandler,TCallback,TResult}.cs
@@ -8,11 +8,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Bridges an event whose handler is built by a caller-supplied conversion, letting the handler do synchronous work
-/// inside the event before the notification is published downstream. The conversion replaces reflective delegate
-/// creation, so the bridge is trim- and AOT-safe.
-/// </summary>
+/// <summary>Bridges an event through a caller-supplied conversion that runs before publishing each notification.</summary>
 /// <typeparam name="TEventHandler">The delegate type used by the event.</typeparam>
 /// <typeparam name="TCallback">The notification callback type handed to the conversion.</typeparam>
 /// <typeparam name="TResult">The element type published downstream.</typeparam>
diff --git a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
index a8b984f4..52fabb1e 100644
--- a/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/IsEmptySignal{T}.cs
@@ -48,7 +48,6 @@ public IDisposable Subscribe(IObserver<bool> observer)
             return EmptyDisposable.Instance;
         }
 
-        // Acquire the subscription before the first value can terminate the source.
         if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
         {
             return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs b/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs
index c00d2ec6..fee8adb7 100644
--- a/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs
@@ -181,7 +181,7 @@ private void OnInnerCompleted(OnceDisposable inner)
         _ = SubscribeNext();
     }
 
-    /// <summary>Marks the coordinator failed and forwards the error. Caller must hold the gate.</summary>
+    /// <summary>Marks the coordinator failed and forwards the error while the caller holds the gate.</summary>
     /// <param name="error">The terminal error.</param>
     private void FailCore(Exception error)
     {
@@ -189,7 +189,7 @@ private void FailCore(Exception error)
         _observer.OnError(error);
     }
 
-    /// <summary>Completes downstream once enumeration and all active sources have completed. Caller must hold the gate.</summary>
+    /// <summary>Completes downstream after enumeration and all active sources finish, while the caller holds the gate.</summary>
     private void TryCompleteCore()
     {
         if (_done || !_enumerationCompleted || _active != 0)
diff --git a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
index d2688174..2ff3ef13 100644
--- a/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
+++ b/src/Primitives.Shared/Advanced/MergeCoordinator{T}.cs
@@ -84,7 +84,6 @@ public void OnSource(IObservable<T>? source)
             Active++;
         }
 
-        // Latch completion per source so duplicate terminal notifications cannot decrement a sibling's count.
         var completed = 0;
         Subscriptions.Add(source.Subscribe(
             OnInnerNext,
diff --git a/src/Primitives.Shared/Advanced/RaceWitness{T}.cs b/src/Primitives.Shared/Advanced/RaceWitness{T}.cs
index 96028de6..2616f73e 100644
--- a/src/Primitives.Shared/Advanced/RaceWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/RaceWitness{T}.cs
@@ -52,7 +52,7 @@ public RaceWitness<T> Run(IEnumerable<IObservable<T>> sources)
     /// <summary>Handles completion of the outer source.</summary>
     private static void OnOuterCompleted()
     {
-        // Race completion is controlled by the first inner source to win.
+        // Only the winning source determines completion.
     }
 
     /// <summary>Subscribes to a candidate source.</summary>
diff --git a/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs b/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
index 52b55198..deb331e4 100644
--- a/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
+++ b/src/Primitives.Shared/Advanced/RecoverSignal{T,TException}.cs
@@ -10,15 +10,12 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>
-/// Cold signal that mirrors the source and, on an error of type <typeparamref name="TException"/>, switches to
-/// the sequence the handler selects for it. Any other error, and an error thrown by the handler itself, is
-/// forwarded downstream unchanged.
-/// </summary>
+/// <summary>Mirrors the source and switches to a handler-selected sequence on errors of the specified type.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <typeparam name="TException">The handled exception type.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="handler">The handler that selects the fallback sequence for a caught error.</param>
+/// <remarks>Other error types and exceptions thrown by the handler propagate unchanged.</remarks>
 [System.Diagnostics.DebuggerDisplay("RecoverSignal: Source = {_source}")]
 public sealed class RecoverSignal<T, TException>(IObservable<T> source, Func<TException, IObservable<T>> handler) : IRequireCurrentThread<T>
     where TException : Exception
diff --git a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
index 786fd5b9..546c40b7 100644
--- a/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ResumeSignal{T}.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Reactive.Advanced;
 namespace ReactiveUI.Primitives.Advanced;
 #endif
 
-/// <summary>Cold signal that mirrors the source and, when it produces any error, subscribes the fallback sequence in its place. The error is not forwarded downstream.</summary>
+/// <summary>Replaces a failed source with the fallback sequence without forwarding the source error.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="fallback">The fallback observable subscribed to after the source errors.</param>
diff --git a/src/Primitives.Shared/Advanced/StartSignal.cs b/src/Primitives.Shared/Advanced/StartSignal.cs
index a6d89a1d..661e3e96 100644
--- a/src/Primitives.Shared/Advanced/StartSignal.cs
+++ b/src/Primitives.Shared/Advanced/StartSignal.cs
@@ -21,12 +21,12 @@ public StartSignal(Action action, ISequencer scheduler)
         Scheduler = scheduler;
     }
 
+    /// <summary>Gets the sequencer that runs the action.</summary>
+    internal ISequencer Scheduler { get; }
+
     /// <summary>Gets the action to run.</summary>
     private Action Action { get; }
 
-    /// <summary>Gets the sequencer that runs the action.</summary>
-    private ISequencer Scheduler { get; }
-
     /// <inheritdoc/>
     public bool IsRequiredSubscribeOnCurrentThread() => Scheduler == Sequencer.CurrentThread;
 
@@ -43,7 +43,7 @@ public IDisposable Subscribe(IObserver<RxVoid> observer)
 
     /// <summary>Runs the action and forwards its terminal notification.</summary>
     /// <param name="observer">The downstream observer.</param>
-    private void Run(IObserver<RxVoid> observer)
+    internal void Run(IObserver<RxVoid> observer)
     {
         try
         {
diff --git a/src/Primitives.Shared/Advanced/StartSignal{T}.cs b/src/Primitives.Shared/Advanced/StartSignal{T}.cs
index e1f4141d..1f00dc8a 100644
--- a/src/Primitives.Shared/Advanced/StartSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/StartSignal{T}.cs
@@ -22,12 +22,12 @@ public StartSignal(Func<T> function, ISequencer scheduler)
         Scheduler = scheduler;
     }
 
+    /// <summary>Gets the sequencer that runs the function.</summary>
+    internal ISequencer Scheduler { get; }
+
     /// <summary>Gets the function to run.</summary>
     private Func<T> Function { get; }
 
-    /// <summary>Gets the sequencer that runs the function.</summary>
-    private ISequencer Scheduler { get; }
-
     /// <inheritdoc/>
     public bool IsRequiredSubscribeOnCurrentThread() => Scheduler == Sequencer.CurrentThread;
 
@@ -44,7 +44,7 @@ public IDisposable Subscribe(IObserver<T> observer)
 
     /// <summary>Runs the function and forwards its terminal notification.</summary>
     /// <param name="observer">The downstream observer.</param>
-    private void Run(IObserver<T> observer)
+    internal void Run(IObserver<T> observer)
     {
         try
         {
diff --git a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
index 3c054045..b2f27654 100644
--- a/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
+++ b/src/Primitives.Shared/Advanced/SwitchWitness{T}.cs
@@ -80,7 +80,7 @@ private void OnSource(IObservable<T> source)
             error => OnError(current, error),
             () => OnCompleted(current));
 
-        // Reentrant subscription can install a newer generation; only the current generation may occupy the slot.
+        // Only the newest subscription remains active after reentrant subscription.
         var superseded = false;
         lock (_gate)
         {
diff --git a/src/Primitives.Shared/Advanced/TaskFaultObservation.cs b/src/Primitives.Shared/Advanced/TaskFaultObservation.cs
new file mode 100644
index 00000000..6d3f4a0e
--- /dev/null
+++ b/src/Primitives.Shared/Advanced/TaskFaultObservation.cs
@@ -0,0 +1,25 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+
+#if REACTIVE_SHIM
+namespace ReactiveUI.Primitives.Reactive.Advanced;
+#else
+namespace ReactiveUI.Primitives.Advanced;
+#endif
+
+/// <summary>Observes faults from tasks whose result is no longer awaited.</summary>
+internal static class TaskFaultObservation
+{
+    /// <summary>Registers fault observation without changing the task's outcome.</summary>
+    /// <param name="task">The task that may outlive its consumer.</param>
+    [ExcludeFromCodeCoverage]
+    internal static void Register(Task task) =>
+        _ = task.ContinueWith(
+            static completed => _ = completed.Exception,
+            CancellationToken.None,
+            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+            TaskScheduler.Default);
+}
diff --git a/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs b/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
index eea0ab6e..9d20912a 100644
--- a/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/WitnessOnSignal{T}.cs
@@ -233,7 +233,7 @@ private Notification(SparkKind kind, T value, Exception? exception)
             public Exception Exception { get; }
 
             /// <summary>Creates an OnNext notification.</summary>
-            /// <param name="value">The value.</param>
+            /// <param name="value">The value to carry.</param>
             /// <returns>The notification.</returns>
             public static Notification OnNext(T value) => new(SparkKind.OnNext, value, null);
 
diff --git a/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs b/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
index 2454e531..0a72a09d 100644
--- a/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
+++ b/src/Primitives.Shared/ConnectableSignalRxNameExtensions.cs
@@ -18,7 +18,7 @@ public static class ConnectableSignalRxNameExtensions
     /// <param name="source">Connectable signal to reference count.</param>
     extension<T>(ConnectableSignal<T> source)
     {
-        /// <summary>Shares a single subscription while observers are present. System.Reactive name for <c>AutoShare</c>.</summary>
+        /// <summary>Shares a single subscription while observers are present.</summary>
         /// <returns>A reference-counted sequence.</returns>
         public IObservable<T> RefCount()
         {
@@ -33,7 +33,7 @@ public IObservable<T> RefCount()
     /// <param name="source">Source sequence to share or replay.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Creates a connectable live signal. System.Reactive name for <c>ShareLive</c>.</summary>
+        /// <summary>Creates a connectable live signal.</summary>
         /// <returns>A connectable live signal.</returns>
         public ConnectableSignal<T> Publish()
         {
@@ -69,7 +69,7 @@ public IObservable<TResult> Publish<TResult>(Func<IObservable<T>, IObservable<TR
             return new PublishSelectorSignal<T, TResult>(source, selector);
         }
 
-        /// <summary>Replays all source values through an unbounded replay hub. System.Reactive name for <c>ReplayLive</c>.</summary>
+        /// <summary>Replays all source values through an unbounded replay hub.</summary>
         /// <returns>A connectable replay signal.</returns>
         public ConnectableSignal<T> Replay()
         {
@@ -78,7 +78,7 @@ public ConnectableSignal<T> Replay()
             return new(source, new ReplaySignal<T>());
         }
 
-        /// <summary>Replays source values through a bounded replay hub. System.Reactive name for <c>ReplayLive</c>.</summary>
+        /// <summary>Replays source values through a bounded replay hub.</summary>
         /// <param name="bufferSize">Maximum number of values to replay.</param>
         /// <returns>A connectable replay signal.</returns>
         public ConnectableSignal<T> Replay(int bufferSize)
@@ -89,7 +89,7 @@ public ConnectableSignal<T> Replay(int bufferSize)
             return new(source, hub);
         }
 
-        /// <summary>Replays source values through a replay hub constrained by count and time. System.Reactive name for <c>ReplayLive</c>.</summary>
+        /// <summary>Replays source values through a replay hub constrained by count and time.</summary>
         /// <param name="bufferSize">Maximum number of values to replay.</param>
         /// <param name="window">Maximum replay window.</param>
         /// <returns>A connectable replay signal.</returns>
diff --git a/src/Primitives.Shared/Core/Spark{T}.cs b/src/Primitives.Shared/Core/Spark{T}.cs
index 72fc4bf5..c1b9c26b 100644
--- a/src/Primitives.Shared/Core/Spark{T}.cs
+++ b/src/Primitives.Shared/Core/Spark{T}.cs
@@ -12,7 +12,7 @@ namespace ReactiveUI.Primitives.Reactive.Core;
 namespace ReactiveUI.Primitives.Core;
 #endif
 
-/// <summary>Represents a spark to an observer. Being a value type, materializing a sequence allocates no per-notification heap object.</summary>
+/// <summary>Represents a value, error, or completion notification.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
 [Serializable]
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -32,11 +32,7 @@ private Spark(SparkKind kind, T value, Exception? exception)
         _exception = exception;
     }
 
-    /// <summary>
-    /// Gets the value carried by an OnNext spark, or the default value for OnError and OnCompleted
-    /// sparks. Check <see cref="HasValue"/> (or <see cref="Kind"/>) to determine whether the value is
-    /// meaningful, and read <see cref="Exception"/> for the error carried by an OnError spark.
-    /// </summary>
+    /// <summary>Gets the value for an OnNext notification, or the default value for an error or completion notification.</summary>
     public T Value { get; }
 
     /// <summary>Gets a value indicating whether the spark carries a value.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs b/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
index 6cb93de3..92396ac2 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.BlendUnique.cs
@@ -10,20 +10,14 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Fused <c>Blend</c> + <c>Unique</c> operator: concurrently merges a fixed set of sources and forwards a value
-/// only when it differs from the last forwarded one, through one sink instead of two.
-/// </summary>
+/// <summary>Concurrently merges sources and suppresses values equal to the last forwarded value.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>
-    /// Concurrently merges the supplied sources and forwards only values that differ from the last forwarded
-    /// value, using the default equality comparer. Errors are forwarded from the first failing source;
-    /// completion is signalled once every source has completed.
-    /// </summary>
+    /// <summary>Concurrently merges sources and suppresses adjacent duplicate values using the default equality comparer.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="sources">The sources to merge.</param>
     /// <returns>An observable of the distinct merged values.</returns>
+    /// <remarks>The first source error terminates the result; successful completion waits for every source.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservable<T> BlendUnique<T>(params IObservable<T>[] sources) =>
         BlendUnique(sources, null);
@@ -105,10 +99,8 @@ private sealed class BlendUniqueSink<T>(IObserver<T> downstream, IEqualityCompar
         /// <param name="sources">The sources to merge.</param>
         public void Run(IObservable<T>[] sources)
         {
-            // Sources and their elements are validated eagerly by the public entry point, so no null check here.
             if (sources.Length == 0)
             {
-                // Runs once during subscription before any source can notify, so no _done check is needed.
                 lock (_gate)
                 {
                     _done = true;
diff --git a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
index f9a617d8..897ae4fd 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.ChooseSwitchSelect.cs
@@ -22,10 +22,7 @@ public static partial class LinqExtensions
         /// <typeparam name="TOut">The element type of the projected inner observables.</typeparam>
         /// <param name="selector">Projects each source value to an inner observable.</param>
         /// <returns>An observable that mirrors the latest projected inner observable.</returns>
-        /// <remarks>
-        /// Every source value switches, a null among them included. Skipping nulls, which leaves the active
-        /// inner subscription in place, is <see cref="SwitchSelect{TSource, TResult}"/> instead.
-        /// </remarks>
+        /// <remarks>Null switches the active subscription too; use SwitchSelect to ignore nulls and keep the current subscription.</remarks>
         public IObservable<TOut> SwitchMap<TOut>(Func<TIn, IObservable<TOut>> selector)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -35,11 +32,7 @@ public IObservable<TOut> SwitchMap<TOut>(Func<TIn, IObservable<TOut>> selector)
             return new SwitchMapSignal<TIn, TOut>(source, selector);
         }
 
-        /// <summary>
-        /// Maps each source value to a <c>(HasValue, Value)</c> pair and forwards only the values whose
-        /// <c>HasValue</c> is <see langword="true"/> — a single fused sink in place of <c>Where(...).Select(...)</c>.
-        /// Unlike a <c>TOut?</c>-returning projection, the explicit flag lets a non-nullable value type be skipped.
-        /// </summary>
+        /// <summary>Projects each value to a value-and-flag pair and forwards the value only when the flag is true.</summary>
         /// <typeparam name="TOut">The forwarded element type.</typeparam>
         /// <param name="chooser">Maps a source value to <c>(HasValue, Value)</c>; the value is skipped when <c>HasValue</c> is <see langword="false"/>.</param>
         /// <returns>An observable of the chosen values.</returns>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
index 857f3512..53b96adc 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CollectionSignals.cs
@@ -77,7 +77,7 @@ public IDisposable Subscribe(IObserver<IList<T>> observer)
                 values.Add(_range.Start + i);
             }
 
-            // A value-type argument is not covariant, so this cast holds only because every call site fixes T to int.
+            // This helper requires T to be int.
             observer.OnNext((IList<T>)(object)values);
             observer.OnCompleted();
             return EmptyDisposable.Instance;
@@ -106,7 +106,7 @@ public IDisposable Subscribe(IObserver<T[]> observer)
                 values[i] = _range.Start + i;
             }
 
-            // A value-type argument is not covariant, so this cast holds only because every call site fixes T to int.
+            // This helper requires T to be int.
             observer.OnNext((T[])(object)values);
             observer.OnCompleted();
             return EmptyDisposable.Instance;
diff --git a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
index cadbaa0b..56c8c2cd 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.CombineLatest.cs
@@ -380,7 +380,7 @@ private sealed class CombineLatestSlot<TResult, T>(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal override IDisposable Subscribe() => source.Subscribe(this);
 
-        /// <summary>Records the latest value. Called by the coordinator while it holds the serialization gate.</summary>
+        /// <summary>Records the latest value while the coordinator holds the serialization gate.</summary>
         /// <param name="value">The value the source produced.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void Accept(T value) => Value = value;
@@ -444,7 +444,6 @@ internal CombineLatestSlot<TResult, T> Attach<T>(IObservable<T> source)
         /// <returns>This coordinator.</returns>
         internal CombineLatestCoordinator<TResult> Run(Func<TResult> project)
         {
-            // Installed before the first subscribe, so a source that emits inside its own Subscribe has a target.
             _project = project;
             _flags = new bool[_slots.Count * FlagsPerSource];
             _missingValues = _slots.Count;
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
index c0bce856..2fd6067f 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Coordinators.cs
@@ -388,7 +388,7 @@ internal RaceCoordinator<T> Run(IObservable<IObservable<T>> sources)
         /// <summary>Handles completion of the outer sequence.</summary>
         private static void OnOuterCompleted()
         {
-            // Race completion is controlled by the first inner source to win.
+            // Only the winning source determines completion.
         }
     }
 
diff --git a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
index ea076748..e4c8d5dd 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.SchedulerSignals.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// Signals for the scheduler and time operators. The current-thread variants implement
-/// <see cref="IRequireCurrentThread{T}"/> and schedule their subscription onto the current-thread sequencer.
-/// </summary>
+/// <summary>Schedules current-thread subscriptions and time-based notifications.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>Coordinates delayed notification delivery with a single serialized timer.</summary>
@@ -304,6 +301,105 @@ public static DelayedNotification Completed(DateTimeOffset dueAt) =>
         }
     }
 
+    /// <summary>Dedicated signal for absolute <c>Shift</c> overloads.</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="dueTime">The absolute time at which notifications may be forwarded.</param>
+    /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
+    internal sealed class AbsoluteShiftSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<T> _source = source;
+
+        /// <summary>The absolute time at which notifications may be forwarded.</summary>
+        private readonly DateTimeOffset _dueTime = dueTime;
+
+        /// <summary>The sequencer used to schedule delayed notifications.</summary>
+        private readonly ISequencer _scheduler = scheduler;
+
+        /// <summary>Gets the sequencer used to schedule delayed notifications.</summary>
+        internal ISequencer Scheduler => _scheduler;
+
+        /// <inheritdoc/>
+        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
+            return _source is RangeSignal range && typeof(T) == typeof(int)
+                ? new ShiftedRangeSignal<T>(range, dueTime, _scheduler).Subscribe(observer)
+                : new ShiftSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
+        }
+    }
+
+    /// <summary>Dedicated signal for absolute <c>DelayStart</c>/<c>DelaySubscription</c> overloads.</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="dueTime">The absolute time at which to subscribe to the source.</param>
+    /// <param name="scheduler">The sequencer used to schedule the delayed subscription.</param>
+    internal sealed class AbsoluteDelayStartSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IObservable<T>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<T> _source = source;
+
+        /// <summary>The absolute time at which to subscribe to the source.</summary>
+        private readonly DateTimeOffset _dueTime = dueTime;
+
+        /// <summary>The sequencer used to schedule the delayed subscription.</summary>
+        private readonly ISequencer _scheduler = scheduler;
+
+        /// <summary>Gets the sequencer used to schedule the delayed subscription.</summary>
+        internal ISequencer Scheduler => _scheduler;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
+            return _source is RangeSignal range && typeof(T) == typeof(int)
+                ? new ShiftedRangeSignal<T>(range, dueTime, _scheduler).Subscribe(observer)
+                : new DelayStartSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
+        }
+    }
+
+    /// <summary>Dedicated signal for absolute <c>Expire</c>/<c>Timeout</c> overloads.</summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="dueTime">The absolute timeout time.</param>
+    /// <param name="scheduler">The sequencer used to schedule the timeout.</param>
+    internal sealed class AbsoluteExpireSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<T> _source = source;
+
+        /// <summary>The absolute timeout time.</summary>
+        private readonly DateTimeOffset _dueTime = dueTime;
+
+        /// <summary>The sequencer used to schedule the timeout.</summary>
+        private readonly ISequencer _scheduler = scheduler;
+
+        /// <summary>Gets the sequencer used to schedule the timeout.</summary>
+        internal ISequencer Scheduler => _scheduler;
+
+        /// <inheritdoc/>
+        public bool IsRequiredSubscribeOnCurrentThread() =>
+            _scheduler == Sequencer.CurrentThread
+            || (_source is IRequireCurrentThread<T> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread());
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
+            return new ExpireSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
+        }
+    }
+
     /// <summary>Dedicated signal for <c>Calm</c> (quiet-period debounce).</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -404,37 +500,6 @@ private ShiftCoordinator<T> RunCore(IObserver<T> observer)
         }
     }
 
-    /// <summary>Dedicated signal for absolute <c>Shift</c> overloads.</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="dueTime">The absolute time at which notifications may be forwarded.</param>
-    /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
-    private sealed class AbsoluteShiftSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<T> _source = source;
-
-        /// <summary>The absolute time at which notifications may be forwarded.</summary>
-        private readonly DateTimeOffset _dueTime = dueTime;
-
-        /// <summary>The sequencer used to schedule delayed notifications.</summary>
-        private readonly ISequencer _scheduler = scheduler;
-
-        /// <inheritdoc/>
-        public bool IsRequiredSubscribeOnCurrentThread() => _scheduler == Sequencer.CurrentThread;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
-            return _source is RangeSignal range && typeof(T) == typeof(int)
-                ? new ShiftedRangeSignal<T>(range, dueTime, _scheduler).Subscribe(observer)
-                : new ShiftSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
-        }
-    }
-
     /// <summary>Dedicated signal for <c>SubscribeOn</c> (defer subscription to a sequencer).</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="source">The source observable.</param>
@@ -498,65 +563,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         }
     }
 
-    /// <summary>Dedicated signal for absolute <c>DelayStart</c>/<c>DelaySubscription</c> overloads.</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="dueTime">The absolute time at which to subscribe to the source.</param>
-    /// <param name="scheduler">The sequencer used to schedule the delayed subscription.</param>
-    private sealed class AbsoluteDelayStartSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IObservable<T>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<T> _source = source;
-
-        /// <summary>The absolute time at which to subscribe to the source.</summary>
-        private readonly DateTimeOffset _dueTime = dueTime;
-
-        /// <summary>The sequencer used to schedule the delayed subscription.</summary>
-        private readonly ISequencer _scheduler = scheduler;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
-            return _source is RangeSignal range && typeof(T) == typeof(int)
-                ? new ShiftedRangeSignal<T>(range, dueTime, _scheduler).Subscribe(observer)
-                : new DelayStartSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
-        }
-    }
-
-    /// <summary>Dedicated signal for absolute <c>Expire</c>/<c>Timeout</c> overloads.</summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="dueTime">The absolute timeout time.</param>
-    /// <param name="scheduler">The sequencer used to schedule the timeout.</param>
-    private sealed class AbsoluteExpireSignal<T>(IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) : IRequireCurrentThread<T>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<T> _source = source;
-
-        /// <summary>The absolute timeout time.</summary>
-        private readonly DateTimeOffset _dueTime = dueTime;
-
-        /// <summary>The sequencer used to schedule the timeout.</summary>
-        private readonly ISequencer _scheduler = scheduler;
-
-        /// <inheritdoc/>
-        public bool IsRequiredSubscribeOnCurrentThread() =>
-            _scheduler == Sequencer.CurrentThread
-            || (_source is IRequireCurrentThread<T> currentThread && currentThread.IsRequiredSubscribeOnCurrentThread());
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<T> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            var dueTime = Sequencer.Normalize(_dueTime - _scheduler.Now);
-            return new ExpireSignal<T>(_source, dueTime, _scheduler).Subscribe(observer);
-        }
-    }
-
     /// <summary>Dedicated signal for <c>Reattempt</c> (retry on error).</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="source">The source observable.</param>
diff --git a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
index bcd24388..869bf3e3 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.StatefulSignals.cs
@@ -36,7 +36,6 @@ public IDisposable Subscribe(IObserver<T> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // Acquire the subscription before the trampoline delivers values that can terminate it.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -82,7 +81,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // Acquire both subscriptions before either trampoline starts delivering values.
             if ((!CurrentThreadRequirement.IsRequired(_source) && !CurrentThreadRequirement.IsRequired(_other))
                 || !CurrentThreadSequencer.IsScheduleRequired)
             {
@@ -454,7 +452,6 @@ public IDisposable Subscribe(IObserver<T> observer)
         {
             ArgumentExceptionHelper.ThrowIfNull(observer);
 
-            // Acquire the subscription before a predicate can stop the source.
             if (!CurrentThreadRequirement.IsRequired(_source) || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
index d098d34f..282d2289 100644
--- a/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
+++ b/src/Primitives.Shared/SignalOperatorMixins.Switch.cs
@@ -63,33 +63,29 @@ internal SwitchCoordinator<T> Run(IObservable<IObservable<T>> sources)
             return this;
         }
 
-        /// <summary>Switches to a new inner source.</summary>
-        /// <param name="source">The new inner source.</param>
-        private void OnSource(IObservable<T> source)
+        /// <summary>Activates the next inner generation unless a terminal notification has been sent.</summary>
+        /// <param name="version">The activated generation, or zero when the coordinator is done.</param>
+        /// <returns>True when an inner generation was activated; otherwise, false.</returns>
+        internal bool TryBeginSource(out int version)
         {
-            int current;
             lock (_gate)
             {
                 if (_done)
                 {
-                    return;
+                    version = 0;
+                    return false;
                 }
 
-                current = _version + 1;
+                version = _version + 1;
 
-                // Publish the new version so readers in gated operations observe it.
-                Volatile.Write(ref _version, current);
+                Volatile.Write(ref _version, version);
                 _innerActive = true;
+                return true;
             }
-
-            _innerSlot.Create(source.Subscribe(
-                value => OnNext(current, value),
-                error => OnError(current, error),
-                () => OnCompleted(current)));
         }
 
         /// <summary>Marks the outer source as complete.</summary>
-        private void OnOuterCompleted()
+        internal void OnOuterCompleted()
         {
             lock (_gate)
             {
@@ -105,7 +101,7 @@ private void OnOuterCompleted()
 
         /// <summary>Forwards an outer source error once.</summary>
         /// <param name="error">The error to forward.</param>
-        private void OnOuterError(Exception error)
+        internal void OnOuterError(Exception error)
         {
             lock (_gate)
             {
@@ -122,7 +118,7 @@ private void OnOuterError(Exception error)
         /// <summary>Forwards an inner value when it belongs to the current source.</summary>
         /// <param name="version">The inner version.</param>
         /// <param name="value">The value to forward.</param>
-        private void OnNext(int version, T value)
+        internal void OnNext(int version, T value)
         {
             lock (_gate)
             {
@@ -138,7 +134,7 @@ private void OnNext(int version, T value)
         /// <summary>Forwards an inner error when it belongs to the current source.</summary>
         /// <param name="version">The inner version.</param>
         /// <param name="error">The error to forward.</param>
-        private void OnError(int version, Exception error)
+        internal void OnError(int version, Exception error)
         {
             lock (_gate)
             {
@@ -154,7 +150,7 @@ private void OnError(int version, Exception error)
 
         /// <summary>Completes an inner source when it belongs to the current source.</summary>
         /// <param name="version">The inner version.</param>
-        private void OnCompleted(int version)
+        internal void OnCompleted(int version)
         {
             lock (_gate)
             {
@@ -168,6 +164,21 @@ private void OnCompleted(int version)
             }
         }
 
+        /// <summary>Switches to a new inner source.</summary>
+        /// <param name="source">The new inner source.</param>
+        private void OnSource(IObservable<T> source)
+        {
+            if (!TryBeginSource(out var current))
+            {
+                return;
+            }
+
+            _innerSlot.Create(source.Subscribe(
+                value => OnNext(current, value),
+                error => OnError(current, error),
+                () => OnCompleted(current)));
+        }
+
         /// <summary>Completes the observer when both outer and inner sources are complete.</summary>
         private void TryComplete()
         {
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
index 0b0e84f3..ef82822e 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.AggregateHelpers.cs
@@ -338,7 +338,6 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // Acquire the subscription before the first value can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -393,7 +392,6 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // Acquire the subscription before a match can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs b/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
index 24910d2c..ae788b80 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.AwaitableTerminals.cs
@@ -66,8 +66,7 @@ public Task<T> FirstOrDefaultAsync(T defaultValue)
         /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
         /// <returns>A task that completes with the first source value, or <see langword="default"/> when the source is empty.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
-        /// <remarks>Deprioritized, so a call like <c>FirstOrDefaultAsync(default!)</c> binds to the
-        /// <c>FirstOrDefaultAsync(T)</c> overload rather than this one.</remarks>
+        /// <remarks>A call to FirstOrDefaultAsync(default!) selects the default-value overload.</remarks>
         [OverloadResolutionPriority(-1)]
         public Task<T> FirstOrDefaultAsync(CancellationToken cancellationToken)
         {
@@ -141,8 +140,7 @@ public Task<T> LastOrDefaultAsync(T defaultValue)
         /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
         /// <returns>A task that completes with the final source value, or <see langword="default"/> when the source is empty.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
-        /// <remarks>Deprioritized, so a call like <c>LastOrDefaultAsync(default!)</c> binds to the
-        /// <c>LastOrDefaultAsync(T)</c> overload rather than this one.</remarks>
+        /// <remarks>A call to LastOrDefaultAsync(default!) selects the default-value overload.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [OverloadResolutionPriority(-1)]
         public Task<T> LastOrDefaultAsync(CancellationToken cancellationToken) =>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
index e386144f..3051d17c 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.BooleanTerminalHelpers.cs
@@ -38,7 +38,6 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // Acquire the subscription before a rejected value can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
@@ -127,7 +126,6 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 return EmptyDisposable.Instance;
             }
 
-            // Acquire the subscription before a match can terminate the source.
             if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
             {
                 return SubscribeCore(observer);
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
index 26f721cf..5e1aa6b1 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
@@ -228,7 +228,6 @@ private void OnOuterCompleted()
         /// <param name="value">The inner value.</param>
         private void OnInnerNext(TResult value)
         {
-            // One inner source runs at a time; the volatile disposal check needs no delivery gate.
             if (Volatile.Read(ref _disposed))
             {
                 return;
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
index 026c59f7..6e383544 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
@@ -543,7 +543,6 @@ private void OnCompleted()
 
                 _done = true;
 
-                // Completion flushes the pending value; the timer clears the same flag under this gate.
                 if (_hasLatest)
                 {
                     _hasLatest = false;
@@ -576,7 +575,6 @@ private void Tick()
                 return;
             }
 
-            // Serialize the timer emission against a concurrent terminal notification.
             lock (_gate)
             {
                 if (_done)
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
index 4a9d399f..e3fd9f66 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Probe.cs
@@ -109,7 +109,7 @@ public void Dispose()
                 return;
             }
 
-            // Latch termination to reject notifications from sources that ignore disposal.
+            // Notifications received after termination are ignored.
             lock (_gate)
             {
                 _done = true;
@@ -206,7 +206,7 @@ private void ScheduleNext()
         /// <returns>An empty disposable.</returns>
         private EmptyDisposable Tick()
         {
-            // Hold the gate across the emission so the sample cannot interleave with a terminal.
+            // Samples cannot interleave with terminal notifications.
             lock (_gate)
             {
                 if (_done || !_hasLatest)
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
index 66cd1e6c..9c57216b 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.CombineLatest.Collections.cs
@@ -24,7 +24,7 @@ public static partial class LinqExtensions
         /// may keep it. An empty source collection produces an empty sequence.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> or one of its elements is <see langword="null"/>.</exception>
-        /// <remarks>The collection is enumerated once, when the operator is called, not on each subscription.</remarks>
+        /// <remarks>The collection is enumerated once when the operator is called.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<IList<T>> CombineLatest() => CombineLatestOf(CombineLatestSources(sources));
 
@@ -33,7 +33,7 @@ public static partial class LinqExtensions
         /// <param name="resultSelector">Projects the latest value of every source into a result.</param>
         /// <returns>An observable sequence of projected results. An empty source collection produces an empty sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/>, one of its elements, or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The collection is enumerated once, when the operator is called, not on each subscription.</remarks>
+        /// <remarks>The collection is enumerated once when the operator is called.</remarks>
         public IObservable<TResult> CombineLatest<TResult>(Func<IList<T>, TResult> resultSelector)
         {
             ArgumentExceptionHelper.ThrowIfNull(resultSelector);
@@ -54,8 +54,7 @@ public IObservable<TResult> CombineLatest<TResult>(Func<IList<T>, TResult> resul
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="sources"/> or one of its elements is <see langword="null"/>.</exception>
     /// <remarks>
-    /// Ranked below the tuple overloads, so two to sixteen same-typed sources listed inline bind to the tuple
-    /// overload instead; this one takes over past that arity and whenever the sources arrive as an array.
+    /// Inline calls with two through sixteen same-typed sources select tuple overloads; larger calls and arrays select this overload.
     /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [OverloadResolutionPriority(-2)]
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
index 08b03163..17565226 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs
@@ -10,10 +10,7 @@ namespace ReactiveUI.Primitives.Reactive;
 namespace ReactiveUI.Primitives;
 #endif
 
-/// <summary>
-/// System.Reactive and LINQ names for the Primitives operator vocabulary. Each one builds the same sink as its
-/// Primitives-named counterpart, so either name can be used interchangeably.
-/// </summary>
+/// <summary>Provides System.Reactive and LINQ aliases for the Primitives operators.</summary>
 public static partial class LinqExtensions
 {
     /// <summary>System.Reactive-named combining operators for enumerable observable sources.</summary>
@@ -21,7 +18,7 @@ public static partial class LinqExtensions
     /// <param name="sources">The observable sources.</param>
     extension<T>(IEnumerable<IObservable<T>> sources)
     {
-        /// <summary>Concurrently merges the supplied observable sources. System.Reactive name for <c>Blend</c>.</summary>
+        /// <summary>Concurrently merges the supplied observable sources.</summary>
         /// <returns>An observable that forwards values from every source.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Merge()
@@ -51,7 +48,7 @@ public IObservable<T> Merge(int maxConcurrent)
     /// <param name="sources">The outer sequence of inner sequences.</param>
     extension<T>(IObservable<IObservable<T>> sources)
     {
-        /// <summary>Subscribes to all inner sequences and forwards their values as they arrive. System.Reactive name for <c>Blend</c>.</summary>
+        /// <summary>Subscribes to all inner sequences and forwards their values as they arrive.</summary>
         /// <returns>A sequence containing values from all inner sequences.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Merge()
@@ -61,7 +58,7 @@ public IObservable<T> Merge()
             return new BlendSignal<T>(sources);
         }
 
-        /// <summary>Subscribes to inner sequences one at a time in source order. System.Reactive name for <c>Chain</c>.</summary>
+        /// <summary>Subscribes to inner sequences one at a time in source order.</summary>
         /// <returns>A sequence that emits each inner sequence after the previous one completes.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Concat()
@@ -71,7 +68,7 @@ public IObservable<T> Concat()
             return new ChainSignal<T>(sources);
         }
 
-        /// <summary>Mirrors the first inner sequence to produce any notification. System.Reactive name for <c>Race</c>.</summary>
+        /// <summary>Mirrors the first inner sequence to produce any notification.</summary>
         /// <returns>A sequence that mirrors the winning inner sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Amb()
@@ -81,7 +78,7 @@ public IObservable<T> Amb()
             return new RaceSignal<T>(sources);
         }
 
-        /// <summary>Switches to the most recent inner sequence. System.Reactive name for <c>SwitchTo</c>.</summary>
+        /// <summary>Switches to the most recent inner sequence.</summary>
         /// <returns>A sequence that mirrors only the latest inner sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Switch()
@@ -99,7 +96,7 @@ public IObservable<T> Switch()
     /// <param name="source">The spark sequence.</param>
     extension<T>(IObservable<Spark<T>> source)
     {
-        /// <summary>Converts <see cref="Spark{T}"/> values back into observer notifications. System.Reactive name for <c>Unspark</c>.</summary>
+        /// <summary>Converts <see cref="Spark{T}"/> values back into observer notifications.</summary>
         /// <returns>A sequence represented by the supplied spark values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> Dematerialize()
@@ -127,8 +124,8 @@ public IObservable<T> Dematerialize()
         /// <returns>A disposable that cancels the subscription.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="observer"/> is <see langword="null"/>.</exception>
         /// <remarks>
-        /// System.Reactive declares an observer-taking <c>SubscribeSafe</c> in the <c>System</c> namespace, so the
-        /// two are ambiguous whenever both packages are in scope; the other overloads have no such counterpart.
+        /// The observer overload is ambiguous when System.Reactive also supplies SubscribeSafe in the System namespace; other overloads are
+        /// unaffected.
         /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IDisposable SubscribeSafePrimitives(IObserver<T> observer) => SubscribeSafeCore(source, observer);
@@ -169,7 +166,7 @@ public IDisposable SubscribeSafe(Action<Exception> onError) =>
         public IDisposable SubscribeSafe(Action<Exception> onError, Action onCompleted) =>
             SubscribeSafeCore(source, Witness.Create<T>(static _ => { }, onError, onCompleted));
 
-        /// <summary>Invokes an action for each value while preserving the sequence. System.Reactive name for <c>Tap</c>.</summary>
+        /// <summary>Invokes an action for each value while preserving the sequence.</summary>
         /// <param name="onNext">The action to invoke for each value.</param>
         /// <returns>The source values after the action has run.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="onNext"/> is <see langword="null"/>.</exception>
@@ -182,7 +179,7 @@ public IObservable<T> Do(Action<T> onNext)
             return new TapSignal<T>(source, onNext, static _ => { }, static () => { });
         }
 
-        /// <summary>Invokes actions for each value and error while preserving the sequence. System.Reactive name for <c>Tap</c>.</summary>
+        /// <summary>Invokes actions for each value and error while preserving the sequence.</summary>
         /// <param name="onNext">The action to invoke for each value.</param>
         /// <param name="onError">The action to invoke for an error.</param>
         /// <returns>The source values after the actions have run.</returns>
@@ -198,7 +195,7 @@ public IObservable<T> Do(Action<T> onNext, Action<Exception> onError)
             return new TapSignal<T>(source, onNext, onError, static () => { });
         }
 
-        /// <summary>Invokes actions for each value and completion while preserving the sequence. System.Reactive name for <c>Tap</c>.</summary>
+        /// <summary>Invokes actions for each value and completion while preserving the sequence.</summary>
         /// <param name="onNext">The action to invoke for each value.</param>
         /// <param name="onCompleted">The action to invoke when the sequence completes.</param>
         /// <returns>The source values after the actions have run.</returns>
@@ -214,7 +211,7 @@ public IObservable<T> Do(Action<T> onNext, Action onCompleted)
             return new TapSignal<T>(source, onNext, static _ => { }, onCompleted);
         }
 
-        /// <summary>Invokes actions for each value, error, and completion while preserving the sequence. System.Reactive name for <c>Tap</c>.</summary>
+        /// <summary>Invokes actions for each value, error, and completion while preserving the sequence.</summary>
         /// <param name="onNext">The action to invoke for each value.</param>
         /// <param name="onError">The action to invoke for an error.</param>
         /// <param name="onCompleted">The action to invoke when the sequence completes.</param>
@@ -236,11 +233,7 @@ public IObservable<T> Do(
             return new TapSignal<T>(source, onNext, onError, onCompleted);
         }
 
-        /// <summary>
-        /// Serializes notifications behind a gate so downstream operators observe the single-threaded
-        /// <c>OnNext*</c> then <c>OnError</c>|<c>OnCompleted</c> grammar even when the source delivers
-        /// concurrently. System.Reactive name for the same operation.
-        /// </summary>
+        /// <summary>Serializes concurrent notifications so values precede a single terminal notification.</summary>
         /// <returns>A sequence that forwards the source notifications one at a time.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> Synchronize()
@@ -250,11 +243,7 @@ public IObservable<T> Synchronize()
             return new SynchronizeSignal<T>(source);
         }
 
-        /// <summary>
-        /// Serializes notifications behind the supplied <paramref name="gate"/>, so this sequence and every other
-        /// sequence synchronized on the same gate observe the single-threaded grammar relative to one another.
-        /// System.Reactive name for the same operation.
-        /// </summary>
+        /// <summary>Serializes notifications with every sequence using the supplied gate.</summary>
         /// <param name="gate">The gate shared with other synchronized sequences.</param>
         /// <returns>A sequence that forwards the source notifications one at a time under the shared gate.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="gate"/> is <see langword="null"/>.</exception>
@@ -297,7 +286,7 @@ public IObservable<T> Synchronize(object gate)
         }
 #endif
 
-        /// <summary>Invokes a stateful action for each value while preserving the sequence. State-carrying name for <c>TapWith</c>.</summary>
+        /// <summary>Invokes a stateful action for each value while preserving the sequence.</summary>
         /// <typeparam name="TState">The state type.</typeparam>
         /// <param name="state">The state passed to <paramref name="onNext"/>.</param>
         /// <param name="onNext">The action to invoke for each value.</param>
@@ -312,7 +301,7 @@ public IObservable<T> DoWith<TState>(TState state, Action<TState, T> onNext)
             return new TapWithSignal<T, TState>(source, state, onNext);
         }
 
-        /// <summary>Emits the accumulated state after each source value. System.Reactive name for <c>Fold</c>.</summary>
+        /// <summary>Emits the accumulated state after each source value.</summary>
         /// <typeparam name="TAccumulate">The accumulated value type.</typeparam>
         /// <param name="seed">The initial accumulated value.</param>
         /// <param name="accumulator">The function that combines the current state with the next source value.</param>
@@ -329,7 +318,7 @@ public IObservable<TAccumulate> Scan<TAccumulate>(
             return new FoldSignal<T, TAccumulate>(source, seed, accumulator);
         }
 
-        /// <summary>Emits the final accumulated state when the source completes. System.Reactive name for <c>Reduce</c>.</summary>
+        /// <summary>Emits the final accumulated state when the source completes.</summary>
         /// <typeparam name="TAccumulate">The accumulated value type.</typeparam>
         /// <param name="seed">The initial accumulated value.</param>
         /// <param name="accumulator">The function that combines the current state with the next source value.</param>
@@ -346,7 +335,7 @@ public IObservable<TAccumulate> Aggregate<TAccumulate>(
             return new ReduceSignal<T, TAccumulate>(source, seed, accumulator);
         }
 
-        /// <summary>Suppresses adjacent duplicate values. System.Reactive name for <c>Unique</c>.</summary>
+        /// <summary>Suppresses adjacent duplicate values.</summary>
         /// <returns>A sequence with adjacent duplicates removed.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> DistinctUntilChanged()
@@ -356,7 +345,7 @@ public IObservable<T> DistinctUntilChanged()
             return new UniqueSignal<T>(source, EqualityComparer<T>.Default);
         }
 
-        /// <summary>Suppresses adjacent duplicate values using the supplied comparer. System.Reactive name for <c>Unique</c>.</summary>
+        /// <summary>Suppresses adjacent duplicate values using the supplied comparer.</summary>
         /// <param name="comparer">The comparer used to compare adjacent values.</param>
         /// <returns>A sequence with adjacent duplicates removed.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
@@ -368,7 +357,7 @@ public IObservable<T> DistinctUntilChanged(IEqualityComparer<T>? comparer)
             return new UniqueSignal<T>(source, comparer);
         }
 
-        /// <summary>Suppresses adjacent values with duplicate keys. System.Reactive name for <c>UniqueBy</c>.</summary>
+        /// <summary>Suppresses adjacent values with duplicate keys.</summary>
         /// <typeparam name="TKey">The key type.</typeparam>
         /// <param name="keySelector">The function that selects the comparison key.</param>
         /// <returns>A sequence with adjacent duplicate keys removed.</returns>
@@ -382,7 +371,7 @@ public IObservable<T> DistinctUntilChangedBy<TKey>(Func<T, TKey> keySelector)
             return new UniqueBySignal<T, TKey>(source, keySelector, EqualityComparer<TKey>.Default);
         }
 
-        /// <summary>Suppresses adjacent values with duplicate keys using the supplied comparer. System.Reactive name for <c>UniqueBy</c>.</summary>
+        /// <summary>Suppresses adjacent values with duplicate keys using the supplied comparer.</summary>
         /// <typeparam name="TKey">The key type.</typeparam>
         /// <param name="keySelector">The function that selects the comparison key.</param>
         /// <param name="comparer">The comparer used to compare adjacent keys.</param>
@@ -398,7 +387,7 @@ public IObservable<T> DistinctUntilChangedBy<TKey>(Func<T, TKey> keySelector, IE
             return new UniqueBySignal<T, TKey>(source, keySelector, comparer);
         }
 
-        /// <summary>Drops every value, forwarding only the terminal notification. System.Reactive name for <c>IgnoreValues</c>.</summary>
+        /// <summary>Drops every value, forwarding only the terminal notification.</summary>
         /// <returns>A sequence that forwards only completion or error.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> IgnoreElements()
@@ -408,7 +397,7 @@ public IObservable<T> IgnoreElements()
             return new IgnoreValuesSignal<T>(source);
         }
 
-        /// <summary>Prepends values before the source sequence. System.Reactive name for <c>Prepend</c>.</summary>
+        /// <summary>Prepends values before the source sequence.</summary>
         /// <param name="values">The values to emit before the source.</param>
         /// <returns>A sequence that emits <paramref name="values"/> before the source values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="values"/> is <see langword="null"/>.</exception>
@@ -428,7 +417,7 @@ public IObservable<T> StartWith(params T[] values)
                 : new StartWithEnumerableSignal<T>(source, values);
         }
 
-        /// <summary>Prepends values before the source sequence. System.Reactive name for <c>Prepend</c>.</summary>
+        /// <summary>Prepends values before the source sequence.</summary>
         /// <param name="values">The values to emit before the source.</param>
         /// <returns>A sequence that emits <paramref name="values"/> before the source values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="values"/> is <see langword="null"/>.</exception>
@@ -441,7 +430,7 @@ public IObservable<T> StartWith(IEnumerable<T> values)
             return new StartWithEnumerableSignal<T>(source, values);
         }
 
-        /// <summary>Collects values into time-windowed batches. System.Reactive name for <c>Collect</c>.</summary>
+        /// <summary>Collects values into time-windowed batches.</summary>
         /// <param name="timeSpan">The duration of each buffer window.</param>
         /// <returns>A sequence that emits non-empty batches of source values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
@@ -466,7 +455,7 @@ public IObservable<IList<T>> Buffer(TimeSpan timeSpan, ISequencer scheduler)
             return new BufferSignal<T>(source, timeSpan, scheduler);
         }
 
-        /// <summary>Invokes an action when the subscription terminates or is disposed. System.Reactive name for <c>OnCleanup</c>.</summary>
+        /// <summary>Invokes an action when the subscription terminates or is disposed.</summary>
         /// <param name="finallyAction">The action to invoke exactly once.</param>
         /// <returns>A sequence that mirrors the source and invokes <paramref name="finallyAction"/> on cleanup.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="finallyAction"/> is <see langword="null"/>.</exception>
@@ -479,7 +468,7 @@ public IObservable<T> Finally(Action finallyAction)
             return new FinallySignal<T>(source, finallyAction);
         }
 
-        /// <summary>Emits a value only after no newer value arrives within the quiet period. System.Reactive name for <c>Calm</c>.</summary>
+        /// <summary>Emits a value only after no newer value arrives within the quiet period.</summary>
         /// <param name="dueTime">The quiet period.</param>
         /// <returns>A sequence that emits the latest value after each quiet period.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
@@ -490,7 +479,7 @@ public IObservable<T> Throttle(TimeSpan dueTime)
             return new CalmSignal<T>(source, dueTime, ThreadPoolSequencer.Instance);
         }
 
-        /// <summary>Emits a value only after no newer value arrives within the scheduler quiet period. System.Reactive name for <c>Calm</c>.</summary>
+        /// <summary>Emits a value only after no newer value arrives within the scheduler quiet period.</summary>
         /// <param name="dueTime">The quiet period.</param>
         /// <param name="scheduler">The scheduler used to schedule quiet-period timers.</param>
         /// <returns>A sequence that emits the latest value after each quiet period.</returns>
@@ -518,7 +507,7 @@ public IObservable<T> Catch<TException>(Func<TException, IObservable<T>> handler
             return new RecoverSignal<T, TException>(source, handler);
         }
 
-        /// <summary>Projects each value to an inner sequence and merges the results. LINQ name for concurrent flattening.</summary>
+        /// <summary>Projects each value to an inner sequence and merges the results.</summary>
         /// <typeparam name="TResult">The inner value type.</typeparam>
         /// <param name="selector">The function that projects each source value to an inner sequence.</param>
         /// <returns>A sequence containing the merged values of every inner sequence.</returns>
@@ -580,7 +569,7 @@ public IObservable<TResult> SelectMany<TCollection, TResult>(
             return new SelectManyResultSignal<T, TCollection, TResult>(source, collectionSelector, resultSelector);
         }
 
-        /// <summary>Merges this sequence with another observable sequence. System.Reactive name for <c>Blend</c>.</summary>
+        /// <summary>Merges this sequence with another observable sequence.</summary>
         /// <param name="second">The second sequence to merge.</param>
         /// <returns>A sequence containing values from both sources as they arrive.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="second"/> is <see langword="null"/>.</exception>
@@ -593,7 +582,7 @@ public IObservable<T> Merge(IObservable<T> second)
             return new MergeSignal<T>(source, second);
         }
 
-        /// <summary>Concatenates two sequences. System.Reactive name for <c>Chain</c>.</summary>
+        /// <summary>Concatenates two sequences.</summary>
         /// <param name="second">The second sequence.</param>
         /// <returns>A sequence that emits <paramref name="second"/> after <paramref name="source"/> completes.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="second"/> is <see langword="null"/>.</exception>
@@ -626,7 +615,7 @@ public IObservable<T> OnErrorResumeNext(IObservable<T> second)
     extension<T>(IObservable<T?> source)
         where T : class
     {
-        /// <summary>Filters out null values, emitting only non-null values. Familiar name for <c>KeepNotNull</c>.</summary>
+        /// <summary>Filters out null values, emitting only non-null values.</summary>
         /// <returns>An observable sequence that emits only the non-null values from the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         public IObservable<T> WhereNotNull()
@@ -642,7 +631,7 @@ public IObservable<T> WhereNotNull()
     /// <param name="left">The left sequence.</param>
     extension<TLeft>(IObservable<TLeft> left)
     {
-        /// <summary>Combines paired values from two sequences by index. System.Reactive name for <c>Pair</c>.</summary>
+        /// <summary>Combines paired values from two sequences by index.</summary>
         /// <typeparam name="TRight">The right value type.</typeparam>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <param name="right">The right sequence.</param>
@@ -665,7 +654,7 @@ public IObservable<TResult> Zip<TRight, TResult>(
                 : new ZipSignal<TLeft, TRight, TResult>(left, right, selector);
         }
 
-        /// <summary>Combines the latest values once both sequences have produced a value. System.Reactive name for <c>SyncLatest</c>.</summary>
+        /// <summary>Combines the latest values once both sequences have produced a value.</summary>
         /// <typeparam name="TRight">The right value type.</typeparam>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <param name="right">The right sequence.</param>
@@ -691,7 +680,7 @@ public IObservable<TResult> CombineLatest<TRight, TResult>(
                 : new CombineLatestSignal<TLeft, TRight, TResult>(left, right, selector);
         }
 
-        /// <summary>Combines each left value with the latest right value. System.Reactive name for <c>Latch</c>.</summary>
+        /// <summary>Combines each left value with the latest right value.</summary>
         /// <typeparam name="TRight">The right value type.</typeparam>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <param name="right">The sequence that supplies the latest value.</param>
@@ -714,7 +703,7 @@ public IObservable<TResult> WithLatestFrom<TRight, TResult>(
                 : new LatchSignal<TLeft, TRight, TResult>(left, right, selector);
         }
 
-        /// <summary>Delays source notifications by the specified duration. System.Reactive name for <c>Shift</c>.</summary>
+        /// <summary>Delays source notifications by the specified duration.</summary>
         /// <param name="dueTime">The delay applied to each notification.</param>
         /// <returns>A sequence that forwards source notifications after the delay.</returns>
         public IObservable<TLeft> Delay(TimeSpan dueTime)
@@ -726,7 +715,7 @@ public IObservable<TLeft> Delay(TimeSpan dueTime)
                 : new ShiftSignal<TLeft>(left, dueTime, ThreadPoolSequencer.Instance);
         }
 
-        /// <summary>Delays source notifications by the specified duration on a sequencer. System.Reactive name for <c>Shift</c>.</summary>
+        /// <summary>Delays source notifications by the specified duration on a sequencer.</summary>
         /// <param name="dueTime">The delay applied to each notification.</param>
         /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
         /// <returns>A sequence that forwards source notifications after the delay.</returns>
@@ -762,7 +751,7 @@ public IObservable<TLeft> Delay(DateTimeOffset dueTime, ISequencer? scheduler)
             return new AbsoluteShiftSignal<TLeft>(left, dueTime, scheduler);
         }
 
-        /// <summary>Fails the sequence if it does not terminate before the timeout. System.Reactive name for <c>Expire</c>.</summary>
+        /// <summary>Fails the sequence if it does not terminate before the timeout.</summary>
         /// <param name="dueTime">The timeout duration.</param>
         /// <returns>A sequence that errors with <see cref="TimeoutException"/> when the timeout elapses first.</returns>
         public IObservable<TLeft> Timeout(TimeSpan dueTime)
@@ -772,7 +761,7 @@ public IObservable<TLeft> Timeout(TimeSpan dueTime)
             return new ExpireSignal<TLeft>(left, dueTime, ThreadPoolSequencer.Instance);
         }
 
-        /// <summary>Fails the sequence if it does not terminate before the sequencer timeout. System.Reactive name for <c>Expire</c>.</summary>
+        /// <summary>Fails the sequence if it does not terminate before the sequencer timeout.</summary>
         /// <param name="dueTime">The timeout duration.</param>
         /// <param name="scheduler">The sequencer used to schedule the timeout.</param>
         /// <returns>A sequence that errors with <see cref="TimeoutException"/> when the timeout elapses first.</returns>
@@ -806,7 +795,7 @@ public IObservable<TLeft> Timeout(DateTimeOffset dueTime, ISequencer? scheduler)
             return new AbsoluteExpireSignal<TLeft>(left, dueTime, scheduler);
         }
 
-        /// <summary>Emits the most recent value at the end of each sampling period. System.Reactive name for <c>Probe</c>.</summary>
+        /// <summary>Emits the most recent value at the end of each sampling period.</summary>
         /// <param name="interval">The sampling period.</param>
         /// <returns>A sequence containing the latest source value sampled at each period boundary.</returns>
         public IObservable<TLeft> Sample(TimeSpan interval)
@@ -818,7 +807,7 @@ public IObservable<TLeft> Sample(TimeSpan interval)
             return new ProbeSignal<TLeft>(left, interval, ThreadPoolSequencer.Instance);
         }
 
-        /// <summary>Emits the most recent value at the end of each sampling period on a sequencer. System.Reactive name for <c>Probe</c>.</summary>
+        /// <summary>Emits the most recent value at the end of each sampling period on a sequencer.</summary>
         /// <param name="interval">The sampling period.</param>
         /// <param name="scheduler">The sequencer used to schedule sampling.</param>
         /// <returns>A sequence containing the latest source value sampled at each period boundary.</returns>
@@ -834,7 +823,7 @@ public IObservable<TLeft> Sample(TimeSpan interval, ISequencer? scheduler)
             return new ProbeSignal<TLeft>(left, interval, scheduler);
         }
 
-        /// <summary>Resubscribes to the source after an error up to <paramref name="retryCount"/> times. System.Reactive name for <c>Reattempt</c>.</summary>
+        /// <summary>Resubscribes to the source after an error up to <paramref name="retryCount"/> times.</summary>
         /// <param name="retryCount">The maximum number of retry attempts after the initial subscription.</param>
         /// <returns>A sequence that retries the source before forwarding the final error.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="left"/> is <see langword="null"/>.</exception>
@@ -848,7 +837,7 @@ public IObservable<TLeft> Retry(int retryCount)
             return new ReattemptSignal<TLeft>(left, retryCount);
         }
 
-        /// <summary>Converts source values and terminal notifications into <see cref="Spark{T}"/> values. System.Reactive name for <c>Spark</c>.</summary>
+        /// <summary>Converts source values and terminal notifications into <see cref="Spark{T}"/> values.</summary>
         /// <returns>A sequence of spark values representing source notifications.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="left"/> is <see langword="null"/>.</exception>
         public IObservable<Spark<TLeft>> Materialize()
@@ -864,7 +853,7 @@ public IObservable<Spark<TLeft>> Materialize()
     /// <param name="source">An observable sequence of elements to project.</param>
     extension<TSource>(IObservable<TSource> source)
     {
-        /// <summary>Projects each element of an observable sequence into a new form. LINQ name for <c>Map</c>.</summary>
+        /// <summary>Projects each element of an observable sequence into a new form.</summary>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the transform function on each source element.</returns>
@@ -878,7 +867,7 @@ public IObservable<TResult> Select<TResult>(Func<TSource, TResult> selector)
             return new MapSignal<TSource, TResult>(source, selector);
         }
 
-        /// <summary>Projects each element and its zero-based index into a new form. LINQ name for <c>MapIndexed</c>.</summary>
+        /// <summary>Projects each element and its zero-based index into a new form.</summary>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
         /// <param name="selector">A transform function to apply to each element and its index.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the transform on each source element and index.</returns>
@@ -892,7 +881,7 @@ public IObservable<TResult> Select<TResult>(Func<TSource, int, TResult> selector
             return new MapIndexedSignal<TSource, TResult>(source, selector);
         }
 
-        /// <summary>Projects each element into a new form using external state passed to the selector. State-carrying name for <c>MapWith</c>.</summary>
+        /// <summary>Projects each element into a new form using external state passed to the selector.</summary>
         /// <typeparam name="TState">The type of the state used in the selector function.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
         /// <param name="state">The state to pass to the selector function.</param>
@@ -908,7 +897,7 @@ public IObservable<TResult> SelectWith<TState, TResult>(TState state, Func<TStat
             return new MapWithSignal<TSource, TState, TResult>(source, state, selector);
         }
 
-        /// <summary>Filters an observable sequence to elements that satisfy a predicate. LINQ name for <c>Keep</c>.</summary>
+        /// <summary>Filters an observable sequence to elements that satisfy a predicate.</summary>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns>An observable sequence containing the elements that satisfy <paramref name="predicate"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
@@ -921,7 +910,7 @@ public IObservable<TSource> Where(Func<TSource, bool> predicate)
             return new KeepSignal<TSource>(source, predicate);
         }
 
-        /// <summary>Filters elements using a predicate that uses external state. State-carrying name for <c>KeepWith</c>.</summary>
+        /// <summary>Filters elements using a predicate that uses external state.</summary>
         /// <typeparam name="TState">The type of the state parameter passed to the predicate.</typeparam>
         /// <param name="state">The state value to pass to the predicate for each element.</param>
         /// <param name="predicate">A function to test each element along with the state.</param>
@@ -942,7 +931,7 @@ public IObservable<TSource> WhereWith<TState>(TState state, Func<TState, TSource
     /// <param name="sources">The outer sequence of task sources.</param>
     extension<T>(IObservable<Task<T>> sources)
     {
-        /// <summary>Subscribes to task results one at a time in source order. System.Reactive name for <c>Chain</c>.</summary>
+        /// <summary>Subscribes to task results one at a time in source order.</summary>
         /// <returns>A sequence that emits each task result after the previous task signal completes.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
         public IObservable<T> Concat()
@@ -957,7 +946,7 @@ public IObservable<T> Concat()
     /// <param name="source">The source sequence.</param>
     extension(IObservable<object?> source)
     {
-        /// <summary>Filters values to those assignable to <typeparamref name="TResult"/>. System.Reactive name for <c>KeepType</c>.</summary>
+        /// <summary>Filters values to those assignable to <typeparamref name="TResult"/>.</summary>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <returns>A sequence containing only values assignable to <typeparamref name="TResult"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
@@ -972,7 +961,7 @@ public IObservable<TResult> OfType<TResult>()
             return new KeepTypeSignal<TResult>(source);
         }
 
-        /// <summary>Casts each source value to <typeparamref name="TResult"/>. System.Reactive name for <c>CastTo</c>.</summary>
+        /// <summary>Casts each source value to <typeparamref name="TResult"/>.</summary>
         /// <typeparam name="TResult">The result value type.</typeparam>
         /// <returns>A sequence containing each value cast to <typeparamref name="TResult"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.cs b/src/Primitives.Shared/SignalOperatorParityMixins.cs
index a47bd918..5f0a645a 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.cs
@@ -60,7 +60,7 @@ public IObservable<T> ToObservable(CancellationToken cancellationToken)
     /// <param name="source">The source sequence.</param>
     extension<T>(IObservable<T> source)
     {
-        /// <summary>Prepends a value before the source sequence. Alias of <c>Prepend</c> using Primitives vocabulary.</summary>
+        /// <summary>Prepends a value before the source sequence.</summary>
         /// <param name="value">The value to emit before the source.</param>
         /// <returns>A sequence that emits <paramref name="value"/> before the source values.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
@@ -128,7 +128,7 @@ public IObservable<T> Append(T value)
                 : new AppendSignal<T>(source, value);
         }
 
-        /// <summary>Returns the source as an observable. This is an identity adapter for BCL observable sources.</summary>
+        /// <summary>Returns the source observable unchanged.</summary>
         /// <returns>The supplied source sequence.</returns>
         /// <exception cref="ArgumentNullException">The receiver sequence is <see langword="null"/>.</exception>
         public IObservable<T> AsObservable() => source ?? throw new ArgumentNullException(nameof(source));
@@ -836,12 +836,8 @@ private static async Task<T> AwaitWithCancellationAsync<T>(Task<T> task, Cancell
         }
         catch (OperationCanceledException)
         {
-            // Observe faults from work that outlives cancellation of the wait.
-            _ = task.ContinueWith(
-                static abandoned => _ = abandoned.Exception,
-                CancellationToken.None,
-                TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
-                TaskScheduler.Default);
+            // Faults are observed even after the wait is cancelled.
+            TaskFaultObservation.Register(task);
             throw;
         }
     }
diff --git a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
index b971523a..151b145d 100644
--- a/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/PrioritySemaphoreSignal{T}.cs
@@ -103,17 +103,8 @@ public void OnNext(T value)
     /// <summary>Releases one semaphore slot and drains queued values when capacity is available.</summary>
     public void Release()
     {
-        int previousCount;
-        do
-        {
-            previousCount = Volatile.Read(ref _count);
-            if (previousCount <= 0)
-            {
-                return;
-            }
-        } while (Interlocked.CompareExchange(ref _count, previousCount - 1, previousCount) != previousCount);
-
-        YieldUntilEmptyOrBlocked();
+        var previousCount = Volatile.Read(ref _count);
+        ReleaseObserved(previousCount);
     }
 
     /// <inheritdoc />
@@ -174,6 +165,23 @@ public void Dispose()
         _inner.Dispose();
     }
 
+    /// <summary>Releases one occupied slot, retrying when the observed count has changed.</summary>
+    /// <param name="previousCount">The count observed before attempting release.</param>
+    internal void ReleaseObserved(int previousCount)
+    {
+        while (previousCount > 0)
+        {
+            var currentCount = Interlocked.CompareExchange(ref _count, previousCount - 1, previousCount);
+            if (currentCount == previousCount)
+            {
+                YieldUntilEmptyOrBlocked();
+                return;
+            }
+
+            previousCount = currentCount;
+        }
+    }
+
     /// <summary>Queues a value while the signal accepts input.</summary>
     /// <param name="value">The value to enqueue.</param>
     /// <returns><see langword="true"/> when the value was queued; otherwise, <see langword="false"/>.</returns>
@@ -208,7 +216,6 @@ private void YieldUntilEmptyOrBlocked()
                 Deliver(item);
             }
 
-            // TryTakeNextDrainItem cleared ownership when it returned false.
             owned = false;
         }
         finally
@@ -248,7 +255,6 @@ private bool TryTakeNextDrainItem(out DrainItem item)
                 return true;
             }
 
-            // Release ownership under the queue gate so subsequent producers can start a drain.
             _isDraining = false;
             return false;
         }
diff --git a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
index c051205e..b743f5b5 100644
--- a/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
+++ b/src/Primitives.Shared/Signals/ReplaySignal{T}.cs
@@ -220,7 +220,6 @@ public void OnError(Exception error)
     /// <remarks>Concurrent subscription receives each value once, through replay or live delivery, in emission order.</remarks>
     public void OnNext(T value)
     {
-        // Read the scheduler clock outside the lock; the window inputs are immutable.
         var interval = _usesWindow ? _scheduler.Now - _startTime : TimeSpan.Zero;
         lock (_observerLock)
         {
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
index e4a506ca..8e8efc8d 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
@@ -46,7 +46,7 @@ public IEnumerable<T> ToEnumerable()
                 },
                 completed.Set);
 
-            completed.Wait();
+            WaitForCompletion(completed);
 
             if (error is not null)
             {
@@ -56,4 +56,10 @@ public IEnumerable<T> ToEnumerable()
             return values;
         }
     }
+
+    /// <summary>Blocks until the source signals completion.</summary>
+    /// <param name="completed">The source's completion signal.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void WaitForCompletion(ManualResetEventSlim completed) => completed.Wait();
 }
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs b/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
index 52c95051..dbe02530 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{FromTask}.cs
@@ -14,7 +14,7 @@ namespace ReactiveUI.Primitives.Signals;
 public static partial class SignalExtensions
 {
     /// <summary>Cancellation-handling operators for an observable source sequence.</summary>
-    /// <typeparam name="TResult">The type.</typeparam>
+    /// <typeparam name="TResult">The source element type.</typeparam>
     /// <param name="asyncTask">The asynchronous task.</param>
     extension<TResult>(IObservable<TResult> asyncTask)
     {
@@ -34,7 +34,7 @@ public static partial class SignalExtensions
             try
             {
                 token.ThrowIfCancellationRequested();
-                return await Task.Run(async () => await asyncTask, token).ConfigureAwait(false);
+                return await AwaitOnTaskPoolAsync(asyncTask, token).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -110,19 +110,12 @@ public async Task HandleCancellation(Action? action)
 
             try
             {
-                // Create a task that completes when either the async operation completes,
-                // or cancellation is requested.
                 var readyTask = await Task.WhenAny(asyncTask, cancellationTask).ConfigureAwait(false);
 
-                // In case of cancellation, register a continuation to observe any unhandled
-                // exceptions from the asynchronous operation once it completes.
+                // Faults from work that outlives cancellation are still observed.
                 if (readyTask == cancellationTask)
                 {
-                    _ = asyncTask.ContinueWith(
-                        static task => _ = task.Exception,
-                        CancellationToken.None,
-                        TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
-                        TaskScheduler.Default);
+                    TaskFaultObservation.Register(asyncTask);
                 }
 
                 return (await readyTask.ConfigureAwait(false), tcs.Task.IsCanceled || readyTask.IsCanceled);
@@ -137,4 +130,14 @@ public async Task HandleCancellation(Action? action)
             }
         }
     }
+
+    /// <summary>Starts an observable wait on the task pool.</summary>
+    /// <typeparam name="TResult">The source value type.</typeparam>
+    /// <param name="source">The source to await.</param>
+    /// <param name="token">The token cancelling dispatch.</param>
+    /// <returns>The source's terminal result.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Task<TResult> AwaitOnTaskPoolAsync<TResult>(IObservable<TResult> source, CancellationToken token) =>
+        Task.Run(async () => await source, token);
 }
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs b/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
index 8172b432..285a36d5 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{GetAwaiter}.cs
@@ -18,20 +18,14 @@ public static partial class SignalExtensions
     /// <param name="source">Source sequence to await.</param>
     extension<TSource>(IObservable<TSource> source)
     {
-        /// <summary>
-        /// Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty.
-        /// This operation subscribes to the observable sequence, making it hot.
-        /// </summary>
+        /// <summary>Subscribes immediately and returns an awaiter for the last value, throwing if the sequence is empty.</summary>
         /// <returns>A final signal awaiter.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IAwaitSignal<TSource> GetAwaiter() =>
             Signal.RunAsync(source);
 
-        /// <summary>
-        /// Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty.
-        /// This operation subscribes to the observable sequence, making it hot.
-        /// </summary>
+        /// <summary>Subscribes immediately and returns an awaiter for the last value, throwing if the sequence is empty.</summary>
         /// <param name="cancellationToken">Token that cancels the await and disposes the subscription.</param>
         /// <returns>A final signal awaiter.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
diff --git a/src/Primitives.Shared/Signals/Signal{Create}.cs b/src/Primitives.Shared/Signals/Signal{Create}.cs
index 182218f6..163f42ec 100644
--- a/src/Primitives.Shared/Signals/Signal{Create}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Create}.cs
@@ -15,10 +15,7 @@ namespace ReactiveUI.Primitives.Signals;
 /// <summary>Factory methods that build signals from subscribe functions and deferred sources.</summary>
 public static partial class Signal
 {
-    /// <summary>
-    /// Creates a signal that runs the subscribe function for each observer. A downstream <c>OnNext</c> that throws
-    /// leaves the subscription intact, which suits hot signals built over operators and events.
-    /// </summary>
+    /// <summary>Runs the subscription factory for each observer and preserves the subscription when a downstream OnNext throws.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
     /// <returns>A signal backed by <paramref name="subscribe"/>.</returns>
@@ -31,7 +28,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe
     }
 
     /// <summary>Creates an observable from an asynchronous subscription function.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type of the created sequence.</typeparam>
     /// <param name="subscribe">The asynchronous subscription function.</param>
     /// <returns>An observable sequence backed by the asynchronous subscription.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe"/> is <see langword="null"/>.</exception>
@@ -43,7 +40,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, Task<IDisposable>> sub
     }
 
     /// <summary>Creates an observable from a cancellable asynchronous subscription function.</summary>
-    /// <typeparam name="T">The type.</typeparam>
+    /// <typeparam name="T">The element type of the created sequence.</typeparam>
     /// <param name="subscribe">The asynchronous subscription function.</param>
     /// <returns>An observable sequence backed by the asynchronous subscription.</returns>
     /// <exception cref="ArgumentExceptionHelper"><paramref name="subscribe"/> is <see langword="null"/>.</exception>
@@ -58,10 +55,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, CancellationToken, Tas
         return new AsyncCreateSignal<T>(subscribe);
     }
 
-    /// <summary>
-    /// Creates a signal that runs the subscribe function for each observer. A downstream <c>OnNext</c> that throws
-    /// leaves the subscription intact, which suits hot signals built over operators and events.
-    /// </summary>
+    /// <summary>Runs the subscription factory for each observer and preserves the subscription when a downstream OnNext throws.</summary>
     /// <typeparam name="T">The element type.</typeparam>
     /// <param name="subscribe">Invoked for each observer; returns the disposable that releases the subscription.</param>
     /// <param name="isRequiredSubscribeOnCurrentThread">Whether subscription must be dispatched through the current-thread sequencer.</param>
diff --git a/src/Primitives.Shared/Signals/Signal{Factories}.cs b/src/Primitives.Shared/Signals/Signal{Factories}.cs
index ba4f3e45..c5d07b43 100644
--- a/src/Primitives.Shared/Signals/Signal{Factories}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Factories}.cs
@@ -90,7 +90,7 @@ public static IObservable<TResult> Unfold<TState, TResult>(
         return new UnfoldSignal<TState, TResult>(initialState, condition, iterate, resultSelector);
     }
 
-    /// <summary>Generates a finite signal from state. Alias of <see cref="Unfold{TState, TResult}(TState, Func{TState, bool}, Func{TState, TState}, Func{TState, TResult})"/>.</summary>
+    /// <summary>Generates a finite signal by advancing state while the condition holds.</summary>
     /// <typeparam name="TState">The type of the state.</typeparam>
     /// <typeparam name="TResult">The type of the result.</typeparam>
     /// <param name="initialState">The initial state.</param>
diff --git a/src/Primitives.Shared/Signals/Signal{FromTask}.cs b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
index 161c63ec..0428db9f 100644
--- a/src/Primitives.Shared/Signals/Signal{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
@@ -230,7 +230,7 @@ private static void Cancel(CancellationTokenSource source)
         }
         catch (ObjectDisposedException)
         {
-            // Another completion path released the token source.
+            // Cancellation remains harmless after task completion.
         }
     }
 
diff --git a/src/Primitives.Shared/Signals/TaskSignal{T}.cs b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
index cfd1e872..35b00d1a 100644
--- a/src/Primitives.Shared/Signals/TaskSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
@@ -97,7 +97,7 @@ private void Dispose(bool disposing)
         }
         catch (ObjectDisposedException)
         {
-            // The token source can be disposed by the task completion path.
+            // Cancellation remains harmless after task completion.
         }
 
         _cleanUp.Dispose();
diff --git a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
index b43d4a94..225ed040 100644
--- a/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskTerminalCompletion{T}.cs
@@ -56,7 +56,6 @@ internal void FailEmpty() =>
     /// <returns>The terminal task.</returns>
     internal Task<T> Attach(IDisposable subscription, CancellationToken cancellationToken)
     {
-        // Writing the subscription before registering publishes it to the thread that runs the cancellation callback.
         _subscription = subscription;
         if (_completion.Task.IsCompleted)
         {
@@ -71,8 +70,6 @@ internal Task<T> Attach(IDisposable subscription, CancellationToken cancellation
                 static state => ((TaskTerminalCompletion<T>)state!).Cancel(),
                 this);
 
-            // A source that completed while the registration was being created saw a default registration in the
-            // observer callbacks, so release the real one here.
             if (_completion.Task.IsCompleted)
             {
                 _ = _cancellationRegistration.Unregister();
diff --git a/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs b/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
index a464807f..76b9a695 100644
--- a/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/CancellationDisposable.cs
@@ -41,7 +41,7 @@ public CancellationDisposable()
     /// <summary>Cancels the source on the first call; repeated calls have no further effect.</summary>
     public void Dispose()
     {
-        // Atomic run-once latch so concurrent disposal cannot cancel the source twice.
+        // Concurrent disposal cancels the source at most once.
         if (Interlocked.Exchange(ref _isDisposed, 1) != 0)
         {
             return;
diff --git a/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs b/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
index 92d07b89..0a6fd70b 100644
--- a/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/EmptyDisposable.cs
@@ -24,6 +24,6 @@ private EmptyDisposable()
     /// <inheritdoc/>
     public void Dispose()
     {
-        // Intentionally empty: represents the absence of a resource, so there is nothing to release.
+        // Disposing an empty resource has no effect.
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs b/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
index 96268934..9baaa337 100644
--- a/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/MultipleDisposable.cs
@@ -8,11 +8,6 @@
 namespace ReactiveUI.Primitives.Disposables;
 
 /// <summary>A disposable pocket that contains a set of disposables and disposes them together.</summary>
-/// <remarks>
-/// Implements <see cref="ICollection{T}"/> over <see cref="IDisposable"/> so it can stand in for a
-/// composite disposable: it supports collection initializers, membership queries, and
-/// <c>DisposeWith</c>-style extension methods that accept an <see cref="ICollection{T}"/>.
-/// </remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class MultipleDisposable : IsDisposed, ICollection<IDisposable>
 {
@@ -86,7 +81,7 @@ public MultipleDisposable(params IDisposable[] disposables)
     /// <summary>Gets a value indicating whether the object is disposed.</summary>
     public bool IsDisposed => Volatile.Read(ref _disposed);
 
-    /// <summary>Gets the number of disposables currently held. Returns zero once disposed.</summary>
+    /// <summary>Gets the number of held disposables, or zero after disposal.</summary>
     public int Count
     {
         get
@@ -114,7 +109,7 @@ public int Count
         }
     }
 
-    /// <summary>Gets a value indicating whether the collection is read-only. Always <see langword="false"/>.</summary>
+    /// <summary>Gets a value indicating whether the collection is read-only, which is always false.</summary>
     public bool IsReadOnly => false;
 
     /// <summary>Gets the debugger display text.</summary>
diff --git a/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs b/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
index d5da0447..2228848b 100644
--- a/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/MutableDisposable.cs
@@ -6,12 +6,8 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>
-/// A disposable holder whose inner disposable can be re-assigned. The displaced inner
-/// disposable is NOT disposed when replaced (in contrast to <see cref="SwapDisposable"/>).
-/// Once this object is disposed, any inner disposable assigned afterwards is disposed
-/// immediately.
-/// </summary>
+/// <summary>Holds a replaceable disposable without disposing the displaced value.</summary>
+/// <remarks>Assignments after disposal are disposed immediately.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class MutableDisposable : IsDisposed
 {
diff --git a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
index ac3ad4f7..6e572e77 100644
--- a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
@@ -4,12 +4,8 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>
-/// A disposable holder whose inner disposable can be set exactly once. A second
-/// assignment throws <see cref="InvalidOperationException"/>; if the holder was disposed
-/// before the assignment, the supplied disposable is disposed immediately and no exception
-/// is thrown.
-/// </summary>
+/// <summary>Holds a disposable that can be assigned once.</summary>
+/// <remarks>Repeated assignment throws InvalidOperationException; an assignment after disposal is disposed immediately.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class OnceDisposable : IsDisposed
 {
@@ -25,7 +21,7 @@ public sealed class OnceDisposable : IsDisposed
     /// <summary>Gets a value indicating whether this instance has been disposed.</summary>
     public bool IsDisposed => ReferenceEquals(Volatile.Read(ref _current), DisposedSentinel);
 
-    /// <summary>Gets or sets the inner disposable. Setting more than once throws.</summary>
+    /// <summary>Gets or sets the inner disposable, throwing on repeated assignment.</summary>
     public IDisposable? Disposable
     {
         get
@@ -75,7 +71,7 @@ private sealed class DisposedMarker : IDisposable
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Intentionally empty.
+            // Disposing the terminal marker has no effect.
         }
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
index 76b1303d..54df8768 100644
--- a/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SingleDisposable.cs
@@ -103,8 +103,7 @@ private sealed class DisposedMarker : IDisposable
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Intentionally empty: a reference-identity sentinel marking a disposed slot. It is only ever
-            // compared with ReferenceEquals and never itself disposed, so this body is unreachable.
+            // Disposing the terminal marker has no effect.
         }
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
index 65fc271b..9c4dabe1 100644
--- a/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SingleReplaceableDisposable.cs
@@ -57,25 +57,7 @@ public SingleReplaceableDisposable(IDisposable disposable, Action? action)
     public void Create(IDisposable disposable)
     {
         ArgumentExceptionHelper.ThrowIfNull(disposable);
-
-        while (true)
-        {
-            var current = Volatile.Read(ref _disposable);
-            if (ReferenceEquals(current, DisposedSentinel))
-            {
-                disposable.Dispose();
-                _action?.Invoke();
-                return;
-            }
-
-            if (!ReferenceEquals(Interlocked.CompareExchange(ref _disposable, disposable, current), current))
-            {
-                continue;
-            }
-
-            current?.Dispose();
-            return;
-        }
+        CreateWithRetry(disposable);
     }
 
     /// <summary>Disposes the inner value and blocks further assignments; repeated calls have no further effect.</summary>
@@ -85,6 +67,28 @@ public void Dispose()
         GC.SuppressFinalize(this);
     }
 
+    /// <summary>Replaces the observed value, or disposes the incoming value when the slot is closed.</summary>
+    /// <param name="current">The observed slot value.</param>
+    /// <param name="disposable">The incoming disposable.</param>
+    /// <returns>True when the incoming value was handled; false when the observed slot was stale.</returns>
+    internal bool TryCreate(IDisposable? current, IDisposable disposable)
+    {
+        if (ReferenceEquals(current, DisposedSentinel))
+        {
+            disposable.Dispose();
+            _action?.Invoke();
+            return true;
+        }
+
+        if (!ReferenceEquals(Interlocked.CompareExchange(ref _disposable, disposable, current), current))
+        {
+            return false;
+        }
+
+        current?.Dispose();
+        return true;
+    }
+
     /// <summary>Disposes the inner value and then invokes the constructor-supplied action, once.</summary>
     /// <param name="disposing"><see langword="true"/> when invoked from <see cref="Dispose()"/>.</param>
     protected virtual void Dispose(bool disposing)
@@ -99,6 +103,20 @@ protected virtual void Dispose(bool disposing)
         _action?.Invoke();
     }
 
+    /// <summary>Retries replacement until the observed slot is current.</summary>
+    /// <param name="disposable">The incoming disposable.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private void CreateWithRetry(IDisposable disposable)
+    {
+        while (true)
+        {
+            if (TryCreate(Volatile.Read(ref _disposable), disposable))
+            {
+                return;
+            }
+        }
+    }
+
     /// <summary>Disposable marker for disposed slots.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private sealed class DisposedMarker : IDisposable
@@ -106,8 +124,7 @@ private sealed class DisposedMarker : IDisposable
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Intentionally empty: a reference-identity sentinel marking a disposed slot. It is only ever
-            // compared with ReferenceEquals and never itself disposed, so this body is unreachable.
+            // Disposing the terminal marker has no effect.
         }
     }
 }
diff --git a/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs b/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
index 2d4aeb80..ce8057af 100644
--- a/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/SwapDisposable.cs
@@ -6,12 +6,8 @@
 
 namespace ReactiveUI.Primitives.Disposables;
 
-/// <summary>
-/// A disposable holder whose inner disposable can be re-assigned. The displaced inner
-/// disposable is disposed when replaced (in contrast to <see cref="MutableDisposable"/>).
-/// Once this object is disposed, any inner disposable assigned afterwards is disposed
-/// immediately.
-/// </summary>
+/// <summary>Holds a replaceable disposable and disposes each displaced value.</summary>
+/// <remarks>Assignments after disposal are disposed immediately.</remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class SwapDisposable : IsDisposed
 {
@@ -24,7 +20,7 @@ public sealed class SwapDisposable : IsDisposed
     /// <summary>Gets a value indicating whether this instance has been disposed.</summary>
     public bool IsDisposed => Volatile.Read(ref _disposed) == DisposableSlotHelper.DisposedSentinel;
 
-    /// <summary>Gets or sets the current inner disposable. Setting disposes the previous value.</summary>
+    /// <summary>Gets or sets the current inner disposable, disposing the previous value on assignment.</summary>
     public IDisposable? Disposable
     {
         get => Volatile.Read(ref _current);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
index 43006eba..921dcb16 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/AsyncSerialGate.cs
@@ -7,7 +7,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>Serializes asynchronous critical sections with disposable leases. Reentrant acquisition is allowed only on the managed thread that currently owns the gate.</summary>
+/// <summary>Serializes asynchronous critical sections, permitting reentry only from the owning managed thread.</summary>
 [System.Diagnostics.DebuggerDisplay("AsyncSerialGate: OwnerThreadId = {_ownerThreadId}, Waiters = {_waiters}, RecursionDepth = {_recursionDepth}")]
 public sealed class AsyncSerialGate : IDisposable
 {
@@ -75,7 +75,7 @@ internal ValueTask<Lease> EnterForThreadAsync(int currentThreadId, CancellationT
             : WaitForEntryAsync(cancellationToken);
     }
 
-    /// <summary>Exits the gate. Decrements the recursion depth on a nested exit, or clears the owner and signals one waiter (if any) on the outermost release.</summary>
+    /// <summary>Releases one acquisition, waking a waiter after the outermost release.</summary>
     internal void Exit()
     {
         if (_recursionDepth > 0)
@@ -98,8 +98,6 @@ internal async ValueTask<Lease> WaitForEntryAsync(CancellationToken cancellation
         {
             while (true)
             {
-                // Retry the CAS before waiting; closes the race where the owner releases between
-                // the caller's fast-path failure and our increment of _waiters.
                 if (Interlocked.CompareExchange(ref _ownerThreadId, Environment.CurrentManagedThreadId, 0) == 0)
                 {
                     return new(this);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
index b3611bb8..abc4c553 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/BackgroundJobSignal{T}.cs
@@ -13,7 +13,7 @@ public sealed class BackgroundJobSignal<T> : IObservableAsync<T>
     /// <param name="job">The job to execute for each subscription.</param>
     /// <param name="startSynchronously">A value indicating whether the job starts synchronously on subscribe.</param>
     /// <param name="taskScheduler">The scheduler that starts the job, or <see langword="null"/> to start it on
-    /// the thread pool after a yield.</param>
+    /// the current context after yielding.</param>
     public BackgroundJobSignal(
         Func<IObserverAsync<T>, CancellationToken, ValueTask> job,
         bool startSynchronously,
@@ -59,6 +59,7 @@ ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
     /// <param name="observer">The observer receiving job notifications.</param>
     /// <param name="cancellationToken">The cancellation token for the job.</param>
     /// <returns>A task representing the job.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private async ValueTask ExecuteAfterYieldAsync(IObserverAsync<T> observer, CancellationToken cancellationToken)
     {
         await Task.Yield();
@@ -70,6 +71,7 @@ private async ValueTask ExecuteAfterYieldAsync(IObserverAsync<T> observer, Cance
     /// <param name="taskScheduler">The scheduler that runs the job.</param>
     /// <param name="cancellationToken">The cancellation token for the job.</param>
     /// <returns>A task representing the job.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private async ValueTask ExecuteOnSchedulerAsync(
         IObserverAsync<T> observer,
         TaskScheduler taskScheduler,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
index be99c208..1ffdadf7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/CallbackWitnessAsync.cs
@@ -4,8 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>A witness that routes notifications through caller-supplied asynchronous callbacks. A callback left
-/// unset reports resumable errors and terminal failures to the unhandled exception handler.</summary>
+/// <summary>Routes notifications to callbacks and unhandled failures to the exception handler.</summary>
 /// <typeparam name="T">The type of the elements received by the witness.</typeparam>
 /// <param name="onNextAsync">The asynchronous function invoked for each element.</param>
 /// <param name="onErrorResumeAsync">An optional asynchronous function invoked when a resumable error occurs.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
index 4e1a6b1f..3c7f3f2a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/FlatMapCoordinator{TResult}.cs
@@ -53,7 +53,7 @@ public FlatMapCoordinator(IObserverAsync<TResult> observer)
     /// <summary>Gets or sets a value indicating whether this coordinator has been disposed.</summary>
     private bool Disposed { get; set; }
 
-    /// <summary>Takes ownership of the outer subscription, disposing it immediately when this coordinator has finished. Callable once per coordinator.</summary>
+    /// <summary>Accepts the outer subscription once, disposing it immediately if this coordinator has finished.</summary>
     /// <param name="observer">The outer subscription to own.</param>
     /// <returns>A task that completes once the subscription has been stored or disposed.</returns>
     /// <exception cref="InvalidOperationException">Thrown when an outer subscription is set twice.</exception>
@@ -61,8 +61,7 @@ public FlatMapCoordinator(IObserverAsync<TResult> observer)
     public ValueTask SetOuterObserverAsync(IAsyncDisposable observer) =>
         OuterObserver.SetDisposableAsync(observer);
 
-    /// <summary>Cancels this coordinator's lifetime when <paramref name="external"/> is cancelled. A token that
-    /// cannot be cancelled is ignored; a token cancelled at call time cancels the lifetime immediately.</summary>
+    /// <summary>Links external cancellation to this lifetime, immediately honoring an already cancelled token.</summary>
     /// <param name="external">The subscribe-time cancellation token.</param>
     public void LinkExternalCancellation(CancellationToken external)
     {
@@ -86,8 +85,7 @@ public void LinkExternalCancellation(CancellationToken external)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask DisposeAsync() => FinishAsync(null);
 
-    /// <summary>Subscribes to an inner sequence and counts it as active until it completes. A failure raised while
-    /// subscribing finishes the whole sequence with that failure; a call after teardown is a no-op.</summary>
+    /// <summary>Tracks an inner subscription until completion, terminating the sequence if subscribing fails.</summary>
     /// <param name="inner">The inner sequence.</param>
     /// <returns>A task that completes once the inner sequence has been subscribed.</returns>
     public async ValueTask SubscribeInnerAsync(IObservableAsync<TResult> inner)
@@ -117,7 +115,7 @@ public async ValueTask SubscribeInnerAsync(IObservableAsync<TResult> inner)
     }
 
     /// <summary>Forwards an inner value downstream, serialized against the other inner sequences so the observer is never entered concurrently.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The inner value to forward.</param>
     /// <returns>A task that completes once the observer has accepted the value.</returns>
     public async ValueTask RelayNextAsync(TResult value)
     {
@@ -172,7 +170,7 @@ public ValueTask CompleteInnerAsync(Result result)
         return shouldComplete ? FinishAsync(result) : default;
     }
 
-    /// <summary>Completes the downstream observer and disposes every tracked subscription. Idempotent; a failure handed in after teardown goes to the unhandled exception handler.</summary>
+    /// <summary>Completes and releases this coordinator once, reporting subsequent failures to the unhandled exception handler.</summary>
     /// <param name="result">The result to forward, or <see langword="null"/> to tear down without completing
     /// the observer.</param>
     /// <returns>A task that completes once teardown has finished.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
index 4bb02c4e..b94d55a9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/ForwardingWitnessAsync.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Base observer that forwards every notification unchanged to a downstream observer. A derived type
-/// overrides only the notifications it needs to intercept and inherits pass-through behaviour for the rest.
-/// </summary>
+/// <summary>Forwards notifications unchanged unless a derived observer overrides them.</summary>
 /// <typeparam name="T">The observed element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("ForwardingWitnessAsync: Downstream = {Downstream}")]
 public class ForwardingWitnessAsync<T> : WitnessAsync<T>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
index 01b0b253..2e535962 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSignal.cs
@@ -4,8 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>An observable that emits incrementing ticks at a fixed interval. Ticks are numbered from one, each
-/// emitted after a further period has elapsed, and continue until the subscription is disposed.</summary>
+/// <summary>Emits ticks numbered from one, waiting one period between notifications until disposal.</summary>
 [System.Diagnostics.DebuggerDisplay("IntervalSignal: Period = {Period}, TimeProvider = {TimeProvider}")]
 public sealed class IntervalSignal : IObservableAsync<long>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
index 24b95d8b..1dc3b05d 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/IntervalSubscription.cs
@@ -36,7 +36,7 @@ protected override async ValueTask ExecuteAsyncCore(
         {
             if (TimeProvider is null || TimeProvider == TimeProvider.System)
             {
-                await Task.Delay(Period, cancellationToken).ConfigureAwait(false);
+                await SignalAsyncExtensions.DelayAsync(Period, TimeProvider.System, cancellationToken).ConfigureAwait(false);
             }
             else
             {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
index 63f4e692..bb93e2e4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/LeadSubscription{T}.cs
@@ -99,7 +99,7 @@ private async Task RunAsync()
         }
         catch (OperationCanceledException)
         {
-            // Cooperative subscription cancellation.
+            // Subscription cancellation is not reported as a failure.
         }
         catch (Exception e)
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
index 7be36594..109501e6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/PooledDelaySource.cs
@@ -8,12 +8,8 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>Poolable <see cref="IValueTaskSource"/> backing <c>DelayAsync</c> for non-System <see cref="TimeProvider"/> instances, so a delay costs no per-call allocation.</summary>
-/// <remarks>
-/// Whichever of the timer callback and the cancellation registration fires first claims completion
-/// through an <see cref="Interlocked.CompareExchange(ref int, int, int)"/> on a state flag; the
-/// loser is a no-op.
-/// </remarks>
+/// <summary>Provides reusable cancellable delays driven by a supplied time provider.</summary>
+/// <remarks>The first timer or cancellation callback determines the result.</remarks>
 [System.Diagnostics.DebuggerDisplay("PooledDelaySource: Completed = {_completed}, Timer = {_timer}")]
 public sealed class PooledDelaySource : IValueTaskSource
 {
@@ -27,7 +23,7 @@ public sealed class PooledDelaySource : IValueTaskSource
     [ThreadStatic]
     private static PooledDelaySource? _threadCached;
 
-    /// <summary>Backing source. Continuations run asynchronously so awaiters never re-enter the timer / cancel path.</summary>
+    /// <summary>The completion source, whose continuations run asynchronously.</summary>
     private ManualResetValueTaskSourceCore<bool> _core = new() { RunContinuationsAsynchronously = true };
 
     /// <summary>Tracks completion: <see cref="StateOpen"/> until the timer or cancellation claims completion; then <see cref="StateClaimed"/>.</summary>
@@ -58,15 +54,12 @@ public static PooledDelaySource Rent()
         return cached;
     }
 
-    /// <summary>
-    /// Begins the delay. The returned <see cref="ValueTask"/> completes when the timer fires or
-    /// the cancellation token is signalled — whichever happens first. The caller MUST await it
-    /// exactly once; the instance returns to the pool inside <see cref="GetResult(short)"/>.
-    /// </summary>
+    /// <summary>Begins a delay that completes when its timer or cancellation fires first.</summary>
     /// <param name="delay">The dueTime passed to <see cref="TimeProvider.CreateTimer"/>.</param>
     /// <param name="timeProvider">The non-System time provider supplying the timer.</param>
     /// <param name="cancellationToken">Cancellation token observed while waiting.</param>
     /// <returns>A <see cref="ValueTask"/> backed by this source.</returns>
+    /// <remarks>Await the returned value exactly once; consuming its result returns this source to the pool.</remarks>
     public ValueTask BeginAsync(TimeSpan delay, TimeProvider timeProvider, CancellationToken cancellationToken)
     {
         if (cancellationToken.IsCancellationRequested)
@@ -76,8 +69,6 @@ public ValueTask BeginAsync(TimeSpan delay, TimeProvider timeProvider, Cancellat
             return new(this, _core.Version);
         }
 
-        // CreateTimer may invoke the callback synchronously, flipping _completed to Claimed before
-        // this call returns.
         _timer = timeProvider.CreateTimer(
             static state => ((PooledDelaySource)state!).OnTimerFired(),
             this,
@@ -86,7 +77,6 @@ public ValueTask BeginAsync(TimeSpan delay, TimeProvider timeProvider, Cancellat
 
         if (Volatile.Read(ref _completed) == StateClaimed)
         {
-            // Sync-fire fast path: the source is complete, so no cancellation registration is needed.
             return new(this, _core.Version);
         }
 
@@ -159,7 +149,6 @@ private void ReturnToPool()
         _completed = StateOpen;
         _core.Reset();
 
-        // One instance cached per thread; any extra instances are dropped for the GC.
         _threadCached ??= this;
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/ReattemptSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/ReattemptSubscription{T}.cs
index da8bcd80..4ac57321 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/ReattemptSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/ReattemptSubscription{T}.cs
@@ -61,7 +61,7 @@ public async ValueTask SubscribeOnceAsync()
         }
         catch (OperationCanceledException)
         {
-            // Cooperative subscription cancellation.
+            // Subscription cancellation is not reported as a failure.
         }
         catch (Exception e)
         {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SequenceSubscription.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SequenceSubscription.cs
index 7846b700..044f0d00 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SequenceSubscription.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SequenceSubscription.cs
@@ -34,7 +34,6 @@ protected override async ValueTask ExecuteAsyncCore(
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            // Keep the observer notification token-free on the hot path; the loop checks the subscription token.
             await observer.OnNextAsync(StartValue + i, CancellationToken.None).ConfigureAwait(false);
         }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
index a784cc14..a5b59c45 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/StartSubscription{TResult}.cs
@@ -43,7 +43,21 @@ protected override async ValueTask ExecuteAsyncCore(
             return;
         }
 
-        await Task.Factory.StartNew(
+        await ExecuteOnSchedulerAsync(observer, taskScheduler, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>Starts the function through the supplied scheduler.</summary>
+    /// <param name="observer">The observer receiving the produced value.</param>
+    /// <param name="taskScheduler">The scheduler that starts the function.</param>
+    /// <param name="cancellationToken">Cancellation for the scheduled task and notifications.</param>
+    /// <returns>The scheduled function and notification operation.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private Task ExecuteOnSchedulerAsync(
+        IObserverAsync<TResult> observer,
+        TaskScheduler taskScheduler,
+        CancellationToken cancellationToken) =>
+        Task.Factory.StartNew(
                 static s =>
                 {
                     var (self, observer, cancellationToken) =
@@ -54,9 +68,7 @@ await Task.Factory.StartNew(
                 cancellationToken,
                 TaskCreationOptions.DenyChildAttach,
                 taskScheduler)
-            .Unwrap()
-            .ConfigureAwait(false);
-    }
+            .Unwrap();
 
     /// <summary>Invokes the function and forwards its result to the observer.</summary>
     /// <param name="observer">The observer receiving the produced value.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
index 5eacb0fe..e8142c97 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestCoordinatorBase.cs
@@ -55,7 +55,7 @@ internal ValueTask RelaySourceErrorAsync(Exception error, CancellationToken canc
         return Lifecycle.OnErrorResumeAsync(error);
     }
 
-    /// <summary>Projects the latest values once every source has emitted. Called after updating a slot under ValuesLock.</summary>
+    /// <summary>Projects the latest values under ValuesLock once every source has emitted.</summary>
     /// <returns>A ValueTask representing the asynchronous emit.</returns>
     internal abstract ValueTask EmitLatestAsync();
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
index 7138fc4f..88d0e402 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestEnumerableCoordinator{TSource,TResult}.cs
@@ -99,7 +99,7 @@ public async ValueTask SubscribeSourcesAsync(CancellationToken cancellationToken
 
     /// <summary>Records the source's latest value and emits the projected snapshot once every source has produced one.</summary>
     /// <param name="index">The source index.</param>
-    /// <param name="indexValue">The value.</param>
+    /// <param name="indexValue">That source's latest value.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>A value task representing the operation.</returns>
     internal async ValueTask OnNextAsync(int index, TSource indexValue, CancellationToken cancellationToken)
@@ -162,7 +162,7 @@ internal async ValueTask OnErrorResumeAsync(Exception error, CancellationToken c
 
     /// <summary>Completes the combined sequence when the source failed, completed without a value, or was the last to complete.</summary>
     /// <param name="index">The source index.</param>
-    /// <param name="result">The result.</param>
+    /// <param name="result">That source's completion result.</param>
     /// <returns>A value task representing the operation.</returns>
     internal ValueTask OnCompletedAsync(int index, Result result)
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
index 81bbcb87..a884d656 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestIndexedWitness.cs
@@ -4,12 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Per-source <see cref="WitnessAsync{T}"/> for a <c>CombineLatestN</c> subscription: records each
-/// value into the parent's typed slot under the values-lock, then asks the parent to emit. One
-/// instance is built per source at subscribe time, so the per-emission cost is a single delegate
-/// invoke.
-/// </summary>
+/// <summary>Updates one source's latest value and requests a combined notification.</summary>
 /// <typeparam name="TSource">The element type of the upstream source this witness subscribes to.</typeparam>
 /// <typeparam name="TResult">The downstream element type owned by the parent subscription.</typeparam>
 /// <param name="parent">The parent subscription that owns the values-lock and lifecycle.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
index c9ab8df4..2563fadc 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/SyncLatestLifecycle.cs
@@ -30,7 +30,7 @@ public sealed class SyncLatestLifecycle<TResult> : IAsyncDisposable
     /// <summary>Bitmask value with every source-completion bit set; the sequence completes when <see cref="_doneFlags"/> equals this value.</summary>
     private readonly int _allDoneMask;
 
-    /// <summary>Bitmask of completed sources. Bit N is set when source N completes (no failure).</summary>
+    /// <summary>Bitmask of sources that completed successfully.</summary>
     private int _doneFlags;
 
     /// <summary>Set once disposal has begun, via <see cref="DisposalHelper"/>.</summary>
@@ -114,11 +114,7 @@ public async ValueTask EmitDownstreamAsync(TResult value)
         }
     }
 
-    /// <summary>
-    /// Records completion of a single source. If the source failed, completes the combined sequence
-    /// with the failure; otherwise sets the matching <paramref name="doneBit"/> and, once every
-    /// source bit is set, completes the combined sequence successfully.
-    /// </summary>
+    /// <summary>Completes the combined sequence on any failure or after every source succeeds.</summary>
     /// <param name="result">The completion result from the upstream source.</param>
     /// <param name="doneBit">The bitmask bit owned by the completing source (<c>1 &lt;&lt; index</c>).</param>
     /// <returns>A ValueTask representing the asynchronous handler.</returns>
@@ -174,8 +170,7 @@ public async ValueTask FinishAsync(Result? result)
         }
         finally
         {
-            // A throwing upstream DisposeAsync or OnCompletedAsync must not leak the gate's
-            // SemaphoreSlim or the dispose CTS's wait handles.
+            // Cleanup completes even when completion or upstream disposal throws.
 #if NETCOREAPP3_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
             await _externalLinkRegistration.DisposeAsync().ConfigureAwait(false);
 #else
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
index 5de76507..4a36eea7 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TakeUntilLifecycle.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Advanced;
 
-/// <summary>
-/// Subscription lifecycle for the TakeUntil family of operators (CancellationToken, Task,
-/// raw-signal, async-observable and async-predicate triggers): owns the serialization gate, the
-/// dispose cancellation source, the external-link registration and the gated observer fan-out.
-/// </summary>
+/// <summary>Serializes TakeUntil notifications and links their lifetime to subscription cancellation.</summary>
 /// <typeparam name="T">The downstream element type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("TakeUntilLifecycle: Observer = {_observer}, DisposeRequested = {DisposeToken.IsCancellationRequested}")]
 public sealed class TakeUntilLifecycle<T> : IAsyncDisposable
@@ -92,11 +88,7 @@ public async ValueTask RelayCompletionAsync(Result result)
         }
     }
 
-    /// <summary>
-    /// Cancels the dispose token, releases the external-link registration and disposes the gate. The
-    /// owning subscription disposes its own per-operator handles (source subscription, token
-    /// callback) separately, in whichever order that operator requires.
-    /// </summary>
+    /// <summary>Cancels notifications and releases cancellation registration and serialization resources.</summary>
     /// <returns>A ValueTask representing the asynchronous teardown.</returns>
     public async ValueTask DisposeAsync()
     {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
index 4a5d7a63..84c262e4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskSignalSubscription{T}.cs
@@ -7,8 +7,7 @@ namespace ReactiveUI.Primitives.Async.Advanced;
 /// <summary>A subscription that runs a cancellable asynchronous job feeding a single observer, and joins that job on disposal.</summary>
 /// <typeparam name="T">The type of the elements observed by the subscription.</typeparam>
 /// <param name="observer">The observer that receives notifications for the subscription. Cannot be null.</param>
-/// <remarks>Disposal cancels the running job and waits for it to finish before releasing resources;
-/// derived classes supply the job body in <see cref="ExecuteAsyncCore"/>.</remarks>
+/// <remarks>Disposal waits for the cancelled job except when called from inside that job.</remarks>
 [System.Diagnostics.DebuggerDisplay("TaskSignalSubscription: Disposed = {_disposed}, Completed = {_tcs.Task.IsCompleted}")]
 public abstract class TaskSignalSubscription<T>(IObserverAsync<T> observer) : IAsyncDisposable
 {
@@ -49,10 +48,7 @@ public async ValueTask DisposeAsync()
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>
-    /// Attempts to complete the observer with a failure result. If the observer's completion handler
-    /// also throws, the exception is routed to <see cref="UnhandledExceptionHandler"/>.
-    /// </summary>
+    /// <summary>Forwards a failure result, reporting a throwing completion handler to the unhandled exception handler.</summary>
     /// <param name="observer">The observer to complete.</param>
     /// <param name="error">The original exception.</param>
     /// <returns>A <see cref="ValueTask"/> representing the operation.</returns>
diff --git a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
index 885d4ee3..409d38f6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/ConnectableSignalAsyncHelper.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Async.Advanced;
 using ReactiveUI.Primitives.Async.Disposables;
 
@@ -22,7 +23,6 @@ internal static async ValueTask<IAsyncDisposable> ConnectAsync<T>(
         ConnectableSignalAsyncState<T> state,
         CancellationToken cancellationToken)
     {
-        // The gate's fast path does not check cancellation; reject disposed signals before entering.
         state.DisposedCancellationToken.ThrowIfCancellationRequested();
 
         CancellationTokenSource? linkedCts = null;
@@ -81,10 +81,6 @@ internal static async ValueTask<IAsyncDisposable> ConnectAsync<T>(
     /// <summary>Disposes the connection state and releases its gate resources.</summary>
     /// <typeparam name="T">The type of elements produced by the source sequence.</typeparam>
     /// <param name="state">The connectable signal state to dispose.</param>
-    [SuppressMessage(
-        "Concurrency",
-        "PSH1315:A blocking wait on an awaitable that may not be done",
-        Justification = "The synchronous dispose contract leaves no way to await teardown of the async connection state.")]
     internal static void Dispose<T>(ConnectableSignalAsyncState<T> state)
     {
         if (!state.TryMarkDisposed())
@@ -93,7 +89,11 @@ internal static void Dispose<T>(ConnectableSignalAsyncState<T> state)
         }
 
         state.DisposedCts.Cancel();
-        state.Connection?.DisposeAsync().AsTask().Wait(CancellationToken.None);
+        if (state.Connection is { } connection)
+        {
+            WaitForDisposal(connection.DisposeAsync().AsTask());
+        }
+
         state.Dispose();
     }
 
@@ -116,4 +116,14 @@ internal static ValueTask<IAsyncDisposable> SubscribeAsync<T>(
 
         return state.Signal.Values.SubscribeAsync(wrap, cancellationToken);
     }
+
+    /// <summary>Waits synchronously for connection disposal to finish.</summary>
+    /// <param name="completion">The connection's disposal task.</param>
+    [ExcludeFromCodeCoverage]
+    [SuppressMessage(
+        "Concurrency",
+        "PSH1315:A blocking wait on an awaitable that may not be done",
+        Justification = "The synchronous dispose contract leaves no way to await teardown of the async connection state.")]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void WaitForDisposal(Task completion) => completion.Wait(CancellationToken.None);
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
index 7eb311f4..b4ebec09 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsync.cs
@@ -25,11 +25,7 @@ public static IAsyncDisposable Create(Func<ValueTask> disposeAsync)
         return new DelegateAsyncDisposable(disposeAsync);
     }
 
-    /// <summary>
-    /// Creates a new asynchronous disposable that invokes the specified delegate, passing the supplied state, when
-    /// disposed asynchronously. Preferred over <see cref="Create(Func{ValueTask})"/> wherever the lambda would capture
-    /// locals or <c>this</c>: passing them as state lets the lambda be <c>static</c> and costs no closure.
-    /// </summary>
+    /// <summary>Creates a disposable that passes explicit state to its cleanup delegate.</summary>
     /// <typeparam name="TState">The type of the state passed to the dispose delegate.</typeparam>
     /// <param name="state">The state forwarded to <paramref name="disposeAsync"/> at dispose time.</param>
     /// <param name="disposeAsync">The dispose delegate. Must not be null.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
index aa266e5a..0b6359d8 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/DisposableAsyncSlot.cs
@@ -7,21 +7,13 @@
 
 namespace ReactiveUI.Primitives.Async.Disposables;
 
-/// <summary>
-/// Zero-allocation static helpers that implement <see cref="SingleReplaceableDisposableAsync"/>-style swap
-/// and <see cref="SingleAssignmentDisposableAsync"/>-style single-assignment semantics directly
-/// against a caller-owned <see cref="IAsyncDisposable"/> field. Use these when the wrapper-class
-/// allocation that the convenience types incur is on a hot path.
-/// </summary>
+/// <summary>Manages atomic replacement, single assignment, and disposal of a caller-owned resource slot.</summary>
 public static class DisposableAsyncSlot
 {
     /// <summary>Shared marker used by all async-disposable slot implementations once a slot is closed.</summary>
     internal static readonly IAsyncDisposable DisposedSentinel = new DisposedAsyncDisposable();
 
-    /// <summary>Swaps the slot's current contents with <paramref name="value"/> and asynchronously
-    /// disposes the previous occupant. Equivalent to
-    /// <see cref="SingleReplaceableDisposableAsync.SetDisposableAsync"/>, but operates on a caller-owned field
-    /// so no wrapper instance is allocated.</summary>
+    /// <summary>Replaces the slot's resource and asynchronously disposes the previous value.</summary>
     /// <param name="slot">Reference to the caller-owned <see cref="IAsyncDisposable"/> field.</param>
     /// <param name="value">The new value to store, or <see langword="null"/> to clear the slot.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once the previous occupant (if any) has been disposed.</returns>
@@ -30,9 +22,7 @@ public static class DisposableAsyncSlot
     public static ValueTask SwapAsync(ref IAsyncDisposable? slot, IAsyncDisposable? value) =>
         SwapObservedAsync(ref slot, value, Volatile.Read(ref slot));
 
-    /// <summary>Atomically fills an empty slot with <paramref name="value"/>. A closed slot disposes
-    /// <paramref name="value"/> instead. Equivalent to
-    /// <see cref="SingleAssignmentDisposableAsync.SetDisposableAsync(IAsyncDisposable?)"/>.</summary>
+    /// <summary>Assigns an empty slot once, disposing the supplied value if the slot is closed.</summary>
     /// <param name="slot">Reference to the caller-owned <see cref="IAsyncDisposable"/> field.</param>
     /// <param name="value">The value to assign, or <see langword="null"/>.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once <paramref name="value"/> has been disposed when the slot
@@ -52,9 +42,7 @@ public static ValueTask AssignAsync(ref IAsyncDisposable? slot, IAsyncDisposable
             : throw CreateAlreadyAssignedException();
     }
 
-    /// <summary>Asynchronously disposes the slot's current contents and marks the slot as disposed.
-    /// Subsequent <see cref="SwapAsync"/> / <see cref="AssignAsync"/> calls will dispose their incoming
-    /// value rather than store it. Idempotent.</summary>
+    /// <summary>Closes and disposes the slot once, causing future assignments to dispose their incoming values.</summary>
     /// <param name="slot">Reference to the caller-owned <see cref="IAsyncDisposable"/> field.</param>
     /// <returns>A <see cref="ValueTask"/> that completes once the prior occupant has been disposed.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
index 17b7c488..6407029c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/MultipleDisposableAsync.cs
@@ -33,7 +33,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>Backing array; a removal zeroes its slot, so <see cref="_length"/> is the high-water mark and <see cref="_count"/> the non-null slots.</summary>
     private IAsyncDisposable?[]? _items;
 
-    /// <summary>High-water mark of used slots in <see cref="_items"/>. Includes slots zeroed by Remove.</summary>
+    /// <summary>The used array length, including gaps left by removed items.</summary>
     private int _length;
 
     /// <summary>The number of non-<see langword="null"/> disposables in the collection.</summary>
@@ -73,11 +73,7 @@ public MultipleDisposableAsync(params IAsyncDisposable[] disposables)
         _count = disposables.Length;
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class that contains the specified
-    /// disposables. The backing array is sized exactly when <paramref name="disposables"/> implements
-    /// <see cref="ICollection{T}"/>; otherwise it grows from the default capacity.
-    /// </summary>
+    /// <summary>Initializes a new instance of the <see cref="MultipleDisposableAsync"/> class containing the supplied disposables.</summary>
     /// <param name="disposables">The collection of <see cref="IAsyncDisposable"/> instances to include.</param>
     public MultipleDisposableAsync(IEnumerable<IAsyncDisposable> disposables)
     {
@@ -250,7 +246,7 @@ public bool Contains(IAsyncDisposable item)
     /// <param name="arrayIndex">The index in <paramref name="array"/> at which copying begins.</param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="arrayIndex"/> falls outside
     /// <paramref name="array"/>, or the space from it to the end of the array cannot hold every item.</exception>
-    /// <remarks>A disposed collection copies nothing and raises nothing.</remarks>
+    /// <remarks>A disposed collection copies nothing, but destination index validation still applies.</remarks>
     public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
     {
         if (arrayIndex < 0 || arrayIndex >= array?.Length)
@@ -281,7 +277,7 @@ public void CopyTo(IAsyncDisposable[]? array, int arrayIndex)
 
     /// <summary>Asynchronously releases all resources used by the collection and disposes of each contained asynchronous disposable object.</summary>
     /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>Idempotent. Items are disposed one after another in insertion order.</remarks>
+    /// <remarks>Disposes items once, sequentially in insertion order.</remarks>
     public async ValueTask DisposeAsync()
     {
         IAsyncDisposable?[]? snapshot;
@@ -373,7 +369,7 @@ private void CopyToCore(IAsyncDisposable[] array, int arrayIndex)
         }
     }
 
-    /// <summary>Ensures <see cref="_items"/> has at least one free slot at index <see cref="_length"/>. Allocates the default-capacity array on first use; doubles on subsequent overflow.</summary>
+    /// <summary>Grows the array when no unused slot remains.</summary>
     private void EnsureCapacityForOneMore()
     {
         if (_items is null)
@@ -392,7 +388,7 @@ private void EnsureCapacityForOneMore()
         _items = grown;
     }
 
-    /// <summary>Removes null gaps inside <see cref="_items"/> and shrinks the backing array to half its capacity. Caller must hold <see cref="_gate"/>.</summary>
+    /// <summary>Compacts and halves the array while the caller holds the gate.</summary>
     private void CompactInPlace()
     {
         var src = _items!;
diff --git a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
index d9dc6ad0..7526153f 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Disposables/SingleReplaceableDisposableAsync.cs
@@ -7,8 +7,8 @@
 namespace ReactiveUI.Primitives.Async.Disposables;
 
 /// <summary>Owns one asynchronous disposable at a time, replacing it on assignment.</summary>
-/// <remarks>Exactly one resource is live at a time: each assignment disposes the one it displaces, and disposing this
-/// instance closes the slot so a further assignment disposes its argument. Safe to use from several threads.</remarks>
+/// <remarks>Assignments await disposal of the replaced resource; assignments after disposal release their incoming resource.
+/// Concurrent calls are supported.</remarks>
 [System.Diagnostics.DebuggerDisplay("SingleReplaceableDisposableAsync: Current = {_current}")]
 public class SingleReplaceableDisposableAsync : IAsyncDisposable
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
index 552c90ba..447fb89c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Helpers/FireAndForgetHelper.cs
@@ -39,7 +39,7 @@ internal static async ValueTask RunAsync(Func<ValueTask> action)
         }
         catch (Exception e)
         {
-            // Fire-and-forget has no caller to propagate to; surface the failure to the global handler.
+            // Detached-operation failures reach the global handler.
             UnhandledExceptionHandler.ReportUnhandledException(e);
         }
     }
diff --git a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
index 89864d45..4b04a432 100644
--- a/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/IObserverAsync.cs
@@ -6,8 +6,7 @@ namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Defines an asynchronous observer that receives notifications about a sequence of values, completion, or errors, and supports asynchronous resource cleanup.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
-/// <remarks>Every notification is awaitable and cancellable, so a producer that awaits them gets backpressure for
-/// free: the observer's handler has to finish before the next value is pushed.</remarks>
+/// <remarks>Producers must await each notification before sending the next.</remarks>
 public interface IObserverAsync<in T> : IAsyncDisposable
 {
     /// <summary>Signals that the sequence has terminated, successfully or with a failure.</summary>
@@ -19,8 +18,7 @@ public interface IObserverAsync<in T> : IAsyncDisposable
     /// <param name="error">The exception to report.</param>
     /// <param name="cancellationToken">A token that cancels the observer's handling of the error.</param>
     /// <returns>A task that completes when the observer has handled the error.</returns>
-    /// <remarks>Unlike a faulted <see cref="OnCompletedAsync"/>, this does not end the sequence; an implementation
-    /// chooses whether to swallow the error or tear itself down.</remarks>
+    /// <remarks>The observer may handle the error and continue receiving notifications or dispose its subscription.</remarks>
     ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken);
 
     /// <summary>Delivers the next value in the sequence.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
index 5d9cfade..7d90ae53 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Create.cs
@@ -7,8 +7,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides factory methods for creating asynchronous observables and background jobs that emit values to observers asynchronously.</summary>
-/// <remarks>These are the entry points for turning an arbitrary asynchronous producer into a sequence: supply the
-/// subscribe logic yourself, or hand over a job to run per subscriber.</remarks>
 public static partial class SignalAsync
 {
     /// <summary>Creates a new asynchronous observable sequence using the specified subscription function.</summary>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
index b36b582c..a981f041 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Empty.cs
@@ -14,7 +14,6 @@ public static partial class SignalAsync
     /// <summary>Creates an observable sequence that completes immediately without emitting any items.</summary>
     /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
     /// <returns>An observable sequence of type <typeparamref name="T"/> that completes immediately without producing any values.</returns>
-    /// <remarks>The returned instance is a singleton per element type.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
index 24376c6f..4a3dcc48 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Never.cs
@@ -14,7 +14,6 @@ public static partial class SignalAsync
     /// <summary>Creates an observable sequence that never produces any values and never completes.</summary>
     /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
     /// <returns>An observable sequence of type <typeparamref name="T"/> that never emits any items and never terminates.</returns>
-    /// <remarks>The returned instance is a singleton per element type.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [SuppressMessage(
         "Design",
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
index ee4627d0..1dc61fcd 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/Return.cs
@@ -13,8 +13,7 @@ public static partial class SignalAsync
     /// <typeparam name="T">The type of the value to be emitted by the observable sequence.</typeparam>
     /// <param name="value">The value to be emitted by the observable sequence.</param>
     /// <returns>An observable sequence that emits the specified value and then signals completion.</returns>
-    /// <remarks>Subscribing returns before the value is observed: the emit and the completion are scheduled onto the
-    /// thread pool, so an observer must not assume it has seen the value by the time subscribe finishes.</remarks>
+    /// <remarks>Notification starts during subscription and may finish synchronously.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IObservableAsync<T> Emit<T>(T value) => new ReturnSignalAsync<T>(value);
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
index cb240e00..631fb006 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Observables/ToAsyncSignal.cs
@@ -8,8 +8,6 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides extension methods for converting tasks, asynchronous enumerables, and enumerable sequences into asynchronous observable sequences.</summary>
-/// <remarks>Every overload is spelled <c>ToAsyncSignal</c>, so the conversion reads the same whatever the source, and a
-/// sequence that is an <see cref="IObservableAsync{T}"/> passes straight through.</remarks>
 public static partial class SignalAsyncExtensions
 {
     /// <summary>Observable-conversion operators for an asynchronous enumerable source.</summary>
@@ -33,11 +31,10 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The enumerable sequence to convert to an asynchronous observable. Cannot be null.</param>
     extension<T>(IEnumerable<T> source)
     {
-        /// <summary>Converts the specified enumerable sequence to an asynchronous observable sequence, emitting each element in the background.</summary>
+        /// <summary>Emits the enumerable's elements, awaiting each observer notification.</summary>
         /// <returns>An asynchronous observable sequence that emits each element from the source enumerable and completes when all
         /// elements have been emitted.</returns>
-        /// <remarks>Enumeration runs on a background thread, once per subscriber, so a blocking or side-effecting
-        /// sequence neither stalls the subscribe call nor is shared between observers.</remarks>
+        /// <remarks>Enumeration starts on the subscribing thread, once per subscriber.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [SuppressMessage(
             "Roslynator",
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
index dcbd4006..ea33e5da 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Blend.cs
@@ -39,8 +39,8 @@ public IObservableAsync<T> Merge() =>
     {
         /// <summary>Merges multiple asynchronous observable sequences into a single observable sequence that emits items from all inner sequences as they arrive.</summary>
         /// <returns>An asynchronous observable sequence that emits items from all inner observable sequences as they are produced.</returns>
-        /// <remarks>Every inner sequence stays subscribed at once; the result completes only after the outer sequence
-        /// and all inner sequences have completed, and an error from any of them propagates and terminates it.</remarks>
+        /// <remarks>All inner sources remain subscribed; completion waits for the outer source and every inner source,
+        /// and any error terminates immediately.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Blend() =>
             new BlendSignalSourcesSignal<T>(source);
@@ -390,7 +390,6 @@ internal override async ValueTask SubscribeBranchAsync(IObservableAsync<T> inner
             }
             finally
             {
-                // The observer releases its semaphore slot once; failed subscriptions also dispose it here.
                 if (!subscribed)
                 {
                     await innerObserver.DisposeAsync().ConfigureAwait(false);
@@ -515,7 +514,6 @@ internal void BeginSubscribing() => FireAndForgetHelper.Run(async () =>
                 _reentrant.Value = true;
                 try
                 {
-                    // Hold a sentinel while subscribing so synchronous sources cannot complete the merge early.
                     _ = Interlocked.Increment(ref _active);
 
                     foreach (var src in _sources)
@@ -539,7 +537,6 @@ internal void BeginSubscribing() => FireAndForgetHelper.Run(async () =>
                         }
                     }
 
-                    // Remove sentinel: if all inner sources completed during the loop, this triggers final completion.
                     if (Interlocked.Decrement(ref _active) == 0)
                     {
                         await FinishAsync(Result.Success).ConfigureAwait(false);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
index 82412d11..cebe2761 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Chain.cs
@@ -17,8 +17,7 @@ public static partial class SignalAsyncExtensions
         /// <summary>Concatenates multiple asynchronous observable sequences into a single sequence that emits items from each source in order.</summary>
         /// <returns>An asynchronous observable sequence that emits all items from each source sequence in the order they appear in
         /// the collection.</returns>
-        /// <remarks>A source is subscribed only after the previous one completes, so at most one source is active at a
-        /// time; an error from any source stops the concatenation and is propagated.</remarks>
+        /// <remarks>Sources run one at a time in sequence; any error propagates and terminates the result.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> Chain() =>
             new ChainEnumerableSignal<T>(sources);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
index e6bb0b31..abdb9ec6 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainEnumerableSignal{T}.cs
@@ -112,7 +112,7 @@ internal async ValueTask SubscribeNextSignalAsync()
         /// <returns>A task representing the asynchronous operation.</returns>
         internal ValueTask RelayInnerErrorAsync(Exception exception, CancellationToken cancellationToken)
         {
-            // The inner subscription shares this disposal token.
+            // Notifications use subscription cancellation instead of the supplied token.
             _ = cancellationToken;
             return _observer.OnErrorResumeAsync(exception, _disposedCancellationToken);
         }
@@ -127,7 +127,7 @@ internal ValueTask RelayInnerValueAsync(T value, CancellationToken cancellationT
             return _observer.OnNextAsync(value, _disposedCancellationToken);
         }
 
-        /// <summary>Disposes the inner subscription and enumerator, and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
+    /// <summary>Disposes the inner subscription and enumerator once, optionally forwarding completion.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
index cd5f496d..21757709 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ChainSignalSourcesSignal{T}.cs
@@ -177,7 +177,7 @@ await currentInner.SubscribeAsync(new ChainInnerWitness(this), _disposedCancella
             }
         }
 
-        /// <summary>Disposes the inner and outer subscriptions and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
+    /// <summary>Disposes the inner and outer subscriptions once, optionally forwarding completion.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
@@ -219,7 +219,7 @@ protected override async ValueTask OnErrorResumeAsyncCore(
                 Exception error,
                 CancellationToken cancellationToken)
             {
-                // The outer subscription shares this disposal token.
+                // Notifications use subscription cancellation instead of the supplied token.
                 _ = cancellationToken;
                 var token = subscription._disposedCancellationToken;
                 using (await subscription._observerOnSomethingGate.EnterAsync(token).ConfigureAwait(false))
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
index 67adf464..f9744f37 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Expire.cs
@@ -14,10 +14,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Applies a time limit between elements. If the next element does not arrive within
-        /// <paramref name="dueTime"/>, the sequence completes with a <see cref="TimeoutException"/>.
-        /// </summary>
+        /// <summary>Completes with a TimeoutException when the next element misses the deadline.</summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <returns>An observable sequence that mirrors the source but completes with a
         /// <see cref="TimeoutException"/> once an inter-element gap exceeds <paramref name="dueTime"/>.</returns>
@@ -84,7 +81,7 @@ internal void StartTimer(CancellationToken cancellationToken)
                 }
                 catch (Exception e)
                 {
-                    // Timer creation failure is reported; values continue without timeout enforcement.
+                    // If timeout setup fails, values continue without timeout enforcement.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
index e6495cca..56352a9a 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Fold.cs
@@ -64,8 +64,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TAcc>.SubscribeAsync(
         {
             FoldAsyncWitness sink = new(observer, seed, accumulator, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<TAcc> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
@@ -87,8 +85,7 @@ internal sealed class FoldAsyncWitness(
             Func<TAcc, T, CancellationToken, ValueTask<TAcc>> accumulator,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>The running accumulator state. Mutated only inside <see cref="OnNextAsyncCore"/>, which the
-            /// base observer serializes via its reentrancy gate, so no additional locking is required.</summary>
+            /// <summary>The accumulator state protected by the observer's notification gate.</summary>
             private TAcc _acc = seed;
 
             /// <inheritdoc/>
@@ -145,8 +142,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TAcc>.SubscribeAsync(
         {
             FoldSyncWitness sink = new(observer, seed, accumulator, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<TAcc> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
@@ -168,8 +163,7 @@ internal sealed class FoldSyncWitness(
             Func<TAcc, T, TAcc> accumulator,
             CancellationToken subscribeToken) : WitnessAsync<T>(subscribeToken)
         {
-            /// <summary>The running accumulator state. Mutated only inside <see cref="OnNextAsyncCore"/>, which the
-            /// base observer serializes via its reentrancy gate, so no additional locking is required.</summary>
+            /// <summary>The accumulator state protected by the observer's notification gate.</summary>
             private TAcc _acc = seed;
 
             /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
index 8c8a33c6..637368a9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Keep.cs
@@ -83,8 +83,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             KeepAsyncWitness sink = new(observer, predicate, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<T> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
@@ -141,8 +139,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             KeepSyncWitness sink = new(observer, predicate, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<T> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
index 4eee32e5..de3ae39e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Map.cs
@@ -89,8 +89,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TDest>.SubscribeAsync(
         {
             MapAsyncWitness sink = new(observer, selector, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<TDest> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
@@ -143,8 +141,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<TDest>.SubscribeAsync(
         {
             MapSyncWitness sink = new(observer, selector, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<TDest> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
index f71f81a4..d857adaf 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Multicast.cs
@@ -21,10 +21,7 @@ public static partial class SignalAsyncExtensions
         public ConnectableSignalAsync<T> Multicast(ISignalAsync<T> signal) =>
             new(source, signal);
 
-        /// <summary>
-        /// Returns a connectable observable sequence that shares a single subscription to the underlying asynchronous
-        /// observable. Observers will receive all notifications published after they subscribe.
-        /// </summary>
+        /// <summary>Shares one source subscription, forwarding live notifications to connected observers.</summary>
         /// <returns>A connectable observable sequence that multicasts notifications to all subscribed observers. The sequence
         /// does not begin emitting items until its Connect method is called.</returns>
         /// <remarks>Notifications are delivered to observers serially.</remarks>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
index dfd2ff09..f89b8031 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Pair.cs
@@ -23,8 +23,8 @@ public static partial class SignalAsyncExtensions
         /// <returns>An observable sequence whose elements are the result of pair-wise combining the source
         /// elements using the result selector.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="src1"/>, <paramref name="second"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The nth element of one source is paired with the nth element of the other, so an element waits until
-        /// its partner arrives. The result completes when either source completes with no pending pair.</remarks>
+        /// <remarks>Values wait for their partner at the same index; the result completes when either source completes
+        /// with no pending pair.</remarks>
         public IObservableAsync<TResult> Pair<T2, TResult>(
             IObservableAsync<T2> second,
             Func<T1, T2, TResult> resultSelector)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
index 02a2fb54..00646b52 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.FilterFusions.cs
@@ -139,8 +139,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             WhereIsNotNullWitness sink = new(observer, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so its hot path recognises
-            // this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<T> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
index f2b9b19c..b5700d26 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.OperatorFusions.cs
@@ -313,7 +313,6 @@ private async Task FireAfterDelayAsync(T value, long id, CancellationToken cance
                 }
                 catch (Exception e)
                 {
-                    // ReportUnhandledException drops cancellation itself, so no separate catch for it.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
@@ -514,7 +513,7 @@ protected override ValueTask OnNextAsyncCore(T value, CancellationToken cancella
             {
                 if (condition(value))
                 {
-                    // Bypass path: cancel any pending delay and emit immediately.
+                    // Bypass cancels pending delayed delivery and emits immediately.
                     lock (_gate)
                     {
                         _id++;
@@ -580,7 +579,6 @@ private async Task DelayAndEmitAsync(T value, long id, CancellationToken cancell
                 }
                 catch (Exception e)
                 {
-                    // ReportUnhandledException drops cancellation itself, so no separate catch for it.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
index dfcfe537..73577a64 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.Partition.cs
@@ -237,7 +237,6 @@ internal sealed class PartitionBranchSignal(bool isTrueBranch) : IObservableAsyn
             ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
                 IObserverAsync<T> observer,
                 CancellationToken cancellationToken) =>
-                // The coordinator's constructor sets Coordinator on both branches, so it is never null here.
                 Coordinator.SubscribeBranchAsync(isTrueBranch, observer, cancellationToken);
         }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
index 89957229..82db74c4 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ParityHelpers.cs
@@ -185,11 +185,7 @@ public IObservableAsync<T> DropIfBusy(Func<T, CancellationToken, ValueTask> asyn
             return new DropIfBusySignal<T>(source, asyncAction);
         }
 
-        /// <summary>
-        /// Emits the latest value or the provided default value before the source produces its first value.
-        /// If the first source value equals <paramref name="defaultValue"/>, it will be suppressed by the
-        /// distinct-until-changed filter.
-        /// </summary>
+        /// <summary>Starts with the default value and emits subsequent source values only when they change.</summary>
         /// <param name="defaultValue">The default value to emit first.</param>
         /// <returns>A sequence that starts with the provided default value and then emits distinct source updates.</returns>
         public IObservableAsync<T> LatestOrDefault(T defaultValue)
@@ -230,7 +226,7 @@ public IObservableAsync<T> WaitUntil(Func<T, bool> predicate)
             return new PairwiseSignal<T>(source);
         }
 
-        /// <summary>Partitions the source sequence into values that satisfy the predicate and values that do not. The predicate is evaluated exactly once per element.</summary>
+        /// <summary>Partitions the source into matches and nonmatches, evaluating the predicate once per element.</summary>
         /// <param name="predicate">The partition predicate.</param>
         /// <returns>A tuple of true and false partitions.</returns>
         public (IObservableAsync<T> True, IObservableAsync<T> False) Partition(Func<T, bool> predicate)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
index 29815e2d..868eac50 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Recover.cs
@@ -80,8 +80,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             CatchWitness sink = new(observer, handler, onErrorResume, cancellationToken);
 
-            // Wire sink's dispose token into the downstream's link chain so the downstream's hot path
-            // recognises this token without allocating a per-emission linked CTS.
             if (observer is WitnessAsync<T> downstreamBase)
             {
                 downstreamBase.LinkUpstreamCancellation(sink.InternalDisposedToken);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
index c1660ae7..c4bbfd66 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/RefCount.cs
@@ -81,7 +81,6 @@ async ValueTask<IAsyncDisposable> IObservableAsync<T>.SubscribeAsync(
         {
             using (await _gate.EnterAsync(cancellationToken).ConfigureAwait(false))
             {
-                // Increment before subscribing: a source that completes during the subscribe decrements it again.
                 ++_refCount;
                 var needConnect = _refCount == 1;
                 RefCountWitness refCountWitness = new(this, observer);
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
index 62c90480..f838fc58 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Shift.cs
@@ -12,7 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
+        /// <summary>Delays each element notification by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <returns>An observable sequence with element notifications time-shifted by the specified duration.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="delayInterval"/> is negative.</exception>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
index b29b3292..a17b3508 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Delay.Rx.cs
@@ -12,7 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
+        /// <summary>Delays each element notification by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <returns>An observable sequence with element notifications time-shifted by the specified duration.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="delayInterval"/> is negative.</exception>
@@ -25,7 +25,7 @@ public IObservableAsync<T> Delay(TimeSpan delayInterval)
                 : new DelaySignal<T>(source, delayInterval, TimeProvider.System);
         }
 
-        /// <summary>Time-shifts the observable sequence by the specified time span. Each element notification is delayed by the specified duration.</summary>
+        /// <summary>Delays each element notification by the specified duration.</summary>
         /// <param name="delayInterval">The time span by which to delay each element notification. Must be non-negative.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
         /// is used.</param>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
index e25370cc..a81a2174 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SignalAsyncExtensions.Timeout.Rx.cs
@@ -12,10 +12,7 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>
-        /// Applies a timeout policy to the observable sequence. If the next element is not received within
-        /// the specified time span, the sequence completes with a <see cref="TimeoutException"/>.
-        /// </summary>
+        /// <summary>Completes with a TimeoutException when the next element misses the deadline.</summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <returns>An observable sequence that mirrors the source but completes with a
         /// <see cref="TimeoutException"/> if any inter-element interval exceeds the specified interval.</returns>
@@ -27,10 +24,7 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime)
             return new TimeoutSignal<T>(source, dueTime, TimeProvider.System);
         }
 
-        /// <summary>
-        /// Applies a timeout policy to the observable sequence. If the next element is not received within
-        /// the specified time span, the sequence completes with a <see cref="TimeoutException"/>.
-        /// </summary>
+        /// <summary>Completes with a TimeoutException when the next element misses the deadline.</summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
         /// is used.</param>
@@ -44,10 +38,7 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, TimeProvider? timeProvider)
             return new TimeoutSignal<T>(source, dueTime, timeProvider ?? TimeProvider.System);
         }
 
-        /// <summary>
-        /// Applies a timeout policy to the observable sequence. If the next element is not received within
-        /// the specified time span, the sequence switches to the specified fallback observable.
-        /// </summary>
+        /// <summary>Switches to the fallback sequence when the next element misses the deadline.</summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <param name="fallback">The fallback observable to switch to when a timeout occurs. Cannot be null.</param>
         /// <returns>An observable sequence that mirrors the source, switching to the fallback sequence
@@ -62,10 +53,7 @@ public IObservableAsync<T> Timeout(TimeSpan dueTime, IObservableAsync<T> fallbac
             return new TimeoutWithFallbackSignal<T>(source, dueTime, fallback, TimeProvider.System);
         }
 
-        /// <summary>
-        /// Applies a timeout policy to the observable sequence. If the next element is not received within
-        /// the specified time span, the sequence switches to the specified fallback observable.
-        /// </summary>
+        /// <summary>Switches to the fallback sequence when the next element misses the deadline.</summary>
         /// <param name="dueTime">The maximum time span allowed between consecutive elements. Must be positive.</param>
         /// <param name="fallback">The fallback observable to switch to when a timeout occurs. Cannot be null.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
index a0ff1658..8b9dc410 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/StartWith.cs
@@ -18,7 +18,6 @@ public static partial class SignalAsyncExtensions
         /// <param name="value">The value to prepend to the sequence.</param>
         /// <returns>An observable sequence that emits the specified value first, followed by the elements
         /// of the source sequence.</returns>
-        /// <remarks>Equivalent to <c>Prepend(T)</c>, under the System.Reactive name.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> StartWith(T value) => new LeadSignal<T>(source, [value]);
 
@@ -26,8 +25,7 @@ public static partial class SignalAsyncExtensions
         /// <param name="values">The values to prepend to the sequence. Cannot be null.</param>
         /// <returns>An observable sequence that emits the specified values first, followed by the elements
         /// of the source sequence.</returns>
-        /// <remarks>Equivalent to <c>Prepend(IEnumerable&lt;T&gt;)</c>, under the System.Reactive name; the values are
-        /// emitted in collection order.</remarks>
+        /// <remarks>The values are emitted in enumeration order.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<T> StartWith(IEnumerable<T> values) => new LeadSignal<T>(source, values);
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
index 252a0faf..9be20488 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SubscribeAsync.cs
@@ -25,7 +25,7 @@ public static partial class SignalAsyncExtensions
         /// <returns>A value task that represents the asynchronous operation. The result is an <see cref="IAsyncDisposable"/>
         /// that can be disposed to unsubscribe from the data source.</returns>
         /// <exception cref="ArgumentNullException">The source sequence or <paramref name="onNextAsync"/> is <see langword="null"/>.</exception>
-        /// <remarks>Callbacks may be invoked concurrently, so the supplied delegates must be thread-safe.</remarks>
+        /// <remarks>Callbacks are serialized per subscription; overlapping notifications from another thread are rejected.</remarks>
         public ValueTask<IAsyncDisposable> SubscribeAsync(
             Func<T, CancellationToken, ValueTask> onNextAsync,
             Func<Exception, CancellationToken, ValueTask>? onErrorResumeAsync,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
index 817c72bd..eaf77654 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SwitchToSignal.cs
@@ -238,7 +238,7 @@ internal async ValueTask SubscribeReplacementInnerAsync(
             }
         }
 
-        /// <summary>Disposes the current inner subscription, the outer subscription, and optionally forwards a completion result to the downstream observer. This method is idempotent.</summary>
+    /// <summary>Disposes the current inner and outer subscriptions once, optionally forwarding completion.</summary>
         /// <param name="result">The completion result to forward, or <see langword="null"/> if disposing without signaling completion.</param>
         /// <returns>A task representing the asynchronous operation.</returns>
         internal async ValueTask FinishAsync(Result? result)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest2.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest2.cs
index da778461..01d8383e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest2.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatest2.cs
@@ -23,11 +23,8 @@ public static partial class SignalAsyncExtensions
         /// <param name="src2">Source observable 2 whose latest value is combined.</param>
         /// <param name="selector">Projects the latest value of every source into a result.</param>
         /// <returns>An observable sequence of projected results.</returns>
-        /// <remarks>
-        /// The returned sequence does not produce a value until every source has emitted at least
-        /// once. After that, each new value from any source produces a fresh projection using the
-        /// most recent value from each. Completion / failure of any source propagates downstream.
-        /// </remarks>
+        /// <remarks>Emits after both sources have a value, then on either source's updates.
+        /// Successful completion waits for both sources; a failure terminates immediately.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservableAsync<TResult> SyncLatest<T2, TResult>(
             IObservableAsync<T2> src2,
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
index 3457e33c..d1f89323 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/SyncLatestEnumerable.cs
@@ -21,7 +21,6 @@ public IObservableAsync<IReadOnlyList<TSource>> SyncLatest()
         {
             ArgumentExceptionHelper.ThrowIfNull(sources);
 
-            // An identity selector lets one subscription implementation back both shapes.
             return new SyncLatestEnumerableSignal<TSource, IReadOnlyList<TSource>>(sources, static s => s);
         }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
index 50e41393..df516d1e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/TakeUntil.cs
@@ -389,11 +389,21 @@ internal void LinkExternalCancellation(CancellationToken external) =>
 
             /// <summary>Callback invoked when the external cancellation token is canceled; forwards completion to the observer.</summary>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void CompleteFromCancellation() => FireAndForgetHelper.Run(async () =>
+            internal void CompleteFromCancellation() => FireAndForgetHelper.Run(CompleteAfterYieldAsync);
+
+            /// <summary>Forwards successful completion through the notification gate.</summary>
+            /// <returns>The completion notification.</returns>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal ValueTask CompleteFromCancellationAsync() => _lifecycle.RelayCompletionAsync(Result.Success);
+
+            /// <summary>Defers completion until after the cancellation callback returns.</summary>
+            /// <returns>The deferred completion notification.</returns>
+            [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+            private async ValueTask CompleteAfterYieldAsync()
             {
                 await Task.Yield();
-                await _lifecycle.RelayCompletionAsync(Result.Success).ConfigureAwait(false);
-            });
+                await CompleteFromCancellationAsync().ConfigureAwait(false);
+            }
         }
     }
 
@@ -492,7 +502,7 @@ internal void AwaitStopThenComplete()
             {
                 Volatile.Write(ref _stopRegistration, _parent._stopSignal(Stop));
 
-                // Release registrations returned after a synchronous stop notification.
+                // Registrations returned after termination are disposed immediately.
                 if (Volatile.Read(ref _stopSignalled) != 1)
                 {
                     return;
@@ -552,7 +562,7 @@ private async ValueTask DisposeStopRegistrationAsync()
                 }
                 catch (Exception disposeError)
                 {
-                    // Best-effort: a secondary dispose failure while ending the sequence goes to the global handler.
+                    // Secondary disposal failures reach the global handler.
                     UnhandledExceptionHandler.ReportUnhandledException(disposeError);
                 }
             }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
index 3f40e1b4..3e346c54 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Throttle.cs
@@ -12,13 +12,12 @@ public static partial class SignalAsyncExtensions
     /// <param name="source">The source observable sequence.</param>
     extension<T>(IObservableAsync<T> source)
     {
-        /// <summary>Ignores elements from the source sequence that are followed by another element within the specified time span. Only the last element in each burst is forwarded.</summary>
+        /// <summary>Forwards the latest element after a full quiet period.</summary>
         /// <param name="dueTime">The time span that must elapse after the last element before it is forwarded.
         /// Must be non-negative.</param>
         /// <returns>An observable sequence containing only those elements that are not followed by another
         /// element within the specified due time.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative.</exception>
-        /// <remarks>Each source element restarts the quiet period, so a continuous burst forwards only its final element.</remarks>
         public IObservableAsync<T> Throttle(TimeSpan dueTime)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(dueTime, TimeSpan.Zero);
@@ -26,7 +25,7 @@ public IObservableAsync<T> Throttle(TimeSpan dueTime)
             return new ThrottleSignal<T>(source, dueTime, TimeProvider.System);
         }
 
-        /// <summary>Ignores elements from the source sequence that are followed by another element within the specified time span. Only the last element in each burst is forwarded.</summary>
+        /// <summary>Forwards the latest element after a full quiet period.</summary>
         /// <param name="dueTime">The time span that must elapse after the last element before it is forwarded.
         /// Must be non-negative.</param>
         /// <param name="timeProvider">An optional time provider for controlling timing. If null, <see cref="TimeProvider.System"/>
@@ -34,7 +33,6 @@ public IObservableAsync<T> Throttle(TimeSpan dueTime)
         /// <returns>An observable sequence containing only those elements that are not followed by another
         /// element within the specified due time.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="dueTime"/> is negative.</exception>
-        /// <remarks>Each source element restarts the quiet period, so a continuous burst forwards only its final element.</remarks>
         public IObservableAsync<T> Throttle(TimeSpan dueTime, TimeProvider? timeProvider)
         {
             ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(dueTime, TimeSpan.Zero);
@@ -55,10 +53,18 @@ internal ValueTask DelayAsync(
             TimeProvider timeProvider,
             CancellationToken cancellationToken) =>
             timeProvider == TimeProvider.System
-                ? new(Task.Delay(delay, cancellationToken))
+                ? DelayOnSystemClockAsync(delay, cancellationToken)
                 : PooledDelaySource.Rent().BeginAsync(delay, timeProvider, cancellationToken);
     }
 
+    /// <summary>Waits for the system clock or cancellation.</summary>
+    /// <param name="delay">The duration to wait.</param>
+    /// <param name="cancellationToken">Cancellation for the wait.</param>
+    /// <returns>The delay operation.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static ValueTask DelayOnSystemClockAsync(TimeSpan delay, CancellationToken cancellationToken) =>
+        new(Task.Delay(delay, cancellationToken));
+
     /// <summary>Async observable that debounces the source sequence, only forwarding elements that are not followed by another element within the specified due time.</summary>
     /// <typeparam name="T">The type of elements in the sequence.</typeparam>
     /// <param name="source">The source observable sequence to throttle.</param>
@@ -128,8 +134,6 @@ internal async Task FireAfterDelayAsync(T value, long id, CancellationToken canc
                 }
                 catch (Exception e)
                 {
-                    // UnhandledExceptionHandler filters OperationCanceledException internally so
-                    // a separate OCE-only catch would just duplicate the silent-drop behavior.
                     UnhandledExceptionHandler.ReportUnhandledException(e);
                 }
             }
@@ -171,7 +175,7 @@ protected override ValueTask OnCompletedAsyncCore(Result result)
                 return observer.OnCompletedAsync(result);
             }
 
-            /// <summary>Marks any in-flight delay as superseded during disposal. The dispose token threaded through <see cref="DelayAsync"/> by the base observer also unblocks the awaits.</summary>
+            /// <summary>Invalidates pending values before releasing the observer.</summary>
             /// <returns>A completed task.</returns>
             protected override ValueTask DisposeAsyncCore()
             {
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
index 248bcf57..cc0c2bb5 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/Unique.cs
@@ -15,9 +15,7 @@ public static partial class SignalAsyncExtensions
         /// <summary>Returns an observable sequence that emits only distinct consecutive elements, suppressing duplicates that are equal to the previous element.</summary>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not equal to their
         /// immediate predecessor.</returns>
-        /// <remarks>Elements are compared using the default equality comparer for the type <typeparamref
-        /// name="T"/>. Only consecutive duplicate elements are suppressed; non-consecutive duplicates are not
-        /// affected.</remarks>
+        /// <remarks>Uses the default equality comparer.</remarks>
         public IObservableAsync<T> Unique()
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -33,8 +31,6 @@ public IObservableAsync<T> Unique()
         /// <returns>An observable sequence that contains only distinct consecutive elements from the source sequence, as
         /// determined by the specified equality comparer.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="equalityComparer"/> is <see langword="null"/>.</exception>
-        /// <remarks>Only elements that differ from their immediate predecessor, as judged by <paramref
-        /// name="equalityComparer"/>, are emitted; non-consecutive duplicates are not suppressed.</remarks>
         public IObservableAsync<T> Unique(IEqualityComparer<T> equalityComparer)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -48,9 +44,7 @@ public IObservableAsync<T> Unique(IEqualityComparer<T> equalityComparer)
         /// <param name="keySelector">A function that extracts the comparison key from each element in the source sequence.</param>
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
         /// duplicates according to the specified key.</returns>
-        /// <remarks>The comparison of keys uses the default equality comparer for the type <typeparamref
-        /// name="TKey"/>. Only consecutive duplicate elements are suppressed; non-consecutive duplicates are not
-        /// affected.</remarks>
+        /// <remarks>Compares keys with the default equality comparer.</remarks>
         public IObservableAsync<T> UniqueBy<TKey>(Func<T, TKey> keySelector)
         {
             ArgumentExceptionHelper.ThrowIfNull(source);
@@ -66,9 +60,6 @@ public IObservableAsync<T> UniqueBy<TKey>(Func<T, TKey> keySelector)
         /// <returns>An observable sequence that contains only the elements from the source sequence that are not consecutive
         /// duplicates according to the specified key and comparer.</returns>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="keySelector"/> or <paramref name="equalityComparer"/> is null.</exception>
-        /// <remarks>The first element in the sequence is always emitted. Subsequent elements are emitted
-        /// only if their key, as determined by <paramref name="keySelector"/>, is not equal to the key of the
-        /// immediately preceding element, as determined by <paramref name="equalityComparer"/>.</remarks>
         public IObservableAsync<T> UniqueBy<TKey>(
             Func<T, TKey> keySelector,
             IEqualityComparer<TKey> equalityComparer)
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
index 29fd7e11..fa408ea9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/ReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -39,11 +39,11 @@ private async ValueTask RemoveObserverAsync()
         }
         catch (OperationCanceledException)
         {
-            // The signal was disposed while removal was waiting to enter the gate.
+            // Unsubscription is harmless after signal disposal.
         }
         catch (ObjectDisposedException)
         {
-            // The gate was disposed while removal was waiting to enter it.
+            // Unsubscription is harmless after signal disposal.
         }
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
index 9777bde9..16301b09 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/Base/StatelessReplayLatestSignalAsyncStateObserverLease{T}.cs
@@ -43,11 +43,11 @@ private async ValueTask RemoveObserverAndResetAsync()
         }
         catch (OperationCanceledException)
         {
-            // The signal was disposed while removal was waiting to enter the gate.
+            // Unsubscription is harmless after signal disposal.
         }
         catch (ObjectDisposedException)
         {
-            // The gate was disposed while removal was waiting to enter it.
+            // Unsubscription is harmless after signal disposal.
         }
     }
 }
diff --git a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
index 015c5b24..0c901566 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Signals/ConcurrentStatelessReplayLatestSignalAsync.cs
@@ -10,7 +10,7 @@ namespace ReactiveUI.Primitives.Async.Signals;
 /// <typeparam name="T">The type of the elements processed by the Signal.</typeparam>
 /// <param name="startValue">The value replayed until something is published, and restored when the last observer
 /// leaves.</param>
-/// <remarks>Cancellation can stop some observers from receiving a notification the others do receive.</remarks>
+/// <remarks>Completion order across observers is unspecified, and a cancelled notification does not stop the others.</remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrentStatelessReplayLatestSignalAsync: Value = {_state.Value}, IsDisposed = {_state.IsDisposed}")]
 public sealed class ConcurrentStatelessReplayLatestSignalAsync<T>(Optional<T> startValue) : ISignalAsync<T>
 {
diff --git a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
index 83b816d1..7ac20b8c 100644
--- a/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/UnhandledExceptionHandler.cs
@@ -7,9 +7,7 @@
 namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Provides a mechanism for registering a global handler to process unhandled exceptions that occur during application execution.</summary>
-/// <remarks>The process-wide default writes the exception to <see cref="System.Diagnostics.Trace"/>. Register a
-/// handler to log, clean up or notify instead. Cancellation is treated as normal flow and never reaches the
-/// handler.</remarks>
+/// <remarks>The default handler writes to System.Diagnostics.Trace; cancellation exceptions are ignored.</remarks>
 public static class UnhandledExceptionHandler
 {
     /// <summary>The currently registered handler action invoked when an unhandled exception occurs.</summary>
@@ -20,8 +18,7 @@ public static class UnhandledExceptionHandler
 
     /// <summary>Registers a handler to be invoked when an unhandled exception occurs.</summary>
     /// <param name="unhandledExceptionHandler">The action that receives each unhandled exception. Cannot be null.</param>
-    /// <remarks>There is one handler per process and registration replaces it, so a library that registers here takes
-    /// the sink away from the host application. A handler that throws has its exception swallowed.</remarks>
+    /// <remarks>Replaces the process-wide handler; exceptions thrown by the handler are ignored.</remarks>
     public static void Register(Action<Exception> unhandledExceptionHandler) =>
         _unhandledException = unhandledExceptionHandler;
 
@@ -44,7 +41,7 @@ internal static void ReportUnhandledException(Exception e)
         }
         catch
         {
-            // Ignored
+            // Exceptions from the registered handler are ignored.
         }
     }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
index e1e6e7f5..8a927b98 100644
--- a/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/WitnessAsync.cs
@@ -11,9 +11,8 @@ namespace ReactiveUI.Primitives.Async;
 
 /// <summary>Base class for an asynchronous observer: handles the notification gate, cancellation linking and disposal so a derived sink only has to implement the three <c>Core</c> methods.</summary>
 /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
-/// <remarks>One notification runs at a time. A reentrant call from the thread that holds the gate is allowed, but an
-/// overlapping call from another thread is a contract violation: the notification is dropped and a
-/// <see cref="ConcurrentWitnessCallsException"/> goes to <see cref="UnhandledExceptionHandler"/>.</remarks>
+/// <remarks>Reentrant calls on the active thread are allowed; overlapping calls from another thread are dropped and
+/// reported to UnhandledExceptionHandler as <see cref="ConcurrentWitnessCallsException"/>.</remarks>
 [System.Diagnostics.DebuggerDisplay("WitnessAsync: Disposed = {_disposed}, CallState = {_callState}")]
 public abstract class WitnessAsync<T> : IObserverAsync<T>, IReentrantAsyncDisposable
 {
@@ -51,10 +50,7 @@ protected WitnessAsync()
     /// <param name="externalLink">The external token whose cancellation should trigger this observer's disposal.</param>
     protected WitnessAsync(CancellationToken externalLink) => LinkExternalCancellation(externalLink);
 
-    /// <summary>
-    /// Gets the cancellation token that fires when this observer disposes, for an operator to link into a downstream
-    /// observer's dispose chain. Reading it creates the backing <see cref="CancellationTokenSource"/>.
-    /// </summary>
+    /// <summary>Gets the lazily created token cancelled when this observer is disposed.</summary>
     public CancellationToken InternalDisposedToken => GetOrCreateDisposeCts().Token;
 
     /// <summary>Gets a value indicating whether this observer has been disposed.</summary>
@@ -366,7 +362,7 @@ internal async ValueTask RouteObserverErrorAsync(Exception error, CancellationTo
         }
     }
 
-    /// <summary>Handles the sequence's terminal result. Called at most once, before this observer is disposed.</summary>
+    /// <summary>Handles the terminal result at most once, before disposal.</summary>
     /// <param name="result">The result of the operation to be processed during completion.</param>
     /// <returns>A task that completes when the result has been handled.</returns>
     protected abstract ValueTask OnCompletedAsyncCore(Result result);
@@ -376,13 +372,11 @@ internal async ValueTask RouteObserverErrorAsync(Exception error, CancellationTo
     [DebuggerStepThrough]
     protected void LinkExternalCancellation(CancellationToken external)
     {
-        // A token that cannot fire adds nothing to the dispose chain, so skip creating the source entirely.
         if (!external.CanBeCanceled)
         {
             return;
         }
 
-        // A cancelled token needs the source created only to hold the cancelled state for later token requests.
         if (external.IsCancellationRequested)
         {
             Volatile.Write(ref _disposed, 1);
@@ -413,7 +407,6 @@ protected void LinkExternalCancellation(CancellationToken external)
     [DebuggerStepThrough]
     protected virtual async ValueTask DisposeAsyncCore()
     {
-        // First disposer wins; the latch moves whether or not a dispose source exists.
         if (Interlocked.Exchange(ref _disposed, 1) != 0)
         {
             return;
@@ -429,7 +422,7 @@ protected virtual async ValueTask DisposeAsyncCore()
             allOnSomethingCallsCompleted = PublishCallCompletionWaiter();
         }
 
-        // Only an existing source needs the cancellation broadcast; a later token request builds one pre-cancelled.
+        // Tokens requested after disposal are already cancelled.
         var cts = Volatile.Read(ref _disposeCts);
         if (cts is not null)
         {
@@ -490,7 +483,7 @@ private async ValueTask OnNextAsyncSlow(ValueTask core, LinkedTokenScope scope)
         }
         catch (OperationCanceledException)
         {
-            // Cooperative cancellation; swallow.
+            // Cancellation does not report a handler failure.
         }
         catch (Exception e)
         {
diff --git a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
index 0288932d..0eff29ad 100644
--- a/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia.Reactive/Concurrency/AvaloniaScheduler.cs
@@ -3,14 +3,13 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 using Avalonia.Threading;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>Avalonia UI-thread scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
-/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/> and delayed work fires on a
-/// <see cref="DispatcherTimer"/>, so disposing the returned subscription stops that timer as well as suppressing work
-/// that has not started.</remarks>
+/// <remarks>Callbacks run on the dispatcher thread at Priority; cancellation stops pending timers and suppresses unstarted actions.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("AvaloniaScheduler: Dispatcher = {Dispatcher}, Priority = {Priority}")]
 public sealed class AvaloniaScheduler : CoalescingDispatchScheduler
@@ -19,6 +18,12 @@ public sealed class AvaloniaScheduler : CoalescingDispatchScheduler
     public static readonly AvaloniaScheduler Instance =
         new(Dispatcher.UIThread, DispatcherPriority.Background);
 
+    /// <summary>Posts immediate work.</summary>
+    private readonly Action<Action> _post;
+
+    /// <summary>Schedules delayed work.</summary>
+    private readonly Func<Action, TimeSpan, IDisposable> _scheduleDelayed;
+
     /// <summary>Initializes a new instance of the <see cref="AvaloniaScheduler"/> class.</summary>
     /// <param name="dispatcher">The dispatcher used to marshal work to the UI thread.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
@@ -32,9 +37,26 @@ public AvaloniaScheduler(Dispatcher dispatcher)
     /// <param name="priority">Dispatcher priority used for posted drains and delayed work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public AvaloniaScheduler(Dispatcher dispatcher, DispatcherPriority priority)
+        : this(dispatcher, priority, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="AvaloniaScheduler"/> class.</summary>
+    /// <param name="dispatcher">The dispatcher exposed by the scheduler.</param>
+    /// <param name="priority">The selected dispatcher priority.</param>
+    /// <param name="post">Posts drains, or null to use the dispatcher.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work, or null to use dispatcher timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is null.</exception>
+    internal AvaloniaScheduler(
+        Dispatcher dispatcher,
+        DispatcherPriority priority,
+        Action<Action>? post,
+        Func<Action, TimeSpan, IDisposable>? scheduleDelayed)
     {
         Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         Priority = priority;
+        _post = post ?? PostToDispatcher;
+        _scheduleDelayed = scheduleDelayed ?? StartDispatcherTimer;
     }
 
     /// <summary>Gets the dispatcher used to marshal work to the UI thread.</summary>
@@ -46,13 +68,21 @@ public AvaloniaScheduler(Dispatcher dispatcher, DispatcherPriority priority)
     /// <inheritdoc/>
     protected override bool Post(Action drain)
     {
-        Dispatcher.Post(drain, Priority);
+        _post(drain);
         return true;
     }
 
     /// <inheritdoc/>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
+    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime) =>
+        _scheduleDelayed(work, dueTime);
+
+    /// <summary>Starts a cancellable dispatcher timer.</summary>
+    /// <param name="work">The callback to run when due.</param>
+    /// <param name="dueTime">The requested delay.</param>
+    /// <returns>The timer cancellation handle.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private IDisposable StartDispatcherTimer(Action work, TimeSpan dueTime)
     {
         DispatcherTimer timer = new(Priority, Dispatcher) { Interval = dueTime };
         timer.Tick += (_, _) =>
@@ -63,4 +93,10 @@ protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTim
         timer.Start();
         return Disposable.Create(timer, static value => value.Stop());
     }
+
+    /// <summary>Posts the callback at the configured dispatcher priority.</summary>
+    /// <param name="drain">The callback to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void PostToDispatcher(Action drain) => Dispatcher.Post(drain, Priority);
 }
diff --git a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
index 4a556500..3e8a7440 100644
--- a/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
+++ b/src/ReactiveUI.Primitives.Avalonia/Concurrency/AvaloniaScheduler.cs
@@ -9,9 +9,7 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Avalonia UI-thread scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
-/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/>, one batch per posted drain; scheduling from
-/// that thread queues the item for the next drain rather than running it inline. Delayed work fires on a
-/// <see cref="DispatcherTimer"/>, and an item cancelled before its drain reaches it is skipped.</remarks>
+/// <remarks>Callbacks run at Priority in posted dispatcher batches without inline reentrancy; cancellation suppresses unstarted work.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class AvaloniaScheduler : ISequencer
@@ -36,10 +34,25 @@ public AvaloniaScheduler(Dispatcher dispatcher)
     /// <param name="priority">Dispatcher priority used for posted drains and delayed work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public AvaloniaScheduler(Dispatcher dispatcher, DispatcherPriority priority)
+        : this(dispatcher, priority, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="AvaloniaScheduler"/> class.</summary>
+    /// <param name="dispatcher">The dispatcher exposed by the scheduler.</param>
+    /// <param name="priority">The selected dispatcher priority.</param>
+    /// <param name="post">Posts drains, or null to use the dispatcher.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work, or null to use dispatcher timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is null.</exception>
+    internal AvaloniaScheduler(
+        Dispatcher dispatcher,
+        DispatcherPriority priority,
+        Func<Action, bool>? post,
+        Action<IWorkItem, long>? scheduleDelayed)
     {
         Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         Priority = priority;
-        _state = new(this, Post, RunDrain, ScheduleDelayed);
+        _state = new(this, post ?? Post, RunDrain, scheduleDelayed ?? ScheduleDelayed);
     }
 
     /// <summary>Gets the dispatcher used to marshal work to the UI thread.</summary>
@@ -70,6 +83,7 @@ public AvaloniaScheduler(Dispatcher dispatcher, DispatcherPriority priority)
     /// <summary>Marshals the cached drain callback onto the dispatcher.</summary>
     /// <param name="drain">The drain callback.</param>
     /// <returns><see langword="true"/>, since the dispatcher accepts the work.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private bool Post(Action drain)
     {
         Dispatcher.Post(drain, Priority);
diff --git a/src/ReactiveUI.Primitives.Avalonia/ReactiveUI.Primitives.Avalonia.csproj b/src/ReactiveUI.Primitives.Avalonia/ReactiveUI.Primitives.Avalonia.csproj
index 5b576213..8fa11a07 100644
--- a/src/ReactiveUI.Primitives.Avalonia/ReactiveUI.Primitives.Avalonia.csproj
+++ b/src/ReactiveUI.Primitives.Avalonia/ReactiveUI.Primitives.Avalonia.csproj
@@ -11,4 +11,8 @@
     <ProjectReference Include="..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj"/>
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="ReactiveUI.Primitives.Avalonia.Tests"/>
+  </ItemGroup>
+
 </Project>
diff --git a/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs b/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
index 97069fa7..894eb08c 100644
--- a/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
+++ b/src/ReactiveUI.Primitives.Blazor.Reactive/Concurrency/BlazorRendererSequencer.cs
@@ -9,9 +9,7 @@
 namespace ReactiveUI.Primitives.Blazor.Reactive.Concurrency;
 
 /// <summary>Scheduler that coalesces scheduled work through a Blazor renderer dispatcher delegate.</summary>
-/// <remarks>Work runs on the renderer's dispatcher, and delayed work waits on a background scheduler that marshals it
-/// back through the renderer when due. A renderer task that faults reaches
-/// <see cref="UnhandledExceptionHandler"/>.</remarks>
+/// <remarks>Immediate and delayed callbacks run on the renderer dispatcher; renderer task failures reach UnhandledExceptionHandler.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("BlazorRendererSequencer: InvokeAsync = {_invokeAsync}, UnhandledExceptionHandler = {UnhandledExceptionHandler}")]
 public sealed class BlazorRendererSequencer : CoalescingDispatchScheduler
@@ -33,40 +31,38 @@ public BlazorRendererSequencer(Dispatcher dispatcher)
     {
     }
 
-    /// <summary>
-    /// Gets or sets the handler for exceptions the renderer task surfaces after the drain is posted.
-    /// When <see langword="null"/>, faults are rethrown on the thread pool instead of being lost as
-    /// unobserved task exceptions.
-    /// </summary>
+    /// <summary>Gets or sets the renderer fault handler, rethrowing faults on the thread pool when null.</summary>
     public Action<Exception>? UnhandledExceptionHandler { get; set; }
 
-    /// <inheritdoc/>
-    protected override bool Post(Action drain)
+    /// <summary>Registers fault observation unless the renderer task has already succeeded.</summary>
+    /// <param name="task">The renderer task to observe.</param>
+    /// <param name="register">Registers the task and its owning sequencer for fault notification.</param>
+    internal void ObserveFaults(Task task, Action<Task, BlazorRendererSequencer> register)
     {
-        ObserveFaults(_invokeAsync(drain));
-        return true;
+        if (task.IsCompletedSuccessfully)
+        {
+            return;
+        }
+
+        register(task, this);
     }
 
-    /// <summary>Routes renderer-task faults to the handler instead of leaving them unobserved.</summary>
-    /// <param name="task">The renderer task to observe.</param>
-    private void ObserveFaults(Task task)
+    /// <summary>Forwards a renderer task's base exception when the task faulted.</summary>
+    /// <param name="task">The renderer task whose state changed.</param>
+    internal void CompleteRendererTask(Task task)
     {
-        if (task.IsCompletedSuccessfully)
+        if (!task.IsFaulted)
         {
             return;
         }
 
-        _ = task.ContinueWith(
-            static (t, state) => ((BlazorRendererSequencer)state!).HandleFault(t.Exception!.GetBaseException()),
-            this,
-            CancellationToken.None,
-            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
-            TaskScheduler.Default);
+        HandleFault(task.Exception!.GetBaseException(), Rethrow);
     }
 
     /// <summary>Hands a fault to the handler, or rethrows it on the thread pool.</summary>
     /// <param name="exception">The observed fault.</param>
-    private void HandleFault(Exception exception)
+    /// <param name="rethrow">The fallback invoked when no fault handler is configured.</param>
+    internal void HandleFault(Exception exception, Action<Exception> rethrow)
     {
         var handler = UnhandledExceptionHandler;
         if (handler is not null)
@@ -75,8 +71,33 @@ private void HandleFault(Exception exception)
             return;
         }
 
+        rethrow(exception);
+    }
+
+    /// <inheritdoc/>
+    protected override bool Post(Action drain)
+    {
+        ObserveFaults(_invokeAsync(drain), RegisterFaultContinuation);
+        return true;
+    }
+
+    /// <summary>Registers notification for a renderer task that faults.</summary>
+    /// <param name="task">The renderer task to observe.</param>
+    /// <param name="sequencer">The owner receiving the fault notification.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void RegisterFaultContinuation(Task task, BlazorRendererSequencer sequencer) =>
+        _ = task.ContinueWith(
+            static (completed, state) => ((BlazorRendererSequencer)state!).CompleteRendererTask(completed),
+            sequencer,
+            CancellationToken.None,
+            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+            TaskScheduler.Default);
+
+    /// <summary>Rethrows a fault on the thread pool with its captured stack.</summary>
+    /// <param name="exception">The fault to rethrow.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void Rethrow(Exception exception) =>
         _ = ThreadPool.UnsafeQueueUserWorkItem(
             static state => ((ExceptionDispatchInfo)state!).Throw(),
             ExceptionDispatchInfo.Capture(exception));
-    }
 }
diff --git a/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs b/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
index 0f6434bb..3fa09091 100644
--- a/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
+++ b/src/ReactiveUI.Primitives.Blazor/Concurrency/BlazorRendererSequencer.cs
@@ -11,10 +11,7 @@
 namespace ReactiveUI.Primitives.Blazor.Concurrency;
 
 /// <summary>Sequencer that coalesces scheduled work through a Blazor renderer dispatcher delegate.</summary>
-/// <remarks>Work runs on the renderer's dispatcher, one batch per posted drain; scheduling from that thread queues the
-/// item for the next drain rather than running it inline. Delayed work waits on a shared timer that marshals it back
-/// through the renderer when due, and a renderer task that faults reaches
-/// <see cref="UnhandledExceptionHandler"/>.</remarks>
+/// <remarks>Callbacks run in posted renderer batches without inline reentrancy; renderer task failures reach UnhandledExceptionHandler.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class BlazorRendererSequencer : ISequencer
@@ -42,11 +39,7 @@ public BlazorRendererSequencer(Dispatcher dispatcher)
     {
     }
 
-    /// <summary>
-    /// Gets or sets the handler for exceptions the renderer task surfaces after the drain is posted.
-    /// When <see langword="null"/>, faults are rethrown on the thread pool instead of being lost as
-    /// unobserved task exceptions.
-    /// </summary>
+    /// <summary>Gets or sets the renderer fault handler, rethrowing faults on the thread pool when null.</summary>
     public Action<Exception>? UnhandledExceptionHandler { get; set; }
 
     /// <inheritdoc/>
@@ -67,35 +60,35 @@ public BlazorRendererSequencer(Dispatcher dispatcher)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Schedule(IWorkItem item, long dueTimestamp) => _state.Schedule(item, dueTimestamp);
 
-    /// <summary>Marshals the cached drain callback through the Blazor renderer.</summary>
-    /// <param name="drain">The drain callback.</param>
-    /// <returns><see langword="true"/>, since the renderer always accepts the work.</returns>
-    private bool Post(Action drain)
+    /// <summary>Registers fault observation unless the renderer task has already succeeded.</summary>
+    /// <param name="task">The renderer task to observe.</param>
+    /// <param name="register">Registers the task and its owning sequencer for fault notification.</param>
+    internal void ObserveFaults(Task task, Action<Task, BlazorRendererSequencer> register)
     {
-        ObserveFaults(_invokeAsync(drain));
-        return true;
+        if (task.IsCompletedSuccessfully)
+        {
+            return;
+        }
+
+        register(task, this);
     }
 
-    /// <summary>Routes renderer-task faults to the handler instead of leaving them unobserved.</summary>
-    /// <param name="task">The renderer task to observe.</param>
-    private void ObserveFaults(Task task)
+    /// <summary>Forwards a renderer task's base exception when the task faulted.</summary>
+    /// <param name="task">The renderer task whose state changed.</param>
+    internal void CompleteRendererTask(Task task)
     {
-        if (task.IsCompletedSuccessfully)
+        if (!task.IsFaulted)
         {
             return;
         }
 
-        _ = task.ContinueWith(
-            static (t, state) => ((BlazorRendererSequencer)state!).HandleFault(t.Exception!.GetBaseException()),
-            this,
-            CancellationToken.None,
-            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
-            TaskScheduler.Default);
+        HandleFault(task.Exception!.GetBaseException(), Rethrow);
     }
 
     /// <summary>Hands a fault to the handler, or rethrows it on the thread pool.</summary>
     /// <param name="exception">The observed fault.</param>
-    private void HandleFault(Exception exception)
+    /// <param name="rethrow">The fallback invoked when no fault handler is configured.</param>
+    internal void HandleFault(Exception exception, Action<Exception> rethrow)
     {
         var handler = UnhandledExceptionHandler;
         if (handler is not null)
@@ -104,9 +97,36 @@ private void HandleFault(Exception exception)
             return;
         }
 
+        rethrow(exception);
+    }
+
+    /// <summary>Registers notification for a renderer task that faults.</summary>
+    /// <param name="task">The renderer task to observe.</param>
+    /// <param name="sequencer">The owner receiving the fault notification.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void RegisterFaultContinuation(Task task, BlazorRendererSequencer sequencer) =>
+        _ = task.ContinueWith(
+            static (completed, state) => ((BlazorRendererSequencer)state!).CompleteRendererTask(completed),
+            sequencer,
+            CancellationToken.None,
+            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+            TaskScheduler.Default);
+
+    /// <summary>Rethrows a fault on the thread pool with its captured stack.</summary>
+    /// <param name="exception">The fault to rethrow.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void Rethrow(Exception exception) =>
         _ = ThreadPool.UnsafeQueueUserWorkItem(
             static state => ((ExceptionDispatchInfo)state!).Throw(),
             ExceptionDispatchInfo.Capture(exception));
+
+    /// <summary>Marshals the cached drain callback through the Blazor renderer.</summary>
+    /// <param name="drain">The drain callback.</param>
+    /// <returns><see langword="true"/>, since the renderer always accepts the work.</returns>
+    private bool Post(Action drain)
+    {
+        ObserveFaults(_invokeAsync(drain), RegisterFaultContinuation);
+        return true;
     }
 
     /// <summary>Runs one queued batch on the coalescing engine.</summary>
diff --git a/src/ReactiveUI.Primitives.Blazor/ReactiveUI.Primitives.Blazor.csproj b/src/ReactiveUI.Primitives.Blazor/ReactiveUI.Primitives.Blazor.csproj
index e14ce0a3..4a74da99 100644
--- a/src/ReactiveUI.Primitives.Blazor/ReactiveUI.Primitives.Blazor.csproj
+++ b/src/ReactiveUI.Primitives.Blazor/ReactiveUI.Primitives.Blazor.csproj
@@ -24,4 +24,8 @@
     <ProjectReference Include="..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj"/>
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="ReactiveUI.Primitives.Blazor.Tests"/>
+  </ItemGroup>
+
 </Project>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
index ff33b05b..5a0ff809 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AggregateWitness.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Single-source sink that folds every observed value through an immutable value-type <typeparamref name="TAggregator"/>
-/// and emits the aggregate result once the source completes. The accumulator is advanced functionally: each value
-/// yields a replacement accumulator rather than mutating the current one.
-/// </summary>
+/// <summary>Folds source values through an immutable accumulator and emits the result when the source completes.</summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 /// <typeparam name="TResult">The terminal result type.</typeparam>
 /// <typeparam name="TAggregator">The value-type accumulator that folds values and yields the result.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
index d614bd16..ebee5ffe 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/AsyncEnumerableSignal{T}.cs
@@ -98,7 +98,7 @@ internal async Task PumpAsync()
                 Volatile.Write(ref _enumerator, enumerator);
                 while (!_cts.IsCancellationRequested && await enumerator.MoveNextAsync().ConfigureAwait(false))
                 {
-                    // Cancellation during the move suppresses its buffered value.
+                    // Cancellation discards the current buffered value.
                     if (_cts.IsCancellationRequested)
                     {
                         break;
@@ -114,7 +114,7 @@ internal async Task PumpAsync()
             }
             catch (OperationCanceledException) when (_cts.IsCancellationRequested)
             {
-                // Disposal requested cancellation; observers should not receive a terminal signal.
+                // Subscription disposal does not send a terminal notification.
             }
             catch (Exception error) when (!_cts.IsCancellationRequested)
             {
@@ -135,7 +135,7 @@ internal async Task PumpAsync()
         /// <param name="enumerator">The enumerator to dispose.</param>
         private static void FireAndForgetDispose(IAsyncEnumerator<T> enumerator)
         {
-            // IDisposable cannot await enumerator disposal.
+            // Disposal returns before asynchronous enumerator cleanup finishes.
             _ = ObserveAsync(enumerator);
 
             static async Task ObserveAsync(IAsyncEnumerator<T> enumerator)
@@ -146,7 +146,7 @@ static async Task ObserveAsync(IAsyncEnumerator<T> enumerator)
                 }
                 catch (NotSupportedException)
                 {
-                    // Some enumerators only support disposal from the enumeration path.
+                    // Unsupported concurrent enumerator disposal is ignored.
                 }
             }
         }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
index 3d332734..2b05786c 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
@@ -51,7 +51,6 @@ public void OnNext(T value)
             _buffer = buffer;
         }
 
-        // Take while not skipping; the window index doubles as the array slot.
         if (idx >= 0)
         {
             buffer![idx] = value;
@@ -64,11 +63,9 @@ public void OnNext(T value)
             return;
         }
 
-        // Reset the index before a throwing observer can release the buffer.
         _buffer = null;
         _index = 0 - _skip;
 
-        // A full window is exactly the right size, so it needs no trimming.
         Emit(buffer!);
     }
 
@@ -119,7 +116,7 @@ public void OnCompleted()
     /// <inheritdoc/>
     public void Dispose()
     {
-        // Reject further values on every teardown path, including observer failure.
+        // Values after teardown are ignored, including after observer failure.
         Volatile.Write(ref _done, 1);
         SinkSubscription.Dispose(ref _subscription);
     }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs b/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
index a7f1fd99..cd14afc8 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/IAggregator.cs
@@ -4,12 +4,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// An immutable value-type accumulator for a single-source aggregate sink: each <see cref="Add"/> folds a value
-/// into the running state and returns the next accumulator, while <see cref="Result"/> yields the terminal value.
-/// Implement it as a <see langword="readonly record struct"/> so
-/// <see cref="AggregateWitness{T,TResult,TAggregator}"/> can fold without allocating per value.
-/// </summary>
+/// <summary>Accumulates values by returning a replacement state from Add and exposing the aggregate through Result.</summary>
 /// <typeparam name="T">The observed value type.</typeparam>
 /// <typeparam name="TResult">The terminal result type.</typeparam>
 /// <typeparam name="TSelf">The implementing accumulator type, returned by <see cref="Add"/>.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs b/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
index d4448eb4..fefd5803 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SinkSubscription.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Assign-once, dispose-once management of a sink's single upstream subscription. Each helper takes the
-/// caller-owned <see cref="IDisposable"/> field by <see langword="ref"/>, so a sink can implement
-/// <see cref="IObserver{T}"/> directly without deriving from a shared base class.
-/// </summary>
+/// <summary>Assigns and disposes a single upstream subscription held in a caller-owned field.</summary>
 public static class SinkSubscription
 {
     /// <summary>Sentinel stored once a sink is disposed so any late subscription is torn down immediately.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs b/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
index 160d0185..6be85733 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SinkTerminal.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Terminal-forwarding helpers for single-source sink observers: deliver one terminal notification
-/// downstream and dispose the sink afterwards, optionally latching a caller-owned <c>done</c> flag so only
-/// the first terminal call reaches the observer.
-/// </summary>
+/// <summary>Forwards a terminal notification and disposes the sink, optionally preventing repeated terminal delivery.</summary>
 public static class SinkTerminal
 {
     /// <summary>Forwards a fault to <paramref name="observer"/> and then disposes <paramref name="sink"/>.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
index ba06a5df..b5c0b077 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SubscriptionSlots.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Interlocked single-assignment subscription slots for a sink that resubscribes: a slot holds at most one live
-/// subscription and, once released, swaps to a sentinel so a late assignment is disposed instead of stored.
-/// </summary>
+/// <summary>Holds one subscription per slot and disposes assignments made after a slot is released.</summary>
 public static class SubscriptionSlots
 {
     /// <summary>The sentinel stored in a slot once it has been released.</summary>
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
index 424c7a90..08463359 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/SynchronizeWitness.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Observer that serializes notifications behind a gate, so downstream operators observe the single-threaded
-/// <c>OnNext*</c> then <c>OnError</c>|<c>OnCompleted</c> grammar even when the upstream source delivers
-/// concurrently. Place one ahead of a stateful sink to consume a source that does not honour that grammar.
-/// </summary>
+/// <summary>Serializes concurrent observer notifications so values precede a single terminal notification.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("SynchronizeWitness: Observer = {_observer}, Subscription = {_subscription}")]
 public sealed class SynchronizeWitness<T> : IObserver<T>, IDisposable
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
index f0b69257..8eba8a96 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
@@ -7,14 +7,12 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Signal that creates a resource for each subscription and disposes it once the inner signal terminates or
-/// the subscription is disposed. A fault from either factory is delivered to the observer as an error.
-/// </summary>
+/// <summary>Creates a resource per subscription and disposes it when the sequence terminates or the subscription is disposed.</summary>
 /// <typeparam name="TResource">The resource type, disposed with the subscription.</typeparam>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="resourceFactory">Creates the resource, once per subscription.</param>
 /// <param name="signalFactory">Creates the signal that consumes the resource.</param>
+/// <remarks>A failure from either factory is delivered to the observer.</remarks>
 [System.Diagnostics.DebuggerDisplay("UseSignal: ResourceFactory = {_resourceFactory}, SignalFactory = {_signalFactory}")]
 public sealed class UseSignal<TResource, T>(
     Func<TResource> resourceFactory,
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/WitnessTeardown.cs b/src/ReactiveUI.Primitives.Core/Advanced/WitnessTeardown.cs
index bec05d2d..23771670 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/WitnessTeardown.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/WitnessTeardown.cs
@@ -13,7 +13,7 @@ public static class WitnessTeardown
     /// <returns><see langword="true"/> on the first disposal; otherwise <see langword="false"/>.</returns>
     public static bool Dispose(ref int disposed, ref IDisposable? cancel)
     {
-        // Atomic run-once latch so concurrent disposal cannot double-tear-down.
+        // Concurrent disposal runs teardown at most once.
         if (Interlocked.Exchange(ref disposed, 1) != 0)
         {
             return false;
diff --git a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
index b1c697c4..778a87b4 100644
--- a/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
+++ b/src/ReactiveUI.Primitives.Core/Concurrency/ScheduledItem.cs
@@ -127,10 +127,7 @@ public ScheduledItem(
     /// the same due-time ordering, or a value greater than zero when this item is due later. Any non-null item compares
     /// greater than <see langword="null"/>.
     /// </returns>
-    /// <remarks>
-    /// Ordering is by due time and says nothing about equality: <see cref="Equals(object?)"/> and the equality
-    /// operators compare reference identity instead.
-    /// </remarks>
+    /// <remarks>Ordering compares due times; equality compares reference identity.</remarks>
     public int CompareTo(ScheduledItem<TAbsolute>? other) =>
         other is null ? 1 : _comparer.Compare(DueTime, other.DueTime);
 
@@ -182,10 +179,7 @@ public void Dispose()
     public override int GetHashCode() => RuntimeHelpers.GetHashCode(this);
 
     /// <summary>Runs this scheduled work item if it has not been canceled.</summary>
-    /// <remarks>
-    /// The callback runs once and the disposable it returns is stored. Cancellation before, during, or immediately
-    /// after the call disposes that disposable, so cancellation reaches work the callback created.
-    /// </remarks>
+    /// <remarks>Cancellation disposes the resource returned by the callback, including when cancellation overlaps its execution.</remarks>
     public void Invoke()
     {
         if (IsDisposed)
@@ -201,11 +195,17 @@ public void Invoke()
             return;
         }
 
+        ReleaseCanceledResult();
+    }
+
+    /// <summary>Releases the published result if the work item is cancelled.</summary>
+    internal void ReleaseCanceledResult()
+    {
         if (!IsDisposed)
         {
             return;
         }
 
-        disposable.Dispose();
+        Interlocked.Exchange(ref _disposable, EmptyDisposable.Instance)?.Dispose();
     }
 }
diff --git a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
index 2dca23fb..16419e4a 100644
--- a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs
@@ -22,7 +22,7 @@ public sealed class ConnectableSignal<T> : IObservable<T>
     /// <summary>Multicast hub that receives source values.</summary>
     private readonly ISignal<T> _hub;
 
-    /// <summary>Active source connection slot. The returned connection handle owns disposal.</summary>
+    /// <summary>The active source connection, whose returned handle owns disposal.</summary>
     private StrongBox<Connection>? _connection;
 
     /// <summary>Set after the source sends a terminal notification to the hub.</summary>
@@ -54,7 +54,6 @@ public IDisposable Connect()
                 return Scope.Empty;
             }
 
-            // A dedicated disposable type for the handle, so connecting captures no closure.
             if (_connection?.Value is { } activeConnection)
             {
                 return activeConnection;
diff --git a/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs b/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
index 2a89f996..4c8018af 100644
--- a/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Core/TimeInterval{T}.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Core;
 
-/// <summary>
-/// Represents a value paired with a time interval, whose meaning is the producer's: how long the value took to
-/// produce, the gap since the previous value, or its delivery time relative to a base.
-/// </summary>
+/// <summary>Pairs a value with a producer-defined time interval.</summary>
 /// <typeparam name="T">The annotated value type.</typeparam>
 [Serializable]
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Primitives.Core/Optional.cs b/src/ReactiveUI.Primitives.Core/Optional.cs
index 201f27c5..0f47aa5d 100644
--- a/src/ReactiveUI.Primitives.Core/Optional.cs
+++ b/src/ReactiveUI.Primitives.Core/Optional.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives;
 
-/// <summary>
-/// Represents an optional value, letting an API distinguish an absent value from a default one without using
-/// <see langword="null"/>. A <see langword="null"/> value is treated as absent.
-/// </summary>
+/// <summary>Represents a value that may be absent, treating null as absent.</summary>
 /// <typeparam name="T">The type of the value that may be contained by the optional.</typeparam>
 [System.Diagnostics.DebuggerDisplay("Optional: HasValue = {HasValue}, Value = {_value}")]
 public readonly record struct Optional<T>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
index b412ba6a..1b40547b 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AsyncSignal.cs
@@ -265,7 +265,6 @@ internal void WaitIfPending(Action<AsyncSignal<T>> wait)
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private static void WaitForCompletion(AsyncSignal<T> signal)
     {
-        // Registration precedes waiting so completion cannot be missed.
         using ManualResetEvent completionEvent = new(false);
         signal.SubscribeCompletion(() => completionEvent.Set(), false);
         _ = completionEvent.WaitOne();
diff --git a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
index 89f66d2a..eb3b5bdc 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/AwaitWitness.cs
@@ -49,12 +49,20 @@ public void OnNext(T value)
     {
     }
 
+    /// <summary>Posts a continuation to the captured context.</summary>
+    /// <param name="context">The context receiving the callback.</param>
+    /// <param name="callback">The callback to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Post(SynchronizationContext context, Action callback) =>
+        context.Post(static state => ((Action?)state)?.Invoke(), callback);
+
     /// <summary>Posts the continuation to its captured context, or invokes it directly when none was captured.</summary>
     private void InvokeOnOriginalContext()
     {
         if (_context is not null)
         {
-            _context.Post(static state => ((Action?)state)?.Invoke(), _callback);
+            Post(_context, _callback);
         }
         else
         {
diff --git a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
index 16da1d35..9de914ed 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/BehaviorSignalState{T}.cs
@@ -150,7 +150,7 @@ internal IDisposable Subscribe(IWitnessRemovable<T> owner, IObserver<T> observer
             ThrowIfDisposed();
             if (!_isStopped)
             {
-                // Serialize initial delivery with live broadcast to preserve order and prevent duplicates.
+                // Initial and live values are delivered in order without duplicates.
                 _broadcaster.Add(observer);
                 var subscription = new BehaviorWitnessHandler<T>(owner, observer);
                 observer.OnNext(_lastValue!);
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
index cf8679b2..6eacc452 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Broadcaster{T}.cs
@@ -37,62 +37,24 @@ public struct Broadcaster<T> : IEquatable<Broadcaster<T>>
     /// <returns><see langword="true"/> when the broadcasters reference different observer sets; otherwise, <see langword="false"/>.</returns>
     public static bool operator !=(Broadcaster<T> left, Broadcaster<T> right) => !left.Equals(right);
 
-    /// <summary>Adds an observer with a lock-free compare-and-swap, so no external lock is required.</summary>
+    /// <summary>Adds an observer safely during concurrent updates.</summary>
     /// <param name="observer">Observer to add.</param>
     public void Add(IObserver<T> observer)
     {
-        while (true)
-        {
-            var current = Volatile.Read(ref _observers);
-            object next;
-            if (current is IObserver<T>[] many)
-            {
-                var copy = new IObserver<T>[many.Length + 1];
-                Array.Copy(many, copy, many.Length);
-                copy[many.Length] = observer;
-                next = copy;
-            }
-            else if (current is IObserver<T> single)
-            {
-                next = new[] { single, observer };
-            }
-            else if (Interlocked.CompareExchange(ref _observers, observer, null) is null)
-            {
-                return;
-            }
-            else
-            {
-                continue;
-            }
-
-            if (ReferenceEquals(Interlocked.CompareExchange(ref _observers, next, current), current))
-            {
-                return;
-            }
-        }
+        var current = Volatile.Read(ref _observers);
+        AddWithRetry(current, observer);
     }
 
     /// <summary>Removes all observers from the broadcaster.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Clear() => Volatile.Write(ref _observers, null);
 
-    /// <summary>Removes an observer from the broadcaster using a lock-free compare-and-swap.</summary>
+    /// <summary>Removes an observer safely during concurrent updates.</summary>
     /// <param name="observer">Observer to remove.</param>
     public void Remove(IObserver<T> observer)
     {
-        while (true)
-        {
-            var current = Volatile.Read(ref _observers);
-            if (!TryComputeRemoval(current, observer, out var next))
-            {
-                return;
-            }
-
-            if (ReferenceEquals(Interlocked.CompareExchange(ref _observers, next, current), current))
-            {
-                return;
-            }
-        }
+        var current = Volatile.Read(ref _observers);
+        RemoveWithRetry(current, observer);
     }
 
     /// <summary>Broadcasts a value to the current observers.</summary>
@@ -197,6 +159,42 @@ public override readonly int GetHashCode()
         return hash;
     }
 
+    /// <summary>Adds an observer if the observed slot has not changed.</summary>
+    /// <param name="observers">The live observer slot.</param>
+    /// <param name="current">The observed slot value.</param>
+    /// <param name="observer">The observer to add.</param>
+    /// <returns>True when the observer was added; false when the observed slot was stale.</returns>
+    internal static bool TryAdd(ref object? observers, object? current, IObserver<T> observer)
+    {
+        object next;
+        if (current is IObserver<T>[] many)
+        {
+            var copy = new IObserver<T>[many.Length + 1];
+            Array.Copy(many, copy, many.Length);
+            copy[many.Length] = observer;
+            next = copy;
+        }
+        else if (current is IObserver<T> single)
+        {
+            next = new[] { single, observer };
+        }
+        else
+        {
+            return Interlocked.CompareExchange(ref observers, observer, null) is null;
+        }
+
+        return ReferenceEquals(Interlocked.CompareExchange(ref observers, next, current), current);
+    }
+
+    /// <summary>Removes an observer if the observed slot has not changed.</summary>
+    /// <param name="observers">The live observer slot.</param>
+    /// <param name="current">The observed slot value.</param>
+    /// <param name="observer">The observer to remove.</param>
+    /// <returns>True when removal completed or the observer was absent; false when the observed slot was stale.</returns>
+    internal static bool TryRemove(ref object? observers, object? current, IObserver<T> observer) =>
+        !TryComputeRemoval(current, observer, out var next)
+        || ReferenceEquals(Interlocked.CompareExchange(ref observers, next, current), current);
+
     /// <summary>Computes the observer-set value that results from removing an observer.</summary>
     /// <param name="current">The current observer-set snapshot.</param>
     /// <param name="observer">The observer to remove.</param>
@@ -233,4 +231,38 @@ private static bool TryComputeRemoval(object? current, IObserver<T> observer, ou
         next = copy;
         return true;
     }
+
+    /// <summary>Retries observer addition until the observed slot is current.</summary>
+    /// <param name="current">The initial observer snapshot.</param>
+    /// <param name="observer">The observer to add.</param>
+    [ExcludeFromCodeCoverage]
+    private void AddWithRetry(object? current, IObserver<T> observer)
+    {
+        while (true)
+        {
+            if (TryAdd(ref _observers, current, observer))
+            {
+                return;
+            }
+
+            current = Volatile.Read(ref _observers);
+        }
+    }
+
+    /// <summary>Retries observer removal until the observed slot is current.</summary>
+    /// <param name="current">The initial observer snapshot.</param>
+    /// <param name="observer">The observer to remove.</param>
+    [ExcludeFromCodeCoverage]
+    private void RemoveWithRetry(object? current, IObserver<T> observer)
+    {
+        while (true)
+        {
+            if (TryRemove(ref _observers, current, observer))
+            {
+                return;
+            }
+
+            current = Volatile.Read(ref _observers);
+        }
+    }
 }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
index 41fd43ed..5f359835 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/CommandSignal{TResult}.cs
@@ -341,7 +341,6 @@ private void BeginExecution()
     /// <param name="value">The running state.</param>
     private void SetRunning(bool value)
     {
-        // Publish the flag and stream value under the installation gate.
         lock (_runningGate)
         {
             _isRunning = value;
@@ -365,7 +364,7 @@ private void ReconcileRunningState()
         }
     }
 
-    /// <summary>Pushes the authoritative running flag onto the stream when one is installed. Caller holds the gate.</summary>
+    /// <summary>Publishes the current running state, when observed, while the caller holds the gate.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void PublishRunningState() => Volatile.Read(ref _isRunningState)?.OnNext(_isRunning);
 
@@ -413,7 +412,6 @@ private void ThrowIfDisposed()
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void AddResult(IObserver<TResult> observer)
     {
-        // Retry only when another thread replaced the observed snapshot.
         while (true)
         {
             if (TryAddResult(ref _resultObservers, Volatile.Read(ref _resultObservers), observer))
@@ -432,7 +430,6 @@ private void AddResult(IObserver<TResult> observer)
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private void RemoveResult(IObserver<TResult> observer)
     {
-        // Retry only when another thread replaced the observed snapshot.
         while (true)
         {
             if (TryRemoveResult(ref _resultObservers, Volatile.Read(ref _resultObservers), observer))
diff --git a/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
index 602e60a7..8b5bc8f4 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/DelayableNotificationSignal{T}.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// A signal that passes notifications through immediately while they are not delayed, but buffers them while delayed
-/// and emits a de-duplicated batch when <see cref="Flush"/> is called (typically as the delay window opens or closes).
-/// Equivalent to the <c>Buffer(boundary).SelectMany(distinct).Publish().RefCount()</c> pipeline in a single sink.
-/// </summary>
+/// <summary>Forwards notifications immediately unless delayed, then buffers them until Flush emits a batch with duplicates removed.</summary>
 /// <typeparam name="T">The notification type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("DelayableNotificationSignal: Stopped = {_stopped}, Buffer = {_buffer}")]
 public sealed class DelayableNotificationSignal<T> : ISignal<T>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/DelegateWitness{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/DelegateWitness{T}.cs
index 71ed4217..5800110c 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/DelegateWitness{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/DelegateWitness{T}.cs
@@ -6,12 +6,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// A lightweight <see cref="IObserver{T}"/> that forwards each notification to the supplied delegates.
-/// Use it to subscribe to an <see cref="IObservable{T}"/> without allocating a bespoke observer class.
-/// The <paramref name="onError"/> and <paramref name="onCompleted"/> delegates are optional; when omitted
-/// the corresponding terminal notification is ignored.
-/// </summary>
+/// <summary>Forwards notifications to supplied delegates and ignores terminal notifications whose delegate is omitted.</summary>
 /// <typeparam name="T">The type of the value being observed.</typeparam>
 /// <param name="onNext">The delegate invoked with each value pushed to <see cref="IObserver{T}.OnNext"/>.</param>
 /// <param name="onError">The optional delegate invoked with the exception when the sequence faults via <see cref="IObserver{T}.OnError"/>.</param>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs b/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
index 41468767..92c875f3 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/MapWithSignal{TSource,TState,TResult}.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// Projects each source value into a new form using a caller-supplied state value, without allocating a per-value
-/// closure: the state is stored on the sink and passed to the selector for each element.
-/// </summary>
+/// <summary>Projects each source value using the supplied state and selector.</summary>
 /// <typeparam name="TSource">The source value type.</typeparam>
 /// <typeparam name="TState">The state type passed to the selector.</typeparam>
 /// <typeparam name="TResult">The result value type.</typeparam>
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
index 073f3bcf..1bfcf994 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
@@ -127,7 +127,7 @@ public void OnError(Exception error)
 
     /// <summary>Emits a value to the current observers; a stopped signal drops it and a disposed signal throws <see cref="ObjectDisposedException"/>.</summary>
     /// <param name="value">The value to emit.</param>
-    /// <remarks>Dispatch reads the published observer set without taking the lock, so concurrent calls are not serialized against each other.</remarks>
+    /// <remarks>Concurrent notification calls are not serialized.</remarks>
     public void OnNext(T value)
     {
         var observers = Volatile.Read(ref _observers);
@@ -247,7 +247,6 @@ protected virtual void Dispose(bool disposing)
         {
             _exception = null;
 
-            // The release write publishes the disposed flag with the terminal marker.
             _isDisposed = true;
             observers = ClearObserversLocked(DisposedMarker);
         }
@@ -509,7 +508,6 @@ private void ClearSlotLocked(SignalSubscription?[] slots, int index)
             return;
         }
 
-        // Keep the array for the next subscriber; only the shape published to dispatch goes back to empty.
         _subscriptionTail = 0;
         Volatile.Write(ref _observers, null);
     }
diff --git a/src/ReactiveUI.Primitives.Core/Signals/StateSignal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/StateSignal{T}.cs
index 55555f5d..d6d0af08 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/StateSignal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/StateSignal{T}.cs
@@ -21,7 +21,7 @@ public sealed class StateSignal<T> : ISignal<T>, IWitnessRemovable<T>
     /// <summary>Gets the observable stream of current and subsequent values.</summary>
     public IObservable<T> Changed => this;
 
-    /// <summary>Gets or sets the current value. Setting the value notifies observers even when equal to the previous value.</summary>
+    /// <summary>Gets or sets the current value, notifying observers on every assignment even when the value is unchanged.</summary>
     public T Value
     {
         get => _state.GetValue();
diff --git a/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs b/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
index 9156e8b7..533d8086 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/TapWithSignal{T,TState}.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Signals;
 
-/// <summary>
-/// Invokes a stateful action for each source value while forwarding the value unchanged, without allocating a
-/// per-value closure: the state is stored on the sink and passed to the action for each element.
-/// </summary>
+/// <summary>Invokes the supplied action with each source value and state, then forwards the value unchanged.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <typeparam name="TState">The state type passed to the action.</typeparam>
 /// <param name="source">The source sequence.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
index a01e09c2..3e18102f 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/ConcurrencyLimiter.cs
@@ -7,15 +7,14 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Drains a task sequence with at most <paramref name="maxConcurrency"/> tasks in flight, emitting each result as it
-/// completes and completing once the sequence is exhausted. A faulted or cancelled task terminates the sequence with
-/// that task's exception. Subscribers share one enumerator over <paramref name="taskFunctions"/>, so a second
-/// subscription continues draining where the first stopped, and disposing any subscription halts the drain for all.
-/// </summary>
+/// <summary>Runs task factories with bounded concurrency and emits results in completion order.</summary>
 /// <typeparam name="T">The type of the task results.</typeparam>
 /// <param name="taskFunctions">The task functions to drain.</param>
 /// <param name="maxConcurrency">The maximum concurrency.</param>
+/// <remarks>
+/// Subscribers share progress; disposing any subscription stops every drain. A task fault or cancellation terminates the sequence with its
+/// error.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("ConcurrencyLimiter: Outstanding = {_outstanding}, Disposed = {_disposed}")]
 public sealed class ConcurrencyLimiter<T>(IEnumerable<Task<T>> taskFunctions, int maxConcurrency) : IObservable<T>
 {
@@ -115,6 +114,22 @@ internal void ProcessTaskCompletion(Subscription subscription, Task<T> completed
         }
     }
 
+    /// <summary>Registers result delivery for the pending task.</summary>
+    /// <param name="task">The pending task.</param>
+    /// <param name="subscription">The result recipient.</param>
+    [ExcludeFromCodeCoverage]
+    private static void RegisterCompletion(Task<T> task, Subscription subscription) =>
+        _ = task.ContinueWith(
+            static (completed, state) =>
+            {
+                var owner = (Subscription)state!;
+                owner.Limiter.ProcessTaskCompletion(owner, completed);
+            },
+            subscription,
+            CancellationToken.None,
+            TaskContinuationOptions.ExecuteSynchronously,
+            TaskScheduler.Default);
+
     /// <summary>Pulls the next task and schedules its continuation against this limiter.</summary>
     /// <param name="subscription">The owning subscription.</param>
     private void PullNextTask(Subscription subscription)
@@ -144,16 +159,10 @@ private void PullNextTask(Subscription subscription)
 
             _outstanding++;
 
-            _rator.Current?.ContinueWith(
-                static (ant, state) =>
-                {
-                    var sub = (Subscription)state!;
-                    sub.Limiter.ProcessTaskCompletion(sub, ant);
-                },
-                subscription,
-                CancellationToken.None,
-                TaskContinuationOptions.ExecuteSynchronously,
-                TaskScheduler.Default);
+            if (_rator.Current is { } task)
+            {
+                RegisterCompletion(task, subscription);
+            }
         }
     }
 
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
index 2296206c..f5213d2a 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Continuation.cs
@@ -2,20 +2,20 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Pairs an emitted item with a release handle so a producer can wait on its consumer: <see cref="Lock{T}"/> hands the
-/// item and this instance to an observer and returns a task that completes once that handle is disposed. The barrier
-/// behind it takes two participants and is torn down by <see cref="Dispose()"/>, so an instance gates one handoff.
-/// </summary>
+/// <summary>Pairs an emitted item with a release handle and completes the producer's task when the handle is disposed.</summary>
 [System.Diagnostics.DebuggerDisplay("Continuation: Locked = {_locked}, CompletedPhases = {CompletedPhases}")]
 public class Continuation : IDisposable
 {
-    /// <summary>The two-participant barrier that synchronizes phases between the gate holder and its continuation.</summary>
-    private readonly Barrier _phaseSync = new(2);
+    /// <summary>Serializes changes to the current handoff.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>The most recently acquired handoff.</summary>
+    private Phase? _phase;
+
+    /// <summary>The number of handoffs whose delivery and release have both completed.</summary>
+    private long _completedPhases;
 
     /// <summary>One once this instance has been disposed; otherwise zero.</summary>
     private int _disposedValue;
@@ -23,91 +23,161 @@ public class Continuation : IDisposable
     /// <summary>One while the continuation is locked; otherwise zero.</summary>
     private int _locked;
 
-    /// <summary>Gets the number of barrier phases that have completed.</summary>
-    public long CompletedPhases => _phaseSync.CurrentPhaseNumber;
+    /// <summary>Whether managed disposal has been requested.</summary>
+    private bool _managedDisposed;
 
-    /// <summary>Releases the gate, completing the task returned by <see cref="Lock{T}"/>, and tears down the barrier.</summary>
+    /// <summary>Gets the number of handoffs whose delivery and release have both completed.</summary>
+    public long CompletedPhases
+    {
+        get
+        {
+            lock (_gate)
+            {
+                return _completedPhases;
+            }
+        }
+    }
+
+    /// <summary>Releases the active handoff and disposes the continuation.</summary>
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }
 
-    /// <summary>
-    /// Takes the gate and hands <paramref name="item"/> to <paramref name="observer"/> paired with this instance as the
-    /// release handle. A call made while the gate is held emits nothing.
-    /// </summary>
+    /// <summary>Emits an item paired with this release handle, or drops the item while another handoff holds the gate.</summary>
     /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
     /// <param name="item">The item handed to the observer.</param>
     /// <param name="observer">The observer receiving the item and its release handle; ignored when <see langword="null"/>.</param>
-    /// <returns>
-    /// A <see cref="Task" /> that completes once the release handle is disposed, or a completed task when the gate was
-    /// held.
-    /// </returns>
+    /// <returns>A task completed after delivery and release, or a completed task when the item was dropped.</returns>
     public Task Lock<T>(T item, IObserver<(T Value, IDisposable Sync)>? observer)
     {
-        if (Interlocked.Exchange(ref _locked, 1) != 0)
+        var phase = TryBeginPhase();
+        if (phase is null)
         {
             return Task.CompletedTask;
         }
 
         observer?.OnNext((item, this));
-        return ScheduleSignalPhase();
+        CompleteDelivery(phase);
+        return phase.Completion.Task;
     }
 
-    /// <summary><see cref="ValueTask"/>-returning counterpart to <see cref="Lock{T}"/>, for call sites that await the result exactly once.</summary>
+    /// <summary>Emits an item with this release handle and returns a value task for its handoff.</summary>
     /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
     /// <param name="item">The item handed to the observer.</param>
     /// <param name="observer">The observer receiving the item and its release handle; ignored when <see langword="null"/>.</param>
-    /// <returns>A <see cref="ValueTask"/> that completes once the release handle is disposed, or a completed task when the gate was held.</returns>
+    /// <returns>A value task completed after delivery and release, or a completed value task when the item was dropped.</returns>
     public ValueTask LockValueTask<T>(T item, IObserver<(T Value, IDisposable Sync)>? observer)
     {
-        if (Interlocked.Exchange(ref _locked, 1) != 0)
+        var handoff = Lock(item, observer);
+        return ReferenceEquals(handoff, Task.CompletedTask) ? default : new(handoff);
+    }
+
+    /// <summary>Releases the current handoff; repeated releases have no effect.</summary>
+    /// <returns>The handoff task, completed once its delivery has returned.</returns>
+    internal Task UnLock()
+    {
+        var completion = Task.CompletedTask;
+        lock (_gate)
         {
-            return default;
+            if (_locked != 0)
+            {
+                _locked = 0;
+                var phase = _phase!;
+                phase.Released = true;
+                TryCompletePhase(phase);
+                completion = phase.Completion.Task;
+            }
         }
 
-        observer?.OnNext((item, this));
-        return new(ScheduleSignalPhase());
+        return completion;
     }
 
-    /// <summary>Releases the gate and signals the barrier phase; a no-op when the gate is not held.</summary>
-    /// <returns>A <see cref="Task"/> that completes once the barrier phase is signalled.</returns>
-    internal Task UnLock() =>
-        Interlocked.Exchange(ref _locked, 0) == 0 ? Task.CompletedTask : ScheduleSignalPhase();
+    /// <summary>Acquires a new handoff while the gate is free.</summary>
+    /// <returns>The acquired handoff, or null when another handoff holds the gate.</returns>
+    internal Phase? TryBeginPhase()
+    {
+        lock (_gate)
+        {
+            if (_locked != 0)
+            {
+                return null;
+            }
+
+            _locked = 1;
+            _phase = new(_managedDisposed);
+            return _phase;
+        }
+    }
+
+    /// <summary>Records delivery completion and completes a handoff that has already been released.</summary>
+    /// <param name="phase">The handoff whose observer callback returned.</param>
+    internal void CompleteDelivery(Phase phase)
+    {
+        lock (_gate)
+        {
+            phase.Delivered = true;
+            TryCompletePhase(phase);
+        }
+    }
 
-    /// <summary>Releases unmanaged and - optionally - managed resources.</summary>
+    /// <summary>Releases the resources held by this continuation.</summary>
     /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage(
-        "Concurrency",
-        "SST1905:Do not use async void",
-        Justification =
-            "The disposal-pattern overload must return void, and no caller is positioned to observe the awaited barrier teardown.")]
-    protected virtual async void Dispose(bool disposing)
+    protected virtual void Dispose(bool disposing)
+    {
+        lock (_gate)
+        {
+            if (_disposedValue != 0)
+            {
+                return;
+            }
+
+            _disposedValue = 1;
+            if (!disposing)
+            {
+                return;
+            }
+
+            _managedDisposed = true;
+        }
+
+        _ = UnLock();
+    }
+
+    /// <summary>Completes a released delivery once, or faults a handoff acquired after disposal.</summary>
+    /// <param name="phase">The handoff to complete.</param>
+    private void TryCompletePhase(Phase phase)
     {
-        if (Interlocked.Exchange(ref _disposedValue, 1) != 0 || !disposing)
+        if (phase.IsDisposed)
         {
+            _ = phase.Completion.TrySetException(new ObjectDisposedException(nameof(Continuation)));
             return;
         }
 
-        await UnLock().ConfigureAwait(false);
-        _phaseSync.Dispose();
+        if (!phase.Delivered || !phase.Released || phase.Completion.Task.IsCompleted)
+        {
+            return;
+        }
+
+        _completedPhases++;
+        phase.Completion.SetResult(true);
     }
 
-    /// <summary>Signals the phase barrier and waits there for the paired participant.</summary>
-    /// <param name="state">The owning <see cref="Continuation"/> instance.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void SignalPhaseSync(object? state) =>
-        ((Continuation)state!)._phaseSync.SignalAndWait(CancellationToken.None);
-
-    /// <summary>Runs the barrier signal on the default task scheduler.</summary>
-    /// <returns>The task for the scheduled signal work.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private Task ScheduleSignalPhase() =>
-        Task.Factory.StartNew(
-            SignalPhaseSync,
-            this,
-            CancellationToken.None,
-            TaskCreationOptions.DenyChildAttach,
-            TaskScheduler.Default);
+    /// <summary>Tracks delivery and release for one acquired handoff.</summary>
+    /// <param name="isDisposed">True when the handoff was acquired after managed disposal.</param>
+    internal sealed class Phase(bool isDisposed)
+    {
+        /// <summary>Gets the completion shared by the delivery and release participants.</summary>
+        internal TaskCompletionSource<bool> Completion { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        /// <summary>Gets a value indicating whether the handoff was acquired after managed disposal.</summary>
+        internal bool IsDisposed { get; } = isDisposed;
+
+        /// <summary>Gets or sets a value indicating whether the observer callback returned.</summary>
+        internal bool Delivered { get; set; }
+
+        /// <summary>Gets or sets a value indicating whether the handoff was released.</summary>
+        internal bool Released { get; set; }
+    }
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs b/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
index 849d22c4..899b4994 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/CurrentValueSubject.cs
@@ -18,7 +18,7 @@ public sealed class CurrentValueSubject<T> : IObservable<T>, IObserver<T>, IDisp
     /// <summary>Single-observer fast path; non-null when exactly one observer is subscribed.</summary>
     private IObserver<T>? _observer;
 
-    /// <summary>Multi-observer snapshot; non-null when two or more observers are subscribed. Copy-on-write.</summary>
+    /// <summary>The observer snapshot, copied on modification and populated when at least two observers subscribe.</summary>
     private IObserver<T>[]? _observers;
 
     /// <summary>Latest value, replayed to new subscribers.</summary>
@@ -253,7 +253,6 @@ private void Unsubscribe(IObserver<T> observer)
 
             if (existing.Length == 2)
             {
-                // Collapse back to the single-observer fast path.
                 _observer = index == 0 ? existing[1] : existing[0];
                 _observers = null;
                 return;
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
index 1b488707..f4d65e49 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/FirstAsValueTaskHelper.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// <see cref="ValueTask{T}"/>-returning counterpart to <see cref="FirstAsTaskHelper"/>. The returned value task is
-/// backed by a pooled <see cref="IValueTaskSource{T}"/>, so each one must be consumed exactly once: awaiting it twice,
-/// or reading its result after the backing instance returns to the pool, observes another caller's outcome.
-/// </summary>
+/// <summary>Returns the first source value as a ValueTask that must be consumed exactly once.</summary>
 /// <typeparam name="T">The element type.</typeparam>
 public static class FirstAsValueTaskHelper<T>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs b/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
index a27b1f82..6a250276 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Heartbeat.cs
@@ -4,12 +4,9 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Carries either a heartbeat tick or a value update from an observable sequence. <c>default(Heartbeat&lt;T&gt;)</c> is a
-/// value update holding the default <typeparamref name="T"/>; construct a heartbeat tick with
-/// <c>new Heartbeat&lt;T&gt;()</c>.
-/// </summary>
+/// <summary>Represents either a heartbeat tick or a value update.</summary>
 /// <typeparam name="T">The type of the update value.</typeparam>
+/// <remarks>The default struct value is an update containing the default T; the parameterless constructor creates a heartbeat tick.</remarks>
 [System.Diagnostics.DebuggerDisplay("Heartbeat: IsHeartbeat = {IsHeartbeat}, Update = {Update}")]
 public readonly record struct Heartbeat<T> : IHeartbeat<T>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
index 8e26104b..2fb07655 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Internal/ReduceSinkState.cs
@@ -44,7 +44,7 @@ public ReduceSinkState(IObserver<TOut> downstream, int count)
     /// <summary>Gets a value indicating whether every source has produced at least one value.</summary>
     internal bool AllValuesPresent => HasValueCount >= Values.Length;
 
-    /// <summary>Records source <paramref name="index"/>'s latest value and emits the reduced result once every source has one. Runs under the gate.</summary>
+    /// <summary>Records the source value and emits the reduction once every source has a value, while the caller holds the gate.</summary>
     /// <param name="index">The 0-based source index that emitted.</param>
     /// <param name="value">The latest value from that source.</param>
     /// <param name="reduce">Projects the per-source latest values into the downstream result.</param>
@@ -73,7 +73,7 @@ internal void HandleNext(int index, TIn value, Func<TIn?[], TOut> reduce)
         }
     }
 
-    /// <summary>Forwards a terminal error to the downstream observer and marks the sink terminal. Idempotent.</summary>
+    /// <summary>Forwards the first terminal error and marks the sink terminal.</summary>
     /// <param name="error">The error to forward.</param>
     internal void HandleError(Exception error)
     {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
index 15247b6f..9e81b438 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BinaryMinMaxObservable.cs
@@ -7,15 +7,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits the larger or smaller of the latest values from two sources, starting once both have produced one. An error
-/// from either source terminates the sequence; completion waits for both sources, or fires as soon as one completes
-/// without having emitted.
-/// </summary>
+/// <summary>Emits the larger or smaller latest value after both sources have emitted.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="left">The first source.</param>
 /// <param name="right">The second source.</param>
 /// <param name="emitMaximum"><c>true</c> to emit the maximum; <c>false</c> to emit the minimum.</param>
+/// <remarks>An error terminates immediately; successful completion waits for both sources unless one completes without emitting.</remarks>
 [System.Diagnostics.DebuggerDisplay("BinaryMinMaxObservable: Left = {_left}, Right = {_right}")]
 public sealed class BinaryMinMaxObservable<T>(IObservable<T> left, IObservable<T> right, bool emitMaximum) : IObservable<T>
     where T : struct, IComparable<T>
@@ -68,7 +65,7 @@ private sealed class Sink(IObserver<T> downstream, bool emitMaximum)
 
         /// <summary>Records one side's latest value and emits the winning comparison once both sides have a value.</summary>
         /// <param name="isLeft"><c>true</c> for the left source.</param>
-        /// <param name="value">The value.</param>
+        /// <param name="value">That side's latest value.</param>
         public void OnNext(bool isLeft, T value)
         {
             lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
index 24cd7c7c..a9a210e3 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BooleanReduceObservable.cs
@@ -8,13 +8,13 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits whether every source's latest boolean equals <paramref name="target"/>, re-evaluating on each value once all
-/// sources have produced one. An empty source list emits <c>true</c> and completes on subscribe; any source's error
-/// terminates the sequence, and the sequence completes when every source completes or one completes without emitting.
-/// </summary>
+/// <summary>Emits whether every latest source value equals the target, starting after every source has emitted.</summary>
 /// <param name="sources">The source observables.</param>
 /// <param name="target">The value every source must hold for the operator to emit <c>true</c>.</param>
+/// <remarks>
+/// Empty input emits true and completes. An error terminates immediately; otherwise completion waits for all sources unless one completes
+/// without emitting.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("BooleanReduceObservable: Sources = {_sourceList}")]
 public sealed class BooleanReduceObservable(IEnumerable<IObservable<bool>> sources, bool target) : IObservable<bool>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
index 13f90a05..ba52c0a3 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/BufferUntilObservable.cs
@@ -7,11 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Buffers characters from <paramref name="startsWith"/> through <paramref name="endsWith"/> inclusive and emits each
-/// delimited run as one string, discarding characters outside a run. Completion flushes a run whose end delimiter never
-/// arrived.
-/// </summary>
+/// <summary>Emits strings delimited by startsWith and endsWith, including both delimiters and flushing an unfinished string on completion.</summary>
 /// <param name="source">The source observable of characters.</param>
 /// <param name="startsWith">The starting delimiter.</param>
 /// <param name="endsWith">The ending delimiter.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
index f132df7d..daa7afb9 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchAndReturnWithFactoryObservable.cs
@@ -6,15 +6,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Catches <typeparamref name="TException"/>, emits a fallback built from it, and completes. Other exception types
-/// propagate unchanged, and an exception thrown by <paramref name="fallbackFactory"/> terminates the sequence in place
-/// of the caught one.
-/// </summary>
+/// <summary>Replaces matching errors with a factory-produced fallback value and completes.</summary>
 /// <typeparam name="T">Element type.</typeparam>
 /// <typeparam name="TException">Exception type to catch.</typeparam>
 /// <param name="source">Upstream source.</param>
 /// <param name="fallbackFactory">Builds the fallback from the caught exception.</param>
+/// <remarks>Other error types propagate unchanged; a fallback factory failure replaces the caught error.</remarks>
 public sealed class CatchAndReturnWithFactoryObservable<T, TException>(
     IObservable<T> source,
     Func<TException, T> fallbackFactory) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
index 02e171cf..31f422a5 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/CatchIgnoreObservable.cs
@@ -6,14 +6,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Catches <typeparamref name="TException"/>, hands it to <paramref name="errorAction"/> and completes. Other exception
-/// types propagate unchanged, and an exception thrown by the action terminates the sequence in place of the caught one.
-/// </summary>
+/// <summary>Passes matching errors to the action and completes.</summary>
 /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
 /// <typeparam name="TException">The type of the exception to catch.</typeparam>
 /// <param name="source">The source observable sequence.</param>
 /// <param name="errorAction">Action to invoke when an exception of type <typeparamref name="TException"/> occurs.</param>
+/// <remarks>Other error types propagate unchanged; an action failure replaces the caught error.</remarks>
 [System.Diagnostics.DebuggerDisplay("CatchIgnoreObservable: Source = {_source}, ErrorAction = {_errorAction}")]
 public sealed class CatchIgnoreObservable<TSource, TException>(
     IObservable<TSource> source,
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
index 0a31b029..f15e3d74 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/DropIfBusyObservable.cs
@@ -6,13 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Runs <paramref name="asyncAction"/> for each source value and forwards the value once it finishes, dropping every
-/// value that arrives while an action is in flight. An exception from the action terminates the sequence.
-/// </summary>
+/// <summary>Runs the action before forwarding each value, dropping values received while the action is running.</summary>
 /// <typeparam name = "T">The element type.</typeparam>
 /// <param name = "source">The source observable.</param>
 /// <param name = "asyncAction">The asynchronous action to execute for each forwarded element.</param>
+/// <remarks>An action failure terminates the sequence.</remarks>
 public sealed class DropIfBusyObservable<T>(IObservable<T> source, Func<T, ValueTask> asyncAction) : IObservable<T>
 {
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
index 80bbdab0..687f2c3e 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FilterRegexObservable.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Forwards the source strings that <paramref name="regex"/> matches, dropping non-matches and nulls. An exception
-/// raised while matching, such as a regex timeout, terminates the sequence.
-/// </summary>
+/// <summary>Forwards non-null strings that match the regex and terminates on matching errors.</summary>
 /// <param name="source">The source observable emitting strings.</param>
 /// <param name="regex">The regex to use for filtering.</param>
 public sealed class FilterRegexObservable(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
index 2e3d981a..8f6150a3 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/FirstMatchFromCandidatesObservable.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projects candidates sequentially and emits the first transformed value satisfying the predicate.
-/// Projection errors skip the candidate. If none matches, emits the fallback value and completes.
-/// </summary>
+/// <summary>Projects candidates sequentially, skipping projection errors, and emits the first matching transformed value or the fallback.</summary>
 /// <typeparam name="TKey">The type of candidate keys.</typeparam>
 /// <typeparam name="TRaw">The element type emitted by the projected observable.</typeparam>
 /// <typeparam name="TResult">The final result type emitted to downstream after transformation.</typeparam>
@@ -19,7 +16,9 @@ namespace ReactiveUI.Primitives.Extensions.Operators;
 /// <param name="transform">Synchronous transform applied to each raw value to produce the result.</param>
 /// <param name="predicate">Returns <see langword="true"/> when a transformed value is a match.</param>
 /// <param name="fallback">Value emitted when no candidate matches.</param>
-/// <remarks>A projection that completes synchronously runs on the subscribing thread; one that does not keeps the walk alive until its callbacks arrive.</remarks>
+/// <remarks>
+/// Synchronous projections run on the subscribing thread; asynchronous projections continue the candidate search from their callbacks.
+/// </remarks>
 public sealed class FirstMatchFromCandidatesObservable<TKey, TRaw, TResult>(
     IReadOnlyList<TKey> candidates,
     Func<TKey, IObservable<TRaw>> project,
@@ -240,7 +239,6 @@ public void OnError(Exception error)
 
             if (_looping)
             {
-                // The walk in TryNext reads this terminal notification off the probe instead.
                 return;
             }
 
@@ -262,7 +260,6 @@ public void OnCompleted()
 
             if (_looping)
             {
-                // The walk in TryNext reads this terminal notification off the probe instead.
                 return;
             }
 
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
index 072f4781..b1302541 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/MinMaxObservable.cs
@@ -8,14 +8,14 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits the maximum or minimum of the latest values from every source, re-evaluating on each value once all sources
-/// have produced one. An empty source list completes on subscribe; any source's error terminates the sequence, and the
-/// sequence completes when every source completes or one completes without emitting.
-/// </summary>
+/// <summary>Emits the minimum or maximum latest value after every source has emitted.</summary>
 /// <typeparam name="T">The value type.</typeparam>
 /// <param name="sources">The source observables.</param>
 /// <param name="emitMaximum"><c>true</c> to emit the maximum; <c>false</c> to emit the minimum.</param>
+/// <remarks>
+/// Empty input completes immediately. An error terminates immediately; otherwise completion waits for all sources unless one completes without
+/// emitting.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("MinMaxObservable: Sources = {_sourceList.Count}")]
 public sealed class MinMaxObservable<T>(IReadOnlyList<IObservable<T>> sources, bool emitMaximum) : IObservable<T>
     where T : struct, IComparable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
index 6efebca2..d6a352d6 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
@@ -8,12 +8,9 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Splits a sequence into a <see cref="True"/> and a <see cref="False"/> side by predicate. Both sides share one
-/// subscription to the source, opened when the first side is subscribed and released when the last subscription is
-/// disposed; each value reaches one side only, while an error or completion reaches both.
-/// </summary>
+/// <summary>Partitions values by predicate into two outputs that share a source subscription.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <remarks>The first subscriber connects and the last disposal disconnects; terminal notifications reach both outputs.</remarks>
 [System.Diagnostics.DebuggerDisplay("PartitionObservable: Source = {_source}, Subscriptions = {_subscriptionCount}")]
 public sealed class PartitionObservable<T>
 {
@@ -106,12 +103,10 @@ public void Dispose()
 
             lock (_parent._gate)
             {
-                // Subscribe assigns the sink under this lock before returning the handle.
                 _parent._sink!.Remove(_observer, _side);
                 _parent._subscriptionCount--;
                 if (_parent._subscriptionCount == 0)
                 {
-                    // Set alongside the sink under this same lock, so the last disposal finds it non-null.
                     _parent._sourceSubscription!.Dispose();
                     _parent._sourceSubscription = null;
                     _parent._sink = null;
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
index 87381ba5..aa73d652 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ReplayLastOnSubscribeObservable.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits the fixed initial value to each subscriber, then subscribes independently to the source.
-/// Late subscribers receive that initial value, not a cached source emission.
-/// </summary>
+/// <summary>Emits the fixed initial value to each subscriber before subscribing independently to the source.</summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="initialValue">The initial value emitted to every new subscriber.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
index 27dcfb83..dd9c47c3 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SampleLatestObservable.cs
@@ -7,14 +7,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Emits the source's latest value each time <paramref name="trigger"/> fires, repeating it when no newer value has
-/// arrived and emitting nothing until the source produces its first. An error from either sequence terminates the
-/// result; the source's completion completes it, while the trigger's completion is ignored.
-/// </summary>
+/// <summary>Emits the latest source value on each trigger after the source first emits.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="trigger">The trigger observable.</param>
+/// <remarks>Source completion or either error terminates the result; trigger completion is ignored.</remarks>
 public sealed class SampleLatestObservable<T>(
     IObservable<T> source,
     IObservable<object> trigger) : IObservable<T>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
index ed7f452b..ee7dccdb 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ScanWithInitialObservable.cs
@@ -6,10 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Emits <paramref name="initial"/> on subscribe, then the running accumulation after each source element. An exception
-/// thrown by <paramref name="accumulator"/> terminates the sequence and the accumulation stops there.
-/// </summary>
+/// <summary>Emits the initial value followed by each accumulation result, terminating if the accumulator throws.</summary>
 /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name="TAccumulate">The type of the accumulated value.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
index 2e87fd00..2d044e72 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncConcurrentObservable.cs
@@ -5,16 +5,13 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projects each element through an asynchronous selector with at most <paramref name="maxConcurrency"/> operations in
-/// flight and queues the rest, so results arrive in completion order rather than source order. The first selector
-/// failure terminates the sequence, and the source's completion is held back until the queue drains.
-/// </summary>
+/// <summary>Queues asynchronous projections with bounded concurrency and emits results in completion order.</summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
 /// <param name = "selector">The asynchronous projection function.</param>
 /// <param name = "maxConcurrency">The maximum number of concurrent operations.</param>
+/// <remarks>Selector failure terminates immediately; source completion waits for queued projections to finish.</remarks>
 public sealed class SelectAsyncConcurrentObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector, int maxConcurrency) : IObservable<TResult>
 {
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
index cee3b71a..8bd0afcb 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectAsyncSequentialObservable.cs
@@ -5,15 +5,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projects each element through an asynchronous selector one operation at a time, queueing values that arrive while an
-/// operation runs so results keep source order. The first selector failure terminates the sequence, and the source's
-/// completion waits for the queue to drain.
-/// </summary>
+/// <summary>Queues asynchronous projections and emits results in source order.</summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
 /// <param name = "selector">The asynchronous projection function.</param>
+/// <remarks>Selector failure terminates immediately; source completion waits for queued projections to finish.</remarks>
 public sealed class SelectAsyncSequentialObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector) : IObservable<TResult>
 {
     /// <inheritdoc/>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
index 47ad790a..13c21c62 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectConstantObservable.cs
@@ -23,7 +23,7 @@ public IDisposable Subscribe(IObserver<TResult> observer)
         return source.Subscribe(new SelectConstantWitness(observer, constant));
     }
 
-    /// <summary>Forwarding observer that replaces every <see cref="OnNext"/> value with the stored constant. Error and completion signals pass through unchanged.</summary>
+    /// <summary>Replaces values with the stored constant and forwards terminal notifications unchanged.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="constant">The constant value to emit.</param>
     private sealed class SelectConstantWitness(IObserver<TResult> downstream, TResult constant) : IObserver<TSource>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
index 219328db..17011d25 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectLatestAsyncObservable.cs
@@ -5,15 +5,12 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projects each element through an asynchronous selector and emits only the latest projection's result. A superseded
-/// operation keeps running but its result and its failure are both discarded, and the source's completion is deferred
-/// until the latest projection finishes.
-/// </summary>
+/// <summary>Emits only the latest asynchronous projection, discarding superseded results and errors.</summary>
 /// <typeparam name = "TSource">The type of elements in the source sequence.</typeparam>
 /// <typeparam name = "TResult">The type of the result of the asynchronous operation.</typeparam>
 /// <param name = "source">The source observable.</param>
 /// <param name = "selector">The asynchronous projection function.</param>
+/// <remarks>Superseded operations continue running; source completion waits for the latest projection.</remarks>
 public sealed class SelectLatestAsyncObservable<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector) : IObservable<TResult>
 {
     /// <inheritdoc/>
@@ -91,7 +88,7 @@ public void OnCompleted()
                 return;
             }
 
-            _ = toAwait.ContinueWith(static (_, s) => ((SelectLatestAsyncSink)s!).SignalCompleted(), this, TaskScheduler.Default);
+            RegisterCompletion(toAwait, this);
         }
 
         /// <inheritdoc/>
@@ -143,6 +140,14 @@ internal void SignalCompleted()
             }
         }
 
+        /// <summary>Registers completion delivery for the pending projection.</summary>
+        /// <param name="task">The pending projection.</param>
+        /// <param name="sink">The completion recipient.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static void RegisterCompletion(Task task, SelectLatestAsyncSink sink) =>
+            _ = task.ContinueWith(static (_, state) => ((SelectLatestAsyncSink)state!).SignalCompleted(), sink, TaskScheduler.Default);
+
         /// <summary>Awaits the selector and emits or faults only while this operation is the latest one.</summary>
         /// <param name = "value">The value to project.</param>
         /// <param name = "id">The ID of this operation.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
index 222b2a3e..e52ffd7d 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SelectManyThenObservable.cs
@@ -6,17 +6,14 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Projects each source element through <paramref name="first"/> and each intermediate element through
-/// <paramref name="second"/>, emitting the second stage's values. An exception from either projection terminates the
-/// sequence, and the first inner sequence to complete completes the result.
-/// </summary>
+/// <summary>Projects each source value through two successive observable selectors and forwards the second-stage values.</summary>
 /// <typeparam name="TSource">The source element type.</typeparam>
 /// <typeparam name="TMid">The intermediate element type produced by the first projection.</typeparam>
 /// <typeparam name="TResult">The final element type produced by the second projection.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="first">First projection: source element → intermediate observable.</param>
 /// <param name="second">Second projection: intermediate element → result observable.</param>
+/// <remarks>A selector failure terminates the sequence; the first inner completion completes the result.</remarks>
 public sealed class SelectManyThenObservable<TSource, TMid, TResult>(
     IObservable<TSource> source,
     Func<TSource, IObservable<TMid>> first,
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
index bb74a950..43c2e539 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/ShuffleObservable.cs
@@ -7,10 +7,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Reorders each array the source emits in place with non-cryptographic randomness and forwards that same instance, so
-/// any other holder of the array sees the new order. A null array is forwarded untouched.
-/// </summary>
+/// <summary>Shuffles each array in place with non-cryptographic randomness and forwards the same instance, passing null through unchanged.</summary>
 /// <typeparam name="T">The array element type.</typeparam>
 /// <param name="source">The source observable emitting arrays.</param>
 public sealed class ShuffleObservable<T>(IObservable<T[]> source) : IObservable<T[]>
@@ -48,11 +45,7 @@ public void OnNext(T[] value)
                 return;
             }
 
-#if NET8_0_OR_GREATER
-            Random.Shared.Shuffle(value);
-#else
             ShuffleInPlace(value);
-#endif
 
             downstream.OnNext(value);
         }
@@ -65,24 +58,28 @@ public void OnNext(T[] value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnCompleted() => downstream.OnCompleted();
 
-#if !NET8_0_OR_GREATER
-        /// <summary>Fisher-Yates over a per-thread <see cref="Random"/> for targets without <c>Random.Shuffle</c>.</summary>
+        /// <summary>Randomly reorders the array in place.</summary>
         /// <param name="array">The array to shuffle in place.</param>
+#if NET8_0_OR_GREATER
+        [ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ShuffleInPlace(T[] array) => Random.Shared.Shuffle(array);
+#else
         private static void ShuffleInPlace(T[] array)
         {
-            var random = _threadRandom;
-            if (random is null)
-            {
-                random = new();
-                _threadRandom = random;
-            }
-
             for (var n = array.Length - 1; n > 0; n--)
             {
-                var k = random.Next(n + 1);
+                var k = NextIndex(n + 1);
                 (array[n], array[k]) = (array[k], array[n]);
             }
         }
+
+        /// <summary>Returns a random index below the exclusive bound.</summary>
+        /// <param name="exclusiveUpperBound">The exclusive upper bound.</param>
+        /// <returns>A nonnegative index below the bound.</returns>
+        [ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int NextIndex(int exclusiveUpperBound) => (_threadRandom ??= new()).Next(exclusiveUpperBound);
 #endif
     }
 }
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
index b4d9a622..ff15651d 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SubscribeAsyncObservable.cs
@@ -6,12 +6,11 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Subscribes to a source and runs an asynchronous handler for each element, one at a time, queueing values that arrive
-/// while a handler runs. A handler failure goes to the error callback and stops further processing; the completion
-/// callback runs once the queue drains after the source completes, and disposal drops the subscription and the queue.
-/// </summary>
+/// <summary>Queues source values and invokes the asynchronous handler one value at a time.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <remarks>
+/// Handler failure invokes the error callback and stops processing. Completion waits for queued values; disposal drops them and unsubscribes.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("SubscribeAsyncObservable: Queued = {_queue.Count}, Processing = {_isProcessing}, Done = {_done}")]
 public sealed class SubscribeAsyncObservable<T> : IDisposable
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
index d5924f09..f9f096d0 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SwitchIfEmptyObservable.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Forwards the source's values, and when the source completes without having emitted any, subscribes
-/// <paramref name="fallback"/> and forwards that sequence instead. A source error propagates without the fallback being
-/// tried.
-/// </summary>
+/// <summary>Subscribes to the fallback only when the source completes without emitting, propagating source errors unchanged.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="fallback">The fallback observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
index eecb42ab..70c54aaf 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/SynchronizeAsyncObservable.cs
@@ -6,12 +6,10 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Forwards each source value paired with a fresh disposable handle the consumer disposes to acknowledge it. Each value
-/// carries its own handle, and a handle left undisposed leaves only its own acknowledgement wait outstanding.
-/// </summary>
+/// <summary>Pairs each source value with an independent disposable acknowledgement handle.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
+/// <remarks>An undisposed handle leaves only its own acknowledgement pending.</remarks>
 public sealed class SynchronizeAsyncObservable<T>(IObservable<T> source) : IObservable<(T Value, IDisposable Sync)>
 {
     /// <inheritdoc/>
@@ -39,7 +37,7 @@ internal sealed class SynchronizeAsyncSink(IObserver<(T Value, IDisposable Sync)
         private bool _disposed;
 
         /// <inheritdoc/>
-        /// <param name="value">The value.</param>
+        /// <param name="value">The value to forward.</param>
         public void OnNext(T value)
         {
             lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
index 86cd9e05..366203c1 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TakeUntilInclusiveObservable.cs
@@ -4,10 +4,7 @@
 
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
-/// <summary>
-/// Forwards source elements until <paramref name="predicate"/> returns <see langword="true"/>, emits that element too,
-/// then completes. An exception from the predicate terminates the sequence before that element is emitted.
-/// </summary>
+/// <summary>Emits values through the first predicate match and completes, terminating before emission if the predicate throws.</summary>
 /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
 /// <param name="source">The source observable.</param>
 /// <param name="predicate">The predicate to determine when to stop taking elements.</param>
@@ -39,7 +36,7 @@ private sealed class TakeUntilInclusiveWitness(
         private bool _done;
 
         /// <inheritdoc/>
-        /// <param name="value">The value.</param>
+        /// <param name="value">The value to forward.</param>
         public void OnNext(T value)
         {
             lock (_gate)
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
index fa5c7138..970abe44 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/TrySelectObservable.cs
@@ -24,7 +24,7 @@ public IDisposable Subscribe(IObserver<TOut> observer)
         return source.Subscribe(new TrySelectWitness(observer, selector));
     }
 
-    /// <summary>Observer that applies the selector and only forwards non-null results. Exceptions from the selector are routed to <see cref="IObserver{T}.OnError"/>.</summary>
+    /// <summary>Projects values and forwards non-null results, reporting selector exceptions through OnError.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="selector">The projection delegate.</param>
     private sealed class TrySelectWitness(
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
index 66c49651..60f7a5c0 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/WaitUntilObservable.cs
@@ -7,9 +7,7 @@
 namespace ReactiveUI.Primitives.Extensions.Operators;
 
 /// <summary>
-/// Emits the first source value that satisfies <paramref name="predicate"/>, completes, and disposes the source
-/// subscription. An exception from the predicate terminates the sequence, and the source completing first ends the
-/// sequence without a value.
+/// Emits the first predicate match and completes, propagating predicate failures and completing without a value if the source ends first.
 /// </summary>
 /// <typeparam name="T">The element type of the source observable.</typeparam>
 /// <param name="source">The source observable.</param>
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs b/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
index 4563c921..f7a94a83 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Stale.cs
@@ -4,12 +4,12 @@
 
 namespace ReactiveUI.Primitives.Extensions;
 
-/// <summary>
-/// Carries either a staleness signal or a value update from an observable sequence. <c>default(Stale&lt;T&gt;)</c> is a
-/// value update holding the default <typeparamref name="T"/>; construct a staleness signal with
-/// <c>new Stale&lt;T&gt;()</c>, and read <see cref="Update"/> only when <see cref="IsStale"/> is <see langword="false"/>.
-/// </summary>
+/// <summary>Represents either a staleness notification or a value update.</summary>
 /// <typeparam name="T">The type of the update value.</typeparam>
+/// <remarks>
+/// The default struct value is an update containing the default T; the parameterless constructor creates a staleness notification. Read Update
+/// only when IsStale is false.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("Stale: IsStale = {IsStale}")]
 public readonly record struct Stale<T> : IStale<T>
 {
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
index ec8bf461..c319844e 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/TimerSinkState.cs
@@ -24,7 +24,7 @@ public sealed class TimerSinkState<T>(IObserver<T> downstream)
     /// <summary>Gets a value indicating whether the sink has terminated through error, completion or disposal; read it under the owning sink's gate.</summary>
     public bool Done { get; private set; }
 
-    /// <summary>Forwards a terminal error to the downstream observer and tears the sink down. The caller must hold the sink's gate.</summary>
+    /// <summary>Forwards an error and disposes the sink while the caller holds its gate.</summary>
     /// <param name="error">The error to forward.</param>
     public void HandleErrorLocked(Exception error)
     {
@@ -38,7 +38,7 @@ public void HandleErrorLocked(Exception error)
         downstream.OnError(error);
     }
 
-    /// <summary>Forwards completion to the downstream observer and tears the sink down. The caller must hold the sink's gate.</summary>
+    /// <summary>Forwards completion and disposes the sink while the caller holds its gate.</summary>
     public void HandleCompletedLocked()
     {
         if (Done)
@@ -51,7 +51,7 @@ public void HandleCompletedLocked()
         downstream.OnCompleted();
     }
 
-    /// <summary>Marks the sink terminal and disposes the timer without forwarding a notification. The caller must hold the sink's gate.</summary>
+    /// <summary>Marks the sink terminal and disposes its timer without notification, while the caller holds its gate.</summary>
     public void HandleDisposeLocked()
     {
         Done = true;
diff --git a/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs b/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
index c159f795..ebb5e1ae 100644
--- a/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Maui.Reactive/Concurrency/MauiDispatcherSequencer.cs
@@ -8,9 +8,7 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>MAUI dispatcher scheduler that coalesces scheduled work through an <see cref="IDispatcher"/>.</summary>
-/// <remarks>Work runs on the dispatcher's thread. Delayed work goes to the dispatcher's own delayed dispatch, which
-/// cannot be called off once armed, so disposing the returned subscription suppresses the action without cancelling
-/// the delay.</remarks>
+/// <remarks>Callbacks run on the dispatcher thread; cancellation suppresses delayed actions without cancelling the underlying delay.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("MauiDispatcherSequencer: Dispatcher = {Dispatcher}")]
 public sealed class MauiDispatcherSequencer : CoalescingDispatchScheduler
@@ -32,7 +30,7 @@ protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTim
     {
         _ = Dispatcher.DispatchDelayed(dueTime, work);
 
-        // The dispatcher hands back no handle for an armed delay, so there is nothing to stop here.
+        // Cancelling suppresses delivery while the requested delay remains scheduled.
         return Disposable.Empty;
     }
 }
diff --git a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
index ee33076d..ad7aa548 100644
--- a/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Maui/Concurrency/MauiDispatcherSequencer.cs
@@ -9,9 +9,10 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>MAUI dispatcher sequencer that coalesces scheduled work through an <see cref="IDispatcher"/>.</summary>
-/// <remarks>Work runs on the dispatcher's thread, one batch per posted drain; scheduling from that thread queues the
-/// item for the next drain rather than running it inline. Delayed work goes to the dispatcher's own delayed dispatch,
-/// which cannot be called off once armed, so a cancelled item is skipped when the delay elapses.</remarks>
+/// <remarks>
+/// Callbacks run in posted dispatcher batches without inline reentrancy; cancellation suppresses delayed actions without cancelling the
+/// underlying delay.
+/// </remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class MauiDispatcherSequencer : ISequencer
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
index 54d95eb6..1a45a377 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/ActivationExtensionsEmitter.cs
@@ -30,7 +30,6 @@ internal static string Emit(ImmutableArray<ActivationModel> models)
         var builder = new PooledStringBuilder(ScaffoldCapacity + (models.Length * OverloadCapacity));
         _ = builder.Append(Constants.GeneratedFileHeader);
 
-        // Every overload was extracted from the same compilation, so they agree on what its language allows.
         if (models[0].SupportsNullableAnnotations)
         {
             _ = builder.Append(Constants.NullableEnableDirective);
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
index 77aa8837..e372a475 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/GeneratedNames.cs
@@ -71,8 +71,7 @@ private static void AppendSanitized(PooledStringBuilder builder, string identity
         var start = 0;
         var end = identity.Length;
 
-        // Leading and trailing punctuation would sanitize to uninformative underscores; the hash separates
-        // identities that differ only there.
+        // Identity differences in leading or trailing punctuation contribute to the generated name.
         while (start < end && !char.IsLetterOrDigit(identity[start]))
         {
             start++;
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
index 6f269ca7..ac04fd50 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/CodeGeneration/PooledStringBuilder.cs
@@ -246,7 +246,6 @@ private void EnsureCapacity(int required)
             return;
         }
 
-        // Doubling unless the caller asked for more outright, so a run of small appends does not re-rent per append.
         var next = RentBuffer(Math.Max(required, _buffer.Length * GrowthFactor));
         Array.Copy(_buffer, next, _position);
         var toReturn = _buffer;
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
index bbc69cf5..c86a26a5 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/EventGenerator.cs
@@ -12,7 +12,7 @@
 namespace ReactiveUI.Primitives.ObservableEvents;
 
 /// <summary>Generates observable wrappers for the event-bearing types a consumer asks for.</summary>
-/// <remarks>Requests come from Events() calls or static-host attributes. Output is cached per host, namespace, and activation signature.</remarks>
+/// <remarks>Requests come from Events() calls or static-host attributes.</remarks>
 [Generator(LanguageNames.CSharp)]
 public sealed class EventGenerator : IIncrementalGenerator
 {
@@ -21,7 +21,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         RegisterActivationOutput(in context);
 
-        // Resolve provider names independently so reference changes do not invalidate event extraction.
         var provider = context.CompilationProvider
             .Select(static (compilation, _) => ProviderResolver.Resolve(compilation))
             .WithTrackingName(GeneratorStepNames.Provider);
@@ -72,7 +71,6 @@ private static void RegisterInstanceOutputs(
             targets.Combine(provider),
             static (output, data) => EmitInstanceTarget(in output, data.Left, data.Right));
 
-        // Keyed on the overload signatures alone, so changing what a wrapper exposes leaves this file untouched.
         context.RegisterSourceOutput(
             targets
                 .Where(static target => !target.Events.IsEmpty)
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
index 8659b6c1..a1c9fdba 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/InstanceTargetExtractor.cs
@@ -71,7 +71,7 @@ private static InstanceTargetModel Create(
         var typeParameterList = SymbolHelpers.BuildTypeParameterList(typeParameters, typeParameterNames);
         var typeReference = SymbolHelpers.Display(host, typeParameterNames, supportsNullableAnnotations);
 
-        // Keyed on the unannotated name, so a generated file does not change identity with the language version.
+        // Generated file identity is independent of nullable annotations.
         var identity = host.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
         var displayName = host.ToDisplayString();
         var namespaceName = host.ContainingNamespace.IsGlobalNamespace
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
index b9a0c997..89e2349b 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/SymbolHelpers.cs
@@ -169,7 +169,6 @@ internal static string EscapeIdentifier(string value) =>
     /// <returns>The escaped text, or the original instance when nothing needed escaping.</returns>
     internal static string EscapeXml(string value)
     {
-        // Most references have nothing to escape, so the scan is what keeps the common case allocation-free.
         if (value.IndexOfAny(XmlSpecialCharacters) < 0)
         {
             return value;
@@ -241,7 +240,7 @@ private static string SelectPrimaryConstraint(ITypeParameterSymbol parameter, bo
 
         if (parameter.HasReferenceTypeConstraint)
         {
-            // Omit referenced nullable constraints when the consumer's language cannot express them.
+            // Generated constraints omit nullable syntax unsupported by the consumer language version.
             return supportsNullableAnnotations
                 && parameter.ReferenceTypeConstraintNullableAnnotation == NullableAnnotation.Annotated
                 ? "class?"
diff --git a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
index 6b8a3ed4..dc7c1796 100644
--- a/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
+++ b/src/ReactiveUI.Primitives.ObservableEvents/Helpers/TargetCollections.cs
@@ -80,7 +80,6 @@ internal static StaticNamespaceModel[] GroupByNamespace(ImmutableArray<StaticTar
                 continue;
             }
 
-            // Every request came out of the same compilation, so they agree on what its language allows.
             supportsNullableAnnotations = target.SupportsNullableAnnotations;
             if (!byNamespace.TryGetValue(target.Namespace, out var events))
             {
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
index 0f6f4fb9..f9d18bf0 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
@@ -4,13 +4,12 @@
 
 using System.Collections.Concurrent;
 using System.Reactive.Concurrency;
+using System.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// Schedules work on a single-threaded event loop without blocking or starting threads. Immediate work runs in
-/// batches between event-loop turns; delayed and periodic work use timers. Long-running scheduling is unsupported.
-/// </summary>
+/// <summary>Schedules immediate batches and timed work on a single-threaded event loop.</summary>
+/// <remarks>Immediate batches yield between event-loop turns; long-running scheduling is unsupported.</remarks>
 [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
 public sealed class WasmScheduler : LocalScheduler, ISchedulerPeriodic, IDisposable
 {
@@ -54,14 +53,15 @@ public sealed class WasmScheduler : LocalScheduler, ISchedulerPeriodic, IDisposa
     internal WasmScheduler(TimeProvider? timeProvider = null)
     {
         _timeProvider = timeProvider ?? TimeProvider.System;
-        _drainTimer = _timeProvider.CreateTimer(
+        _drainTimer = CreateTimer(
+            _timeProvider,
             static state => ((WasmScheduler)state!).RunDrain(),
             this,
             Timeout.InfiniteTimeSpan,
             Timeout.InfiniteTimeSpan);
     }
 
-    /// <summary>A queued work item awaiting an event-loop drain or a one-shot timer. Disposing it cancels it.</summary>
+    /// <summary>Represents queued work that disposal cancels before execution.</summary>
     internal interface IReadyWorkItem : IDisposable
     {
         /// <summary>Runs the scheduled action unless cancelled.</summary>
@@ -115,17 +115,11 @@ public override IDisposable Schedule<TState>(
 
         var item = new StatefulWorkItem<TState>(this, state, action);
 
-        // The timer roots itself while armed through the callback's target (the work item), which stores the
-        // timer; the item's Dispose cancels and releases it.
-        item.AttachTimer(_timeProvider.CreateTimer(static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
+        item.AttachTimer(CreateTimer(_timeProvider, static s => ((IReadyWorkItem)s!).Run(), item, dt, Timeout.InfiniteTimeSpan));
         return item;
     }
 
-    /// <summary>
-    /// Schedules a periodic action. Periods below one millisecond (including zero) are clamped to one millisecond:
-    /// a tight sequential loop would starve a single-threaded event loop, and browsers clamp nested
-    /// <c>setTimeout</c> anyway.
-    /// </summary>
+    /// <summary>Schedules a periodic action, clamping periods below one millisecond to one millisecond.</summary>
     /// <typeparam name="TState">The type of the state passed to the action.</typeparam>
     /// <param name="state">Initial state passed to the action upon the first iteration.</param>
     /// <param name="period">Period for running the work periodically.</param>
@@ -148,10 +142,8 @@ public IDisposable SchedulePeriodic<TState>(TState state, TimeSpan period, Func<
         return PeriodicWorkItem<TState>.Start(state, period, action, _timeProvider);
     }
 
-    /// <summary>
-    /// Releases the drain timer and cancels queued work. Subsequent scheduling throws ObjectDisposedException.
-    /// Running work completes; callers retain responsibility for cancelling delayed work through its returned handle.
-    /// </summary>
+    /// <summary>Cancels queued immediate work and rejects further scheduling, allowing running work to finish.</summary>
+    /// <remarks>Delayed work remains owned by its returned cancellation handle.</remarks>
     public void Dispose()
     {
         if (Interlocked.Exchange(ref _isDisposed, 1) != 0)
@@ -170,7 +162,6 @@ internal void Enqueue(IReadyWorkItem item)
         QueueReady(item);
         PostDrain();
 
-        // Release work enqueued after disposal drained the queue.
         if (!IsDisposed)
         {
             return;
@@ -223,6 +214,26 @@ internal bool TryPostDrain(int observedState)
         return true;
     }
 
+    /// <summary>Registers a timer callback with the supplied provider.</summary>
+    /// <param name="provider">The timer provider.</param>
+    /// <param name="callback">The callback invoked when due.</param>
+    /// <param name="state">The callback state.</param>
+    /// <param name="dueTime">The initial delay.</param>
+    /// <param name="period">The repeat interval.</param>
+    /// <returns>The timer's cancellation handle.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ITimer CreateTimer(TimeProvider provider, TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period) =>
+        provider.CreateTimer(callback, state, dueTime, period);
+
+    /// <summary>Updates a timer's next firing and repeat interval.</summary>
+    /// <param name="timer">The timer to update.</param>
+    /// <param name="dueTime">The initial delay.</param>
+    /// <param name="period">The repeat interval.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ChangeTimer(ITimer timer, TimeSpan dueTime, TimeSpan period) => _ = timer.Change(dueTime, period);
+
     /// <summary>Cancels and removes every queued work item.</summary>
     private void ReleaseReady()
     {
@@ -248,14 +259,13 @@ private void PostDrain()
     /// <summary>Yields the claimed drain batch to the event loop, or hands the latch back when disposal beat it.</summary>
     private void ArmDrain()
     {
-        // Release the drain claim when disposal prevents arming the timer.
         if (IsDisposed)
         {
             Volatile.Write(ref _drainState, DrainIdle);
             return;
         }
 
-        _ = _drainTimer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+        ChangeTimer(_drainTimer, TimeSpan.Zero, Timeout.InfiniteTimeSpan);
     }
 
     /// <summary>Drains queued batches until no further pass is requested.</summary>
@@ -263,11 +273,8 @@ private void RunDrain()
     {
         do
         {
-            // Claim this pass; a concurrent PostDrain that observes DrainRunning will bump it to DrainRunningPending.
             Volatile.Write(ref _drainState, DrainRunning);
             RunReadyBatch();
-
-            // Finish only when no work was flagged during this pass.
         }
         while (Interlocked.CompareExchange(ref _drainState, DrainIdle, DrainRunning) != DrainRunning);
 
@@ -276,7 +283,6 @@ private void RunDrain()
             return;
         }
 
-        // Cover the narrow window where an item was enqueued but its PostDrain has not run yet.
         PostDrain();
     }
 
@@ -299,7 +305,6 @@ public StatefulWorkItem(WasmScheduler scheduler, TState state, Func<IScheduler,
         /// <inheritdoc/>
         public void Dispose()
         {
-            // Publish cancellation before reclaiming timers so a concurrent attachment releases its handle.
             if (!TryClaimDispose())
             {
                 return;
@@ -314,12 +319,18 @@ public void Dispose()
         internal void AttachTimer(IDisposable timer)
         {
             Volatile.Write(ref _timer, timer);
+            ReleaseCanceledTimer();
+        }
+
+        /// <summary>Releases the attached timer when the work item is cancelled.</summary>
+        internal void ReleaseCanceledTimer()
+        {
             if (!IsDisposed)
             {
                 return;
             }
 
-            timer.Dispose();
+            Interlocked.Exchange(ref _timer, null)?.Dispose();
         }
     }
 
@@ -363,7 +374,6 @@ public void Dispose()
 
                 _isDisposed = true;
 
-                // Start assigns the timer before returning; only the first Dispose reaches this point.
                 _timer!.Dispose();
                 _timer = null;
                 _state = default!;
@@ -383,14 +393,15 @@ internal static PeriodicWorkItem<TState> Start(
             TimeProvider timeProvider)
         {
             PeriodicWorkItem<TState> item = new(state, action);
-            var timer = timeProvider.CreateTimer(
+            var timer = CreateTimer(
+                timeProvider,
                 static s => ((PeriodicWorkItem<TState>)s!).Tick(),
                 item,
                 Timeout.InfiniteTimeSpan,
                 Timeout.InfiniteTimeSpan);
 
             item._timer = timer;
-            _ = timer.Change(period, period);
+            ChangeTimer(timer, period, period);
             return item;
         }
 
diff --git a/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs b/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
index 02ce2775..897e53a7 100644
--- a/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Disposables/ContainerDisposable.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Reactive.Disposables;
 
-/// <summary>
-/// A <see cref="MultipleDisposable"/> that a System.Reactive consumer can use as a
-/// <see cref="CompositeDisposable"/>, so an activation-scoped container flows into APIs written against
-/// System.Reactive - <c>DisposeWith</c> above all - without the caller converting it by hand.
-/// </summary>
+/// <summary>Holds disposables and supports implicit conversion to a System.Reactive composite disposable.</summary>
 /// <remarks>Conversions reuse a composite owned by the container. Composite registrations occupy one container slot and are not individually visible through Count, Contains, or Remove.</remarks>
 [System.Diagnostics.DebuggerDisplay("ContainerDisposable: Count = {Count}, IsDisposed = {IsDisposed}")]
 public sealed class ContainerDisposable : MultipleDisposable
@@ -77,7 +73,7 @@ public CompositeDisposable ToCompositeDisposable()
             var created = new CompositeDisposable();
             _composite = created;
 
-            // Register the composite so its lifetime follows the container.
+            // Composite disposal follows container disposal.
             Add(created);
             return created;
         }
@@ -88,7 +84,7 @@ protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
 
-        // The container owns the composite; repeated disposal is harmless.
+        // Repeated composite disposal has no effect.
         _composite?.Dispose();
     }
 }
diff --git a/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs b/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
index 56783db4..ca7c51ca 100644
--- a/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Disposables/LinqExtensions.ContainerDisposable.cs
@@ -19,7 +19,7 @@ public static partial class LinqExtensions
         /// <param name="disposables">The container.</param>
         /// <returns>The original disposable.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="disposables"/> is <see langword="null"/>.</exception>
-        /// <remarks>This exact container overload resolves DisposeWith calls when System.Reactive's composite overload is also in scope.</remarks>
+        /// <remarks>This overload resolves DisposeWith calls when System.Reactive also supplies a composite overload.</remarks>
         public T DisposeWith(ContainerDisposable disposables)
         {
             ArgumentExceptionHelper.ThrowIfNull(disposables);
diff --git a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
index 5af649b3..6608b865 100644
--- a/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Platforms/android/HandlerSequencer.cs
@@ -3,16 +3,12 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 using Android.OS;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// System.Reactive-flavoured Android scheduler that coalesces scheduled work onto the thread backing a
-/// <see cref="Handler"/> (typically the main/UI looper). Immediate work is batched through a single cached
-/// <see cref="Java.Lang.IRunnable"/> drain, so the per-post path allocates nothing; delayed work uses the native
-/// <see cref="Handler.PostDelayed(Java.Lang.IRunnable, long)"/>.
-/// </summary>
+/// <summary>Schedules immediate and delayed work on the Android handler thread.</summary>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class HandlerSequencer : CoalescingDispatchScheduler
@@ -47,13 +43,30 @@ public HandlerSequencer(Handler handler) =>
     protected override bool Post(Action drain)
     {
         _drainRunnable ??= new Java.Lang.Runnable(drain);
-        return Handler.Post(_drainRunnable);
+        return PostToHandler(_drainRunnable);
     }
 
     /// <inheritdoc/>
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         var runnable = new Java.Lang.Runnable(work);
+        return ScheduleOnHandler(runnable, dueTime);
+    }
+
+    /// <summary>Posts the runnable through the native handler.</summary>
+    /// <param name="runnable">The runnable to post.</param>
+    /// <returns>Whether the handler accepted the runnable.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool PostToHandler(Java.Lang.IRunnable runnable) => Handler.Post(runnable);
+
+    /// <summary>Schedules cancellable work through the native handler.</summary>
+    /// <param name="runnable">The callback to run.</param>
+    /// <param name="dueTime">The requested delay.</param>
+    /// <returns>The callback cancellation handle.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private IDisposable ScheduleOnHandler(Java.Lang.IRunnable runnable, TimeSpan dueTime)
+    {
         _ = Handler.PostDelayed(runnable, (long)dueTime.TotalMilliseconds);
         return Disposable.Create((Handler, runnable), static state => state.Handler.RemoveCallbacks(state.runnable));
     }
diff --git a/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs b/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
index eff3ce0a..b6650359 100644
--- a/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Platforms/apple/NSRunloopSequencer.cs
@@ -3,17 +3,13 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 
 using CoreFoundation;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
-/// <summary>
-/// System.Reactive-flavoured Apple scheduler that coalesces scheduled work onto the main <see cref="DispatchQueue"/>
-/// (the UI thread on iOS, tvOS, Mac Catalyst, and macOS). Immediate work is batched through a single cached
-/// <see cref="DispatchBlock"/> drain, so the per-post path allocates nothing; delayed work uses
-/// <see cref="DispatchQueue.DispatchAfter(DispatchTime, DispatchBlock)"/>.
-/// </summary>
+/// <summary>Schedules immediate and delayed work on the Apple main dispatch queue.</summary>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class NSRunloopSequencer : CoalescingDispatchScheduler
@@ -43,7 +39,7 @@ private NSRunloopSequencer()
     protected override bool Post(Action drain)
     {
         _drainBlock ??= new DispatchBlock(drain);
-        DispatchQueue.MainQueue.DispatchAsync(_drainBlock);
+        DispatchOnMainQueue(_drainBlock);
         return true;
     }
 
@@ -51,6 +47,22 @@ protected override bool Post(Action drain)
     protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
     {
         var block = new DispatchBlock(work);
+        return ScheduleOnMainQueue(block, dueTime);
+    }
+
+    /// <summary>Posts the block through the native main queue.</summary>
+    /// <param name="block">The callback block to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void DispatchOnMainQueue(DispatchBlock block) => DispatchQueue.MainQueue.DispatchAsync(block);
+
+    /// <summary>Schedules a cancellable block through the native main queue.</summary>
+    /// <param name="block">The callback block to run.</param>
+    /// <param name="dueTime">The requested delay.</param>
+    /// <returns>The block cancellation handle.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static IDisposable ScheduleOnMainQueue(DispatchBlock block, TimeSpan dueTime)
+    {
         var nanoseconds = (long)dueTime.TotalMilliseconds * NanosecondsPerMillisecond;
         DispatchQueue.MainQueue.DispatchAfter(new(DispatchTime.Now, nanoseconds), block);
         return Disposable.Create(block, static b => b.Cancel());
diff --git a/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs b/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
index 24c38195..98abc213 100644
--- a/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinForms.Reactive/Concurrency/ControlSequencer.cs
@@ -2,47 +2,65 @@
 // ReactiveUI Association Incorporated 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.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>Windows Forms scheduler that coalesces scheduled work through a UI control.</summary>
-/// <remarks>Work runs on the control's UI thread. Work scheduled before the control has a handle stays queued until
-/// handle creation posts a drain, and delayed work waits on a background scheduler that marshals it back through the
-/// control when due.</remarks>
+/// <remarks>Callbacks run on the control thread; work queued before handle creation waits for the handle.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("ControlSequencer: Control = {Control}")]
 public sealed class ControlSequencer : CoalescingDispatchScheduler
 {
+    /// <summary>Optional callback for posting ready work.</summary>
+    private readonly Func<Action, bool>? _post;
+
     /// <summary>Initializes a new instance of the <see cref="ControlSequencer"/> class.</summary>
     /// <param name="control">The control used to marshal work to the UI thread.</param>
     /// <exception cref="ArgumentNullException"><paramref name="control"/> is <see langword="null"/>.</exception>
     public ControlSequencer(Control control)
+        : this(control, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ControlSequencer"/> class.</summary>
+    /// <param name="control">The control associated with this scheduler.</param>
+    /// <param name="post">Posts ready work, or null to use the control.</param>
+    /// <param name="delayScheduler">Schedules delayed work, or null to use the default scheduler.</param>
+    /// <exception cref="ArgumentNullException">The control is null.</exception>
+    internal ControlSequencer(Control control, Func<Action, bool>? post, IScheduler? delayScheduler)
+        : base(delayScheduler ?? DefaultScheduler.Instance)
     {
         Control = control ?? throw new ArgumentNullException(nameof(control));
+        _post = post;
         Control.HandleCreated += OnHandleCreated;
     }
 
     /// <summary>Gets the control used to marshal work to the UI thread.</summary>
     public Control Control { get; }
 
-    /// <inheritdoc/>
-    /// <exception cref="ObjectDisposedException">The control has been disposed.</exception>
-    protected override bool Post(Action drain)
+    /// <summary>Posts work when the control is live and its handle is available.</summary>
+    /// <param name="control">The control whose disposal state is checked.</param>
+    /// <param name="handleCreated">Whether the control handle is available.</param>
+    /// <param name="drain">The callback to post.</param>
+    /// <param name="beginInvoke">Posts the callback to the control.</param>
+    /// <returns>False if the handle is unavailable or disappears while posting.</returns>
+    internal static bool TryPost(Control control, bool handleCreated, Action drain, Action<Control, Action> beginInvoke)
     {
-        ObjectDisposedExceptionHelper.ThrowIf(Control.IsDisposed, Control);
+        ObjectDisposedExceptionHelper.ThrowIf(control.IsDisposed, control);
 
-        if (!Control.IsHandleCreated)
+        if (!handleCreated)
         {
             return false;
         }
 
         try
         {
-            _ = Control.BeginInvoke(drain);
+            beginInvoke(control, drain);
             return true;
         }
-        catch (InvalidOperationException) when (!Control.IsDisposed)
+        catch (InvalidOperationException) when (!control.IsDisposed)
         {
             return false;
         }
@@ -52,5 +70,16 @@ protected override bool Post(Action drain)
     /// <param name="sender">The event source.</param>
     /// <param name="e">The event arguments.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void OnHandleCreated(object? sender, EventArgs e) => RequestDrain();
+    internal void OnHandleCreated(object? sender, EventArgs e) => RequestDrain();
+
+    /// <inheritdoc/>
+    /// <exception cref="ObjectDisposedException">The control has been disposed.</exception>
+    protected override bool Post(Action drain) =>
+        _post is null ? TryPost(Control, Control.IsHandleCreated, drain, BeginInvoke) : _post(drain);
+
+    /// <summary>Invokes the platform's asynchronous control dispatch.</summary>
+    /// <param name="control">The target control.</param>
+    /// <param name="drain">The callback to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void BeginInvoke(Control control, Action drain) => _ = control.BeginInvoke(drain);
 }
diff --git a/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs b/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
index 4d883877..0187d28f 100644
--- a/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinForms/Concurrency/ControlSequencer.cs
@@ -8,14 +8,16 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>Windows Forms sequencer that coalesces scheduled work through a UI control.</summary>
-/// <remarks>Work runs on the control's UI thread, one batch per posted drain; scheduling from that thread queues the
-/// item for the next drain rather than running it inline. Work scheduled before the control has a handle stays queued
-/// until handle creation posts a drain, and delayed work waits on a shared timer that marshals it back through the
-/// control when due.</remarks>
+/// <remarks>
+/// Callbacks run in posted control-thread batches without inline reentrancy; work queued before handle creation waits for the handle.
+/// </remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ControlSequencer : ISequencer
 {
+    /// <summary>Optional callback for posting ready work.</summary>
+    private readonly Func<Action, bool>? _post;
+
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
@@ -23,9 +25,20 @@ public sealed class ControlSequencer : ISequencer
     /// <param name="control">The control used to marshal work to the UI thread.</param>
     /// <exception cref="ArgumentNullException"><paramref name="control"/> is <see langword="null"/>.</exception>
     public ControlSequencer(Control control)
+        : this(control, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ControlSequencer"/> class.</summary>
+    /// <param name="control">The control associated with this sequencer.</param>
+    /// <param name="post">Posts ready work, or null to use the control.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work, or null to use the shared timer.</param>
+    /// <exception cref="ArgumentNullException">The control is null.</exception>
+    internal ControlSequencer(Control control, Func<Action, bool>? post, Action<IWorkItem, long>? scheduleDelayed)
     {
         Control = control ?? throw new ArgumentNullException(nameof(control));
-        _state = new(this, Post, RunDrain);
+        _post = post;
+        _state = new(this, Post, RunDrain, scheduleDelayed);
         Control.HandleCreated += OnHandleCreated;
     }
 
@@ -50,37 +63,52 @@ public ControlSequencer(Control control)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Schedule(IWorkItem item, long dueTimestamp) => _state.Schedule(item, dueTimestamp);
 
-    /// <summary>Marshals the cached drain callback onto the control's UI thread.</summary>
-    /// <param name="drain">The drain callback.</param>
-    /// <returns><see langword="true"/> when the drain was posted; otherwise, <see langword="false"/>.</returns>
-    /// <exception cref="ObjectDisposedException">The control has been disposed.</exception>
-    private bool Post(Action drain)
+    /// <summary>Posts work when the control is live and its handle is available.</summary>
+    /// <param name="control">The control whose disposal state is checked.</param>
+    /// <param name="handleCreated">Whether the control handle is available.</param>
+    /// <param name="drain">The callback to post.</param>
+    /// <param name="beginInvoke">Posts the callback to the control.</param>
+    /// <returns>False if the handle is unavailable or disappears while posting.</returns>
+    internal static bool TryPost(Control control, bool handleCreated, Action drain, Action<Control, Action> beginInvoke)
     {
-        ObjectDisposedExceptionHelper.ThrowIf(Control.IsDisposed, Control);
+        ObjectDisposedExceptionHelper.ThrowIf(control.IsDisposed, control);
 
-        if (!Control.IsHandleCreated)
+        if (!handleCreated)
         {
             return false;
         }
 
         try
         {
-            _ = Control.BeginInvoke(drain);
+            beginInvoke(control, drain);
             return true;
         }
-        catch (InvalidOperationException) when (!Control.IsDisposed)
+        catch (InvalidOperationException) when (!control.IsDisposed)
         {
             return false;
         }
     }
 
-    /// <summary>Runs one queued batch on the coalescing engine.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void RunDrain() => _state.RunDrain();
-
     /// <summary>Posts queued work once the control handle becomes available.</summary>
     /// <param name="sender">The event source.</param>
     /// <param name="e">The event arguments.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void OnHandleCreated(object? sender, EventArgs e) => _state.PostDrain();
+    internal void OnHandleCreated(object? sender, EventArgs e) => _state.PostDrain();
+
+    /// <summary>Invokes the platform's asynchronous control dispatch.</summary>
+    /// <param name="control">The target control.</param>
+    /// <param name="drain">The callback to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static void BeginInvoke(Control control, Action drain) => _ = control.BeginInvoke(drain);
+
+    /// <summary>Marshals the cached drain callback onto the control's UI thread.</summary>
+    /// <param name="drain">The drain callback.</param>
+    /// <returns>True when the drain was posted.</returns>
+    /// <exception cref="ObjectDisposedException">The control has been disposed.</exception>
+    private bool Post(Action drain) =>
+        _post is null ? TryPost(Control, Control.IsHandleCreated, drain, BeginInvoke) : _post(drain);
+
+    /// <summary>Runs one queued batch on the coalescing engine.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void RunDrain() => _state.RunDrain();
 }
diff --git a/src/ReactiveUI.Primitives.WinForms/Properties/AssemblyInfo.cs b/src/ReactiveUI.Primitives.WinForms/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..cd293f13
--- /dev/null
+++ b/src/ReactiveUI.Primitives.WinForms/Properties/AssemblyInfo.cs
@@ -0,0 +1,7 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+
+[assembly: InternalsVisibleTo("ReactiveUI.Primitives.WinForms.Tests")]
diff --git a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
index 23724cdc..7ff954f9 100644
--- a/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI.Reactive/Concurrency/DispatcherQueueSequencer.cs
@@ -3,17 +3,23 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 using Microsoft.UI.Dispatching;
 
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>WinUI dispatcher queue scheduler that coalesces scheduled work through a <see cref="DispatcherQueue"/>.</summary>
-/// <remarks>Work runs on the dispatcher queue's thread and delayed work fires on a dispatcher queue timer, so disposing
-/// the returned subscription stops that timer as well as suppressing work that has not started.</remarks>
+/// <remarks>Callbacks run on the dispatcher queue thread; cancellation stops pending timers and suppresses unstarted actions.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("DispatcherQueueSequencer: DispatcherQueue = {DispatcherQueue}, Priority = {Priority}")]
 public sealed class DispatcherQueueSequencer : CoalescingDispatchScheduler
 {
+    /// <summary>Optional callback for enqueueing native drain delegates.</summary>
+    private readonly Func<DispatcherQueuePriority, DispatcherQueueHandler, bool>? _tryEnqueue;
+
+    /// <summary>Optional callback for delayed work.</summary>
+    private readonly Func<Action, TimeSpan, IDisposable>? _scheduleDelayed;
+
     /// <summary>Cached dispatcher queue handler used for the drain.</summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Maintainability",
@@ -39,6 +45,21 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
         Priority = priority;
     }
 
+    /// <summary>Initializes a new instance of the <see cref="DispatcherQueueSequencer"/> class.</summary>
+    /// <param name="priority">Priority passed to the enqueue callback.</param>
+    /// <param name="tryEnqueue">Attempts to enqueue each drain.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work.</param>
+    internal DispatcherQueueSequencer(
+        DispatcherQueuePriority priority,
+        Func<DispatcherQueuePriority, DispatcherQueueHandler, bool> tryEnqueue,
+        Func<Action, TimeSpan, IDisposable> scheduleDelayed)
+    {
+        DispatcherQueue = null!;
+        Priority = priority;
+        _tryEnqueue = tryEnqueue;
+        _scheduleDelayed = scheduleDelayed;
+    }
+
     /// <summary>Gets the dispatcher queue used to marshal work to the UI thread.</summary>
     public DispatcherQueue DispatcherQueue { get; }
 
@@ -50,7 +71,7 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
     protected override bool Post(Action drain)
     {
         _handler ??= drain.Invoke;
-        if (DispatcherQueue.TryEnqueue(Priority, _handler))
+        if (_tryEnqueue is null ? TryEnqueue(_handler) : _tryEnqueue(Priority, _handler))
         {
             return true;
         }
@@ -60,7 +81,15 @@ protected override bool Post(Action drain)
 
     /// <inheritdoc/>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
+    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime) =>
+        _scheduleDelayed is null ? StartDispatcherTimer(work, dueTime) : _scheduleDelayed(work, dueTime);
+
+    /// <summary>Schedules a cancellable native dispatcher timer.</summary>
+    /// <param name="work">The callback to run.</param>
+    /// <param name="dueTime">The requested delay.</param>
+    /// <returns>The timer cancellation handle.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private IDisposable StartDispatcherTimer(Action work, TimeSpan dueTime)
     {
         var timer = DispatcherQueue.CreateTimer();
         timer.Interval = dueTime;
@@ -73,4 +102,11 @@ protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTim
         timer.Start();
         return Disposable.Create(timer, static t => t.Stop());
     }
+
+    /// <summary>Attempts a native dispatcher queue post.</summary>
+    /// <param name="handler">The callback to enqueue.</param>
+    /// <returns>Whether the dispatcher accepted the callback.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool TryEnqueue(DispatcherQueueHandler handler) => DispatcherQueue.TryEnqueue(Priority, handler);
 }
diff --git a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
index d4b3ffed..bfa1ac2d 100644
--- a/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
+++ b/src/ReactiveUI.Primitives.WinUI/Concurrency/DispatcherQueueSequencer.cs
@@ -9,13 +9,14 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>WinUI dispatcher queue sequencer that coalesces scheduled work through a <see cref="DispatcherQueue"/>.</summary>
-/// <remarks>Work runs on the dispatcher queue's thread, one batch per posted drain; scheduling from that thread queues
-/// the item for the next drain rather than running it inline. Delayed work fires on a dispatcher queue timer, and an
-/// item cancelled before its drain reaches it is skipped.</remarks>
+/// <remarks>Callbacks run in posted dispatcher queue batches without inline reentrancy; cancellation suppresses unstarted work.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class DispatcherQueueSequencer : ISequencer
 {
+    /// <summary>Optional callback for enqueueing native drain delegates.</summary>
+    private readonly Func<DispatcherQueuePriority, DispatcherQueueHandler, bool>? _tryEnqueue;
+
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
@@ -45,6 +46,21 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
         _state = new(this, Post, RunDrain, ScheduleDelayed);
     }
 
+    /// <summary>Initializes a new instance of the <see cref="DispatcherQueueSequencer"/> class.</summary>
+    /// <param name="priority">Priority passed to the enqueue callback.</param>
+    /// <param name="tryEnqueue">Attempts to enqueue each drain.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work.</param>
+    internal DispatcherQueueSequencer(
+        DispatcherQueuePriority priority,
+        Func<DispatcherQueuePriority, DispatcherQueueHandler, bool> tryEnqueue,
+        Action<IWorkItem, long> scheduleDelayed)
+    {
+        DispatcherQueue = null!;
+        Priority = priority;
+        _tryEnqueue = tryEnqueue;
+        _state = new(this, Post, RunDrain, scheduleDelayed);
+    }
+
     /// <summary>Gets the dispatcher queue used to marshal work to the UI thread.</summary>
     public DispatcherQueue DispatcherQueue { get; }
 
@@ -76,7 +92,7 @@ public DispatcherQueueSequencer(DispatcherQueue dispatcherQueue, DispatcherQueue
     private bool Post(Action drain)
     {
         _handler ??= drain.Invoke;
-        if (DispatcherQueue.TryEnqueue(Priority, _handler))
+        if (_tryEnqueue is null ? TryEnqueue(_handler) : _tryEnqueue(Priority, _handler))
         {
             return true;
         }
@@ -84,6 +100,13 @@ private bool Post(Action drain)
         throw new InvalidOperationException("The dispatcher queue is no longer accepting work.");
     }
 
+    /// <summary>Attempts a native dispatcher queue post.</summary>
+    /// <param name="handler">The callback to enqueue.</param>
+    /// <returns>Whether the dispatcher accepted the callback.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool TryEnqueue(DispatcherQueueHandler handler) => DispatcherQueue.TryEnqueue(Priority, handler);
+
     /// <summary>Runs delayed work on a dispatcher queue timer so it executes directly on the dispatcher thread.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
diff --git a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
index aa360fc7..3e88c29a 100644
--- a/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf.Reactive/Concurrency/DispatcherSequencer.cs
@@ -8,13 +8,17 @@
 namespace ReactiveUI.Primitives.Reactive.Concurrency;
 
 /// <summary>WPF dispatcher scheduler that coalesces scheduled work onto a dispatcher drain.</summary>
-/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/> and delayed work fires on a
-/// <see cref="DispatcherTimer"/>, so disposing the returned subscription stops that timer as well as suppressing work
-/// that has not started.</remarks>
+/// <remarks>Callbacks run on the dispatcher thread at Priority; cancellation stops pending timers and suppresses unstarted actions.</remarks>
 /// <seealso cref="System.Reactive.Concurrency.IScheduler" />
 [System.Diagnostics.DebuggerDisplay("DispatcherSequencer: Dispatcher = {Dispatcher}, Priority = {Priority}")]
 public sealed class DispatcherSequencer : CoalescingDispatchScheduler
 {
+    /// <summary>Optional callback for posting ready work.</summary>
+    private readonly Func<Action, bool>? _post;
+
+    /// <summary>Optional callback for delayed work.</summary>
+    private readonly Func<Action, TimeSpan, IDisposable>? _scheduleDelayed;
+
     /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
     /// <param name="dispatcher">The dispatcher whose thread runs the scheduled work.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
@@ -28,9 +32,26 @@ public DispatcherSequencer(Dispatcher dispatcher)
     /// <param name="priority">Dispatcher priority used for posted drains.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
+        : this(dispatcher, priority, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
+    /// <param name="dispatcher">The dispatcher associated with this scheduler.</param>
+    /// <param name="priority">The dispatcher priority.</param>
+    /// <param name="post">Posts ready work, or null to use the dispatcher.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work, or null to use a dispatcher timer.</param>
+    /// <exception cref="ArgumentNullException">The dispatcher is null.</exception>
+    internal DispatcherSequencer(
+        Dispatcher dispatcher,
+        DispatcherPriority priority,
+        Func<Action, bool>? post,
+        Func<Action, TimeSpan, IDisposable>? scheduleDelayed)
     {
         Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         Priority = priority;
+        _post = post;
+        _scheduleDelayed = scheduleDelayed;
     }
 
     /// <summary>Gets the dispatcher whose thread runs the scheduled work.</summary>
@@ -40,15 +61,29 @@ public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
     public DispatcherPriority Priority { get; }
 
     /// <inheritdoc/>
-    protected override bool Post(Action drain)
+    protected override bool Post(Action drain) => _post is null ? PostToDispatcher(drain) : _post(drain);
+
+    /// <inheritdoc/>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime) =>
+        _scheduleDelayed is null ? StartDispatcherTimer(work, dueTime) : _scheduleDelayed(work, dueTime);
+
+    /// <summary>Posts a drain at the configured dispatcher priority.</summary>
+    /// <param name="drain">The drain callback.</param>
+    /// <returns>True once the dispatcher accepts the callback.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private bool PostToDispatcher(Action drain)
     {
         _ = Dispatcher.BeginInvoke(drain, Priority);
         return true;
     }
 
-    /// <inheritdoc/>
+    /// <summary>Starts a cancellable dispatcher timer.</summary>
+    /// <param name="work">The callback to run.</param>
+    /// <param name="dueTime">The requested delay.</param>
+    /// <returns>The timer cancellation handle.</returns>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    protected override IDisposable ScheduleOnDispatcher(Action work, TimeSpan dueTime)
+    private IDisposable StartDispatcherTimer(Action work, TimeSpan dueTime)
     {
         DispatcherTimer timer = new(Priority, Dispatcher) { Interval = dueTime };
         timer.Tick += (_, _) =>
diff --git a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
index b8680340..47f49db5 100644
--- a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
@@ -9,9 +9,7 @@
 namespace ReactiveUI.Primitives.Concurrency;
 
 /// <summary>WPF dispatcher sequencer that coalesces scheduled work onto a dispatcher drain.</summary>
-/// <remarks>Work runs on the dispatcher's thread at <see cref="Priority"/>, one batch per posted drain; scheduling from
-/// that thread queues the item for the next drain rather than running it inline. Delayed work fires on a
-/// <see cref="DispatcherTimer"/>, and an item cancelled before its drain reaches it is skipped.</remarks>
+/// <remarks>Callbacks run at Priority in posted dispatcher batches without inline reentrancy; cancellation suppresses unstarted work.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class DispatcherSequencer : ISequencer
@@ -32,10 +30,25 @@ public DispatcherSequencer(Dispatcher dispatcher)
     /// <param name="priority">Dispatcher priority used for posted drains.</param>
     /// <exception cref="ArgumentNullException"><paramref name="dispatcher"/> is <see langword="null"/>.</exception>
     public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
+        : this(dispatcher, priority, null, null)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="DispatcherSequencer"/> class.</summary>
+    /// <param name="dispatcher">The dispatcher associated with this sequencer.</param>
+    /// <param name="priority">The dispatcher priority.</param>
+    /// <param name="post">Posts ready work, or null to use the dispatcher.</param>
+    /// <param name="scheduleDelayed">Schedules delayed work, or null to use a dispatcher timer.</param>
+    /// <exception cref="ArgumentNullException">The dispatcher is null.</exception>
+    internal DispatcherSequencer(
+        Dispatcher dispatcher,
+        DispatcherPriority priority,
+        Func<Action, bool>? post,
+        Action<IWorkItem, long>? scheduleDelayed)
     {
         Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         Priority = priority;
-        _state = new(this, Post, RunDrain, ScheduleDelayed);
+        _state = new(this, post ?? Post, RunDrain, scheduleDelayed ?? ScheduleDelayed);
     }
 
     /// <summary>Gets the dispatcher whose thread runs the scheduled work.</summary>
@@ -65,6 +78,7 @@ public DispatcherSequencer(Dispatcher dispatcher, DispatcherPriority priority)
     /// <summary>Marshals the cached drain callback onto the dispatcher.</summary>
     /// <param name="drain">The drain callback.</param>
     /// <returns><see langword="true"/>, since the dispatcher always accepts the work.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private bool Post(Action drain)
     {
         _ = Dispatcher.BeginInvoke(drain, Priority);
diff --git a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
index 2fb26692..7cb29a38 100644
--- a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
+++ b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
@@ -9,11 +9,7 @@
 
 namespace ReactiveUI.Primitives.Advanced;
 
-/// <summary>
-/// Coalescing engine shared by UI-thread sequencers. A sequencer holds one inline and supplies its platform
-/// <c>post</c> delegate, an optional <c>scheduleDelayed</c> delegate and a cached drain callback; immediate work is
-/// queued and drained one batch per post.
-/// </summary>
+/// <summary>Queues immediate work into posted batches and schedules delayed work through the supplied delegates.</summary>
 [SuppressMessage(
     "Performance",
     "SST1803:Make record struct readonly",
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index 97957e2b..8e17ef32 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -105,7 +105,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         SequencerQueue<long>? queue;
 
-        // Nothing is running on this thread, so the item runs inline rather than through the trampoline.
+        // Initial work executes before Schedule returns.
         if (!_running)
         {
             SetRunning(true);
@@ -126,7 +126,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
                 throw;
             }
 
-            // Work the item scheduled recursively runs on the same trampoline before returning.
+            // Nested work finishes before the outer Schedule call returns.
             queue = GetQueue();
             if (queue is not null)
             {
@@ -150,7 +150,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         queue = GetQueue();
 
-        // Work is running on this thread, so the item joins the trampoline queue, created on first use.
+        // Nested work waits for the current item to finish.
         if (queue is null)
         {
             queue = new(InitialQueueCapacity);
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
index d0bc349b..3ad5a707 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Disposables;
 
@@ -141,20 +140,18 @@ public void Execute()
                 return;
             }
 
-            DisposeIfRaced(disposable);
+            ReleaseCanceledResult();
         }
 
-        /// <summary>Releases what the scheduled action returned when a concurrent <see cref="Dispose"/> latches the cancellation flag after the slot is claimed.</summary>
-        /// <param name="disposable">The disposable the scheduled action returned.</param>
-        [ExcludeFromCodeCoverage]
-        private void DisposeIfRaced(IDisposable disposable)
+        /// <summary>Releases the published result if the work item is cancelled.</summary>
+        internal void ReleaseCanceledResult()
         {
             if (!IsDisposed)
             {
                 return;
             }
 
-            disposable.Dispose();
+            Interlocked.Exchange(ref _disposable, EmptyDisposable.Instance)?.Dispose();
         }
     }
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
index 1e5f1e32..5393717f 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
@@ -17,9 +17,11 @@ public static partial class Sequencer
     public static ISequencer Default => TaskPoolSequencer.Default;
 
     /// <summary>Gets the shared wall-clock time used by real-time sequencers.</summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     internal static DateTimeOffset Now => TimeProvider.System.GetUtcNow();
 
     /// <summary>Gets the current monotonic timestamp used by real-time sequencers.</summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     internal static long Timestamp => System.Diagnostics.Stopwatch.GetTimestamp();
 
     /// <summary>Normalizes the specified <see cref="TimeSpan"/> value to a positive value.</summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
index b56f57ff..91adaf2a 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
@@ -42,10 +42,10 @@ public static SynchronizationContextSequencer Current
     public SynchronizationContext Context { get; }
 
     /// <summary>Gets the scheduler's notion of current time.</summary>
-    public DateTimeOffset Now => Sequencer.Now;
+    public DateTimeOffset Now => _delaySequencer.Now;
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
-    public long Timestamp => Sequencer.Timestamp;
+    public long Timestamp => _delaySequencer.Timestamp;
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -57,7 +57,7 @@ public void Schedule(IWorkItem item)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
 
-        Context.Post(static state => ExecutePosted((IWorkItem)state!), item);
+        Post(item);
     }
 
     /// <inheritdoc/>
@@ -76,7 +76,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
     /// <summary>Executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
-    private static void ExecutePosted(IWorkItem item)
+    internal static void ExecutePosted(IWorkItem item)
     {
         if (Sequencer.IsCancelled(item))
         {
@@ -86,6 +86,12 @@ private static void ExecutePosted(IWorkItem item)
         item.Execute();
     }
 
+    /// <summary>Posts a work item to the captured context.</summary>
+    /// <param name="item">The callback state.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private void Post(IWorkItem item) => Context.Post(static state => ExecutePosted((IWorkItem)state!), item);
+
     /// <summary>Delayed post work item.</summary>
     /// <param name="owner">Owning sequencer.</param>
     /// <param name="item">Scheduled item.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
index 49341509..faf6e216 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
@@ -45,10 +45,10 @@ internal TaskPoolSequencer(TaskFactory taskFactory, ISequencer delaySequencer)
     public Action<Exception>? UnhandledExceptionHandler { get; set; }
 
     /// <summary>Gets the scheduler's notion of current time.</summary>
-    public DateTimeOffset Now => Sequencer.Now;
+    public DateTimeOffset Now => _delaySequencer.Now;
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
-    public long Timestamp => Sequencer.Timestamp;
+    public long Timestamp => _delaySequencer.Timestamp;
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -62,12 +62,7 @@ public void Schedule(IWorkItem item)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
 
-        _ = _taskFactory.StartNew(
-            static state => ((DispatchState)state!).Run(),
-            new DispatchState(this, item),
-            _taskFactory.CancellationToken,
-            _taskFactory.CreationOptions,
-            _taskFactory.Scheduler ?? TaskScheduler.Default);
+        Queue(new(this, item));
     }
 
     /// <summary>Schedules a work item to be executed through the task factory at a monotonic timestamp.</summary>
@@ -89,7 +84,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
     /// <summary>Executes a work item and routes unhandled exceptions.</summary>
     /// <param name="item">Work item to execute.</param>
-    private void Execute(IWorkItem item)
+    internal void Execute(IWorkItem item)
     {
         if (Sequencer.IsCancelled(item))
         {
@@ -113,6 +108,17 @@ private void Execute(IWorkItem item)
         }
     }
 
+    /// <summary>Queues a callback on the task factory's scheduler.</summary>
+    /// <param name="state">The callback state.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private void Queue(DispatchState state) =>
+        _ = _taskFactory.StartNew(
+            static value => ((DispatchState)value!).Run(),
+            state,
+            _taskFactory.CancellationToken,
+            _taskFactory.CreationOptions,
+            _taskFactory.Scheduler ?? TaskScheduler.Default);
+
     /// <summary>Task factory dispatch state.</summary>
     /// <param name="owner">Owning sequencer.</param>
     /// <param name="item">Work item to execute.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index f7de0562..174d2677 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -48,11 +48,7 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
             "The timer is created disarmed, so nothing can call back into it until Schedule arms it after construction.")]
     internal ThreadPoolSequencer()
     {
-        _timer = new(
-            static state => ((ThreadPoolSequencer)state!).RunDue(),
-            this,
-            Timeout.InfiniteTimeSpan,
-            Timeout.InfiniteTimeSpan);
+        _timer = CreateTimer(this);
         _timestamp = static () => Sequencer.Timestamp;
         _queueImmediate = QueueOnThreadPool;
         _changeTimer = ChangeTimer;
@@ -115,7 +111,6 @@ public void Schedule(IWorkItem item, long dueTimestamp)
 
         lock (_gate)
         {
-            // Queue under the disposal gate so accepted items are released during teardown.
             ObjectDisposedExceptionHelper.ThrowIf(IsDisposed, this);
 
             _queue.Enqueue(new(item, dueTimestamp));
@@ -123,14 +118,9 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         }
     }
 
-    /// <summary>
-    /// Releases the delay timer this sequencer owns and cancels the delayed work queued behind it. Scheduling through
-    /// a disposed sequencer throws <see cref="ObjectDisposedException"/> rather than accepting work that could never
-    /// become due. Work the thread pool has picked up runs to completion.
-    /// </summary>
+    /// <summary>Cancels pending delayed work and rejects further scheduling, allowing work already picked up by the thread pool to finish.</summary>
     public void Dispose()
     {
-        // The gate prevents rearming after disposal; timer disposal does not wait for callbacks.
         lock (_gate)
         {
             if (IsDisposed)
@@ -171,6 +161,13 @@ internal void RunDue()
     private static void QueueOnThreadPool(WaitCallback callback, object state) =>
         ThreadPool.UnsafeQueueUserWorkItem(callback, state);
 
+    /// <summary>Creates a disarmed timer that drains due work.</summary>
+    /// <param name="owner">The sequencer receiving timer callbacks.</param>
+    /// <returns>The disarmed timer.</returns>
+    [ExcludeFromCodeCoverage]
+    private static Timer CreateTimer(ThreadPoolSequencer owner) =>
+        new(static state => ((ThreadPoolSequencer)state!).RunDue(), owner, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+
     /// <summary>Executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     private static void ExecuteQueued(IWorkItem item)
@@ -228,7 +225,6 @@ private void ArmTimerNoLock()
     {
         if (IsDisposed)
         {
-            // A callback unwinding after disposal must not rearm the timer.
             return;
         }
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
index fe630a61..e74267da 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerExtensions.cs
@@ -60,7 +60,6 @@ public IDisposable ScheduleRelative(TRelative dueTime, Action action)
 
             ArgumentExceptionHelper.ThrowIfNull(action);
 
-            // A static lambda rather than a method group, so the compiler caches the delegate.
             return scheduler.ScheduleRelative(action, dueTime, static (_, a) => Invoke(a));
         }
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
index b39a30f4..6f1cf312 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
@@ -6,11 +6,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Virtual time scheduler that runs scheduled work against a controllable clock. Per-clock arithmetic is supplied
-/// as delegates at construction, so a single sealed type serves every <typeparamref name="TAbsolute"/>/
-/// <typeparamref name="TRelative"/> pairing without an inheritance hierarchy.
-/// </summary>
+/// <summary>Runs scheduled work against a controllable clock using the supplied time arithmetic.</summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <typeparam name="TRelative">Relative time representation type.</typeparam>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
index d95c085e..5e266bb8 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeState{TAbsolute,TRelative}.cs
@@ -301,7 +301,6 @@ internal readonly IDisposable ScheduleAbsolute<TState>(
     {
         ArgumentExceptionHelper.ThrowIfNull(action);
 
-        // Capture the queue reference; a struct member cannot capture this in a closure.
         var queue = _queue;
 
         ScheduledItem<TAbsolute> si = new(dueTime, _comparer, self =>
diff --git a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
index 6c594f3b..ad675efd 100644
--- a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
@@ -8,10 +8,8 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Schedules batches on a single-threaded event loop without blocking or starting threads.
-/// Delayed work uses the shared timer; immediate batches yield between event-loop turns.
-/// </summary>
+/// <summary>Schedules immediate batches and delayed work on a single-threaded event loop.</summary>
+/// <remarks>Immediate batches yield between event-loop turns.</remarks>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class WasmSequencer : ISequencer, IDisposable
@@ -42,11 +40,7 @@ public sealed class WasmSequencer : ISequencer, IDisposable
             "The timer is created disarmed, and _state is a struct held inline in this object, so neither reference escapes.")]
     internal WasmSequencer()
     {
-        _timer = new(
-            static state => ((WasmSequencer)state!).RunDrain(),
-            this,
-            Timeout.InfiniteTimeSpan,
-            Timeout.InfiniteTimeSpan);
+        _timer = CreateTimer(this);
         _postDrain = ArmDrainTimer;
         _scheduleDelayed = ThreadPoolSequencer.Instance.Schedule;
         _state = new(this, Post, RunDrain, ScheduleDelayed);
@@ -98,13 +92,10 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         ReleaseQueuedIfDisposed();
     }
 
-    /// <summary>
-    /// Releases the drain timer and cancels queued work. Further scheduling throws.
-    /// Delayed work on the shared timer is released when due unless its caller cancels it first.
-    /// </summary>
+    /// <summary>Cancels queued immediate work and rejects further scheduling.</summary>
+    /// <remarks>Delayed work is released when due unless its caller cancels it first.</remarks>
     public void Dispose()
     {
-        // Timer arming and disposal share the gate; disposal does not wait for active callbacks.
         lock (_gate)
         {
             if (IsDisposed)
@@ -127,6 +118,13 @@ internal void ScheduleReady(IWorkItem item)
         ReleaseQueuedIfDisposed();
     }
 
+    /// <summary>Creates a disarmed timer that drains ready work.</summary>
+    /// <param name="owner">The sequencer receiving timer callbacks.</param>
+    /// <returns>The disarmed timer.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    private static Timer CreateTimer(WasmSequencer owner) =>
+        new(static state => ((WasmSequencer)state!).RunDrain(), owner, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+
     /// <summary>Arms the drain timer to fire on the next event-loop turn.</summary>
     /// <param name="drain">The callback to post.</param>
     /// <returns><see langword="true"/> when the timer accepted the change.</returns>
@@ -134,7 +132,6 @@ private bool Post(Action drain)
     {
         lock (_gate)
         {
-            // Reject posts after disposal so the drain claim is released.
             return !IsDisposed && _postDrain(drain);
         }
     }
@@ -193,7 +190,6 @@ public void Execute()
                 return;
             }
 
-            // A disposal racing this enqueue is caught by ScheduleReady, which releases the queue it just joined.
             _owner.ScheduleReady(_item);
         }
 
diff --git a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
index 91ebc63d..11ea50d4 100644
--- a/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
+++ b/src/ReactiveUI.Primitives/Platforms/android/HandlerSequencer.cs
@@ -8,11 +8,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Android sequencer that coalesces scheduled work onto the thread backing a <see cref="Handler"/> (typically the
-/// main/UI looper). Immediate work is batched through a single cached <see cref="Java.Lang.IRunnable"/> drain, so the
-/// per-post path allocates nothing; delayed work uses the native <see cref="Handler.PostDelayed(Java.Lang.IRunnable, long)"/>.
-/// </summary>
+/// <summary>Schedules immediate and delayed work on the Android handler thread.</summary>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class HandlerSequencer : ISequencer
@@ -69,12 +65,20 @@ public HandlerSequencer(Handler handler)
     private bool Post(Action drain)
     {
         _drainRunnable ??= new Java.Lang.Runnable(drain);
-        return Handler.Post(_drainRunnable);
+        return PostToHandler(_drainRunnable);
     }
 
+    /// <summary>Posts the runnable through the native handler.</summary>
+    /// <param name="runnable">The runnable to post.</param>
+    /// <returns>Whether the handler accepted the runnable.</returns>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool PostToHandler(Java.Lang.IRunnable runnable) => Handler.Post(runnable);
+
     /// <summary>Runs delayed work through the handler's native delayed post.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp) =>
         Handler.PostDelayed(
diff --git a/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs b/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
index 4a9b5ef1..e712c83a 100644
--- a/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
+++ b/src/ReactiveUI.Primitives/Platforms/apple/NSRunloopSequencer.cs
@@ -8,11 +8,7 @@
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>
-/// Apple sequencer that coalesces scheduled work onto the main <see cref="DispatchQueue"/> (the UI thread on
-/// iOS, tvOS, Mac Catalyst, and macOS). Immediate work is batched through a single cached <see cref="DispatchBlock"/>
-/// drain, so the per-post path allocates nothing; delayed work uses <see cref="DispatchQueue.DispatchAfter(DispatchTime, Action)"/>.
-/// </summary>
+/// <summary>Schedules immediate and delayed work on the Apple main dispatch queue.</summary>
 /// <seealso cref="ISequencer" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class NSRunloopSequencer : ISequencer
@@ -56,19 +52,26 @@ public sealed class NSRunloopSequencer : ISequencer
     /// <summary>Runs delayed work through the main queue's native delayed dispatch.</summary>
     /// <param name="item">Work item to execute at the due time.</param>
     /// <param name="dueTimestamp">Absolute monotonic timestamp at which to execute the item.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
     private static void ScheduleDelayed(IWorkItem item, long dueTimestamp)
     {
         var nanoseconds = (long)DispatchSequencerState.DelayUntil(dueTimestamp).TotalMilliseconds * NanosecondsPerMillisecond;
         DispatchQueue.MainQueue.DispatchAfter(new(DispatchTime.Now, nanoseconds), () => DispatchSequencerState.RunIfActive(item));
     }
 
+    /// <summary>Posts the block through the native main queue.</summary>
+    /// <param name="block">The callback block to post.</param>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void DispatchOnMainQueue(DispatchBlock block) => DispatchQueue.MainQueue.DispatchAsync(block);
+
     /// <summary>Marshals the cached drain callback onto the main dispatch queue.</summary>
     /// <param name="drain">The drain callback.</param>
     /// <returns><see langword="true"/>, since the main queue always accepts the work.</returns>
     private bool Post(Action drain)
     {
         _drainBlock ??= new DispatchBlock(drain);
-        DispatchQueue.MainQueue.DispatchAsync(_drainBlock);
+        DispatchOnMainQueue(_drainBlock);
         return true;
     }
 
diff --git a/src/ReactiveUI.Primitives/RxVoid.cs b/src/ReactiveUI.Primitives/RxVoid.cs
index 9762bbcb..1a6e6dd8 100644
--- a/src/ReactiveUI.Primitives/RxVoid.cs
+++ b/src/ReactiveUI.Primitives/RxVoid.cs
@@ -18,14 +18,14 @@ namespace ReactiveUI.Primitives;
     [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
-    /// <summary>Determines whether the two specified <see cref="RxVoid"/> values are not equal. Because <see cref="RxVoid"/> has a single value, this always returns <c>false</c>.</summary>
+    /// <summary>Returns false because all RxVoid values are equal.</summary>
     /// <param name="first">The first <see cref="RxVoid"/> value to compare.</param>
     /// <param name="second">The second <see cref="RxVoid"/> value to compare.</param>
     /// <returns>Because <see cref="RxVoid"/> has a single value, this always returns <c>false</c>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(RxVoid first, RxVoid second) => false;
 
-    /// <summary>Determines whether the two specified <see cref="RxVoid"/> values are equal. Because <see cref="RxVoid"/> has a single value, this always returns <c>true</c>.</summary>
+    /// <summary>Returns true because all RxVoid values are equal.</summary>
     /// <param name="first">The first <see cref="RxVoid"/> value to compare.</param>
     /// <param name="second">The second <see cref="RxVoid"/> value to compare.</param>
     /// <returns>Because <see cref="RxVoid"/> has a single value, this always returns <c>true</c>.</returns>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/BooleanSignalWitness.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/BooleanSignalWitness.cs
index 7d905bd2..5aca5a59 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/BooleanSignalWitness.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/BooleanSignalWitness.cs
@@ -17,7 +17,7 @@ internal sealed class BooleanSignalWitness : IObserver<bool>
     internal int ErrorCount { get; private set; }
 
     /// <summary>Called when a value is received.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The observed value.</param>
     public void OnNext(bool value) => Value = value;
 
     /// <summary>Called when an error is observed.</summary>
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/IntR3ActionWitness.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/IntR3ActionWitness.cs
index 76c787bf..7043483f 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/IntR3ActionWitness.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/IntR3ActionWitness.cs
@@ -17,7 +17,7 @@ internal sealed class IntR3ActionWitness : Observer<int>
     public IntR3ActionWitness(Action<int>? onNext = null) => _onNext = onNext;
 
     /// <summary>Receives the next value.</summary>
-    /// <param name="value">The value.</param>
+    /// <param name="value">The observed value.</param>
     protected override void OnNextCore(int value) => _onNext?.Invoke(value);
 
     /// <summary>Receives an error.</summary>
diff --git a/src/tests/ReactiveUI.Disposables.Tests/SingleReplaceableDisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/SingleReplaceableDisposableTests.cs
new file mode 100644
index 00000000..52a1b209
--- /dev/null
+++ b/src/tests/ReactiveUI.Disposables.Tests/SingleReplaceableDisposableTests.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Disposables.Tests;
+
+/// <summary>Tests replacement ownership when an observed slot changes.</summary>
+public class SingleReplaceableDisposableTests
+{
+    /// <summary>The callback count after disposal and a later rejected assignment.</summary>
+    private const int DisposeAndAssignmentCallbacks = 2;
+
+    /// <summary>A stale replacement leaves both the current and incoming resources untouched.</summary>
+    /// <param name="initiallyEmpty">True when the original slot is empty.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TryCreate_StaleObservation_RetriesWithoutReleasingUnownedValues(bool initiallyEmpty)
+    {
+        CountingDisposable initial = new();
+        CountingDisposable competing = new();
+        CountingDisposable incoming = new();
+        IDisposable? observed = initiallyEmpty ? null : initial;
+        SingleReplaceableDisposable slot = initiallyEmpty ? new() : new(initial);
+        slot.Create(competing);
+
+        await Assert.That(slot.TryCreate(observed, incoming)).IsFalse();
+        await Assert.That(initial.DisposeCount).IsEqualTo(initiallyEmpty ? 0 : 1);
+        await Assert.That(competing.DisposeCount).IsEqualTo(0);
+        await Assert.That(incoming.DisposeCount).IsEqualTo(0);
+
+        await Assert.That(slot.TryCreate(competing, incoming)).IsTrue();
+        await Assert.That(competing.DisposeCount).IsEqualTo(1);
+        await Assert.That(incoming.DisposeCount).IsEqualTo(0);
+        slot.Dispose();
+        await Assert.That(incoming.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposal between observation and assignment rejects publication and releases the later assignment.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TryCreate_DisposedAfterObservation_DoesNotPublishIncomingValue()
+    {
+        CountingDisposable initial = new();
+        CountingDisposable incoming = new();
+        var callbacks = 0;
+        SingleReplaceableDisposable slot = new(initial, () => callbacks++);
+        slot.Dispose();
+
+        await Assert.That(slot.TryCreate(initial, incoming)).IsFalse();
+        await Assert.That(initial.DisposeCount).IsEqualTo(1);
+        await Assert.That(incoming.DisposeCount).IsEqualTo(0);
+
+        slot.Create(incoming);
+
+        await Assert.That(slot.IsDisposed).IsTrue();
+        await Assert.That(incoming.DisposeCount).IsEqualTo(1);
+        await Assert.That(callbacks).IsEqualTo(DisposeAndAssignmentCallbacks);
+    }
+
+    /// <summary>Counts every disposal invocation.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of disposal invocations.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
index 7c5db18a..c7c2c0a1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncRenameCoverageTests.cs
@@ -82,7 +82,7 @@ public async Task AsyncContextRenamedMembersExposeDefaultAndSequencerSchedulerPa
         await Assert.That(AsyncContext.Default.UsesDefaultSequencer).IsTrue();
         await Assert.That(sequencerContext.UsesDefaultSequencer).IsFalse();
         await Assert.That(AsyncContext.From(new SynchronizationContext()).UsesDefaultSequencer).IsFalse();
-        await Assert.That(AsyncContext.From(CustomTaskScheduler.Instance).UsesDefaultSequencer).IsFalse();
+        await Assert.That(AsyncContext.From(new CustomTaskScheduler()).UsesDefaultSequencer).IsFalse();
         await Assert.That(syncSequencerContext.SynchronizationContext).IsSameReferenceAs(syncSequencer);
         await Assert.That(sequencerContext.IsSameAsCurrentAsyncContext()).IsFalse();
         await Assert.That(scheduler.Sequencer).IsSameReferenceAs(sequencer);
@@ -121,7 +121,7 @@ public async Task AsyncContextSwitcherBranchesCoverCustomSchedulersAndCancellati
         canceledAwaitable.OnCompleted(() => cancellationCallbacks++);
         await Assert.That(cancellationCallbacks).IsEqualTo(1);
         TaskCompletionSource scheduled = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var schedulerAwaitable = AsyncContext.From(CustomTaskScheduler.Instance)
+        var schedulerAwaitable = AsyncContext.From(new CustomTaskScheduler())
             .SwitchContextAsync(true, CancellationToken.None);
         schedulerAwaitable.OnCompleted(scheduled.SetResult);
         await scheduled.Task.ConfigureAwait(false);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CancellationStopCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CancellationStopCoordinatorTests.cs
new file mode 100644
index 00000000..38c3b0df
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CancellationStopCoordinatorTests.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests cancellation completion through the serialized notification path.</summary>
+public sealed class CancellationStopCoordinatorTests
+{
+    /// <summary>The recorded value notification.</summary>
+    private const string ValueNotification = "value";
+
+    /// <summary>The recorded start of completion.</summary>
+    private const string CompletionEntered = "completion entered";
+
+    /// <summary>Completion waits for the downstream completion callback.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task CompleteFromCancellationAsync_WhenCompletionIsPending_ThenWaitsForObserver()
+    {
+        var source = Signal.Create<int>();
+        TaskCompletionSource resume = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<string> calls = [];
+        CallbackWitnessAsync<int> observer = new(
+            (_, _) =>
+        {
+            calls.Add(ValueNotification);
+            return default;
+        },
+            null,
+            async result =>
+        {
+            calls.Add(result.IsSuccess ? CompletionEntered : "failed");
+            await resume.Task;
+            calls.Add("completion finished");
+        });
+        SignalAsyncExtensions.CancellationStopSignal<int> signal = new(source.Values, CancellationToken.None);
+        await using SignalAsyncExtensions.CancellationStopSignal<int>.CancellationStopCoordinator coordinator = new(signal, observer);
+        await coordinator.SubscribeSourcesAsync(CancellationToken.None);
+        await source.OnNextAsync(1, CancellationToken.None);
+        var completion = coordinator.CompleteFromCancellationAsync().AsTask();
+        await Assert.That(completion.IsCompleted).IsFalse();
+        await Assert.That(calls).IsCollectionEqualTo([ValueNotification, CompletionEntered]);
+        resume.SetResult();
+        await completion;
+        await Assert.That(calls).IsCollectionEqualTo([ValueNotification, CompletionEntered, "completion finished"]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ContextSwitchSignalAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ContextSwitchSignalAsyncTests.cs
new file mode 100644
index 00000000..abc2984b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ContextSwitchSignalAsyncTests.cs
@@ -0,0 +1,263 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests notification context switches through explicitly delivered callbacks.</summary>
+public class ContextSwitchSignalAsyncTests
+{
+    /// <summary>The value delivered by the source.</summary>
+    private const int Sentinel = 7;
+
+    /// <summary>Default context overloads construct context-switching signals without dispatching.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DefaultContextOverloadsWrapTheSource()
+    {
+        var source = SignalAsync.Return(Sentinel);
+        await Assert.That(source.WitnessOn(AsyncContext.Default, true)).IsTypeOf<WitnessOnSignal<int>>();
+        await Assert.That(source.WitnessOn(AsyncContext.Default)).IsTypeOf<WitnessOnSignal<int>>();
+        await Assert.That(source.WitnessOn(TaskScheduler.Default)).IsTypeOf<WitnessOnSignal<int>>();
+        await Assert.That(source.WitnessOn(new SynchronizationContext())).IsTypeOf<WitnessOnSignal<int>>();
+    }
+
+    /// <summary>The async context overload waits for a callback before delivering a value.</summary>
+    /// <param name="forceYielding">Whether to force a context switch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task AsyncContextOverloadWaitsForDelivery(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        await using var subscription = await source.Values.WitnessOn(AsyncContext.From(context), forceYielding)
+            .SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnNextAsync(Sentinel, CancellationToken.None);
+        await Assert.That(observer.Value).IsNull();
+        await Assert.That(context.PendingCount).IsEqualTo(1);
+        context.RunNext();
+        await pending;
+        await Assert.That(observer.Value).IsEqualTo(Sentinel);
+    }
+
+    /// <summary>Synchronization context overloads retain notifications until their callback runs.</summary>
+    /// <param name="forceYielding">Whether to use the forced-yield overload.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task SynchronizationContextOverloadsWaitForDelivery(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        var observed = forceYielding ? source.Values.WitnessOn(context, true) : source.Values.WitnessOn(context);
+        await using var subscription = await observed.SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnNextAsync(Sentinel, CancellationToken.None);
+        await Assert.That(observer.Value).IsNull();
+        context.RunNext();
+        await pending;
+        await Assert.That(observer.Value).IsEqualTo(Sentinel);
+    }
+
+    /// <summary>Task scheduler overloads wait for explicit scheduler execution.</summary>
+    /// <param name="forceYielding">Whether to use the forced-yield overload.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TaskSchedulerOverloadsWaitForDelivery(bool forceYielding)
+    {
+        ManualTaskScheduler scheduler = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        var observed = forceYielding ? source.Values.WitnessOn(scheduler, true) : source.Values.WitnessOn(scheduler);
+        await using var subscription = await observed.SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnNextAsync(Sentinel, CancellationToken.None);
+        await Assert.That(observer.Value).IsNull();
+        await Assert.That(scheduler.PendingCount).IsEqualTo(1);
+        scheduler.RunNext();
+        await pending;
+        await Assert.That(observer.Value).IsEqualTo(Sentinel);
+    }
+
+    /// <summary>Failure completion is delivered only after the context callback runs.</summary>
+    /// <param name="forceYielding">Whether to force a context switch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task FailureCompletionWaitsForDelivery(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        InvalidOperationException expected = new();
+        await using var subscription = await source.Values.WitnessOn(context, forceYielding)
+            .SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnCompletedAsync(Result.Failure(expected));
+        await Assert.That(observer.Completion).IsNull();
+        context.RunNext();
+        await pending;
+        await Assert.That(observer.Completion!.Value.Exception).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Successful completion waits for the context callback.</summary>
+    /// <param name="forceYielding">Whether to force a context switch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task SuccessfulCompletionWaitsForDelivery(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        await using var subscription = await source.Values.WitnessOn(context, forceYielding)
+            .SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnCompletedAsync(Result.Success);
+        await Assert.That(observer.Completion).IsNull();
+        context.RunNext();
+        await pending;
+        await Assert.That(observer.Completion!.Value.IsSuccess).IsTrue();
+    }
+
+    /// <summary>A resumable error waits for the context callback and preserves its identity.</summary>
+    /// <param name="forceYielding">Whether to force a context switch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task ResumableErrorWaitsForDelivery(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        InvalidOperationException expected = new();
+        await using var subscription = await source.Values.WitnessOn(context, forceYielding)
+            .SubscribeAsync(observer, CancellationToken.None);
+        var pending = source.OnErrorResumeAsync(expected, CancellationToken.None);
+        await Assert.That(observer.Error).IsNull();
+        context.RunNext();
+        await pending;
+        await Assert.That(observer.Error).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Direct forwarding waits for each manually delivered continuation.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DirectForwardingWaitsForEachDelivery()
+    {
+        ManualContext context = new();
+        RecordingWitness observer = new();
+        await using ContextSwitchSignalAsync<int>.ContextSwitchWitness witness = new(observer, AsyncContext.From(context), true);
+        var value = witness.ForwardAfterContextSwitchAsync(Sentinel, CancellationToken.None);
+        await Assert.That(observer.Value).IsNull();
+        context.RunNext();
+        await value;
+        await Assert.That(observer.Value).IsEqualTo(Sentinel);
+        InvalidOperationException expected = new();
+        var error = witness.ForwardErrorAfterContextSwitchAsync(expected, CancellationToken.None);
+        await Assert.That(observer.Error).IsNull();
+        context.RunNext();
+        await error;
+        await Assert.That(observer.Error).IsSameReferenceAs(expected);
+        var completion = witness.ForwardCompletionAfterContextSwitchAsync(Result.Success);
+        await Assert.That(observer.Completion).IsNull();
+        context.RunNext();
+        await completion;
+        await Assert.That(observer.Completion!.Value.IsSuccess).IsTrue();
+    }
+
+    /// <summary>Subscribing directly wraps every notification kind in the selected context.</summary>
+    /// <param name="forceYielding">Whether to force a context switch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task SubscribeWrapsAllNotificationKinds(bool forceYielding)
+    {
+        ManualContext context = new();
+        var source = Signal.Create<int>();
+        RecordingWitness observer = new();
+        IObservableAsync<int> signal = new ContextSwitchSignalAsync<int>(source.Values, AsyncContext.From(context), forceYielding);
+        await using var subscription = await signal.SubscribeAsync(observer, CancellationToken.None);
+        var value = source.OnNextAsync(Sentinel, CancellationToken.None);
+        context.RunNext();
+        await value;
+        await Assert.That(observer.Value).IsEqualTo(Sentinel);
+        InvalidOperationException expected = new();
+        var error = source.OnErrorResumeAsync(expected, CancellationToken.None);
+        context.RunNext();
+        await error;
+        await Assert.That(observer.Error).IsSameReferenceAs(expected);
+        var completion = source.OnCompletedAsync(Result.Success);
+        context.RunNext();
+        await completion;
+        await Assert.That(observer.Completion!.Value.IsSuccess).IsTrue();
+    }
+
+    /// <summary>Retains context continuations until explicitly invoked.</summary>
+    private sealed class ManualContext : SynchronizationContext
+    {
+        /// <summary>Pending callbacks and their state.</summary>
+        private readonly Queue<(SendOrPostCallback Callback, object? State)> _callbacks = new();
+
+        /// <summary>Gets the number of pending callbacks.</summary>
+        public int PendingCount => _callbacks.Count;
+
+        /// <inheritdoc/>
+        public override void Post(SendOrPostCallback d, object? state) => _callbacks.Enqueue((d, state));
+
+        /// <summary>Runs one retained continuation.</summary>
+        public void RunNext()
+        {
+            var pending = _callbacks.Dequeue();
+            pending.Callback(pending.State);
+        }
+    }
+
+    /// <summary>Records notifications without scheduling continuations.</summary>
+    private sealed class RecordingWitness : IObserverAsync<int>
+    {
+        /// <summary>Gets the last value.</summary>
+        public int? Value { get; private set; }
+
+        /// <summary>Gets the last resumable error.</summary>
+        public Exception? Error { get; private set; }
+
+        /// <summary>Gets the completion result.</summary>
+        public Result? Completion { get; private set; }
+
+        /// <inheritdoc/>
+        public ValueTask OnNextAsync(int value, CancellationToken cancellationToken)
+        {
+            Value = value;
+            return default;
+        }
+
+        /// <inheritdoc/>
+        public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken)
+        {
+            Error = error;
+            return default;
+        }
+
+        /// <inheritdoc/>
+        public ValueTask OnCompletedAsync(Result result)
+        {
+            Completion = result;
+            return default;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask DisposeAsync() => default;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
index 29cbcefa..63ba017d 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CustomTaskScheduler.cs
@@ -2,37 +2,64 @@
 // ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>A scheduler distinct from <see cref="TaskScheduler.Default"/> that runs each queued task on the thread pool.</summary>
+/// <summary>Runs tasks on the calling thread, queuing nested work until the current task returns.</summary>
 internal sealed class CustomTaskScheduler : TaskScheduler
 {
-    /// <summary>Singleton instance.</summary>
-    internal static readonly CustomTaskScheduler Instance = new();
+    /// <summary>Serializes access to pending work.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>Tasks waiting for the current task to return.</summary>
+    private readonly Queue<Task> _tasks = new();
+
+    /// <summary>Whether a caller is executing pending work.</summary>
+    private bool _isDraining;
 
     /// <summary>Initializes a new instance of the <see cref="CustomTaskScheduler"/> class.</summary>
-    private CustomTaskScheduler()
+    internal CustomTaskScheduler()
     {
     }
 
     /// <inheritdoc/>
-    protected override void QueueTask(Task task) =>
-        ThreadPool.UnsafeQueueUserWorkItem(
-            static state => IgnoredResult.Of(state.Scheduler.ExecuteQueued(state.Work)),
-            (Scheduler: this, Work: task),
-            false);
+    protected override void QueueTask(Task task)
+    {
+        lock (_gate)
+        {
+            _tasks.Enqueue(task);
+            if (_isDraining)
+            {
+                return;
+            }
+
+            _isDraining = true;
+        }
+
+        while (true)
+        {
+            Task? next;
+            lock (_gate)
+            {
+                if (!_tasks.TryDequeue(out next))
+                {
+                    _isDraining = false;
+                    return;
+                }
+            }
+
+            IgnoredResult.Of(TryExecuteTask(next));
+        }
+    }
 
     /// <inheritdoc/>
     protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
 
     /// <inheritdoc/>
-    protected override IEnumerable<Task>? GetScheduledTasks() => null;
-
-    /// <summary>Runs a queued task on the pool thread that picked it up.</summary>
-    /// <param name="task">The queued task.</param>
-    /// <returns><see langword="true"/> when the task was executed.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private bool ExecuteQueued(Task task) => TryExecuteTask(task);
+    protected override IEnumerable<Task>? GetScheduledTasks()
+    {
+        lock (_gate)
+        {
+            return _tasks.ToArray();
+        }
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
index 5713d6d1..33a357e6 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
@@ -132,7 +132,7 @@ public async Task WhenRetryOnTransientError_ThenSucceedsAfterRetry()
                 await obs.OnNextAsync(SuccessValue, ct);
                 await obs.OnCompletedAsync(Result.Success);
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         var result = await source.Retry(RetryCount).ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SuccessValue]);
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
@@ -226,7 +226,7 @@ public async Task WhenRetryWithCountZero_ThenPropagatesErrorImmediately()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         await using var sub = await source.Retry(0).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -253,7 +253,7 @@ public async Task WhenRetryCountExhausted_ThenPropagatesLastError()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         await using var sub = await source.Retry(RetryCount).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -278,7 +278,7 @@ public async Task WhenRetryWithCountOne_ThenRetriesOnceAndPropagates()
                 attempt++;
                 await obs.OnCompletedAsync(Result.Failure(new InvalidOperationException($"attempt {attempt}")));
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         await using var sub = await source.Retry(1).SubscribeAsync(static (_, _) => default, null, result =>
         {
             _ = completed.TrySetResult(result);
@@ -480,7 +480,7 @@ public async Task WhenRetryParameterless_ThenRetriesUntilSuccess()
                 await obs.OnNextAsync(SuccessValue, ct);
                 await obs.OnCompletedAsync(Result.Success);
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         var result = await source.Retry().ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SuccessValue]);
         await Assert.That(attempt).IsEqualTo(ExpectedAttempts);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
index 1a5f4665..add6f9f1 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/FactorySignalTests.cs
@@ -247,7 +247,7 @@ static async (observer, ct) =>
                 await observer.OnNextAsync(SentinelValue, ct);
                 await observer.OnCompletedAsync(Result.Success);
             },
-            CustomTaskScheduler.Instance);
+            new CustomTaskScheduler());
         var result = await source.ToListAsync();
         await Assert.That(result).IsCollectionEqualTo([SentinelValue]);
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
new file mode 100644
index 00000000..0db42ad6
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests interval cancellation and notification ordering with a controlled clock.</summary>
+public sealed class IntervalSubscriptionTests
+{
+    /// <summary>Cancellation while waiting prevents the pending tick from being delivered.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ExecuteAsync_WhenCanceledBeforeTheTimer_ThenDoesNotEmit()
+    {
+        ManualTimeProvider time = new();
+        using CancellationTokenSource cancellation = new();
+        List<long> ticks = [];
+        List<Result> completions = [];
+        CallbackWitnessAsync<long> observer = new(
+            (tick, _) =>
+        {
+            ticks.Add(tick);
+            return default;
+        },
+            null,
+            result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        await using IntervalSubscription subscription = new(observer, TimeSpan.FromSeconds(1), time);
+        var running = subscription.ExecuteAsync(cancellation.Token).AsTask();
+        var timer = await time.NextTimerAsync();
+        await cancellation.CancelAsync();
+        await running;
+        timer.Fire();
+        await Assert.That(ticks).IsEmpty();
+        await Assert.That(completions).Count().IsEqualTo(1);
+        await Assert.That(completions[0].Exception).IsTypeOf<TaskCanceledException>();
+    }
+
+    /// <summary>The next delay starts only after the current notification finishes.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ExecuteAsync_WhenNotificationIsPending_ThenDoesNotScheduleAnotherTick()
+    {
+        ManualTimeProvider time = new();
+        using CancellationTokenSource cancellation = new();
+        TaskCompletionSource entered = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource resume = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<long> ticks = [];
+        CallbackWitnessAsync<long> observer = new(
+            async (tick, _) =>
+        {
+            ticks.Add(tick);
+            entered.SetResult();
+            await resume.Task;
+        },
+            null,
+            null);
+        await using IntervalSubscription subscription = new(observer, TimeSpan.FromSeconds(1), time);
+        var running = subscription.ExecuteAsync(cancellation.Token).AsTask();
+        await time.FireNextAsync();
+        await entered.Task;
+        await Assert.That(time.PendingTimerCount).IsEqualTo(0);
+        await cancellation.CancelAsync();
+        resume.SetResult();
+        await running;
+        await Assert.That(ticks).IsCollectionEqualTo([1L]);
+        await Assert.That(time.PendingTimerCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTaskScheduler.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTaskScheduler.cs
new file mode 100644
index 00000000..5f4a0ab7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ManualTaskScheduler.cs
@@ -0,0 +1,27 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Retains scheduled tasks until explicitly executed.</summary>
+internal sealed class ManualTaskScheduler : TaskScheduler
+{
+    /// <summary>Tasks waiting for execution.</summary>
+    private readonly Queue<Task> _tasks = new();
+
+    /// <summary>Gets the number of tasks waiting for execution.</summary>
+    internal int PendingCount => _tasks.Count;
+
+    /// <summary>Executes the oldest queued task.</summary>
+    internal void RunNext() => _ = TryExecuteTask(_tasks.Dequeue());
+
+    /// <inheritdoc/>
+    protected override void QueueTask(Task task) => _tasks.Enqueue(task);
+
+    /// <inheritdoc/>
+    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
+
+    /// <inheritdoc/>
+    protected override IEnumerable<Task> GetScheduledTasks() => _tasks;
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
deleted file mode 100644
index 0eb0e4bf..00000000
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnAsyncSignalTests.cs
+++ /dev/null
@@ -1,322 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated 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;
-using ReactiveUI.Primitives.Async.Signals;
-
-namespace ReactiveUI.Primitives.Async.Tests;
-
-/// <summary>Tests for <see cref="ContextSwitchSignalAsync{T}"/> — exercises the
-/// <c>forceYielding: true</c> slow-path branches that switch context on every
-/// <c>OnNext</c> / <c>OnErrorResume</c> / <c>OnCompleted</c> regardless of whether
-/// the call site is already on the target context.</summary>
-public class ObserveOnAsyncSignalTests
-{
-    /// <summary>Single sentinel emitted by the happy-path tests.</summary>
-    private const int Sentinel = 7;
-
-    /// <summary>Verifies the <c>forceYielding: true</c> overload forwards values via the context-switching slow path.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForceYielding_ThenValueForwarded()
-    {
-        var result = await SignalAsync.Return(Sentinel)
-            .WitnessOn(AsyncContext.Default, true)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies the <c>forceYielding: true</c> overload routes <c>OnErrorResume</c> through the context-switching slow path.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForceYieldingSourceErrors_ThenErrorForwarded()
-    {
-        InvalidOperationException expected = new("forced");
-        InvalidOperationException? caught = null;
-
-        try
-        {
-            await SignalAsync.Throw<int>(expected)
-                .WitnessOn(AsyncContext.Default, true)
-                .ToListAsync();
-        }
-        catch (InvalidOperationException ex)
-        {
-            caught = ex;
-        }
-
-        await Assert.That(caught).IsSameReferenceAs(expected);
-    }
-
-    /// <summary>Verifies the <c>forceYielding: true</c> overload routes the completion notification through the context-switching slow path.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForceYieldingSourceEmpty_ThenCompletesSuccessfully()
-    {
-        var result = await SignalAsync.Empty<int>()
-            .WitnessOn(AsyncContext.Default, true)
-            .ToListAsync();
-
-        await Assert.That(result).IsEmpty();
-    }
-
-    /// <summary>Verifies the <c>SynchronizationContext</c> + <c>forceYielding: true</c> overload also forwards values.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSyncContextForceYielding_ThenEmits()
-    {
-        var ctx = SynchronizationContext.Current ?? new SynchronizationContext();
-
-        var result = await SignalAsync.Return(Sentinel)
-            .WitnessOn(ctx, true)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies the default <c>SynchronizationContext</c> overload forwards through the non-forced wrapper.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenSyncContextDefaultOverload_ThenEmits()
-    {
-        var ctx = SynchronizationContext.Current ?? new SynchronizationContext();
-
-        var result = await SignalAsync.Return(Sentinel)
-            .WitnessOn(ctx)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies the default <see cref="TaskScheduler"/> overload forwards through the non-forced wrapper.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenTaskSchedulerDefaultOverload_ThenEmits()
-    {
-        var result = await SignalAsync.Return(Sentinel)
-            .WitnessOn(TaskScheduler.Default)
-            .FirstAsync();
-
-        await Assert.That(result).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies that <c>ObserveOn</c> with a different SynchronizationContext routes
-    /// the error through the slow-path context-switch even when <c>forceYielding</c> is false.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnDifferentContextSourceErrors_ThenForwardedViaSlowPath()
-    {
-        InvalidOperationException expected = new("differing-context-error");
-        InvalidOperationException? caught = null;
-        SynchronizationContext customCtx = new();
-
-        try
-        {
-            await SignalAsync.Throw<int>(expected)
-                .WitnessOn(customCtx, false)
-                .ToListAsync();
-        }
-        catch (InvalidOperationException ex)
-        {
-            caught = ex;
-        }
-
-        await Assert.That(caught).IsSameReferenceAs(expected);
-    }
-
-    /// <summary>Verifies that <c>ObserveOn</c> with a different SynchronizationContext routes
-    /// the completion through the slow-path context-switch even when <c>forceYielding</c> is false.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenObserveOnDifferentContextSourceEmpty_ThenCompletesViaSlowPath()
-    {
-        SynchronizationContext customCtx = new();
-
-        var result = await SignalAsync.Empty<int>()
-            .WitnessOn(customCtx, false)
-            .ToListAsync();
-
-        await Assert.That(result).IsEmpty();
-    }
-
-    /// <summary>Exercises <c>ContextSwitchObserver.OnErrorResumeAsyncCore</c>'s slow-path branch —
-    /// when <c>forceYielding == true</c>, the resumable-error path returns
-    /// <c>ForwardErrorAfterContextSwitchAsync(...)</c> rather than the fast-path direct forward.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForceYieldingSourceEmitsResumableError_ThenSlowPathForwards()
-    {
-        var signal = Signal.Create<int>();
-        Exception? caught = null;
-        TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await signal.Values
-            .WitnessOn(AsyncContext.Default, true)
-            .SubscribeAsync(
-                static (_, _) => default,
-                (ex, _) =>
-                {
-                    caught = ex;
-                    IgnoredResult.Of(errorTcs.TrySetResult());
-                    return default;
-                });
-
-        InvalidOperationException expected = new("observeon-resume");
-        await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-
-        await errorTcs.Task;
-        await Assert.That(caught).IsSameReferenceAs(expected);
-    }
-
-    /// <summary>Verifies <c>ContextSwitchObserver.ForwardAfterContextSwitchAsync</c> by calling it directly
-    /// — the slow path performs the context switch and then forwards the value downstream,
-    /// independent of the fast/slow choice in <c>OnNextAsyncCore</c>.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForwardAfterContextSwitchAsyncInvokedDirectly_ThenValueForwarded()
-    {
-        TaskCompletionSource<int> captured = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        CapturingAsyncWitness<int> downstream = new(captured);
-        ContextSwitchSignalAsync<int>.ContextSwitchWitness sut = new(downstream, AsyncContext.Default, true);
-
-        await sut.ForwardAfterContextSwitchAsync(Sentinel, CancellationToken.None);
-
-        var received = await captured.Task;
-        await Assert.That(received).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies <c>ContextSwitchObserver.ForwardErrorAfterContextSwitchAsync</c> by calling it directly.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForwardErrorAfterContextSwitchAsyncInvokedDirectly_ThenErrorForwarded()
-    {
-        TaskCompletionSource<Exception> captured = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        CapturingAsyncWitness<int> downstream = new(captured);
-        ContextSwitchSignalAsync<int>.ContextSwitchWitness sut = new(downstream, AsyncContext.Default, true);
-        InvalidOperationException expected = new("slow-path-error");
-
-        await sut.ForwardErrorAfterContextSwitchAsync(expected, CancellationToken.None);
-
-        var received = await captured.Task;
-        await Assert.That(received).IsSameReferenceAs(expected);
-    }
-
-    /// <summary>Verifies <c>ContextSwitchObserver.ForwardCompletionAfterContextSwitchAsync</c> by calling it directly.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenForwardCompletionAfterContextSwitchAsyncInvokedDirectly_ThenCompletionForwarded()
-    {
-        TaskCompletionSource<Result> captured = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        CapturingAsyncWitness<int> downstream = new(captured);
-        ContextSwitchSignalAsync<int>.ContextSwitchWitness sut = new(downstream, AsyncContext.Default, true);
-
-        await sut.ForwardCompletionAfterContextSwitchAsync(Result.Success);
-
-        var result = await captured.Task;
-        await Assert.That(result.IsSuccess).IsTrue();
-    }
-
-    /// <summary>Verifies that subscribing to a <see cref="ContextSwitchSignalAsync{T}"/> directly — rather than
-    /// through <c>WitnessOn</c>, which builds a <c>WitnessOnSignal</c> instead — wraps the downstream observer in
-    /// the context-switching witness and forwards source values through it.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenContextSwitchSignalSubscribed_ThenValueForwarded()
-    {
-        var signal = Signal.Create<int>();
-        ContextSwitchSignalAsync<int> sut = new(signal.Values, AsyncContext.Default, true);
-        TaskCompletionSource<int> received = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await sut.SubscribeAsync((x, _) =>
-        {
-            IgnoredResult.Of(received.TrySetResult(x));
-            return default;
-        });
-
-        await signal.OnNextAsync(Sentinel, CancellationToken.None);
-
-        var value = await received.Task;
-        await Assert.That(value).IsEqualTo(Sentinel);
-    }
-
-    /// <summary>Verifies that a resumable error raised by the source of a <see cref="ContextSwitchSignalAsync{T}"/>
-    /// reaches the downstream observer through the witness's <c>OnErrorResumeAsyncCore</c> context-switch path.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenContextSwitchSignalSourceEmitsResumableError_ThenErrorForwarded()
-    {
-        var signal = Signal.Create<int>();
-        ContextSwitchSignalAsync<int> sut = new(signal.Values, AsyncContext.Default, true);
-        Exception? caught = null;
-        TaskCompletionSource errorTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        await using var sub = await sut.SubscribeAsync(
-            static (_, _) => default,
-            (ex, _) =>
-            {
-                caught = ex;
-                IgnoredResult.Of(errorTcs.TrySetResult());
-                return default;
-            });
-
-        InvalidOperationException expected = new("context-switch-resume");
-        await signal.OnErrorResumeAsync(expected, CancellationToken.None);
-
-        await errorTcs.Task;
-        await Assert.That(caught).IsSameReferenceAs(expected);
-    }
-
-    /// <summary>Test observer that captures the first <c>OnNextAsync</c> value, the first
-    /// <c>OnErrorResumeAsync</c> exception, and the <c>OnCompletedAsync</c> result via TCSes.</summary>
-    /// <typeparam name="T">The element type.</typeparam>
-    private sealed class CapturingAsyncWitness<T> : IObserverAsync<T>
-    {
-        /// <summary>Captures the first <c>OnNextAsync</c> value, if a TCS was supplied.</summary>
-        private readonly TaskCompletionSource<T>? _onNext;
-
-        /// <summary>Captures the first <c>OnErrorResumeAsync</c> exception, if a TCS was supplied.</summary>
-        private readonly TaskCompletionSource<Exception>? _onError;
-
-        /// <summary>Captures the <c>OnCompletedAsync</c> result, if a TCS was supplied.</summary>
-        private readonly TaskCompletionSource<Result>? _onCompleted;
-
-        /// <summary>Initializes a new instance of the <see cref="CapturingAsyncWitness{T}"/> class with an <c>OnNext</c> capture target.</summary>
-        /// <param name="onNext">The TCS that receives the first <c>OnNextAsync</c> value.</param>
-        public CapturingAsyncWitness(TaskCompletionSource<T> onNext) => _onNext = onNext;
-
-        /// <summary>Initializes a new instance of the <see cref="CapturingAsyncWitness{T}"/> class with an <c>OnErrorResume</c> capture target.</summary>
-        /// <param name="onError">The TCS that receives the first <c>OnErrorResumeAsync</c> exception.</param>
-        public CapturingAsyncWitness(TaskCompletionSource<Exception> onError) => _onError = onError;
-
-        /// <summary>Initializes a new instance of the <see cref="CapturingAsyncWitness{T}"/> class with an <c>OnCompleted</c> capture target.</summary>
-        /// <param name="onCompleted">The TCS that receives the <c>OnCompletedAsync</c> result.</param>
-        public CapturingAsyncWitness(TaskCompletionSource<Result> onCompleted) => _onCompleted = onCompleted;
-
-        /// <inheritdoc/>
-        public ValueTask OnNextAsync(T value, CancellationToken cancellationToken)
-        {
-            _onNext?.TrySetResult(value);
-            return default;
-        }
-
-        /// <inheritdoc/>
-        public ValueTask OnErrorResumeAsync(Exception error, CancellationToken cancellationToken)
-        {
-            _onError?.TrySetResult(error);
-            return default;
-        }
-
-        /// <inheritdoc/>
-        public ValueTask OnCompletedAsync(Result result)
-        {
-            _onCompleted?.TrySetResult(result);
-            return default;
-        }
-
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public ValueTask DisposeAsync() => default;
-    }
-}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnIfOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnIfOperatorTests.cs
index 980c2f52..bef1d082 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnIfOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnIfOperatorTests.cs
@@ -4,11 +4,7 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Tests for the forced-yield overloads of the <c>ObserveOnIf</c> parity helper — the ones that take an
-/// explicit <c>forceYielding</c> flag. A false condition must hand the source back untouched; a true
-/// condition must wrap it in a context-switching sequence.
-/// </summary>
+/// <summary>Tests conditional context-switching wrapper selection.</summary>
 public class ObserveOnIfOperatorTests
 {
     /// <summary>The value the sources emit.</summary>
@@ -27,18 +23,17 @@ public async Task WhenObserveOnIfAsyncContextConditionFalseWithForcedYielding_Th
         await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies that a true condition makes the forced-yield <see cref="AsyncContext"/> overload wrap
-    /// the source in a context-switching sequence that still forwards the value.</summary>
+    /// <summary>A true condition selects the context-switching wrapper.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenObserveOnIfAsyncContextConditionTrueWithForcedYielding_ThenWrapsAndForwards()
+    public async Task WhenObserveOnIfAsyncContextConditionTrueWithForcedYielding_ThenWrapsSource()
     {
         var source = SignalAsync.Return(Sentinel);
 
         var observed = source.ObserveOnIf(true, AsyncContext.Default, true);
 
         await Assert.That(ReferenceEquals(observed, source)).IsFalse();
-        await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
+        await Assert.That(observed).IsTypeOf<WitnessOnSignal<int>>();
     }
 
     /// <summary>Verifies that a false condition makes the forced-yield <see cref="TaskScheduler"/> overload a no-op.</summary>
@@ -54,17 +49,16 @@ public async Task WhenObserveOnIfTaskSchedulerConditionFalseWithForcedYielding_T
         await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies that a true condition makes the forced-yield <see cref="TaskScheduler"/> overload wrap
-    /// the source in a context-switching sequence that still forwards the value.</summary>
+    /// <summary>A true condition selects the scheduler context wrapper.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenObserveOnIfTaskSchedulerConditionTrueWithForcedYielding_ThenWrapsAndForwards()
+    public async Task WhenObserveOnIfTaskSchedulerConditionTrueWithForcedYielding_ThenWrapsSource()
     {
         var source = SignalAsync.Return(Sentinel);
 
         var observed = source.ObserveOnIf(true, TaskScheduler.Default, true);
 
         await Assert.That(ReferenceEquals(observed, source)).IsFalse();
-        await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
+        await Assert.That(observed).IsTypeOf<WitnessOnSignal<int>>();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnSafeOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnSafeOperatorTests.cs
index 283b1bfc..ec834a4d 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnSafeOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ObserveOnSafeOperatorTests.cs
@@ -4,19 +4,13 @@
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
-/// <summary>
-/// Tests for the forced-yield overloads of the <c>ObserveOnSafe</c> parity helper — the ones that take an
-/// explicit <c>forceYielding</c> flag alongside an optional <see cref="AsyncContext"/> or
-/// <see cref="TaskScheduler"/>. A <see langword="null"/> target must hand back the source untouched;
-/// a supplied target must wrap it.
-/// </summary>
+/// <summary>Tests optional context targets and forced-yield wrapper selection.</summary>
 public class ObserveOnSafeOperatorTests
 {
     /// <summary>The value the sources emit.</summary>
     private const int Sentinel = 42;
 
-    /// <summary>Verifies that a null <see cref="AsyncContext"/> makes the forced-yield overload a no-op:
-    /// the very same sequence instance comes back rather than a context-switching wrapper.</summary>
+    /// <summary>A null context preserves the source instance.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
     public async Task WhenObserveOnSafeAsyncContextIsNullWithForcedYielding_ThenReturnsSourceUnchanged()
@@ -29,18 +23,17 @@ public async Task WhenObserveOnSafeAsyncContextIsNullWithForcedYielding_ThenRetu
         await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies that a supplied <see cref="AsyncContext"/> makes the forced-yield overload wrap the
-    /// source in a context-switching sequence that still forwards the value.</summary>
+    /// <summary>A supplied context selects the context-switching wrapper.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenObserveOnSafeAsyncContextSuppliedWithForcedYielding_ThenWrapsAndForwards()
+    public async Task WhenObserveOnSafeAsyncContextSuppliedWithForcedYielding_ThenWrapsSource()
     {
         var source = SignalAsync.Return(Sentinel);
 
         var observed = source.ObserveOnSafe(AsyncContext.Default, true);
 
         await Assert.That(ReferenceEquals(observed, source)).IsFalse();
-        await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
+        await Assert.That(observed).IsTypeOf<WitnessOnSignal<int>>();
     }
 
     /// <summary>Verifies that a null <see cref="TaskScheduler"/> makes the forced-yield overload a no-op.</summary>
@@ -56,17 +49,16 @@ public async Task WhenObserveOnSafeTaskSchedulerIsNullWithForcedYielding_ThenRet
         await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
     }
 
-    /// <summary>Verifies that a supplied <see cref="TaskScheduler"/> makes the forced-yield overload wrap the
-    /// source in a context-switching sequence that still forwards the value.</summary>
+    /// <summary>A supplied scheduler selects the context-switching wrapper.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
     [Test]
-    public async Task WhenObserveOnSafeTaskSchedulerSuppliedWithForcedYielding_ThenWrapsAndForwards()
+    public async Task WhenObserveOnSafeTaskSchedulerSuppliedWithForcedYielding_ThenWrapsSource()
     {
         var source = SignalAsync.Return(Sentinel);
 
         var observed = source.ObserveOnSafe(TaskScheduler.Default, true);
 
         await Assert.That(ReferenceEquals(observed, source)).IsFalse();
-        await Assert.That(await observed.FirstAsync()).IsEqualTo(Sentinel);
+        await Assert.That(observed).IsTypeOf<WitnessOnSignal<int>>();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/StartSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/StartSubscriptionTests.cs
new file mode 100644
index 00000000..4129c029
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/StartSubscriptionTests.cs
@@ -0,0 +1,105 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests ordered execution and failure delivery for start subscriptions.</summary>
+public sealed class StartSubscriptionTests
+{
+    /// <summary>Both start paths deliver the action result before successful completion.</summary>
+    /// <param name="schedule">Whether to queue the action.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Action_ThenValueAndCompletionAreDeliveredInOrder(bool schedule)
+    {
+        ManualTaskScheduler scheduler = new();
+        List<string> calls = [];
+        CallbackWitnessAsync<RxVoid> observer = new(
+            (_, _) =>
+        {
+            calls.Add("value");
+            return default;
+        },
+            null,
+            result =>
+        {
+            calls.Add(result.IsSuccess ? "completed" : "failed");
+            return default;
+        });
+        await using StartSubscription subscription = new(observer, () => calls.Add("action"), schedule ? scheduler : null);
+        var running = subscription.ExecuteAsync(CancellationToken.None).AsTask();
+        if (schedule)
+        {
+            await Assert.That(calls).IsEmpty();
+            scheduler.RunNext();
+        }
+
+        await running;
+        await Assert.That(calls).IsCollectionEqualTo(["action", "value", "completed"]);
+    }
+
+    /// <summary>A function failure completes the observer without emitting a value.</summary>
+    /// <param name="schedule">Whether to queue the function.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Function_WhenItThrows_ThenCompletesWithTheSameFailure(bool schedule)
+    {
+        ManualTaskScheduler scheduler = new();
+        InvalidOperationException expected = new("function failed");
+        List<int> values = [];
+        List<Result> completions = [];
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
+        {
+            values.Add(value);
+            return default;
+        },
+            null,
+            result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        await using StartSubscription<int> subscription = new(observer, () => throw expected, schedule ? scheduler : null);
+        var running = subscription.ExecuteAsync(CancellationToken.None).AsTask();
+        if (schedule)
+        {
+            await Assert.That(completions).IsEmpty();
+            scheduler.RunNext();
+        }
+
+        await running;
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completions).Count().IsEqualTo(1);
+        await Assert.That(completions[0].Exception).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Cancellation before dispatch prevents the user function from running.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Function_WhenCanceledBeforeDispatch_ThenDoesNotRun()
+    {
+        ManualTaskScheduler scheduler = new();
+        using CancellationTokenSource cancellation = new();
+        var calls = 0;
+        List<Result> completions = [];
+        CallbackWitnessAsync<int> observer = new(static (_, _) => default, null, result =>
+        {
+            completions.Add(result);
+            return default;
+        });
+        await using StartSubscription<int> subscription = new(observer, () => ++calls, scheduler);
+        var running = subscription.ExecuteAsync(cancellation.Token).AsTask();
+        await cancellation.CancelAsync();
+        scheduler.RunNext();
+        await running;
+        await Assert.That(calls).IsEqualTo(0);
+        await Assert.That(completions).Count().IsEqualTo(1);
+        await Assert.That(completions[0].Exception).IsTypeOf<TaskCanceledException>();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
index c92b2511..99a5b883 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TransformationOperatorTests.cs
@@ -611,63 +611,15 @@ public async Task WhenPrependSourceThrowsAndOnCompletedThrows_ThenSecondaryExcep
     public void WhenYieldNullSource_ThenThrowsArgumentNull() =>
         Assert.Throws<ArgumentNullException>(static () => SignalAsyncReactiveExtensions.Yield<int>(null!));
 
-    /// <summary>Verifies that Yield forwards all elements from the source sequence.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenYield_ThenForwardsAllElements()
-    {
-        const int Expected2 = 2;
-        const int Expected3 = 3;
-        const int Expected4 = 4;
-        const int Expected5 = 5;
-        const int SourceValueCount = 5;
-
-        var result = await SignalAsync.Range(1, SourceValueCount).Yield().ToListAsync();
-        await Assert.That(result).IsCollectionEqualTo([1, Expected2, Expected3, Expected4, Expected5]);
-    }
-
-    /// <summary>Verifies that Yield forwards completion from the source sequence.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
-    [Test]
-    public async Task WhenYield_ThenForwardsCompletion()
-    {
-        Result? capturedResult = null;
-        TaskCompletionSource tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        await using var sub = await SignalAsync.Return(SentinelValue)
-            .Yield()
-            .SubscribeAsync(static (_, _) => default, null, result =>
-        {
-            capturedResult = result;
-            _ = tcs.TrySetResult();
-            return default;
-        });
-        await tcs.Task;
-        await Assert.That(capturedResult).IsNotNull();
-        await Assert.That(capturedResult!.Value.IsSuccess).IsTrue();
-    }
-
-    /// <summary>Verifies that Yield forwards errors from the source sequence.</summary>
-    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Yield constructs the wrapper that captures the subscriber's context.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task WhenYieldSourceErrors_ThenForwardsError()
+    public async Task WhenYield_ThenWrapsSource()
     {
-        Result? capturedResult = null;
-        TaskCompletionSource tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        var source = SignalAsync.Create<int>(static async (observer, ct) =>
-        {
-            await observer.OnNextAsync(1, ct);
-            await observer.OnCompletedAsync(Result.Failure(new InvalidOperationException("yield error")));
-            return DisposableAsync.Empty;
-        });
-        await using var sub = await source.Yield().SubscribeAsync(static (_, _) => default, null, result =>
-        {
-            capturedResult = result;
-            _ = tcs.TrySetResult();
-            return default;
-        });
-        await tcs.Task;
-        await Assert.That(capturedResult).IsNotNull();
-        await Assert.That(capturedResult!.Value.IsSuccess).IsFalse();
+        var source = SignalAsync.Return(SentinelValue);
+        var observed = source.Yield();
+        await Assert.That(observed).IsTypeOf<SignalAsyncReactiveExtensions.YieldSignal<int>>();
+        await Assert.That(observed).IsNotSameReferenceAs(source);
     }
 
     /// <summary>Verifies that the three-argument GroupBy overload throws <see cref = "ArgumentNullException"/> when the source parameter is null.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
index 62c51891..45aeb85b 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaSchedulerTests.cs
@@ -3,109 +3,153 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using Avalonia.Threading;
 using ReactiveUI.Primitives.Reactive.Concurrency;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.Avalonia.Reactive.Tests;
 
-/// <summary>Tests for <see cref="AvaloniaScheduler"/> against a pumped Avalonia headless dispatcher.</summary>
+/// <summary>Tests scheduler ordering and cancellation through controlled dispatch callbacks.</summary>
 public sealed class AvaloniaSchedulerTests
 {
-    /// <summary>Verifies constructor validation.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>The second value in an ordered batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Public constructors reject a missing dispatcher.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcher() =>
+    public async Task ConstructorRejectsNullDispatcher()
+    {
         await Assert.That(static () => new AvaloniaScheduler(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new AvaloniaScheduler(null!, DispatcherPriority.Normal))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies the singleton uses Avalonia's UI dispatcher and legacy background priority.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Constructors and the singleton retain the selected dispatcher and priority.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task InstanceUsesUiDispatcherAndBackgroundPriority()
+    public async Task ConstructorsAndSingletonPreserveDispatcherAndPriority()
     {
-        var (scheduler, dispatcher) = await AvaloniaTestSession.Instance.Dispatch(
-            static () => (AvaloniaScheduler.Instance, Dispatcher.UIThread),
-            CancellationToken.None);
-
-        await Assert.That(scheduler.Dispatcher).IsSameReferenceAs(dispatcher);
-        await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Background);
-        await Assert.That(scheduler).IsSameReferenceAs(AvaloniaScheduler.Instance);
+        var dispatcher = Dispatcher.UIThread;
+        AvaloniaScheduler defaults = new(dispatcher);
+        AvaloniaScheduler selected = new(dispatcher, DispatcherPriority.Normal);
+        await Assert.That(defaults.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(defaults.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(selected.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(selected.Priority).IsEqualTo(DispatcherPriority.Normal);
+        await Assert.That(AvaloniaScheduler.Instance.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(AvaloniaScheduler.Instance.Priority).IsEqualTo(DispatcherPriority.Background);
     }
 
-    /// <summary>Verifies immediate scheduler work is posted to and executed on the selected dispatcher thread.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Immediate and nonpositive delays share an ordered batch that skips cancelled work.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        var (dispatcherThreadId, executionThreadId) = await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                var dispatcherThreadId = Environment.CurrentManagedThreadId;
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
-                TaskCompletionSource<int> completion =
-                    new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-                _ = scheduler.Schedule(
-                    () => completion.TrySetResult(Environment.CurrentManagedThreadId));
-
-                return (DispatcherThreadId: dispatcherThreadId, ExecutionThreadId: await completion.Task);
-            },
-            CancellationToken.None);
-
-        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        using var first = scheduler.Schedule(() => values.Add(1));
+        var cancelled = scheduler.Schedule(TimeSpan.Zero, () => values.Add(0));
+        using var last = scheduler.Schedule(TimeSpan.FromTicks(-1), () => values.Add(SecondValue));
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        await Assert.That(dispatcher.Delays).IsEmpty();
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies due work runs on the selected dispatcher at the configured priority.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Work scheduled during a callback waits for a later posted batch.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnDispatcherThread()
+    public async Task ReentrantScheduleRunsInTheNextBatch()
     {
-        var (dispatcherThreadId, executionThreadId, priority) = await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                var dispatcherThreadId = Environment.CurrentManagedThreadId;
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread, DispatcherPriority.Normal);
-                TaskCompletionSource<int> completion =
-                    new(TaskCreationOptions.RunContinuationsAsynchronously);
-
-                _ = scheduler.Schedule(
-                    TimeSpan.Zero,
-                    () => completion.TrySetResult(Environment.CurrentManagedThreadId));
-
-                return (
-                    DispatcherThreadId: dispatcherThreadId,
-                    ExecutionThreadId: await completion.Task,
-                    scheduler.Priority);
-            },
-            CancellationToken.None);
-
-        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
-        await Assert.That(priority).IsEqualTo(DispatcherPriority.Normal);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        using var first = scheduler.Schedule(() =>
+        {
+            values.Add(1);
+            _ = scheduler.Schedule(() => values.Add(SecondValue));
+        });
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies disposing queued work prevents execution.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Delayed work observes its due time and cancellation before or after delivery.</summary>
+    /// <param name="cancelBeforeDelivery">Whether cancellation happens before delivery.</param>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleCanBeCancelled()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleWaitsForItsCallback(bool cancelBeforeDelivery)
     {
-        var executed = await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
-                TaskCompletionSource following = new(TaskCreationOptions.RunContinuationsAsynchronously);
-                var executed = false;
-
-                var disposable = scheduler.Schedule(
-                    TimeSpan.Zero,
-                    () => executed = true);
-                disposable.Dispose();
-
-                _ = scheduler.Schedule(TimeSpan.Zero, following.SetResult);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        BooleanDisposable resource = new();
+        var calls = 0;
+        var delay = TimeSpan.FromTicks(1);
+        var subscription = scheduler.Schedule(resource, delay, (_, state) =>
+        {
+            calls++;
+            return state;
+        });
+        await Assert.That(calls).IsEqualTo(0);
+        await Assert.That(dispatcher.Drains).IsEmpty();
+        var pending = dispatcher.Delays.Dequeue();
+        await Assert.That(pending.Due).IsEqualTo(delay);
+        if (cancelBeforeDelivery)
+        {
+            subscription.Dispose();
+        }
+
+        pending.Work();
+        await Assert.That(calls).IsEqualTo(cancelBeforeDelivery ? 0 : 1);
+        subscription.Dispose();
+        await Assert.That(pending.Cancellation.IsDisposed).IsTrue();
+        await Assert.That(resource.IsDisposed).IsEqualTo(!cancelBeforeDelivery);
+    }
 
-                await following.Task;
-                return executed;
-            },
-            CancellationToken.None);
+    /// <summary>Both scheduling overloads reject missing actions.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ScheduleRejectsNullActions()
+    {
+        var scheduler = new ManualDispatcher().Create();
+        await Assert.That(() => scheduler.Schedule(0, (Func<IScheduler, int, IDisposable>)null!))
+            .ThrowsExactly<ArgumentNullException>();
+        await Assert.That(() => scheduler.Schedule(0, TimeSpan.Zero, (Func<IScheduler, int, IDisposable>)null!))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-        await Assert.That(executed).IsFalse();
+    /// <summary>Retains callbacks until the test delivers them.</summary>
+    private sealed class ManualDispatcher
+    {
+        /// <summary>Gets the posted batches.</summary>
+        public Queue<Action> Drains { get; } = new();
+
+        /// <summary>Gets delayed callbacks and their cancellation handles.</summary>
+        public Queue<(Action Work, TimeSpan Due, BooleanDisposable Cancellation)> Delays { get; } = new();
+
+        /// <summary>Creates a scheduler controlled by these callbacks.</summary>
+        /// <returns>The scheduler.</returns>
+        public AvaloniaScheduler Create() =>
+            new(Dispatcher.UIThread, DispatcherPriority.Normal, Drains.Enqueue, ScheduleDelayed);
+
+        /// <summary>Retains delayed work without running it.</summary>
+        /// <param name="work">The callback to retain.</param>
+        /// <param name="dueTime">The requested delay.</param>
+        /// <returns>The cancellation handle.</returns>
+        private BooleanDisposable ScheduleDelayed(Action work, TimeSpan dueTime)
+        {
+            BooleanDisposable cancellation = new();
+            Delays.Enqueue((work, dueTime, cancellation));
+            return cancellation;
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaTestSession.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaTestSession.cs
deleted file mode 100644
index 87e318b3..00000000
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/AvaloniaTestSession.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-using Avalonia;
-using Avalonia.Headless;
-
-namespace ReactiveUI.Primitives.Avalonia.Reactive.Tests;
-
-/// <summary>Provides one process-wide Avalonia headless session with a continuously pumped UI thread.</summary>
-internal static class AvaloniaTestSession
-{
-    /// <summary>Process-wide headless session.</summary>
-    private static readonly Lazy<HeadlessUnitTestSession> Session =
-        new(
-            static () => HeadlessUnitTestSession.StartNew(typeof(Application)),
-            LazyThreadSafetyMode.ExecutionAndPublication);
-
-    /// <summary>Gets the shared headless test session.</summary>
-    internal static HeadlessUnitTestSession Instance => Session.Value;
-}
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests.csproj b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests.csproj
index 1f1ac570..6fba2f73 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests/ReactiveUI.Primitives.Avalonia.Reactive.Tests.csproj
@@ -7,7 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Avalonia.Headless"/>
     <PackageReference Include="System.Reactive"/>
     <ProjectReference Include="..\..\ReactiveUI.Primitives.Avalonia.Reactive\ReactiveUI.Primitives.Avalonia.Reactive.csproj"/>
   </ItemGroup>
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
index 5bf305e3..91bc96be 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
@@ -4,88 +4,180 @@
 
 using System.Runtime.CompilerServices;
 using Avalonia.Threading;
+using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.Avalonia.Tests;
 
-/// <summary>Tests for <see cref="AvaloniaScheduler"/> against a pumped Avalonia headless dispatcher.</summary>
+/// <summary>Tests scheduler ordering and cancellation through controlled dispatch callbacks.</summary>
 public sealed class AvaloniaSchedulerTests
 {
-    /// <summary>Verifies constructor validation.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>The second value in an ordered batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Public constructors reject a missing dispatcher.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcher() =>
+    public async Task ConstructorRejectsNullDispatcher()
+    {
         await Assert.That(static () => new AvaloniaScheduler(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new AvaloniaScheduler(null!, DispatcherPriority.Normal))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies the singleton uses Avalonia's UI dispatcher and legacy background priority.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Constructors and the singleton retain the selected dispatcher and priority.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task InstanceUsesUiDispatcherAndBackgroundPriority()
+    public async Task ConstructorsAndSingletonPreserveDispatcherAndPriority()
     {
-        var (scheduler, dispatcher) = await AvaloniaTestSession.Instance.Dispatch(
-            static () => (AvaloniaScheduler.Instance, Dispatcher.UIThread),
-            CancellationToken.None);
-        await Assert.That(scheduler.Dispatcher).IsSameReferenceAs(dispatcher);
-        await Assert.That(scheduler.Priority).IsEqualTo(DispatcherPriority.Background);
-        await Assert.That(scheduler).IsSameReferenceAs(AvaloniaScheduler.Instance);
-        await Assert.That(scheduler.Now).IsGreaterThan(DateTimeOffset.MinValue);
+        var dispatcher = Dispatcher.UIThread;
+        AvaloniaScheduler defaults = new(dispatcher);
+        AvaloniaScheduler selected = new(dispatcher, DispatcherPriority.Normal);
+        await Assert.That(defaults.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(defaults.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(selected.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(selected.Priority).IsEqualTo(DispatcherPriority.Normal);
+        await Assert.That(AvaloniaScheduler.Instance.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(AvaloniaScheduler.Instance.Priority).IsEqualTo(DispatcherPriority.Background);
     }
 
-    /// <summary>Verifies immediate work is posted to and executed on the selected dispatcher thread.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Immediate and already-due items share an ordered batch that skips cancelled work.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        var (dispatcherThreadId, executionThreadId) = await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                var dispatcherThreadId = Environment.CurrentManagedThreadId;
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
-                TaskCompletionSource<int> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-                scheduler.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
-                return (dispatcherThreadId, await completion.Task);
-            },
-            CancellationToken.None);
-        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        RecordingWorkItem cancelled = new(() => values.Add(0));
+        scheduler.Schedule(new RecordingWorkItem(() => values.Add(1)));
+        scheduler.Schedule(cancelled);
+        scheduler.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)), long.MinValue);
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        await Assert.That(dispatcher.Delays).IsEmpty();
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies due work executes on the selected dispatcher.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Work scheduled during a callback waits for a later posted batch.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnDispatcherThread()
+    public async Task ReentrantScheduleRunsInTheNextBatch()
     {
-        var (dispatcherThreadId, executionThreadId, priority) = await AvaloniaTestSession.Instance.Dispatch(
-            static async () =>
-            {
-                var dispatcherThreadId = Environment.CurrentManagedThreadId;
-                AvaloniaScheduler scheduler = new(Dispatcher.UIThread, DispatcherPriority.Normal);
-                TaskCompletionSource<int> completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
-                scheduler.Schedule(
-                    new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)),
-                    scheduler.Timestamp);
-                return (dispatcherThreadId, await completion.Task, scheduler.Priority);
-            },
-            CancellationToken.None);
-        await Assert.That(executionThreadId).IsEqualTo(dispatcherThreadId);
-        await Assert.That(priority).IsEqualTo(DispatcherPriority.Normal);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        scheduler.Schedule(new RecordingWorkItem(() =>
+        {
+            values.Add(1);
+            scheduler.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)));
+        }));
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+    }
+
+    /// <summary>A rejected post retains work for a later accepted post.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task RejectedPostRetainsQueuedWork()
+    {
+        ManualDispatcher dispatcher = new() { AcceptsPosts = false };
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        scheduler.Schedule(new RecordingWorkItem(() => values.Add(1)));
+        await Assert.That(dispatcher.Drains).IsEmpty();
+        dispatcher.AcceptsPosts = true;
+        scheduler.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)));
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+    }
+
+    /// <summary>Delayed work retains its due timestamp and observes cancellation before delivery.</summary>
+    /// <param name="cancel">Whether cancellation happens before delivery.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleWaitsForItsCallback(bool cancel)
+    {
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        var calls = 0;
+        RecordingWorkItem item = new(() => calls++);
+        scheduler.Schedule(item, long.MaxValue);
+        await Assert.That(calls).IsEqualTo(0);
+        await Assert.That(dispatcher.Drains).IsEmpty();
+        var pending = dispatcher.Delays.Dequeue();
+        await Assert.That(pending.Item).IsSameReferenceAs(item);
+        await Assert.That(pending.Due).IsEqualTo(long.MaxValue);
+        if (cancel)
+        {
+            item.Dispose();
+        }
+
+        DispatchSequencerState.RunIfActive(pending.Item);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
     }
 
-    /// <summary>Verifies the sequencer validates both work-item overloads.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <summary>Both scheduling overloads reject missing work.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
     public async Task ScheduleRejectsNullWorkItems()
     {
-        var scheduler = await AvaloniaTestSession.Instance.Dispatch(
-            static () => new AvaloniaScheduler(Dispatcher.UIThread),
-            CancellationToken.None);
+        var scheduler = new ManualDispatcher().Create();
         await Assert.That(() => scheduler.Schedule(null!)).ThrowsExactly<ArgumentNullException>();
-        await Assert.That(() => scheduler.Schedule(null!, scheduler.Timestamp)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(() => scheduler.Schedule(null!, long.MaxValue)).ThrowsExactly<ArgumentNullException>();
     }
 
-    /// <summary>Work item backed by an action.</summary>
-    /// <param name="action">Action to invoke.</param>
-    private sealed class DelegateWorkItem(Action action) : IWorkItem
+    /// <summary>Retains callbacks until the test delivers them.</summary>
+    private sealed class ManualDispatcher
     {
+        /// <summary>Gets the posted batches.</summary>
+        public Queue<Action> Drains { get; } = new();
+
+        /// <summary>Gets work awaiting its due timestamp.</summary>
+        public Queue<(IWorkItem Item, long Due)> Delays { get; } = new();
+
+        /// <summary>Gets or sets whether a post is accepted.</summary>
+        public bool AcceptsPosts { get; set; } = true;
+
+        /// <summary>Creates a scheduler controlled by these callbacks.</summary>
+        /// <returns>The scheduler.</returns>
+        public AvaloniaScheduler Create() =>
+            new(Dispatcher.UIThread, DispatcherPriority.Normal, Post, (item, due) => Delays.Enqueue((item, due)));
+
+        /// <summary>Retains an accepted callback without running it.</summary>
+        /// <param name="drain">The callback to retain.</param>
+        /// <returns>Whether the callback was accepted.</returns>
+        private bool Post(Action drain)
+        {
+            if (!AcceptsPosts)
+            {
+                return false;
+            }
+
+            Drains.Enqueue(drain);
+            return true;
+        }
+    }
+
+    /// <summary>Records execution and supports cancellation.</summary>
+    /// <param name="action">The callback to run.</param>
+    private sealed class RecordingWorkItem(Action action) : IWorkItem, IsDisposed
+    {
+        /// <inheritdoc/>
+        public bool IsDisposed { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => IsDisposed = true;
+
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Execute() => action();
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaTestSession.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaTestSession.cs
deleted file mode 100644
index 86006465..00000000
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaTestSession.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-using Avalonia;
-using Avalonia.Headless;
-
-namespace ReactiveUI.Primitives.Avalonia.Tests;
-
-/// <summary>Provides one process-wide Avalonia headless session with a continuously pumped UI thread.</summary>
-internal static class AvaloniaTestSession
-{
-    /// <summary>Process-wide headless session.</summary>
-    private static readonly Lazy<HeadlessUnitTestSession> Session =
-        new(
-            static () => HeadlessUnitTestSession.StartNew(typeof(Application)),
-            LazyThreadSafetyMode.ExecutionAndPublication);
-
-    /// <summary>Gets the shared headless test session.</summary>
-    internal static HeadlessUnitTestSession Instance => Session.Value;
-}
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/ReactiveUI.Primitives.Avalonia.Tests.csproj b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/ReactiveUI.Primitives.Avalonia.Tests.csproj
index e980cd30..1a53fdf7 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/ReactiveUI.Primitives.Avalonia.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/ReactiveUI.Primitives.Avalonia.Tests.csproj
@@ -7,7 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Avalonia.Headless"/>
     <ProjectReference Include="..\..\ReactiveUI.Primitives.Avalonia\ReactiveUI.Primitives.Avalonia.csproj"/>
   </ItemGroup>
 
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
index 10f17454..9b8657a0 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Reactive.Tests/BlazorRendererSequencerTests.cs
@@ -14,6 +14,9 @@ namespace ReactiveUI.Primitives.Blazor.Reactive.Tests;
 /// <summary>Tests for <see cref="BlazorRendererSequencer"/> as an <see cref="IScheduler"/> driven through a fake renderer delegate.</summary>
 public sealed class BlazorRendererSequencerTests
 {
+    /// <summary>The failure reported by a rejected renderer operation.</summary>
+    private const string RendererFailure = "renderer rejected";
+
     /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
@@ -41,12 +44,14 @@ public async Task ToSequencerRejectsNullDispatcher() =>
     [Test]
     public async Task DispatcherSchedulerExecutesWork()
     {
-        var scheduler = Dispatcher.CreateDefault().ToSequencer();
-        TaskCompletionSource<bool> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        FakeRenderer renderer = new();
+        var scheduler = renderer.ToSequencer();
+        var executed = false;
 
-        _ = scheduler.Schedule(() => executed.TrySetResult(true));
+        _ = scheduler.Schedule(() => executed = true);
 
-        await Assert.That(await executed.Task).IsTrue();
+        await Assert.That(executed).IsTrue();
+        await Assert.That(renderer.InvokeCount).IsEqualTo(1);
     }
 
     /// <summary>Verifies renderer-task faults reach the unhandled-exception handler instead of vanishing.</summary>
@@ -55,7 +60,7 @@ public async Task DispatcherSchedulerExecutesWork()
     public async Task FaultedRendererTaskRoutesToHandler()
     {
         TaskCompletionSource<Exception> observed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        InvalidOperationException fault = new("renderer rejected");
+        InvalidOperationException fault = new(RendererFailure);
         BlazorRendererSequencer scheduler = new(_ => Task.FromException(fault));
         scheduler.UnhandledExceptionHandler = ex => observed.TrySetResult(ex);
 
@@ -64,6 +69,86 @@ public async Task FaultedRendererTaskRoutesToHandler()
         await Assert.That(await observed.Task).IsSameReferenceAs(fault);
     }
 
+    /// <summary>A successful renderer task needs no fault registration.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ObserveFaults_SuccessfulTask_SkipsRegistration()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        var registered = false;
+
+        sequencer.ObserveFaults(Task.CompletedTask, (_, _) => registered = true);
+
+        await Assert.That(registered).IsFalse();
+    }
+
+    /// <summary>A pending renderer task retains its owner and forwards a later base exception.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ObserveFaults_PendingTask_ForwardsLaterFault()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        TaskCompletionSource<bool> renderer = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<Exception> observed = [];
+        sequencer.UnhandledExceptionHandler = observed.Add;
+        Task? registeredTask = null;
+        BlazorRendererSequencer? registeredOwner = null;
+        sequencer.ObserveFaults(renderer.Task, (task, owner) =>
+        {
+            registeredTask = task;
+            registeredOwner = owner;
+        });
+
+        await Assert.That(ReferenceEquals(registeredTask, renderer.Task)).IsTrue();
+        await Assert.That(registeredOwner).IsSameReferenceAs(sequencer);
+        await Assert.That(observed).IsEmpty();
+
+        InvalidOperationException fault = new(RendererFailure);
+        renderer.SetException(new AggregateException(fault));
+        registeredOwner!.CompleteRendererTask(registeredTask!);
+
+        await Assert.That(observed).HasSingleItem();
+        await Assert.That(observed[0]).IsSameReferenceAs(fault);
+    }
+
+    /// <summary>Pending, successful, and canceled renderer tasks produce no fault notification.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CompleteRendererTask_WithoutFault_IgnoresTask()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        List<Exception> observed = [];
+        sequencer.UnhandledExceptionHandler = observed.Add;
+        TaskCompletionSource<bool> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        sequencer.CompleteRendererTask(pending.Task);
+        sequencer.CompleteRendererTask(Task.CompletedTask);
+        sequencer.CompleteRendererTask(Task.FromCanceled(new(true)));
+
+        await Assert.That(observed).IsEmpty();
+    }
+
+    /// <summary>A configured handler receives the fault; otherwise the fallback receives it.</summary>
+    /// <param name="hasHandler">True when a renderer fault handler is configured.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task HandleFault_HandlerSelection_UsesOneDestination(bool hasHandler)
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        List<Exception> handled = [];
+        List<Exception> rethrown = [];
+        sequencer.UnhandledExceptionHandler = hasHandler ? handled.Add : null;
+        InvalidOperationException fault = new(RendererFailure);
+
+        sequencer.HandleFault(fault, rethrown.Add);
+
+        await Assert.That(handled.Count).IsEqualTo(hasHandler ? 1 : 0);
+        await Assert.That(rethrown.Count).IsEqualTo(hasHandler ? 0 : 1);
+        await Assert.That((hasHandler ? handled : rethrown)[0]).IsSameReferenceAs(fault);
+    }
+
     /// <summary>Verifies reactive component observation guards reject null inputs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -155,20 +240,30 @@ public async Task ImmediateBurstExecutesInOrder()
     }
 
     /// <summary>Fake renderer that runs marshalled work synchronously and records how often it was invoked.</summary>
-    private sealed class FakeRenderer
+    private sealed class FakeRenderer : Dispatcher
     {
         /// <summary>Gets the number of times <see cref="InvokeAsync(Action)"/> was called.</summary>
         public int InvokeCount { get; private set; }
 
-        /// <summary>Runs the supplied work synchronously, mimicking <c>ComponentBase.InvokeAsync</c>.</summary>
-        /// <param name="action">The work to run.</param>
-        /// <returns>A completed task.</returns>
-        public Task InvokeAsync(Action action)
+        /// <inheritdoc/>
+        public override bool CheckAccess() => true;
+
+        /// <inheritdoc/>
+        public override Task InvokeAsync(Action workItem)
         {
             InvokeCount++;
-            action();
+            workItem();
             return Task.CompletedTask;
         }
+
+        /// <inheritdoc/>
+        public override Task InvokeAsync(Func<Task> workItem) => workItem();
+
+        /// <inheritdoc/>
+        public override Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem) => Task.FromResult(workItem());
+
+        /// <inheritdoc/>
+        public override Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem) => workItem();
     }
 
     /// <summary>Test component that exposes protected reactive component members.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
index 5918118b..19d9f2fd 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
@@ -14,6 +14,9 @@ namespace ReactiveUI.Primitives.Blazor.Tests;
 /// <summary>Tests for <see cref="BlazorRendererSequencer"/> driven through a fake renderer delegate.</summary>
 public sealed class BlazorRendererSequencerTests
 {
+    /// <summary>The failure reported by a rejected renderer operation.</summary>
+    private const string RendererFailure = "renderer rejected";
+
     /// <summary>The values an immediate burst produces, in the FIFO order asserted.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
@@ -41,12 +44,14 @@ public async Task ToSequencerRejectsNullDispatcher() =>
     [Test]
     public async Task DispatcherSequencerExecutesWork()
     {
-        var sequencer = Dispatcher.CreateDefault().ToSequencer();
-        TaskCompletionSource<bool> executed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        FakeRenderer renderer = new();
+        var sequencer = renderer.ToSequencer();
+        var executed = false;
 
-        sequencer.Schedule(new DelegateWorkItem(() => executed.TrySetResult(true)));
+        sequencer.Schedule(new DelegateWorkItem(() => executed = true));
 
-        await Assert.That(await executed.Task).IsTrue();
+        await Assert.That(executed).IsTrue();
+        await Assert.That(renderer.InvokeCount).IsEqualTo(1);
     }
 
     /// <summary>Verifies renderer-task faults reach the unhandled-exception handler instead of vanishing.</summary>
@@ -55,7 +60,7 @@ public async Task DispatcherSequencerExecutesWork()
     public async Task FaultedRendererTaskRoutesToHandler()
     {
         TaskCompletionSource<Exception> observed = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        InvalidOperationException fault = new("renderer rejected");
+        InvalidOperationException fault = new(RendererFailure);
         BlazorRendererSequencer sequencer = new(_ => Task.FromException(fault));
         sequencer.UnhandledExceptionHandler = ex => observed.TrySetResult(ex);
 
@@ -64,6 +69,86 @@ public async Task FaultedRendererTaskRoutesToHandler()
         await Assert.That(await observed.Task).IsSameReferenceAs(fault);
     }
 
+    /// <summary>A successful renderer task needs no fault registration.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ObserveFaults_SuccessfulTask_SkipsRegistration()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        var registered = false;
+
+        sequencer.ObserveFaults(Task.CompletedTask, (_, _) => registered = true);
+
+        await Assert.That(registered).IsFalse();
+    }
+
+    /// <summary>A pending renderer task retains its owner and forwards a later base exception.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ObserveFaults_PendingTask_ForwardsLaterFault()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        TaskCompletionSource<bool> renderer = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<Exception> observed = [];
+        sequencer.UnhandledExceptionHandler = observed.Add;
+        Task? registeredTask = null;
+        BlazorRendererSequencer? registeredOwner = null;
+        sequencer.ObserveFaults(renderer.Task, (task, owner) =>
+        {
+            registeredTask = task;
+            registeredOwner = owner;
+        });
+
+        await Assert.That(ReferenceEquals(registeredTask, renderer.Task)).IsTrue();
+        await Assert.That(registeredOwner).IsSameReferenceAs(sequencer);
+        await Assert.That(observed).IsEmpty();
+
+        InvalidOperationException fault = new(RendererFailure);
+        renderer.SetException(new AggregateException(fault));
+        registeredOwner!.CompleteRendererTask(registeredTask!);
+
+        await Assert.That(observed).HasSingleItem();
+        await Assert.That(observed[0]).IsSameReferenceAs(fault);
+    }
+
+    /// <summary>Pending, successful, and canceled renderer tasks produce no fault notification.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CompleteRendererTask_WithoutFault_IgnoresTask()
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        List<Exception> observed = [];
+        sequencer.UnhandledExceptionHandler = observed.Add;
+        TaskCompletionSource<bool> pending = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        sequencer.CompleteRendererTask(pending.Task);
+        sequencer.CompleteRendererTask(Task.CompletedTask);
+        sequencer.CompleteRendererTask(Task.FromCanceled(new(true)));
+
+        await Assert.That(observed).IsEmpty();
+    }
+
+    /// <summary>A configured handler receives the fault; otherwise the fallback receives it.</summary>
+    /// <param name="hasHandler">True when a renderer fault handler is configured.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task HandleFault_HandlerSelection_UsesOneDestination(bool hasHandler)
+    {
+        BlazorRendererSequencer sequencer = new(static _ => Task.CompletedTask);
+        List<Exception> handled = [];
+        List<Exception> rethrown = [];
+        sequencer.UnhandledExceptionHandler = hasHandler ? handled.Add : null;
+        InvalidOperationException fault = new(RendererFailure);
+
+        sequencer.HandleFault(fault, rethrown.Add);
+
+        await Assert.That(handled.Count).IsEqualTo(hasHandler ? 1 : 0);
+        await Assert.That(rethrown.Count).IsEqualTo(hasHandler ? 0 : 1);
+        await Assert.That((hasHandler ? handled : rethrown)[0]).IsSameReferenceAs(fault);
+    }
+
     /// <summary>Verifies reactive component observation guards reject null inputs.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -170,20 +255,30 @@ private sealed class DelegateWorkItem : IWorkItem
     }
 
     /// <summary>Fake renderer that runs marshalled work synchronously and records how often it was invoked.</summary>
-    private sealed class FakeRenderer
+    private sealed class FakeRenderer : Dispatcher
     {
         /// <summary>Gets the number of times <see cref="InvokeAsync(Action)"/> was called.</summary>
         public int InvokeCount { get; private set; }
 
-        /// <summary>Runs the supplied work synchronously, mimicking <c>ComponentBase.InvokeAsync</c>.</summary>
-        /// <param name="action">The work to run.</param>
-        /// <returns>A completed task.</returns>
-        public Task InvokeAsync(Action action)
+        /// <inheritdoc/>
+        public override bool CheckAccess() => true;
+
+        /// <inheritdoc/>
+        public override Task InvokeAsync(Action workItem)
         {
             InvokeCount++;
-            action();
+            workItem();
             return Task.CompletedTask;
         }
+
+        /// <inheritdoc/>
+        public override Task InvokeAsync(Func<Task> workItem) => workItem();
+
+        /// <inheritdoc/>
+        public override Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem) => Task.FromResult(workItem());
+
+        /// <inheritdoc/>
+        public override Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem) => workItem();
     }
 
     /// <summary>Test component that exposes protected reactive component members.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
index 58a3cf80..5292a705 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
@@ -3,127 +3,290 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive;
+using System.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Extensions.Tests;
 
-/// <summary>Tests for <see cref="Continuation"/>, the phase-barrier lock that serialises emissions.</summary>
+/// <summary>Tests delivery and release ordering for <see cref="Continuation"/>.</summary>
 public class ContinuationTests
 {
-    /// <summary>Item pushed while the continuation holds the lock, which the barrier drops.</summary>
+    /// <summary>An item offered while the current handoff holds the gate.</summary>
     private const int DroppedItem = 2;
 
-    /// <summary>Verifies <see cref="Continuation.LockValueTask{T}"/> pushes the item downstream, locks, and completes once the phase is signalled by an unlock.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>The emitted item carries the release handle, and its task remains pending until release.</summary>
+    /// <param name="valueTask">True to acquire the handoff through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenLockValueTaskNotLocked_ThenEmitsAndCompletesOnUnlock()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Lock_FreeGate_EmitsAndCompletesOnUnlock(bool valueTask)
     {
         using Continuation continuation = new();
         List<int> values = [];
-        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+        IDisposable? handle = null;
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(value =>
+        {
+            values.Add(value.Value);
+            handle = value.Sync;
+        });
+
+        var lockTask = valueTask
+            ? continuation.LockValueTask(1, observer).AsTask()
+            : continuation.Lock(1, observer);
+
+        await Assert.That(lockTask.IsCompleted).IsFalse();
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
+        await Assert.That(handle).IsSameReferenceAs(continuation);
 
-        var lockTask = continuation.LockValueTask(1, observer);
         var unlockTask = continuation.UnLock();
 
-        await lockTask.AsTask();
+        await Assert.That(lockTask.IsCompletedSuccessfully).IsTrue();
+        await Assert.That(unlockTask.IsCompletedSuccessfully).IsTrue();
+        await lockTask;
         await unlockTask;
 
-        await Assert.That(values.Count).IsEqualTo(1);
+        await Assert.That(values).HasSingleItem();
         await Assert.That(values[0]).IsEqualTo(1);
-        await Assert.That(continuation.CompletedPhases).IsGreaterThanOrEqualTo(1);
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
     }
 
-    /// <summary>Verifies a second <see cref="Continuation.LockValueTask{T}"/> taken under the lock returns a completed default value task and drops the item.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>An item offered while the gate is held is dropped without releasing the pending handoff.</summary>
+    /// <param name="valueTask">True to acquire handoffs through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenLockValueTaskAlreadyLocked_ThenReturnsDefaultAndDropsItem()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Lock_HeldGate_DropsItem(bool valueTask)
     {
         using Continuation continuation = new();
         List<int> values = [];
         var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
 
-        var first = continuation.LockValueTask(1, observer);
-        var second = continuation.LockValueTask(DroppedItem, observer);
+        var first = valueTask
+            ? continuation.LockValueTask(1, observer).AsTask()
+            : continuation.Lock(1, observer);
+        var second = valueTask
+            ? continuation.LockValueTask(DroppedItem, observer).AsTask()
+            : continuation.Lock(DroppedItem, observer);
 
-        await Assert.That(second.IsCompleted).IsTrue();
+        await Assert.That(first.IsCompleted).IsFalse();
+        await Assert.That(second.IsCompletedSuccessfully).IsTrue();
         await second;
-
-        var unlockTask = continuation.UnLock();
-        await first.AsTask();
-        await unlockTask;
-
-        await Assert.That(values.Count).IsEqualTo(1);
+        await Assert.That(values).HasSingleItem();
         await Assert.That(values[0]).IsEqualTo(1);
+
+        _ = continuation.UnLock();
+        await Assert.That(first.IsCompletedSuccessfully).IsTrue();
+        await first;
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
     }
 
-    /// <summary>Verifies <see cref="Continuation.Lock{T}"/> (the Task overload) emits and completes on unlock.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>A new lock after release starts a separate pending handoff.</summary>
+    /// <param name="valueTask">True to acquire handoffs through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenLockNotLocked_ThenEmitsAndCompletesOnUnlock()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Lock_AfterUnlock_StartsNextPhase(bool valueTask)
     {
         using Continuation continuation = new();
-        List<int> values = [];
-        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+        var first = valueTask
+            ? continuation.LockValueTask(1, null).AsTask()
+            : continuation.Lock(1, null);
+        _ = continuation.UnLock();
+        await Assert.That(first.IsCompletedSuccessfully).IsTrue();
+        await first;
 
-        var lockTask = continuation.Lock(1, observer);
-        var unlockTask = continuation.UnLock();
+        var second = valueTask
+            ? continuation.LockValueTask(DroppedItem, null).AsTask()
+            : continuation.Lock(DroppedItem, null);
 
-        await lockTask;
-        await unlockTask;
+        await Assert.That(second.IsCompleted).IsFalse();
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
+
+        _ = continuation.UnLock();
+        await Assert.That(second.IsCompletedSuccessfully).IsTrue();
+        await second;
+
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(DroppedItem);
+    }
+
+    /// <summary>A null observer still acquires a handoff that disposal releases once.</summary>
+    /// <param name="valueTask">True to acquire the handoff through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Dispose_PendingHandoffWithNullObserver_CompletesOnce(bool valueTask)
+    {
+        Continuation continuation = new();
+        var handoff = valueTask
+            ? continuation.LockValueTask(1, null).AsTask()
+            : continuation.Lock(1, null);
+
+        await Assert.That(handoff.IsCompleted).IsFalse();
 
-        await Assert.That(values.Count).IsEqualTo(1);
+        continuation.Dispose();
+        continuation.Dispose();
+
+        await Assert.That(handoff.IsCompletedSuccessfully).IsTrue();
+        await handoff;
+        await Assert.That(continuation.UnLock().IsCompletedSuccessfully).IsTrue();
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
     }
 
-    /// <summary>Verifies a second <see cref="Continuation.Lock{T}"/> taken under the lock returns a completed task and drops the item.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Disposal inside the observer releases the handoff without completing it before delivery returns.</summary>
+    /// <param name="valueTask">True to acquire the handoff through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenLockAlreadyLocked_ThenReturnsCompletedAndDropsItem()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Dispose_DuringDelivery_CompletesAfterDelivery(bool valueTask)
     {
         using Continuation continuation = new();
-        List<int> values = [];
-        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+        long phasesDuringDelivery = -1;
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(value =>
+        {
+            value.Sync.Dispose();
+            phasesDuringDelivery = continuation.CompletedPhases;
+        });
 
-        var first = continuation.Lock(1, observer);
-        var second = continuation.Lock(DroppedItem, observer);
+        var handoff = valueTask
+            ? continuation.LockValueTask(1, observer).AsTask()
+            : continuation.Lock(1, observer);
 
-        await Assert.That(second.IsCompleted).IsTrue();
+        await Assert.That(phasesDuringDelivery).IsEqualTo(0);
+        await Assert.That(handoff.IsCompletedSuccessfully).IsTrue();
+        await handoff;
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
+    }
 
-        var unlockTask = continuation.UnLock();
-        await first;
-        await unlockTask;
+    /// <summary>An unlock inside delivery waits for that delivery to return.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task UnLock_DuringDelivery_CompletesAfterDelivery()
+    {
+        using Continuation continuation = new();
+        Task? release = null;
+        var completedDuringDelivery = true;
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(_ =>
+        {
+            release = continuation.UnLock();
+            completedDuringDelivery = release.IsCompleted;
+        });
+
+        var handoff = continuation.Lock(1, observer);
 
-        await Assert.That(values.Count).IsEqualTo(1);
+        await Assert.That(completedDuringDelivery).IsFalse();
+        await Assert.That(release!.IsCompletedSuccessfully).IsTrue();
+        await Assert.That(handoff.IsCompletedSuccessfully).IsTrue();
+        await handoff;
+        await release;
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
     }
 
-    /// <summary>Verifies that unlocking a continuation that was never locked completes immediately.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>Finishing a newer handoff cannot complete an earlier delivery that has not returned.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenUnlockNotLocked_ThenCompletesImmediately()
+    public async Task CompleteDelivery_ReleasedPhasePrecedesNewLock_PreservesPairing()
     {
         using Continuation continuation = new();
+        var first = continuation.TryBeginPhase()!;
+        var firstRelease = continuation.UnLock();
+        var second = continuation.TryBeginPhase()!;
+        continuation.CompleteDelivery(second);
+
+        await Assert.That(firstRelease.IsCompleted).IsFalse();
+        await Assert.That(second.Completion.Task.IsCompleted).IsFalse();
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
 
-        await continuation.UnLock();
+        var secondRelease = continuation.UnLock();
+
+        await Assert.That(secondRelease.IsCompletedSuccessfully).IsTrue();
+        await Assert.That(firstRelease.IsCompleted).IsFalse();
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
+
+        continuation.CompleteDelivery(first);
+        continuation.CompleteDelivery(first);
+
+        await Assert.That(firstRelease.IsCompletedSuccessfully).IsTrue();
+        await firstRelease;
+        await secondRelease;
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(DroppedItem);
+    }
+
+    /// <summary>Releasing and disposing a free gate never advances the completed phase count.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task UnLockAndDispose_FreeGate_RemainNoOps()
+    {
+        Continuation continuation = new();
+
+        await Assert.That(continuation.UnLock().IsCompletedSuccessfully).IsTrue();
+        await Assert.That(continuation.UnLock().IsCompletedSuccessfully).IsTrue();
+        continuation.Dispose();
+        continuation.Dispose();
+        await Assert.That(continuation.UnLock().IsCompletedSuccessfully).IsTrue();
 
         await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
     }
 
-    /// <summary>Verifies disposing twice is an idempotent no-op on the second call.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    /// <summary>A handoff started after disposal emits its item and reports disposal through its task.</summary>
+    /// <param name="valueTask">True to acquire the handoff through the value-task overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
     [Test]
-    public async Task WhenDisposeTwice_ThenSecondDisposeIsNoOp()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Lock_AfterDispose_EmitsAndFaultsTask(bool valueTask)
     {
         Continuation continuation = new();
-        Exception? caught = null;
+        List<int> values = [];
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(value => values.Add(value.Value));
+        continuation.Dispose();
 
-        try
-        {
-            continuation.Dispose();
-            continuation.Dispose();
-        }
-        catch (Exception ex)
-        {
-            caught = ex;
-        }
+        var handoff = valueTask
+            ? continuation.LockValueTask(1, observer).AsTask()
+            : continuation.Lock(1, observer);
+        var dropped = valueTask
+            ? continuation.LockValueTask(DroppedItem, observer).AsTask()
+            : continuation.Lock(DroppedItem, observer);
+
+        await Assert.That(handoff.IsFaulted).IsTrue();
+        await Assert.That(async () => await handoff).Throws<ObjectDisposedException>();
+        await Assert.That(dropped.IsCompletedSuccessfully).IsTrue();
+        await dropped;
+        await Assert.That(values).HasSingleItem();
+        await Assert.That(values[0]).IsEqualTo(1);
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
+
+        var release = continuation.UnLock();
+        await Assert.That(release.IsFaulted).IsTrue();
+        await Assert.That(async () => await release).Throws<ObjectDisposedException>();
+    }
+
+    /// <summary>Unmanaged disposal leaves the pending handoff available for an explicit release.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Dispose_UnmanagedOnly_DoesNotReleaseHandoff()
+    {
+        DerivedContinuation continuation = new();
+        var handoff = continuation.Lock(1, null);
 
-        await Assert.That(caught).IsNull();
+        continuation.DisposeUnmanaged();
+        continuation.Dispose();
+
+        await Assert.That(handoff.IsCompleted).IsFalse();
+        _ = continuation.UnLock();
+        await Assert.That(handoff.IsCompletedSuccessfully).IsTrue();
+        await handoff;
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(1);
+    }
+
+    /// <summary>Exposes unmanaged disposal without changing the public disposal path.</summary>
+    private sealed class DerivedContinuation : Continuation
+    {
+        /// <summary>Requests unmanaged disposal through the protected overload.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void DisposeUnmanaged() => Dispose(false);
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ScheduledWaitTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ScheduledWaitTests.cs
new file mode 100644
index 00000000..443dcecc
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ScheduledWaitTests.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests synchronous wait and action ordering.</summary>
+public class ScheduledWaitTests
+{
+    /// <summary>The action observes the state left by the wait operation.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_WaitReturns_ActionObservesWaitState()
+    {
+        var expectedDelay = TimeSpan.FromSeconds(1);
+        TimeSpan? observedDelay = null;
+        TimeSpan? actionDelay = null;
+        using var result = ScheduledWait.Run(expectedDelay, () => actionDelay = observedDelay, delay => observedDelay = delay);
+        await Assert.That(observedDelay).IsEqualTo(expectedDelay);
+        await Assert.That(actionDelay).IsEqualTo(expectedDelay);
+    }
+
+    /// <summary>A failed wait prevents the action and preserves the original exception.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_WaitThrows_DoesNotInvokeAction()
+    {
+        var ran = false;
+        InvalidOperationException error = new("wait failed");
+        var caught = await Assert.That(() => ScheduledWait.Run(TimeSpan.Zero, () => ran = true, _ => throw error))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(caught).IsSameReferenceAs(error);
+        await Assert.That(ran).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
index 04b3d0f5..f3696308 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
@@ -430,6 +430,24 @@ public async Task AttachTimerReleasesATimerGivenToAnAlreadyCancelledItem()
         await Assert.That(ran).IsEqualTo(0);
     }
 
+    /// <summary>Final cancellation cleanup does not release a result or attached timer twice.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancellationAfterPublication_ReleasesResultAndTimerOnce()
+    {
+        using var scheduler = CreateIsolatedScheduler();
+        CountingDisposable result = new();
+        CountingDisposable timer = new();
+        WasmScheduler.StatefulWorkItem<int> item = new(scheduler, 0, (_, _) => result);
+        item.Run();
+        item.AttachTimer(timer);
+        item.Dispose();
+        item.ReleaseCanceledResult();
+        item.ReleaseCanceledTimer();
+        await Assert.That(result.DisposeCount).IsEqualTo(1);
+        await Assert.That(timer.DisposeCount).IsEqualTo(1);
+    }
+
     /// <summary>Verifies a dispatched periodic callback observes disposal before invoking the action.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -564,6 +582,16 @@ public async Task FinishingDrainSchedulesWorkPublishedDuringItsBatch()
     /// <returns>The isolated scheduler.</returns>
     private static WasmScheduler CreateIsolatedScheduler() => new(new ManualTimeProvider());
 
+    /// <summary>Counts every release, including duplicate calls.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of release calls.</summary>
+        internal int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+
     /// <summary>Stores timer callbacks until the test dispatches them.</summary>
     private sealed class ManualTimeProvider : TimeProvider
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
index 9ba2fc4e..f78dcb8b 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BroadcasterTests.cs
@@ -19,6 +19,91 @@ public class BroadcasterTests
     /// <summary>The literal three.</summary>
     private const int Three = 3;
 
+    /// <summary>A stale observer snapshot cannot replace a newer addition.</summary>
+    /// <param name="observerCount">The number of observers in the original snapshot.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(0)]
+    [Arguments(One)]
+    [Arguments(Two)]
+    public async Task TryAdd_StaleSnapshot_PreservesCompetingAddition(int observerCount)
+    {
+        RecordingWitness<int> first = new();
+        RecordingWitness<int> second = new();
+        RecordingWitness<int> competing = new();
+        RecordingWitness<int> incoming = new();
+        IObserver<int>[] initial = observerCount switch
+        {
+            0 => [],
+            One => [first],
+            _ => [first, second],
+        };
+        object? observers = observerCount switch
+        {
+            0 => null,
+            One => first,
+            _ => initial,
+        };
+        var stale = observers;
+        await Assert.That(Broadcaster<int>.TryAdd(ref observers, stale, competing)).IsTrue();
+        var current = observers;
+
+        await Assert.That(Broadcaster<int>.TryAdd(ref observers, stale, incoming)).IsFalse();
+        await Assert.That(observers).IsSameReferenceAs(current);
+
+        await Assert.That(Broadcaster<int>.TryAdd(ref observers, current, incoming)).IsTrue();
+        var actual = await Assert.That(observers).IsTypeOf<IObserver<int>[]>().And.IsNotNull();
+        await Assert.That(actual.SequenceEqual(initial.Append(competing).Append(incoming))).IsTrue();
+    }
+
+    /// <summary>Removal retries against the current snapshot without losing a competing addition.</summary>
+    /// <param name="multiple">True when the original snapshot contains two observers.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TryRemove_StaleSnapshot_PreservesCompetingAddition(bool multiple)
+    {
+        RecordingWitness<int> removed = new();
+        RecordingWitness<int> retained = new();
+        RecordingWitness<int> competing = new();
+        object? observers = multiple ? new IObserver<int>[] { removed, retained } : removed;
+        var stale = observers;
+        await Assert.That(Broadcaster<int>.TryAdd(ref observers, stale, competing)).IsTrue();
+        var current = observers;
+
+        await Assert.That(Broadcaster<int>.TryRemove(ref observers, stale, removed)).IsFalse();
+        await Assert.That(observers).IsSameReferenceAs(current);
+        await Assert.That(Broadcaster<int>.TryRemove(ref observers, current, removed)).IsTrue();
+
+        if (multiple)
+        {
+            var actual = await Assert.That(observers).IsTypeOf<IObserver<int>[]>().And.IsNotNull();
+            await Assert.That(actual.SequenceEqual([retained, competing])).IsTrue();
+        }
+        else
+        {
+            await Assert.That(observers).IsSameReferenceAs(competing);
+        }
+    }
+
+    /// <summary>Removing an absent observer does not change an empty or single-observer slot.</summary>
+    /// <param name="empty">True when no observer is registered.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TryRemove_AbsentObserver_LeavesSlotUnchanged(bool empty)
+    {
+        RecordingWitness<int> retained = new();
+        RecordingWitness<int> missing = new();
+        object? observers = empty ? null : retained;
+        var current = observers;
+
+        await Assert.That(Broadcaster<int>.TryRemove(ref observers, current, missing)).IsTrue();
+        await Assert.That(ReferenceEquals(observers, current)).IsTrue();
+    }
+
     /// <summary>The equality operators compare the underlying observer set by reference.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
index 14a96867..fbbe24d8 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PrioritySemaphoreSignalTests.cs
@@ -138,6 +138,39 @@ public async Task ReleaseDoesNotAllowNegativeCount()
         subscription.Dispose();
     }
 
+    /// <summary>A release retries against a count changed by an intervening release.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ReleaseWithStaleCountRetriesAgainstCurrentCapacity()
+    {
+        using PrioritySemaphoreSignal<int> signal = new(SecondValue);
+        RecordingObserver<int> observer = new();
+        using var subscription = signal.Subscribe(observer);
+        signal.OnNext(FirstValue);
+        signal.OnNext(SecondValue);
+        signal.Release();
+        signal.ReleaseObserved(SecondValue);
+        signal.OnNext(ThirdValue);
+        signal.OnNext(FourthValue);
+        await Assert.That(observer.Values.SequenceEqual([FirstValue, SecondValue, ThirdValue, FourthValue])).IsTrue();
+    }
+
+    /// <summary>A stale occupied count cannot release capacity after the last slot was released.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ReleaseWithStaleCountStopsWhenCapacityIsAlreadyFree()
+    {
+        using PrioritySemaphoreSignal<int> signal = new(1);
+        RecordingObserver<int> observer = new();
+        using var subscription = signal.Subscribe(observer);
+        signal.OnNext(FirstValue);
+        signal.Release();
+        signal.ReleaseObserved(1);
+        signal.OnNext(SecondValue);
+        signal.OnNext(ThirdValue);
+        await Assert.That(observer.Values.SequenceEqual([FirstValue, SecondValue])).IsTrue();
+    }
+
     /// <summary>Error stops the queue and forwards the exact exception.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
index 4139c9af..db48ebe5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.Scheduling.cs
@@ -10,64 +10,90 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies scheduler selection by time-operator aliases.</summary>
 public partial class RxNamesTests
 {
-    /// <summary>Verifies absolute-time overloads use the default scheduler when no scheduler is supplied.</summary>
+    /// <summary>Absolute-time overloads select the thread-pool sequencer when no scheduler is supplied.</summary>
+    /// <param name="explicitNull">True to supply a null scheduler explicitly.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task AbsoluteTimeOperatorsUseDefaultScheduler()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task AbsoluteTimeOperatorsUseDefaultScheduler(bool explicitNull)
     {
         var dueTime = DateTimeOffset.UnixEpoch;
-        AwaitableWitness<int> delayedScalar = new();
-        AwaitableWitness<int> delayedRange = new();
-        AwaitableWitness<int> delayedSubscriptionScalar = new();
-        AwaitableWitness<int> delayedSubscriptionRange = new();
-        AwaitableWitness<int> delayedExplicitRange = new();
-        AwaitableWitness<int> delayedSubscriptionExplicitRange = new();
-        AwaitableWitness<int> timeout = new();
-        AwaitableWitness<int> explicitTimeout = new();
-        const ISequencer? defaultScheduler = null;
+        IObservable<int>[] sources = [Signal.Emit(One), Signal.Sequence(Two, Two)];
+        foreach (var source in sources)
+        {
+            var delayed = explicitNull ? source.Delay(dueTime, null) : source.Delay(dueTime);
+            var delay = await Assert.That(delayed).IsTypeOf<LinqExtensions.AbsoluteShiftSignal<int>>().And.IsNotNull();
+            await Assert.That(delay.Scheduler).IsSameReferenceAs(ThreadPoolSequencer.Instance);
 
-        using var delayScalarSubscription = Signal.Emit(One)
-            .Delay(dueTime)
-            .Subscribe(delayedScalar);
-        using var delayRangeSubscription = Signal.Sequence(Two, Two)
-            .Delay(dueTime)
-            .Subscribe(delayedRange);
-        using var delayExplicitRangeSubscription = Signal.Sequence(Two, Two)
-            .Delay(dueTime, defaultScheduler)
-            .Subscribe(delayedExplicitRange);
-        using var subscriptionScalarSubscription = Signal.Emit(One)
-            .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionScalar);
-        using var subscriptionRangeSubscription = Signal.Sequence(Two, Two)
-            .DelaySubscription(dueTime)
-            .Subscribe(delayedSubscriptionRange);
-        using var subscriptionExplicitRangeSubscription = Signal.Sequence(Two, Two)
-            .DelaySubscription(dueTime, defaultScheduler)
-            .Subscribe(delayedSubscriptionExplicitRange);
-        using var timeoutSubscription = Signal.Silent<int>()
-            .Timeout(dueTime)
-            .Subscribe(timeout);
-        using var explicitTimeoutSubscription = Signal.Silent<int>()
-            .Timeout(dueTime, defaultScheduler)
-            .Subscribe(explicitTimeout);
+            var delayedSubscription = explicitNull
+                ? source.DelaySubscription(dueTime, null)
+                : source.DelaySubscription(dueTime);
+            var subscription = await Assert.That(delayedSubscription)
+                .IsTypeOf<LinqExtensions.AbsoluteDelayStartSignal<int>>().And.IsNotNull();
+            await Assert.That(subscription.Scheduler).IsSameReferenceAs(ThreadPoolSequencer.Instance);
+        }
 
-        await delayedScalar.ValueCountReaching(One);
-        await delayedRange.ValueCountReaching(Two);
-        await delayedExplicitRange.ValueCountReaching(Two);
-        await delayedSubscriptionScalar.ValueCountReaching(One);
-        await delayedSubscriptionRange.ValueCountReaching(Two);
-        await delayedSubscriptionExplicitRange.ValueCountReaching(Two);
-        var timedOut = await timeout.FirstError;
-        var explicitlyTimedOut = await explicitTimeout.FirstError;
+        var expiring = explicitNull
+            ? Signal.Silent<int>().Timeout(dueTime, null)
+            : Signal.Silent<int>().Timeout(dueTime);
+        var timeout = await Assert.That(expiring).IsTypeOf<LinqExtensions.AbsoluteExpireSignal<int>>().And.IsNotNull();
+        await Assert.That(timeout.Scheduler).IsSameReferenceAs(ThreadPoolSequencer.Instance);
+    }
+
+    /// <summary>Absolute delays emit scalar and range values in order, then complete, when the due time arrives.</summary>
+    /// <param name="range">True to delay a range; false to delay a scalar value.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task AbsoluteDelays_ClockReachesDueTime_EmitValuesAndComplete(bool range)
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var dueTime = clock.Now.AddTicks(DueTicks);
+        var source = range ? Signal.Sequence(Two, Two) : Signal.Emit(One);
+        RecordingWitness<int> delayed = new();
+        RecordingWitness<int> delayedSubscription = new();
+        using var delayHandle = source.Delay(dueTime, clock).Subscribe(delayed);
+        using var subscriptionHandle = source.DelaySubscription(dueTime, clock).Subscribe(delayedSubscription);
+
+        await Assert.That(delayed.Values).IsEmpty();
+        await Assert.That(delayedSubscription.Values).IsEmpty();
+        await Assert.That(delayed.Completed).IsEqualTo(0);
+        await Assert.That(delayedSubscription.Completed).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(DueTicks));
+
+        int[] expected = range ? [Two, Three] : [One];
+        await Assert.That(delayed.Values.SequenceEqual(expected)).IsTrue();
+        await Assert.That(delayedSubscription.Values.SequenceEqual(expected)).IsTrue();
+        await Assert.That(delayed.Completed).IsEqualTo(1);
+        await Assert.That(delayedSubscription.Completed).IsEqualTo(1);
+        await Assert.That(delayed.Errors).IsEmpty();
+        await Assert.That(delayedSubscription.Errors).IsEmpty();
+    }
+
+    /// <summary>An absolute timeout emits one error when the clock reaches its due time.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task AbsoluteTimeout_ClockReachesDueTime_EmitsOneError()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        RecordingWitness<int> observer = new();
+        using var subscription = Signal.Silent<int>()
+            .Timeout(clock.Now.AddTicks(DueTicks), clock)
+            .Subscribe(observer);
+
+        await Assert.That(observer.Errors).IsEmpty();
+        clock.AdvanceBy(TimeSpan.FromTicks(DueTicks));
+
+        await Assert.That(observer.Errors).HasSingleItem();
+        await Assert.That(observer.Errors[0]).IsTypeOf<TimeoutException>();
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
 
-        await Assert.That(delayedScalar.Values.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionScalar.Values.SequenceEqual([One])).IsTrue();
-        await Assert.That(delayedSubscriptionRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(delayedSubscriptionExplicitRange.Values.SequenceEqual([Two, Three])).IsTrue();
-        await Assert.That(timedOut).IsTypeOf<TimeoutException>();
-        await Assert.That(explicitlyTimedOut).IsTypeOf<TimeoutException>();
+        clock.AdvanceBy(TimeSpan.FromTicks(DueTicks));
+        await Assert.That(observer.Errors).HasSingleItem();
     }
 
     /// <summary>Time aliases construct signals when no sequencer is supplied.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
index 96a7d6ea..a88083d5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs
@@ -857,7 +857,7 @@ await Assert.That(new ResumeSignal<int>(Signal.FromEnumerable(_oneToThree), Sign
 
     /// <summary>Returns the value unchanged.</summary>
     /// <param name = "value">The source value.</param>
-    /// <returns>The value.</returns>
+    /// <returns>The same value.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int Identity(int value) => value;
 
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ScheduledItemTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ScheduledItemTests.cs
new file mode 100644
index 00000000..51a389a6
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ScheduledItemTests.cs
@@ -0,0 +1,40 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests ownership of resources returned by scheduled actions.</summary>
+public class ScheduledItemTests
+{
+    /// <summary>Cancellation after publication leaves no resource for final cleanup to release again.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancellationAfterPublication_ReleasesResultOnce()
+    {
+        RecordingDisposable result = new();
+        ScheduledItem<long> item = new(0, Comparer<long>.Default, _ => result);
+        item.Invoke();
+        item.Dispose();
+        item.ReleaseCanceledResult();
+        await Assert.That(result.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Cancellation inside the action releases the result returned afterward.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancellationBeforePublication_ReleasesResultOnce()
+    {
+        RecordingDisposable result = new();
+        ScheduledItem<long> item = new(0, Comparer<long>.Default, pending =>
+        {
+            pending.Dispose();
+            return result;
+        });
+        item.Invoke();
+        item.Dispose();
+        await Assert.That(result.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
index ddfbb345..0ab9d410 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Cancellation.cs
@@ -99,15 +99,28 @@ public async Task TaskPoolSkipsWorkCanceledAfterDispatch()
     public async Task ThreadPoolFinalCancellationCleanupDoesNotReleaseTheResultTwice()
     {
         using ManualThreadPool pool = new();
-        var releases = 0;
+        RecordingDisposable result = new();
         ThreadPoolSequencer.ScheduledWorkItem<int> item = new(
             pool.Sequencer,
             0,
-            (_, _) => new ActionDisposable(() => releases++));
+            (_, _) => result);
         item.Execute();
         item.Dispose();
         item.ReleaseCanceledResult();
-        await Assert.That(releases).IsEqualTo(1);
+        await Assert.That(result.DisposeCount).IsEqualTo(1);
         await Assert.That(item.IsDisposed).IsTrue();
     }
+
+    /// <summary>Cancellation after publication leaves no result for final cleanup to release again.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelegateFinalCancellationCleanupDoesNotReleaseTheResultTwice()
+    {
+        RecordingDisposable result = new();
+        Sequencer.DelegateWorkItem<int> item = new(Sequencer.Immediate, 0, (_, _) => result);
+        item.Execute();
+        item.Dispose();
+        item.ReleaseCanceledResult();
+        await Assert.That(result.DisposeCount).IsEqualTo(1);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
index ee36c617..40be6267 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
@@ -2,6 +2,8 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Signals;
 
 namespace ReactiveUI.Primitives.Tests;
@@ -60,25 +62,21 @@ public async Task ExpireFailsASilentSequenceWhenTheDelayRuns()
         await Assert.That(witness.Errors.Count).IsEqualTo(1);
     }
 
-    /// <summary>Verifies the sequencer-free <c>Start</c> factories run their work and emit its outcome.</summary>
+    /// <summary>The sequencer-free Start factories select the default sequencer without invoking their work.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
-    public async Task StartWithoutASequencerRunsTheWorkOnTheDefaultSequencer()
+    public async Task StartWithoutASequencerSelectsTheDefaultSequencer()
     {
-        AwaitableWitness<int> functionWitness = new();
-        using var functionSubscription = Signal.Start(static () => Two).Subscribe(functionWitness);
-        await functionWitness.ValueCountReaching(1);
-        await Assert.That(functionWitness.Values.SequenceEqual([Two])).IsTrue();
+        var functionRuns = 0;
+        var function = await Assert.That(Signal.Start(() => ++functionRuns)).IsTypeOf<StartSignal<int>>().And.IsNotNull();
         var actionRuns = 0;
-        AwaitableWitness<RxVoid> actionWitness = new();
-
-        // A void method group selects Start(Action); a lambda over 'actionRuns++' would bind to Start<T>.
         void RunAction() => actionRuns++;
+        var action = await Assert.That(Signal.Start(RunAction)).IsTypeOf<StartSignal>().And.IsNotNull();
 
-        using var actionSubscription = Signal.Start(RunAction).Subscribe(actionWitness);
-        await actionWitness.ValueCountReaching(1);
-        await Assert.That(actionRuns).IsEqualTo(1);
-        await Assert.That(actionWitness.Values[0]).IsEqualTo(RxVoid.Default);
+        await Assert.That(function.Scheduler).IsSameReferenceAs(Sequencer.Default);
+        await Assert.That(action.Scheduler).IsSameReferenceAs(Sequencer.Default);
+        await Assert.That(functionRuns).IsEqualTo(0);
+        await Assert.That(actionRuns).IsEqualTo(0);
     }
 
     /// <summary>Each scheduled callback emits the next tick.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
index 20678a05..a8059292 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalTests.cs
@@ -752,7 +752,7 @@ private sealed class RecordingWitness : IObserver<int>
         public int Errors { get; private set; }
 
         /// <summary>Receives the next value.</summary>
-        /// <param name = "value">The value.</param>
+        /// <param name = "value">The observed value.</param>
         public void OnNext(int value) => Total += value;
 
         /// <summary>Receives an error.</summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
index 96974433..4670d9f7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StartSignalTests.cs
@@ -4,10 +4,11 @@
 
 using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Verifies <see cref="StartSignal{T}"/> reports whether it must be subscribed on the current thread.</summary>
+/// <summary>Tests scheduler selection and work results for start signals.</summary>
 public sealed class StartSignalTests
 {
     /// <summary>The value produced by the start function.</summary>
@@ -32,4 +33,80 @@ public async Task StartSignalOffTheCurrentThreadSequencerDoesNotRequireTheCurren
 
         await Assert.That(signal.IsRequiredSubscribeOnCurrentThread()).IsFalse();
     }
+
+    /// <summary>A default start function runs once, emits its result, and completes.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_DefaultFunction_EmitsResultAndCompletes()
+    {
+        var runs = 0;
+        var signal = await Assert.That(Signal.Start(() =>
+        {
+            runs++;
+            return ProducedValue;
+        })).IsTypeOf<StartSignal<int>>().And.IsNotNull();
+        RecordingWitness<int> observer = new();
+
+        signal.Run(observer);
+
+        await Assert.That(runs).IsEqualTo(1);
+        await Assert.That(observer.Values).HasSingleItem();
+        await Assert.That(observer.Values[0]).IsEqualTo(ProducedValue);
+        await Assert.That(observer.Completed).IsEqualTo(1);
+        await Assert.That(observer.Errors).IsEmpty();
+    }
+
+    /// <summary>A default start action runs once, emits its unit value, and completes.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_DefaultAction_EmitsUnitAndCompletes()
+    {
+        var runs = 0;
+        void RunAction() => runs++;
+        var signal = await Assert.That(Signal.Start(RunAction)).IsTypeOf<StartSignal>().And.IsNotNull();
+        RecordingWitness<RxVoid> observer = new();
+
+        signal.Run(observer);
+
+        await Assert.That(runs).IsEqualTo(1);
+        await Assert.That(observer.Values).HasSingleItem();
+        await Assert.That(observer.Values[0]).IsEqualTo(RxVoid.Default);
+        await Assert.That(observer.Completed).IsEqualTo(1);
+        await Assert.That(observer.Errors).IsEmpty();
+    }
+
+    /// <summary>A failing start function forwards its exception without a value or completion.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_FailingFunction_ForwardsError()
+    {
+        InvalidOperationException fault = new("function failed");
+        var signal = await Assert.That(Signal.Start<int>(() => throw fault)).IsTypeOf<StartSignal<int>>().And.IsNotNull();
+        RecordingWitness<int> observer = new();
+
+        signal.Run(observer);
+
+        await Assert.That(observer.Errors).HasSingleItem();
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(fault);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+    }
+
+    /// <summary>A failing start action forwards its exception without a value or completion.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Run_FailingAction_ForwardsError()
+    {
+        InvalidOperationException fault = new("action failed");
+        void RunAction() => throw fault;
+        var signal = await Assert.That(Signal.Start(RunAction)).IsTypeOf<StartSignal>().And.IsNotNull();
+        RecordingWitness<RxVoid> observer = new();
+
+        signal.Run(observer);
+
+        await Assert.That(observer.Errors).HasSingleItem();
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(fault);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchCoordinatorTests.cs
new file mode 100644
index 00000000..dfb41f71
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchCoordinatorTests.cs
@@ -0,0 +1,178 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests generation changes and notification ordering in the switch coordinator.</summary>
+public sealed class SwitchCoordinatorTests
+{
+    /// <summary>The value emitted by the replacement source.</summary>
+    private const int ReplacementValue = 2;
+
+    /// <summary>The value emitted by a superseded source.</summary>
+    private const int StaleValue = 3;
+
+    /// <summary>Switching preserves ordered delivery while callbacks own the coordinator gate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task SwitchTo_SwitchBetweenValues_HoldsGateDuringDelivery()
+    {
+        Signal<IObservable<int>> outer = new();
+        CapturingObservable first = new();
+        CapturingObservable second = new();
+        List<int> values = [];
+        LinqExtensions.SwitchCoordinator<int>? coordinator = null;
+        var ownsGate = true;
+        using var subscription = outer.SwitchTo().Subscribe(value =>
+        {
+            ownsGate &= IsHeld(coordinator!.Gate);
+            values.Add(value);
+        });
+        coordinator = (LinqExtensions.SwitchCoordinator<int>)subscription;
+
+        outer.OnNext(first);
+        first.Observer!.OnNext(1);
+        outer.OnNext(second);
+        first.Observer.OnNext(StaleValue);
+        second.Observer!.OnNext(ReplacementValue);
+
+        await Assert.That(ownsGate).IsTrue();
+        await Assert.That(values.SequenceEqual([1, ReplacementValue])).IsTrue();
+    }
+
+    /// <summary>A value accepted before a switch is retained, and later values from that generation are dropped.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TryBeginSource_BetweenInnerValues_RejectsPreviousGeneration()
+    {
+        RecordingWitness<int> observer = new();
+        using LinqExtensions.SwitchCoordinator<int> coordinator = new(observer);
+
+        await Assert.That(coordinator.TryBeginSource(out var first)).IsTrue();
+        coordinator.OnNext(first, 1);
+        await Assert.That(coordinator.TryBeginSource(out var second)).IsTrue();
+        coordinator.OnNext(first, StaleValue);
+        coordinator.OnError(first, new InvalidOperationException("stale"));
+        coordinator.OnCompleted(first);
+        coordinator.OnOuterCompleted();
+
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Errors).IsEmpty();
+
+        coordinator.OnNext(second, ReplacementValue);
+        coordinator.OnCompleted(second);
+
+        await Assert.That(observer.Values.SequenceEqual([1, ReplacementValue])).IsTrue();
+        await Assert.That(observer.Completed).IsEqualTo(1);
+    }
+
+    /// <summary>Completion waits for both sources and rejects subsequent values and source generations.</summary>
+    /// <param name="outerFirst">True when the outer source completes before the active inner source.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task OnCompleted_SourceOrder_CompletesOnce(bool outerFirst)
+    {
+        RecordingWitness<int> observer = new();
+        using LinqExtensions.SwitchCoordinator<int> coordinator = new(observer);
+        await Assert.That(coordinator.TryBeginSource(out var version)).IsTrue();
+
+        if (outerFirst)
+        {
+            coordinator.OnOuterCompleted();
+        }
+        else
+        {
+            coordinator.OnCompleted(version);
+        }
+
+        await Assert.That(observer.Completed).IsEqualTo(0);
+
+        if (outerFirst)
+        {
+            coordinator.OnCompleted(version);
+        }
+        else
+        {
+            coordinator.OnOuterCompleted();
+        }
+
+        coordinator.OnCompleted(version);
+        coordinator.OnOuterCompleted();
+        coordinator.OnNext(version, 1);
+        coordinator.OnError(version, new InvalidOperationException("late inner"));
+        coordinator.OnOuterError(new InvalidOperationException("late outer"));
+
+        await Assert.That(coordinator.TryBeginSource(out _)).IsFalse();
+        await Assert.That(observer.Completed).IsEqualTo(1);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Errors).IsEmpty();
+    }
+
+    /// <summary>The first source error is forwarded and prevents subsequent errors, values, and completion.</summary>
+    /// <param name="outerFirst">True when the outer source reports the first error.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task OnError_SourceOrder_ForwardsFirstError(bool outerFirst)
+    {
+        RecordingWitness<int> observer = new();
+        using LinqExtensions.SwitchCoordinator<int> coordinator = new(observer);
+        await Assert.That(coordinator.TryBeginSource(out var version)).IsTrue();
+        InvalidOperationException first = new("first");
+        InvalidOperationException second = new("second");
+
+        if (outerFirst)
+        {
+            coordinator.OnOuterError(first);
+            coordinator.OnError(version, second);
+        }
+        else
+        {
+            coordinator.OnError(version, first);
+            coordinator.OnOuterError(second);
+        }
+
+        coordinator.OnNext(version, 1);
+        coordinator.OnCompleted(version);
+        coordinator.OnOuterCompleted();
+
+        await Assert.That(coordinator.TryBeginSource(out _)).IsFalse();
+        await Assert.That(observer.Errors).HasSingleItem();
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(first);
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+    }
+
+    /// <summary>Reports whether the calling thread owns the gate.</summary>
+    /// <param name="gate">The coordinator synchronization gate.</param>
+    /// <returns>True when the calling thread owns the gate; otherwise, false.</returns>
+    private static bool IsHeld(Lock gate)
+    {
+#if NET9_0_OR_GREATER
+        return gate.IsHeldByCurrentThread;
+#else
+        return Monitor.IsEntered(gate);
+#endif
+    }
+
+    /// <summary>Retains the inner observer for notifications after a source switch.</summary>
+    private sealed class CapturingObservable : IObservable<int>
+    {
+        /// <summary>Gets the observer captured by subscription.</summary>
+        public IObserver<int>? Observer { get; private set; }
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<int> observer)
+        {
+            Observer = observer;
+            return EmptyDisposable.Instance;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
index 57298277..02a78cfa 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SwitchWitnessTests.cs
@@ -2,7 +2,6 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Runtime.ExceptionServices;
 using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.Signals;
@@ -36,50 +35,6 @@ public async Task SwitchWitnessSuppressesDuplicateCompletionFromCurrentInner()
         await Assert.That(observer.Completed).IsEqualTo(One);
     }
 
-    /// <summary>Verifies the public switch operator serializes a source switch against an in-flight inner delivery.</summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Test]
-    public async Task SwitchToDoesNotEnterObserverConcurrentlyWhenSwitchingInnerSources()
-{
-        Signal<IObservable<int>> outer = new();
-        CapturingObservable<int> first = new();
-        CapturingObservable<int> second = new();
-        using GatedObserver observer = new();
-        using var subscription = outer.SwitchTo().Subscribe(observer);
-        var coordinator = (LinqExtensions.SwitchCoordinator<int>)subscription;
-        outer.OnNext(first);
-        var firstDelivery = Task.Run(() => first.Observer!.OnNext(One));
-        observer.FirstEntered.Wait();
-        bool entered;
-        try
-        {
-#if NET9_0_OR_GREATER
-            entered = coordinator.Gate.TryEnter();
-            if (entered)
-            {
-                coordinator.Gate.Exit();
-            }
-#else
-            entered = Monitor.TryEnter(coordinator.Gate);
-            if (entered)
-            {
-                Monitor.Exit(coordinator.Gate);
-            }
-#endif
-        }
-        finally
-        {
-            observer.ReleaseFirst.Set();
-        }
-
-        await firstDelivery;
-        await Assert.That(entered).IsFalse();
-        outer.OnNext(second);
-        second.Observer!.OnNext(Two);
-        await Assert.That(observer.ConcurrentOnNext).IsFalse();
-        await Assert.That(observer.Values).IsEqualTo(Two);
-    }
-
     /// <summary>Verifies switching inner sources forwards only the latest source's values.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -328,64 +283,4 @@ public IDisposable Subscribe(IObserver<T> observer)
             return new ActionDisposable(() => Disposed = true);
         }
     }
-
-    /// <summary>Observer that blocks inside its first value callback so concurrent re-entry is detected.</summary>
-    private sealed class GatedObserver : IObserver<int>, IDisposable
-    {
-        /// <summary>Tracks how many threads are currently inside <see cref="OnNext"/>.</summary>
-        private int _inOnNext;
-
-        /// <summary>Counts forwarded values.</summary>
-        private int _values;
-
-        /// <summary>Set when more than one thread is inside <see cref="OnNext"/> at once.</summary>
-        private int _concurrent;
-
-        /// <summary>Gets the event set when the first <see cref="OnNext"/> call is entered.</summary>
-        public ManualResetEventSlim FirstEntered { get; } = new();
-
-        /// <summary>Gets the event released by the test to unblock the first <see cref="OnNext"/> call.</summary>
-        public ManualResetEventSlim ReleaseFirst { get; } = new();
-
-        /// <summary>Gets the number of forwarded values.</summary>
-        public int Values => Volatile.Read(ref _values);
-
-        /// <summary>Gets a value indicating whether <see cref="OnNext"/> was entered concurrently.</summary>
-        public bool ConcurrentOnNext => Volatile.Read(ref _concurrent) != 0;
-
-        /// <inheritdoc/>
-        public void OnCompleted()
-        {
-        }
-
-        /// <inheritdoc/>
-        public void OnError(Exception error)
-        {
-        }
-
-        /// <inheritdoc/>
-        public void OnNext(int value)
-{
-            if (Interlocked.Increment(ref _inOnNext) != 1)
-            {
-                _ = Interlocked.Exchange(ref _concurrent, 1);
-            }
-
-            var index = Interlocked.Increment(ref _values);
-            if (index == 1)
-            {
-                FirstEntered.Set();
-                ReleaseFirst.Wait();
-            }
-
-            _ = Interlocked.Decrement(ref _inOnNext);
-    }
-
-        /// <inheritdoc/>
-        public void Dispose()
-        {
-            FirstEntered.Dispose();
-            ReleaseFirst.Dispose();
-        }
-    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
index d94b3b26..da036cc5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
@@ -111,4 +111,44 @@ public async Task TaskPoolDelayLargerThanIntMaxValue()
         using var scheduled = sequencer.Schedule(dueTime, static () => { });
         await Assert.That(scheduled).IsNotNull();
     }
+
+    /// <summary>Cancellation between the delay callback and task dispatch suppresses the action.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Schedule_CancelAfterDelayBeforeDispatch_DropsWork()
+    {
+        using ManualThreadPool delays = new();
+        ManualTaskScheduler tasks = new();
+        TaskPoolSequencer sequencer = new(new(tasks), delays.Sequencer);
+        StrongBox<int> runs = new();
+        var scheduled = sequencer.Schedule(runs, TimeSpan.FromSeconds(1), static state => state.Value++);
+
+        tasks.RunPending();
+        await Assert.That(runs.Value).IsEqualTo(0);
+        delays.RunDue(Sequencer.ToTimestampDelta(TimeSpan.FromSeconds(1)));
+        scheduled.Dispose();
+        tasks.RunPending();
+        await Assert.That(runs.Value).IsEqualTo(0);
+    }
+
+    /// <summary>Work remains delayed until the supplied monotonic clock reaches its due timestamp.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Schedule_AdvanceClockToDue_DispatchesOnce()
+    {
+        using ManualThreadPool delays = new();
+        ManualTaskScheduler tasks = new();
+        TaskPoolSequencer sequencer = new(new(tasks), delays.Sequencer);
+        StrongBox<int> runs = new();
+        using var scheduled = sequencer.Schedule(runs, TimeSpan.FromSeconds(1), static state => state.Value++);
+        var due = Sequencer.ToTimestampDelta(TimeSpan.FromSeconds(1));
+        delays.RunDue(due - 1);
+        tasks.RunPending();
+        await Assert.That(runs.Value).IsEqualTo(0);
+        delays.RunDue(due);
+        await Assert.That(sequencer.Timestamp).IsEqualTo(due);
+        await Assert.That(runs.Value).IsEqualTo(0);
+        tasks.RunPending();
+        await Assert.That(runs.Value).IsEqualTo(1);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
index 405cf6ec..65079628 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
@@ -3,70 +3,221 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Reactive.Concurrency;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.WinForms.Reactive.Tests;
 
-/// <summary>Tests scheduler dispatch on a dedicated Windows Forms STA thread.</summary>
+/// <summary>Tests control dispatch with manually delivered callbacks and handle notifications.</summary>
 public sealed class ControlSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null control.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Constructor validation rejects a missing control.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
     public async Task ConstructorRejectsNullControl() =>
         await Assert.That(static () => new ControlSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
-    /// <summary>Verifies immediate work is posted to and executed on the control's UI thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Work rejected before handle creation is retried in order when the handle becomes ready.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnControlThread()
+    public async Task HandleCreatedRetriesQueuedWorkAndSkipsCancellation()
     {
-        using var harness = new ControlHarness();
-        var scheduler = new ControlSequencer(harness.Control);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var control = CreateControl();
+        Queue<Action> drains = new();
+        var ready = false;
+        ControlSequencer scheduler = new(
+            control,
+            drain =>
+            {
+                if (!ready)
+                {
+                    return false;
+                }
 
-        _ = scheduler.Schedule(() => completion.TrySetResult(Environment.CurrentManagedThreadId));
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        using var first = scheduler.Schedule(() => values.Add(1));
+        var cancelled = scheduler.Schedule(() => values.Add(0));
+        using var second = scheduler.Schedule(TimeSpan.Zero, () => values.Add(SecondValue));
+        cancelled.Dispose();
+        await Assert.That(scheduler.Control).IsSameReferenceAs(control);
+        await Assert.That(drains).IsEmpty();
+        await Assert.That(values).IsEmpty();
+        ready = true;
+        scheduler.OnHandleCreated(control, EventArgs.Empty);
+        await Assert.That(drains).Count().IsEqualTo(1);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        scheduler.OnHandleCreated(control, EventArgs.Empty);
+        await Assert.That(drains).IsEmpty();
+    }
 
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+    /// <summary>A missing handle rejects a post before invoking the native dispatcher.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostWithoutAHandleDoesNotInvoke()
+    {
+        using var control = CreateControl();
+        var accepted = ControlSequencer.TryPost(
+            control,
+            false,
+            static () => { },
+            static (_, _) => throw new InvalidOperationException("Unexpected dispatch."));
+        await Assert.That(accepted).IsFalse();
     }
 
-    /// <summary>Owns the control and its STA message loop.</summary>
-    private sealed class ControlHarness : IDisposable
+    /// <summary>A live handle forwards exactly the supplied callback.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostWithAHandleForwardsTheCallback()
     {
-        /// <summary>The thread running the Windows Forms message loop.</summary>
-        private readonly Thread _thread;
+        using var control = CreateControl();
+        var calls = 0;
+        Action callback = () => calls++;
+        Action? posted = null;
+        var accepted = ControlSequencer.TryPost(control, true, callback, (_, drain) => posted = drain);
+        await Assert.That(accepted).IsTrue();
+        await Assert.That<Action?>(posted).IsSameReferenceAs(callback);
+        await Assert.That(calls).IsEqualTo(0);
+        posted!();
+        await Assert.That(calls).IsEqualTo(1);
+    }
+
+    /// <summary>A disappeared handle rejects the post while disposal propagates the failure.</summary>
+    /// <param name="dispose">Whether disposal occurs during dispatch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TryPostHandlesDispatcherFailureAccordingToDisposal(bool dispose)
+    {
+        using var control = CreateControl();
+        InvalidOperationException failure = new("Handle lost.");
+        bool Post() => ControlSequencer.TryPost(
+            control,
+            true,
+            static () => { },
+            (target, _) =>
+            {
+                if (dispose)
+                {
+                    target.Dispose();
+                }
 
-        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class with a created control handle.</summary>
-        public ControlHarness()
+                throw failure;
+            });
+        if (dispose)
         {
-            using var ready = new ManualResetEventSlim(false);
-            _thread = new(() =>
+            var observed = await Assert.That(Post).ThrowsExactly<InvalidOperationException>();
+            await Assert.That(observed).IsSameReferenceAs(failure);
+        }
+        else
+        {
+            await Assert.That(Post()).IsFalse();
+        }
+    }
+
+    /// <summary>Disposed controls reject work before dispatch.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostAfterDisposalThrows()
+    {
+        var control = CreateControl();
+        control.Dispose();
+        await Assert.That(() => ControlSequencer.TryPost(control, true, static () => { }, static (_, _) => { }))
+            .ThrowsExactly<ObjectDisposedException>();
+    }
+
+    /// <summary>Disposal cancels a delayed timer and suppresses even a late callback.</summary>
+    /// <param name="cancel">Whether to cancel before delivery.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleHonorsCancellationBeforeDelivery(bool cancel)
+    {
+        using var control = CreateControl();
+        Queue<Action> drains = new();
+        ManualDelayScheduler delayed = new();
+        ControlSequencer scheduler = new(
+            control,
+            drain =>
             {
-                Control = new();
-                _ = Control.Handle; // Force handle creation so BeginInvoke can marshal work.
-                ThreadId = Environment.CurrentManagedThreadId;
-                ready.Set();
-                Application.Run();
-            }) { IsBackground = true, Name = "WinFormsControlHarness" };
-
-            _thread.SetApartmentState(ApartmentState.STA);
-            _thread.Start();
-            ready.Wait();
+                drains.Enqueue(drain);
+                return true;
+            },
+            delayed);
+        var calls = 0;
+        var delay = TimeSpan.FromSeconds(1);
+        var handle = scheduler.Schedule(delay, () => calls++);
+        var pending = delayed.Callbacks.Dequeue();
+        await Assert.That(pending.Delay).IsEqualTo(delay);
+        await Assert.That(calls).IsEqualTo(0);
+        if (cancel)
+        {
+            handle.Dispose();
+        }
+
+        pending.Callback();
+        drains.Dequeue()();
+        await Assert.That(pending.Cancellation.IsDisposed).IsEqualTo(cancel);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
+        if (cancel)
+        {
+            return;
+        }
+
+        handle.Dispose();
+    }
+
+    /// <summary>Creates a control without changing the caller's synchronization context.</summary>
+    /// <returns>The control.</returns>
+    private static Control CreateControl()
+    {
+        var previous = SynchronizationContext.Current;
+        try
+        {
+            return new();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(previous);
         }
+    }
+
+    /// <summary>Retains delayed actions and permits explicit late delivery after cancellation.</summary>
+    private sealed class ManualDelayScheduler : IScheduler
+    {
+        /// <summary>Gets pending callbacks and their cancellation handles.</summary>
+        public Queue<(Action Callback, TimeSpan Delay, SingleAssignmentDisposable Cancellation)> Callbacks { get; } = new();
 
-        /// <summary>Gets the hosted control.</summary>
-        public Control Control { get; private set; } = null!;
+        /// <inheritdoc/>
+        public DateTimeOffset Now => DateTimeOffset.UnixEpoch;
 
-        /// <summary>Gets the managed thread id the control runs on.</summary>
-        public int ThreadId { get; private set; }
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action) =>
+            Schedule(state, TimeSpan.Zero, action);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(TState state, DateTimeOffset dueTime, Func<IScheduler, TState, IDisposable> action) =>
+            Schedule(state, dueTime - Now, action);
 
         /// <inheritdoc/>
-        public void Dispose()
+        public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
         {
-            _ = Control.BeginInvoke(Application.ExitThread);
-            _thread.Join();
-            Control.Dispose();
+            SingleAssignmentDisposable cancellation = new();
+            Callbacks.Enqueue((() => cancellation.Disposable = action(this, state), dueTime, cancellation));
+            return cancellation;
         }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
index e921d343..ca1b0fee 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
@@ -3,85 +3,193 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.WinForms.Tests;
 
-/// <summary>Tests control dispatch on a dedicated Windows Forms STA thread.</summary>
+/// <summary>Tests control dispatch with manually delivered callbacks and handle notifications.</summary>
 public sealed class ControlSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null control.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Constructor validation rejects a missing control.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
     public async Task ConstructorRejectsNullControl() =>
         await Assert.That(static () => new ControlSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
-    /// <summary>Verifies immediate work is posted to and executed on the control's UI thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Work rejected before handle creation is retried in order when the handle becomes ready.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnControlThread()
+    public async Task HandleCreatedRetriesQueuedWorkAndSkipsCancellation()
     {
-        using var harness = new ControlHarness();
-        var sequencer = new ControlSequencer(harness.Control);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var control = CreateControl();
+        Queue<Action> drains = new();
+        var ready = false;
+        ControlSequencer sequencer = new(
+            control,
+            drain =>
+            {
+                if (!ready)
+                {
+                    return false;
+                }
 
-        sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        RecordingWorkItem cancelled = new(() => values.Add(0));
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(1)));
+        sequencer.Schedule(cancelled);
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)), 0);
+        cancelled.Dispose();
+        await Assert.That(sequencer.Control).IsSameReferenceAs(control);
+        await Assert.That(drains).IsEmpty();
+        await Assert.That(values).IsEmpty();
+        ready = true;
+        sequencer.OnHandleCreated(control, EventArgs.Empty);
+        await Assert.That(drains).Count().IsEqualTo(1);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        sequencer.OnHandleCreated(control, EventArgs.Empty);
+        await Assert.That(drains).IsEmpty();
+    }
 
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+    /// <summary>A missing handle rejects a post before invoking the native dispatcher.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostWithoutAHandleDoesNotInvoke()
+    {
+        using var control = CreateControl();
+        var accepted = ControlSequencer.TryPost(
+            control,
+            false,
+            static () => { },
+            static (_, _) => throw new InvalidOperationException("Unexpected dispatch."));
+        await Assert.That(accepted).IsFalse();
+    }
+
+    /// <summary>A live handle forwards exactly the supplied callback.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostWithAHandleForwardsTheCallback()
+    {
+        using var control = CreateControl();
+        var calls = 0;
+        Action callback = () => calls++;
+        Action? posted = null;
+        var accepted = ControlSequencer.TryPost(control, true, callback, (_, drain) => posted = drain);
+        await Assert.That(accepted).IsTrue();
+        await Assert.That<Action?>(posted).IsSameReferenceAs(callback);
+        await Assert.That(calls).IsEqualTo(0);
+        posted!();
+        await Assert.That(calls).IsEqualTo(1);
     }
 
-    /// <summary>Work item that invokes a delegate when executed.</summary>
-    private sealed class DelegateWorkItem : IWorkItem
+    /// <summary>A disappeared handle rejects the post while disposal propagates the failure.</summary>
+    /// <param name="dispose">Whether disposal occurs during dispatch.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task TryPostHandlesDispatcherFailureAccordingToDisposal(bool dispose)
     {
-        /// <summary>The action to run on execution.</summary>
-        private readonly Action _action;
+        using var control = CreateControl();
+        InvalidOperationException failure = new("Handle lost.");
+        bool Post() => ControlSequencer.TryPost(
+            control,
+            true,
+            static () => { },
+            (target, _) =>
+            {
+                if (dispose)
+                {
+                    target.Dispose();
+                }
 
-        /// <summary>Initializes a new instance of the <see cref="DelegateWorkItem"/> class.</summary>
-        /// <param name="action">The action to run on execution.</param>
-        public DelegateWorkItem(Action action) => _action = action;
+                throw failure;
+            });
+        if (dispose)
+        {
+            var observed = await Assert.That(Post).ThrowsExactly<InvalidOperationException>();
+            await Assert.That(observed).IsSameReferenceAs(failure);
+        }
+        else
+        {
+            await Assert.That(Post()).IsFalse();
+        }
+    }
 
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Execute() => _action();
+    /// <summary>Disposed controls reject work before dispatch.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task TryPostAfterDisposalThrows()
+    {
+        var control = CreateControl();
+        control.Dispose();
+        await Assert.That(() => ControlSequencer.TryPost(control, true, static () => { }, static (_, _) => { }))
+            .ThrowsExactly<ObjectDisposedException>();
     }
 
-    /// <summary>Owns the control and its STA message loop.</summary>
-    private sealed class ControlHarness : IDisposable
+    /// <summary>Delayed work waits for its callback and skips cancellation.</summary>
+    /// <param name="cancel">Whether to cancel before delivery.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleWaitsForItsCallback(bool cancel)
     {
-        /// <summary>The thread running the Windows Forms message loop.</summary>
-        private readonly Thread _thread;
+        using var control = CreateControl();
+        Queue<(IWorkItem Item, long Due)> delayed = new();
+        ControlSequencer sequencer = new(control, static _ => false, (item, due) => delayed.Enqueue((item, due)));
+        var calls = 0;
+        RecordingWorkItem item = new(() => calls++);
+        sequencer.Schedule(item, long.MaxValue);
+        await Assert.That(calls).IsEqualTo(0);
+        var pending = delayed.Dequeue();
+        await Assert.That(pending.Due).IsEqualTo(long.MaxValue);
+        if (cancel)
+        {
+            item.Dispose();
+        }
 
-        /// <summary>Initializes a new instance of the <see cref="ControlHarness"/> class with a created control handle.</summary>
-        public ControlHarness()
+        DispatchSequencerState.RunIfActive(pending.Item);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
+    }
+
+    /// <summary>Creates a control without changing the caller's synchronization context.</summary>
+    /// <returns>The control.</returns>
+    private static Control CreateControl()
+    {
+        var previous = SynchronizationContext.Current;
+        try
         {
-            using var ready = new ManualResetEventSlim(false);
-            _thread = new(() =>
-            {
-                Control = new();
-                _ = Control.Handle; // Force handle creation so BeginInvoke can marshal work.
-                ThreadId = Environment.CurrentManagedThreadId;
-                ready.Set();
-                Application.Run();
-            }) { IsBackground = true, Name = "WinFormsControlHarness" };
-
-            _thread.SetApartmentState(ApartmentState.STA);
-            _thread.Start();
-            ready.Wait();
+            return new();
         }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(previous);
+        }
+    }
 
-        /// <summary>Gets the hosted control.</summary>
-        public Control Control { get; private set; } = null!;
+    /// <summary>Records execution and supports cancellation.</summary>
+    /// <param name="action">The callback to run.</param>
+    private sealed class RecordingWorkItem(Action action) : IWorkItem, IsDisposed
+    {
+        /// <inheritdoc/>
+        public bool IsDisposed { get; private set; }
 
-        /// <summary>Gets the managed thread id the control runs on.</summary>
-        public int ThreadId { get; private set; }
+        /// <inheritdoc/>
+        public void Dispose() => IsDisposed = true;
 
         /// <inheritdoc/>
-        public void Dispose()
-        {
-            _ = Control.BeginInvoke(Application.ExitThread);
-            _thread.Join();
-            Control.Dispose();
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Execute() => action();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
index 9006f733..bf09a77b 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
@@ -3,84 +3,169 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using Microsoft.UI.Dispatching;
 using ReactiveUI.Primitives.Reactive.Concurrency;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.WinUI.Reactive.Tests;
 
-/// <summary>Tests scheduler execution on a dedicated WinUI queue thread.</summary>
+/// <summary>Tests dispatcher queue batching, rejection, and cancellation through controlled callbacks.</summary>
 public sealed class DispatcherQueueSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null dispatcher queue.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Expected values after both queued items run.</summary>
+    private static readonly int[] BatchValues = [1, SecondValue];
+
+    /// <summary>Expected values before the reentrant batch runs.</summary>
+    private static readonly int[] FirstBatchValues = [1];
+
+    /// <summary>Public constructors reject a missing dispatcher queue.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcherQueue() =>
+    public async Task ConstructorRejectsNullDispatcherQueue()
+    {
         await Assert.That(static () => new DispatcherQueueSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new DispatcherQueueSequencer(null!, DispatcherQueuePriority.High))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies a stopped dispatcher queue rejects scheduled work.</summary>
-    /// <returns>A task representing the asynchronous test operation.</returns>
+    /// <summary>Queued actions preserve order and cancellation until the drain runs.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task SchedulingAfterQueueShutdownThrows()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        var harness = new DispatcherQueueHarness();
-        DispatcherQueueSequencer scheduler = new(harness.DispatcherQueue);
-        await harness.DisposeAsync();
-        var executed = false;
-        await Assert.That(() => scheduler.Schedule(() => executed = true))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(() => scheduler.Schedule(() => executed = true))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(executed).IsFalse();
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        using var first = scheduler.Schedule(() => values.Add(1));
+        var cancelled = scheduler.Schedule(() => values.Add(0));
+        using var second = scheduler.Schedule(TimeSpan.Zero, () => values.Add(SecondValue));
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        await Assert.That(dispatcher.LastPriority).IsEqualTo(DispatcherQueuePriority.High);
+        await Assert.That(scheduler.Priority).IsEqualTo(DispatcherQueuePriority.High);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies immediate work is enqueued to and executed on the dispatcher-queue thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>A rejected post retains queued actions and reuses its cached callback on retry.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnQueueThread()
+    public async Task RejectedPostCanRetryWithoutLosingQueuedWork()
     {
-        await using var harness = new DispatcherQueueHarness();
-        var scheduler = new DispatcherQueueSequencer(harness.DispatcherQueue);
-        var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        _ = scheduler.Schedule(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess));
+        ManualDispatcher dispatcher = new() { AcceptsPosts = false };
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        await Assert.That(() => scheduler.Schedule(() => values.Add(1)))
+            .ThrowsExactly<InvalidOperationException>();
+        await Assert.That(values).IsEmpty();
+        var rejectedHandler = dispatcher.LastHandler;
+        dispatcher.AcceptsPosts = true;
+        using var next = scheduler.Schedule(() => values.Add(SecondValue));
+        await Assert.That(dispatcher.LastHandler).IsSameReferenceAs(rejectedHandler);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
+    }
 
-        var ranOnQueueThread = await completion.Task;
-        await Assert.That(ranOnQueueThread).IsTrue();
+    /// <summary>Actions queued from inside a callback wait for a later drain.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ReentrantScheduleRunsInTheNextBatch()
+    {
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        List<int> values = [];
+        using var first = scheduler.Schedule(() =>
+        {
+            values.Add(1);
+            _ = scheduler.Schedule(() => values.Add(SecondValue));
+        });
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(FirstBatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies due work executes on the dispatcher queue thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Timer cancellation suppresses a callback even when it is delivered late.</summary>
+    /// <param name="cancel">Whether cancellation precedes delivery.</param>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnQueueThread()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleHonorsCancellationBeforeDelivery(bool cancel)
     {
-        await using var harness = new DispatcherQueueHarness();
-        var scheduler = new DispatcherQueueSequencer(harness.DispatcherQueue);
-        var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        ManualDispatcher dispatcher = new();
+        var scheduler = dispatcher.Create();
+        var calls = 0;
+        var delay = TimeSpan.FromSeconds(1);
+        var handle = scheduler.Schedule(delay, () => calls++);
+        var pending = dispatcher.Delays.Dequeue();
+        await Assert.That(calls).IsEqualTo(0);
+        await Assert.That(dispatcher.Drains).IsEmpty();
+        await Assert.That(pending.Delay).IsEqualTo(delay);
+        if (cancel)
+        {
+            handle.Dispose();
+        }
 
-        _ = scheduler.Schedule(TimeSpan.Zero, () => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess));
+        pending.Callback();
+        await Assert.That(pending.Cancellation.IsDisposed).IsEqualTo(cancel);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
+        if (cancel)
+        {
+            return;
+        }
 
-        var ranOnQueueThread = await completion.Task;
-        await Assert.That(ranOnQueueThread).IsTrue();
+        handle.Dispose();
     }
 
-    /// <summary>Hosts a WinUI <see cref="DispatcherQueue"/> on a dedicated thread and shuts the queue down on disposal.</summary>
-    private sealed class DispatcherQueueHarness : IAsyncDisposable
+    /// <summary>Retains callbacks until they are explicitly delivered.</summary>
+    private sealed class ManualDispatcher
     {
-        /// <summary>The controller owning the dedicated dispatcher-queue thread.</summary>
-        private readonly DispatcherQueueController _controller;
+        /// <summary>Gets queued drains.</summary>
+        public Queue<DispatcherQueueHandler> Drains { get; } = new();
 
-        /// <summary>Initializes a new instance of the <see cref="DispatcherQueueHarness"/> class.</summary>
-        public DispatcherQueueHarness()
-        {
-            _controller = DispatcherQueueController.CreateOnDedicatedThread();
-            DispatcherQueue = _controller.DispatcherQueue;
-        }
+        /// <summary>Gets delayed callbacks and their cancellation handles.</summary>
+        public Queue<(Action Callback, TimeSpan Delay, BooleanDisposable Cancellation)> Delays { get; } = new();
 
-        /// <summary>Gets the hosted dispatcher queue.</summary>
-        public DispatcherQueue DispatcherQueue { get; }
+        /// <summary>Gets or sets whether enqueue attempts succeed.</summary>
+        public bool AcceptsPosts { get; set; } = true;
 
-        /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
-        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask();
+        /// <summary>Gets the most recently posted handler.</summary>
+        public DispatcherQueueHandler? LastHandler { get; private set; }
+
+        /// <summary>Gets the priority of the most recent post.</summary>
+        public DispatcherQueuePriority LastPriority { get; private set; }
+
+        /// <summary>Creates a scheduler using the retained callbacks.</summary>
+        /// <returns>The scheduler.</returns>
+        public DispatcherQueueSequencer Create() =>
+            new(DispatcherQueuePriority.High, TryEnqueue, (callback, delay) =>
+            {
+                BooleanDisposable cancellation = new();
+                Delays.Enqueue((callback, delay, cancellation));
+                return cancellation;
+            });
+
+        /// <summary>Accepts or rejects a drain without executing it.</summary>
+        /// <param name="priority">The requested priority.</param>
+        /// <param name="handler">The drain callback.</param>
+        /// <returns>Whether the callback was accepted.</returns>
+        private bool TryEnqueue(DispatcherQueuePriority priority, DispatcherQueueHandler handler)
+        {
+            LastPriority = priority;
+            LastHandler = handler;
+            if (!AcceptsPosts)
+            {
+                return false;
+            }
+
+            Drains.Enqueue(handler);
+            return true;
+        }
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj
index 7089b97e..b4dd5b9a 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj
@@ -1,10 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <!-- DispatcherQueueSequencer wraps the concrete WinUI Microsoft.UI.Dispatching.DispatcherQueue as an
-       IScheduler. The project targets plain .NET everywhere and adds the WinUI TFMs only on Windows. The WinUI
-       TFM (via the Choose below) turns on UseWinUI, references the WinUI .Reactive library, and compiles the
-       real dispatcher tests (self-contained so DispatcherQueueController activation works without a machine-wide
-       runtime); the cross-platform build compiles only the placeholder so the host reports a discovered test. -->
+  <!-- Windows targets compile the dispatcher tests; other targets compile the platform placeholder. -->
   <PropertyGroup>
     <TargetFrameworks>$(NetTargetFrameworks)</TargetFrameworks>
     <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(WinUITargetFrameworks)</TargetFrameworks>
@@ -16,7 +12,6 @@
     <PackageReference Include="System.Reactive"/>
   </ItemGroup>
 
-  <!-- The dispatcher tests need WinUI types; include them only on the WinUI TFM (see the Choose). -->
   <ItemGroup>
     <Compile Remove="DispatcherQueueSequencerTests.cs"/>
   </ItemGroup>
@@ -26,7 +21,11 @@
       <PropertyGroup>
         <UseWinUI>true</UseWinUI>
         <WindowsPackageType>None</WindowsPackageType>
-        <WindowsAppSDKSelfContained>true</WindowsAppSDKSelfContained>
+        <WindowsAppSDKSelfContained Condition="'$(OS)' == 'Windows_NT'">true</WindowsAppSDKSelfContained>
+        <WindowsAppSDKSelfContained Condition="'$(OS)' != 'Windows_NT'">false</WindowsAppSDKSelfContained>
+        <AppxGeneratePriEnabled Condition="'$(OS)' != 'Windows_NT'">false</AppxGeneratePriEnabled>
+        <IncludePriFilesOutputGroup Condition="'$(OS)' != 'Windows_NT'">false</IncludePriFilesOutputGroup>
+        <IncludeProjectPriFile Condition="'$(OS)' != 'Windows_NT'">false</IncludeProjectPriFile>
         <WindowsAppSdkUndockedRegFreeWinRTInitialize>false</WindowsAppSdkUndockedRegFreeWinRTInitialize>
         <RuntimeIdentifier>win-x64</RuntimeIdentifier>
         <DefineConstants>$(DefineConstants);WINDOWS</DefineConstants>
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
index fee1e84b..658a1383 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
@@ -4,110 +4,175 @@
 
 using System.Runtime.CompilerServices;
 using Microsoft.UI.Dispatching;
+using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.WinUI.Tests;
 
-/// <summary>Tests dispatcher execution on a dedicated WinUI queue thread.</summary>
+/// <summary>Tests dispatcher queue batching, rejection, and cancellation through controlled callbacks.</summary>
 public sealed class DispatcherQueueSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null dispatcher queue.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Expected values after both queued items run.</summary>
+    private static readonly int[] BatchValues = [1, SecondValue];
+
+    /// <summary>Expected values before the reentrant batch runs.</summary>
+    private static readonly int[] FirstBatchValues = [1];
+
+    /// <summary>Public constructors reject a missing dispatcher queue.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcherQueue() =>
+    public async Task ConstructorRejectsNullDispatcherQueue()
+    {
         await Assert.That(static () => new DispatcherQueueSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new DispatcherQueueSequencer(null!, DispatcherQueuePriority.High))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies the clock uses UTC and debugger text identifies the sequencer.</summary>
-    /// <returns>A task representing the asynchronous test operation.</returns>
+    /// <summary>Queued work preserves order and cancellation until the drain runs.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ClockUsesUtcAndDebuggerTextIdentifiesSequencer()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        await using var harness = new DispatcherQueueHarness();
-        DispatcherQueueSequencer sequencer = new(harness.DispatcherQueue);
+        ManualDispatcher dispatcher = new();
+        var sequencer = dispatcher.Create();
+        List<int> values = [];
+        RecordingWorkItem cancelled = new(() => values.Add(0));
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(1)));
+        sequencer.Schedule(cancelled);
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)), 0);
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(dispatcher.Drains).Count().IsEqualTo(1);
+        await Assert.That(dispatcher.LastPriority).IsEqualTo(DispatcherQueuePriority.High);
+        await Assert.That(sequencer.Priority).IsEqualTo(DispatcherQueuePriority.High);
         await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
         await Assert.That(sequencer.DebuggerDisplay).IsEqualTo(typeof(DispatcherQueueSequencer).FullName);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies a stopped dispatcher queue rejects scheduled work.</summary>
-    /// <returns>A task representing the asynchronous test operation.</returns>
+    /// <summary>A rejected post retains queued work and reuses its cached callback on retry.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task SchedulingAfterQueueShutdownThrows()
+    public async Task RejectedPostCanRetryWithoutLosingQueuedWork()
     {
-        var harness = new DispatcherQueueHarness();
-        DispatcherQueueSequencer sequencer = new(harness.DispatcherQueue);
-        await harness.DisposeAsync();
-        var executed = false;
-        await Assert.That(() => sequencer.Schedule(new DelegateWorkItem(() => executed = true)))
-            .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(() => sequencer.Schedule(new DelegateWorkItem(() => executed = true)))
+        ManualDispatcher dispatcher = new() { AcceptsPosts = false };
+        var sequencer = dispatcher.Create();
+        List<int> values = [];
+        await Assert.That(() => sequencer.Schedule(new RecordingWorkItem(() => values.Add(1))))
             .ThrowsExactly<InvalidOperationException>();
-        await Assert.That(executed).IsFalse();
+        await Assert.That(values).IsEmpty();
+        var rejectedHandler = dispatcher.LastHandler;
+        dispatcher.AcceptsPosts = true;
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)));
+        await Assert.That(dispatcher.LastHandler).IsSameReferenceAs(rejectedHandler);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies immediate work is enqueued to and executed on the dispatcher-queue thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Work queued from inside a callback waits for a later drain.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnQueueThread()
+    public async Task ReentrantScheduleRunsInTheNextBatch()
     {
-        await using var harness = new DispatcherQueueHarness();
-        var sequencer = new DispatcherQueueSequencer(harness.DispatcherQueue);
-        var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess)));
-
-        var ranOnQueueThread = await completion.Task;
-        await Assert.That(ranOnQueueThread).IsTrue();
+        ManualDispatcher dispatcher = new();
+        var sequencer = dispatcher.Create();
+        List<int> values = [];
+        sequencer.Schedule(new RecordingWorkItem(() =>
+        {
+            values.Add(1);
+            sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)));
+        }));
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(FirstBatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        dispatcher.Drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo(BatchValues, EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies due work executes on the dispatcher queue thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Delayed callbacks retain their due time and honor cancellation.</summary>
+    /// <param name="cancel">Whether cancellation precedes delivery.</param>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnQueueThread()
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleWaitsForItsCallback(bool cancel)
     {
-        await using var harness = new DispatcherQueueHarness();
-        var sequencer = new DispatcherQueueSequencer(harness.DispatcherQueue);
-        var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var due = sequencer.Timestamp;
-        sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(harness.DispatcherQueue.HasThreadAccess)), due);
+        ManualDispatcher dispatcher = new();
+        var sequencer = dispatcher.Create();
+        var calls = 0;
+        RecordingWorkItem item = new(() => calls++);
+        sequencer.Schedule(item, long.MaxValue);
+        await Assert.That(calls).IsEqualTo(0);
+        await Assert.That(dispatcher.Drains).IsEmpty();
+        var pending = dispatcher.Delays.Dequeue();
+        await Assert.That(pending.Due).IsEqualTo(long.MaxValue);
+        if (cancel)
+        {
+            item.Dispose();
+        }
 
-        var ranOnQueueThread = await completion.Task;
-        await Assert.That(ranOnQueueThread).IsTrue();
+        DispatchSequencerState.RunIfActive(pending.Item);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
     }
 
-    /// <summary>Work item that invokes a delegate when executed.</summary>
-    private sealed class DelegateWorkItem : IWorkItem
+    /// <summary>Retains callbacks until they are explicitly delivered.</summary>
+    private sealed class ManualDispatcher
     {
-        /// <summary>The action to run on execution.</summary>
-        private readonly Action _action;
+        /// <summary>Gets the queued drains.</summary>
+        public Queue<DispatcherQueueHandler> Drains { get; } = new();
 
-        /// <summary>Initializes a new instance of the <see cref="DelegateWorkItem"/> class.</summary>
-        /// <param name="action">The action to run on execution.</param>
-        public DelegateWorkItem(Action action) => _action = action;
+        /// <summary>Gets delayed work and requested timestamps.</summary>
+        public Queue<(IWorkItem Item, long Due)> Delays { get; } = new();
 
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Execute() => _action();
-    }
+        /// <summary>Gets or sets whether enqueue attempts succeed.</summary>
+        public bool AcceptsPosts { get; set; } = true;
 
-    /// <summary>Hosts a WinUI <see cref="DispatcherQueue"/> on a dedicated thread and shuts the queue down on disposal.</summary>
-    private sealed class DispatcherQueueHarness : IAsyncDisposable
-    {
-        /// <summary>The controller owning the dedicated dispatcher-queue thread.</summary>
-        private readonly DispatcherQueueController _controller;
+        /// <summary>Gets the most recently posted handler.</summary>
+        public DispatcherQueueHandler? LastHandler { get; private set; }
+
+        /// <summary>Gets the priority of the most recent post.</summary>
+        public DispatcherQueuePriority LastPriority { get; private set; }
+
+        /// <summary>Creates a sequencer using the retained callbacks.</summary>
+        /// <returns>The sequencer.</returns>
+        public DispatcherQueueSequencer Create() =>
+            new(DispatcherQueuePriority.High, TryEnqueue, (item, due) => Delays.Enqueue((item, due)));
 
-        /// <summary>Initializes a new instance of the <see cref="DispatcherQueueHarness"/> class.</summary>
-        public DispatcherQueueHarness()
+        /// <summary>Accepts or rejects a drain without executing it.</summary>
+        /// <param name="priority">The requested priority.</param>
+        /// <param name="handler">The drain callback.</param>
+        /// <returns>Whether the callback was accepted.</returns>
+        private bool TryEnqueue(DispatcherQueuePriority priority, DispatcherQueueHandler handler)
         {
-            _controller = DispatcherQueueController.CreateOnDedicatedThread();
-            DispatcherQueue = _controller.DispatcherQueue;
+            LastPriority = priority;
+            LastHandler = handler;
+            if (!AcceptsPosts)
+            {
+                return false;
+            }
+
+            Drains.Enqueue(handler);
+            return true;
         }
+    }
+
+    /// <summary>Records execution and supports cancellation.</summary>
+    /// <param name="action">The callback to run.</param>
+    private sealed class RecordingWorkItem(Action action) : IWorkItem, IsDisposed
+    {
+        /// <inheritdoc/>
+        public bool IsDisposed { get; private set; }
 
-        /// <summary>Gets the hosted dispatcher queue.</summary>
-        public DispatcherQueue DispatcherQueue { get; }
+        /// <inheritdoc/>
+        public void Dispose() => IsDisposed = true;
 
         /// <inheritdoc/>
-        /// <returns>A task representing the asynchronous operation.</returns>
-        public async ValueTask DisposeAsync() => await _controller.ShutdownQueueAsync().AsTask();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Execute() => action();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj b/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj
index e2d7d097..1519b741 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj
@@ -1,10 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <!-- DispatcherQueueSequencer wraps the concrete WinUI Microsoft.UI.Dispatching.DispatcherQueue. The
-       project targets plain .NET everywhere and adds the WinUI TFMs only on Windows. The WinUI TFM (via
-       the Choose below) turns on UseWinUI, references the WinUI library, and compiles the real dispatcher
-       tests (self-contained so DispatcherQueueController activation works without a machine-wide runtime);
-       the cross-platform build compiles only the placeholder so the host reports a discovered test. -->
+  <!-- Windows targets compile the dispatcher tests; other targets compile the platform placeholder. -->
   <PropertyGroup>
     <TargetFrameworks>$(NetTargetFrameworks)</TargetFrameworks>
     <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(WinUITargetFrameworks)</TargetFrameworks>
@@ -12,7 +8,6 @@
     <OutputType>Exe</OutputType>
   </PropertyGroup>
 
-  <!-- The dispatcher tests need WinUI types; include them only on the WinUI TFM (see the Choose). -->
   <ItemGroup>
     <Compile Remove="DispatcherQueueSequencerTests.cs"/>
   </ItemGroup>
@@ -22,7 +17,11 @@
       <PropertyGroup>
         <UseWinUI>true</UseWinUI>
         <WindowsPackageType>None</WindowsPackageType>
-        <WindowsAppSDKSelfContained>true</WindowsAppSDKSelfContained>
+        <WindowsAppSDKSelfContained Condition="'$(OS)' == 'Windows_NT'">true</WindowsAppSDKSelfContained>
+        <WindowsAppSDKSelfContained Condition="'$(OS)' != 'Windows_NT'">false</WindowsAppSDKSelfContained>
+        <AppxGeneratePriEnabled Condition="'$(OS)' != 'Windows_NT'">false</AppxGeneratePriEnabled>
+        <IncludePriFilesOutputGroup Condition="'$(OS)' != 'Windows_NT'">false</IncludePriFilesOutputGroup>
+        <IncludeProjectPriFile Condition="'$(OS)' != 'Windows_NT'">false</IncludeProjectPriFile>
         <WindowsAppSdkUndockedRegFreeWinRTInitialize>false</WindowsAppSdkUndockedRegFreeWinRTInitialize>
         <RuntimeIdentifier>win-x64</RuntimeIdentifier>
         <DefineConstants>$(DefineConstants);WINDOWS</DefineConstants>
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
index 81be19e1..052c1a6f 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Reactive.Tests/DispatcherSequencerTests.cs
@@ -3,84 +3,132 @@
 // See the LICENSE file in the project root for full license information.
 
 using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using System.Windows.Threading;
 using ReactiveUI.Primitives.Reactive.Concurrency;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.Wpf.Reactive.Tests;
 
-/// <summary>Tests scheduler execution on a dedicated WPF STA thread.</summary>
+/// <summary>Tests dispatcher batching and cancellation with manually invoked callbacks.</summary>
 public sealed class DispatcherSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Constructor validation rejects a missing dispatcher.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcher() =>
+    public async Task ConstructorRejectsNullDispatcher()
+    {
         await Assert.That(static () => new DispatcherSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new DispatcherSequencer(null!, DispatcherPriority.Normal))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies immediate work is posted to and executed on the dispatcher thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Construction retains dispatcher identity and priority.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    public async Task ConstructorRetainsDispatcherAndPriority()
     {
-        using var harness = new DispatcherHarness();
-        var scheduler = new DispatcherSequencer(harness.Dispatcher);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        _ = scheduler.Schedule(() => completion.TrySetResult(Environment.CurrentManagedThreadId));
-
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        DispatcherSequencer sequencer = new(dispatcher, DispatcherPriority.Background);
+        await Assert.That(sequencer.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(sequencer.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(new DispatcherSequencer(dispatcher).Priority).IsEqualTo(DispatcherPriority.Normal);
     }
 
-    /// <summary>Verifies due work executes on the dispatcher thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>A posted batch preserves order and skips cancelled work.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnDispatcherThread()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        using var harness = new DispatcherHarness();
-        var scheduler = new DispatcherSequencer(harness.Dispatcher);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        _ = scheduler.Schedule(TimeSpan.Zero, () => completion.TrySetResult(Environment.CurrentManagedThreadId));
-
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+        Queue<Action> drains = new();
+        DispatcherSequencer scheduler = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            drain =>
+            {
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        using var first = scheduler.Schedule(() => values.Add(1));
+        var cancelled = scheduler.Schedule(() => values.Add(0));
+        using var second = scheduler.Schedule(TimeSpan.Zero, () => values.Add(SecondValue));
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(drains).Count().IsEqualTo(1);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Owns a WPF dispatcher and its STA message loop.</summary>
-    private sealed class DispatcherHarness : IDisposable
+    /// <summary>Scheduling inside a callback posts another batch.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ScheduleDuringDrainWaitsForTheNextDrain()
     {
-        /// <summary>The thread running the dispatcher message loop.</summary>
-        private readonly Thread _thread;
-
-        /// <summary>Initializes a new instance of the <see cref="DispatcherHarness"/> class and waits until the dispatcher is running.</summary>
-        public DispatcherHarness()
-        {
-            using var ready = new ManualResetEventSlim(false);
-            _thread = new(() =>
+        Queue<Action> drains = new();
+        DispatcherSequencer scheduler = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            drain =>
             {
-                Dispatcher = Dispatcher.CurrentDispatcher;
-                ThreadId = Environment.CurrentManagedThreadId;
-                ready.Set();
-                Dispatcher.Run();
-            }) { IsBackground = true, Name = "WpfDispatcherHarness" };
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        using var first = scheduler.Schedule(() =>
+        {
+            values.Add(1);
+            _ = scheduler.Schedule(() => values.Add(SecondValue));
+        });
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+    }
 
-            _thread.SetApartmentState(ApartmentState.STA);
-            _thread.Start();
-            ready.Wait();
+    /// <summary>Disposal cancels a delayed timer and suppresses even a late callback.</summary>
+    /// <param name="cancel">Whether to cancel before delivery.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleHonorsCancellationBeforeDelivery(bool cancel)
+    {
+        Queue<(Action Callback, TimeSpan Delay, BooleanDisposable Cancellation)> delayed = new();
+        DispatcherSequencer scheduler = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            static _ => throw new InvalidOperationException("Unexpected immediate dispatch."),
+            (callback, delay) =>
+            {
+                BooleanDisposable cancellation = new();
+                delayed.Enqueue((callback, delay, cancellation));
+                return cancellation;
+            });
+        var calls = 0;
+        var delay = TimeSpan.FromSeconds(1);
+        var handle = scheduler.Schedule(delay, () => calls++);
+        var pending = delayed.Dequeue();
+        await Assert.That(pending.Delay).IsEqualTo(delay);
+        await Assert.That(calls).IsEqualTo(0);
+        if (cancel)
+        {
+            handle.Dispose();
         }
 
-        /// <summary>Gets the hosted dispatcher.</summary>
-        public Dispatcher Dispatcher { get; private set; } = null!;
-
-        /// <summary>Gets the managed thread id the dispatcher runs on.</summary>
-        public int ThreadId { get; private set; }
-
-        /// <inheritdoc/>
-        public void Dispose()
+        pending.Callback();
+        await Assert.That(pending.Cancellation.IsDisposed).IsEqualTo(cancel);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
+        if (cancel)
         {
-            Dispatcher.InvokeShutdown();
-            _thread.Join();
+            return;
         }
+
+        handle.Dispose();
     }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
index 666a6753..ee1bedec 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
@@ -4,110 +4,138 @@
 
 using System.Runtime.CompilerServices;
 using System.Windows.Threading;
+using ReactiveUI.Primitives.Advanced;
 using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using TUnit.Assertions.Enums;
 
 namespace ReactiveUI.Primitives.Wpf.Tests;
 
-/// <summary>Tests dispatcher execution on a dedicated WPF STA thread.</summary>
+/// <summary>Tests dispatcher batching and cancellation with manually invoked callbacks.</summary>
 public sealed class DispatcherSequencerTests
 {
-    /// <summary>Verifies the constructor rejects a null dispatcher.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>The second value in a scheduled batch.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Constructor validation rejects a missing dispatcher.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ConstructorRejectsNullDispatcher() =>
+    public async Task ConstructorRejectsNullDispatcher()
+    {
         await Assert.That(static () => new DispatcherSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new DispatcherSequencer(null!, DispatcherPriority.Normal))
+            .ThrowsExactly<ArgumentNullException>();
+    }
 
-    /// <summary>Verifies the clock uses UTC and debugger text identifies the sequencer.</summary>
-    /// <returns>A task representing the asynchronous test operation.</returns>
+    /// <summary>Construction retains dispatcher identity, priority, and UTC clock semantics.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ClockUsesUtcAndDebuggerTextIdentifiesSequencer()
+    public async Task ConstructorRetainsDispatcherAndPriority()
     {
-        using var harness = new DispatcherHarness();
-        DispatcherSequencer sequencer = new(harness.Dispatcher);
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        DispatcherSequencer sequencer = new(dispatcher, DispatcherPriority.Background);
+        await Assert.That(sequencer.Dispatcher).IsSameReferenceAs(dispatcher);
+        await Assert.That(sequencer.Priority).IsEqualTo(DispatcherPriority.Background);
+        await Assert.That(new DispatcherSequencer(dispatcher).Priority).IsEqualTo(DispatcherPriority.Normal);
         await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
         await Assert.That(sequencer.DebuggerDisplay).IsEqualTo(typeof(DispatcherSequencer).FullName);
     }
 
-    /// <summary>Verifies immediate work is posted to and executed on the dispatcher thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>A posted batch preserves order and skips cancelled work.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task ImmediateScheduleExecutesOnDispatcherThread()
+    public async Task ScheduleCoalescesOrderedWorkAndSkipsCancellation()
     {
-        using var harness = new DispatcherHarness();
-        var sequencer = new DispatcherSequencer(harness.Dispatcher);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)));
-
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+        Queue<Action> drains = new();
+        DispatcherSequencer sequencer = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            drain =>
+            {
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        RecordingWorkItem cancelled = new(() => values.Add(0));
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(1)));
+        sequencer.Schedule(cancelled);
+        sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)), 0);
+        cancelled.Dispose();
+        await Assert.That(values).IsEmpty();
+        await Assert.That(drains).Count().IsEqualTo(1);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Verifies due work executes on the dispatcher thread.</summary>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    /// <summary>Reentrant scheduling is delivered by a later batch.</summary>
+    /// <returns>The test operation.</returns>
     [Test]
-    public async Task DueScheduleExecutesOnDispatcherThread()
+    public async Task ScheduleDuringDrainWaitsForTheNextDrain()
     {
-        using var harness = new DispatcherHarness();
-        var sequencer = new DispatcherSequencer(harness.Dispatcher);
-        var completion = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        var due = sequencer.Timestamp;
-        sequencer.Schedule(new DelegateWorkItem(() => completion.TrySetResult(Environment.CurrentManagedThreadId)), due);
-
-        var ranOnThreadId = await completion.Task;
-        await Assert.That(ranOnThreadId).IsEqualTo(harness.ThreadId);
+        Queue<Action> drains = new();
+        DispatcherSequencer sequencer = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            drain =>
+            {
+                drains.Enqueue(drain);
+                return true;
+            },
+            null);
+        List<int> values = [];
+        sequencer.Schedule(new RecordingWorkItem(() =>
+        {
+            values.Add(1);
+            sequencer.Schedule(new RecordingWorkItem(() => values.Add(SecondValue)));
+        }));
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1], EqualityComparer<int>.Default, CollectionOrdering.Matching);
+        drains.Dequeue()();
+        await Assert.That(values).IsEquivalentTo([1, SecondValue], EqualityComparer<int>.Default, CollectionOrdering.Matching);
     }
 
-    /// <summary>Work item that invokes a delegate when executed.</summary>
-    private sealed class DelegateWorkItem : IWorkItem
+    /// <summary>Delayed callbacks preserve cancellation before their explicit delivery.</summary>
+    /// <param name="cancel">Whether to cancel before delivery.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DelayedScheduleWaitsForItsCallback(bool cancel)
     {
-        /// <summary>The action to run on execution.</summary>
-        private readonly Action _action;
-
-        /// <summary>Initializes a new instance of the <see cref="DelegateWorkItem"/> class.</summary>
-        /// <param name="action">The action to run on execution.</param>
-        public DelegateWorkItem(Action action) => _action = action;
+        Queue<(IWorkItem Item, long Due)> delayed = new();
+        DispatcherSequencer sequencer = new(
+            Dispatcher.CurrentDispatcher,
+            DispatcherPriority.Normal,
+            static _ => throw new InvalidOperationException("Unexpected immediate dispatch."),
+            (item, due) => delayed.Enqueue((item, due)));
+        var calls = 0;
+        RecordingWorkItem item = new(() => calls++);
+        sequencer.Schedule(item, long.MaxValue);
+        await Assert.That(calls).IsEqualTo(0);
+        var pending = delayed.Dequeue();
+        await Assert.That(pending.Due).IsEqualTo(long.MaxValue);
+        if (cancel)
+        {
+            item.Dispose();
+        }
 
-        /// <inheritdoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Execute() => _action();
+        DispatchSequencerState.RunIfActive(pending.Item);
+        await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
     }
 
-    /// <summary>Owns a WPF dispatcher and its STA message loop.</summary>
-    private sealed class DispatcherHarness : IDisposable
+    /// <summary>Records execution and supports cancellation.</summary>
+    /// <param name="action">The callback to run.</param>
+    private sealed class RecordingWorkItem(Action action) : IWorkItem, IsDisposed
     {
-        /// <summary>The thread running the dispatcher message loop.</summary>
-        private readonly Thread _thread;
-
-        /// <summary>Initializes a new instance of the <see cref="DispatcherHarness"/> class and waits until the dispatcher is running.</summary>
-        public DispatcherHarness()
-        {
-            using var ready = new ManualResetEventSlim(false);
-            _thread = new(() =>
-            {
-                Dispatcher = Dispatcher.CurrentDispatcher;
-                ThreadId = Environment.CurrentManagedThreadId;
-                ready.Set();
-                Dispatcher.Run();
-            }) { IsBackground = true, Name = "WpfDispatcherHarness" };
-
-            _thread.SetApartmentState(ApartmentState.STA);
-            _thread.Start();
-            ready.Wait();
-        }
-
-        /// <summary>Gets the hosted dispatcher.</summary>
-        public Dispatcher Dispatcher { get; private set; } = null!;
+        /// <inheritdoc/>
+        public bool IsDisposed { get; private set; }
 
-        /// <summary>Gets the managed thread id the dispatcher runs on.</summary>
-        public int ThreadId { get; private set; }
+        /// <inheritdoc/>
+        public void Dispose() => IsDisposed = true;
 
         /// <inheritdoc/>
-        public void Dispose()
-        {
-            Dispatcher.InvokeShutdown();
-            _thread.Join();
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Execute() => action();
     }
 }

From b0340a1a00fca5e79e8f71e0f53d664e66c089b1 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 13 Sep 2026 00:05:59 +1000
Subject: [PATCH 07/11] further

---
 CLAUDE.md                                     |  9 +++---
 .../Concurrency/Sequencer.cs                  | 30 +++++++++++++++----
 2 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index c4987c45..264dd8e0 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -134,12 +134,11 @@ dotnet test "tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async
   --treenode-filter "/*/*/*/Async"
 ```
 
-### API Approval Notes
+### Public API Checks
 
-- API approval baselines live under `src/tests/**/ApiApprovalTests.*.verified.txt`
-- New TFMs usually require corresponding new `DotNet11_0.verified.txt` files
-- If approval tests fail with `.received.txt` output, inspect the generated snapshot and promote it intentionally if the
-  API change is expected
+- `PublicApiSharp.Analyzers` checks each package's `src/<Project>/PublicAPI/<tfm>/PublicAPI.txt` baseline.
+- New target frameworks require a corresponding baseline directory.
+- For an intentional API change, review the affected signatures and update the corresponding framework baselines.
 
 ---
 
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
index 5393717f..1fa9b3b1 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
@@ -72,10 +72,18 @@ internal static TimeSpan ToTimeSpanDelta(long timestampDelta)
             return TimeSpan.Zero;
         }
 
-        var ticks = timestampDelta * (double)TimeSpan.TicksPerSecond / System.Diagnostics.Stopwatch.Frequency;
-        return ticks >= TimeSpan.MaxValue.Ticks
-            ? TimeSpan.MaxValue
-            : TimeSpan.FromTicks(Math.Max(1, (long)Math.Ceiling(ticks)));
+        var frequency = System.Diagnostics.Stopwatch.Frequency;
+        var seconds = timestampDelta / frequency;
+        if (seconds >= TimeSpan.MaxValue.Ticks / TimeSpan.TicksPerSecond)
+        {
+            return TimeSpan.MaxValue;
+        }
+
+        // Integer arithmetic: scaling through double rounds a representable duration up to the next tick.
+        var remainder = timestampDelta % frequency;
+        var ticks = (seconds * TimeSpan.TicksPerSecond)
+                    + ((remainder * TimeSpan.TicksPerSecond) + frequency - 1) / frequency;
+        return TimeSpan.FromTicks(Math.Max(1, ticks));
     }
 
     /// <summary>Converts a relative duration to monotonic timestamp ticks.</summary>
@@ -89,7 +97,17 @@ internal static long ToTimestampDelta(TimeSpan dueTime)
             return 0;
         }
 
-        var ticks = normalized.TotalSeconds * System.Diagnostics.Stopwatch.Frequency;
-        return ticks >= long.MaxValue ? long.MaxValue : Math.Max(1, (long)Math.Ceiling(ticks));
+        var frequency = System.Diagnostics.Stopwatch.Frequency;
+        var seconds = normalized.Ticks / TimeSpan.TicksPerSecond;
+        if (seconds >= long.MaxValue / frequency)
+        {
+            return long.MaxValue;
+        }
+
+        // Integer arithmetic: scaling through double rounds a representable duration up to the next unit.
+        var remainder = normalized.Ticks % TimeSpan.TicksPerSecond;
+        var delta = (seconds * frequency)
+                    + ((remainder * frequency) + TimeSpan.TicksPerSecond - 1) / TimeSpan.TicksPerSecond;
+        return Math.Max(1, delta);
     }
 }

From 7fad6ef7439245fd219c084c14b92944b87d7ad1 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 13 Sep 2026 00:15:44 +1000
Subject: [PATCH 08/11] fix(concurrency): convert durations and timestamps with
 integer math

- Scale between ticks and monotonic timestamps without a double round trip, so
  a duration representable on both grids survives unchanged.
- A 50-tick delay converted at a 10 MHz timestamp frequency no longer lands a
  tick late, which left scheduled work undue at its own due time.
---
 src/ReactiveUI.Primitives/Concurrency/Sequencer.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
index 1fa9b3b1..051ea788 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.cs
@@ -80,9 +80,8 @@ internal static TimeSpan ToTimeSpanDelta(long timestampDelta)
         }
 
         // Integer arithmetic: scaling through double rounds a representable duration up to the next tick.
-        var remainder = timestampDelta % frequency;
         var ticks = (seconds * TimeSpan.TicksPerSecond)
-                    + ((remainder * TimeSpan.TicksPerSecond) + frequency - 1) / frequency;
+                    + ((((timestampDelta % frequency) * TimeSpan.TicksPerSecond) + frequency - 1) / frequency);
         return TimeSpan.FromTicks(Math.Max(1, ticks));
     }
 
@@ -105,9 +104,9 @@ internal static long ToTimestampDelta(TimeSpan dueTime)
         }
 
         // Integer arithmetic: scaling through double rounds a representable duration up to the next unit.
-        var remainder = normalized.Ticks % TimeSpan.TicksPerSecond;
         var delta = (seconds * frequency)
-                    + ((remainder * frequency) + TimeSpan.TicksPerSecond - 1) / TimeSpan.TicksPerSecond;
+                    + ((((normalized.Ticks % TimeSpan.TicksPerSecond) * frequency) + TimeSpan.TicksPerSecond - 1)
+                       / TimeSpan.TicksPerSecond);
         return Math.Max(1, delta);
     }
 }

From 99f1b5dc1f34817cca0d743b9f870427004f00fd Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 13 Sep 2026 00:28:00 +1000
Subject: [PATCH 09/11] docs(extensions): name what each parameter carries

- Replace placeholder parameter text with the role the argument plays.
- Say which window a sequencer times, and which side an observer receives.
---
 .../Operators/BufferUntilIdleObservable.cs    |  2 +-
 .../Operators/DebounceUntilObservable.cs      |  2 +-
 .../Operators/DetectStaleObservable.cs        |  2 +-
 .../Operators/ScheduleConfig.cs               |  2 +-
 .../Operators/SyncTimerObservable.cs          |  4 +-
 .../ReactiveExtensions.cs                     | 42 +++++++++----------
 .../Operators/PartitionObservable.cs          |  6 +--
 7 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
index e0f494f1..7372182c 100644
--- a/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/BufferUntilIdleObservable.cs
@@ -35,7 +35,7 @@ public IDisposable Subscribe(IObserver<IList<T>> observer)
     /// <summary>Sink that accumulates elements and emits the buffer once the idle timer elapses.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="idleTime">The idle time period.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer that times the idle period.</param>
     private sealed class BufferUntilIdleSink(
         IObserver<IList<T>> downstream,
         TimeSpan idleTime,
diff --git a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
index 47772429..6c7f5a37 100644
--- a/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DebounceUntilObservable.cs
@@ -39,7 +39,7 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="debounce">The debounce duration.</param>
     /// <param name="condition">The condition.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer that times the debounce window.</param>
     private sealed class DebounceUntilSink(
         IObserver<T> downstream,
         TimeSpan debounce,
diff --git a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
index 5aadf57f..8854d5c2 100644
--- a/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/DetectStaleObservable.cs
@@ -37,7 +37,7 @@ public IDisposable Subscribe(IObserver<Stale<T>> observer)
     /// <summary>Sink that re-arms the staleness timer on each upstream value and emits a stale marker when the window elapses.</summary>
     /// <param name="downstream">The downstream observer.</param>
     /// <param name="stalenessPeriod">The staleness period.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer that times the staleness window.</param>
     private sealed class DetectStaleSink(
         IObserver<Stale<T>> downstream,
         TimeSpan stalenessPeriod,
diff --git a/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs b/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
index fa93ee26..a69cd481 100644
--- a/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ScheduleConfig.cs
@@ -55,7 +55,7 @@ internal static ScheduleConfig<T> Absolute(ISequencer scheduler, DateTimeOffset
     internal ScheduleConfig<T> WithTransform(Func<T, T> transform) => this with { Transform = transform };
 
     /// <summary>Returns a new config with the supplied side-effect invoked with each value before emission.</summary>
-    /// <param name="action">The action.</param>
+    /// <param name="action">The work to run.</param>
     /// <returns>A new configuration.</returns>
     internal ScheduleConfig<T> WithAction(Action<T> action) => this with { Action = action };
 }
diff --git a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
index 41a531a6..15615085 100644
--- a/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/SyncTimerObservable.cs
@@ -25,7 +25,7 @@ internal static class SyncTimerObservable
 
     /// <summary>Gets a shared timer for the specified period and scheduler.</summary>
     /// <param name="timeSpan">The period.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer that times each tick.</param>
     /// <returns>A shared observable sequence of timer ticks.</returns>
     internal static IObservable<DateTime> Get(TimeSpan timeSpan, ISequencer scheduler)
     {
@@ -36,7 +36,7 @@ internal static IObservable<DateTime> Get(TimeSpan timeSpan, ISequencer schedule
 
     /// <summary>Broadcasts ticks through immutable observer snapshots; subscription changes publish a new snapshot under the gate.</summary>
     /// <param name="timeSpan">The period.</param>
-    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="scheduler">The sequencer that times each tick.</param>
     private sealed class SharedTimer(TimeSpan timeSpan, ISequencer scheduler) : IObservable<DateTime>
     {
         /// <summary>Sentinel empty observer array, shared so unsubscribing the last observer doesn't allocate.</summary>
diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
index b33e1289..6898616c 100644
--- a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
+++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs
@@ -166,7 +166,7 @@ public IObservable<IList<T>> BufferUntilIdle(TimeSpan idleTime) =>
 
         /// <summary>Emit a batch when the stream goes quiet.</summary>
         /// <param name="idleTime">The idle time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer that times the quiet period.</param>
         /// <returns>A sequence of buffered lists.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<IList<T>> BufferUntilIdle(TimeSpan idleTime, ISequencer? scheduler) =>
@@ -183,7 +183,7 @@ public IObservable<T> CatchIgnore<TException>(Action<TException> errorAction)
 
         /// <summary>Detects when a stream becomes inactive for some period of time.</summary>
         /// <param name="stalenessPeriod">If source stream does not OnNext any update during this period, it is declared stale.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer that times the inactivity window.</param>
         /// <returns>Observable stale markers or updates.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<Stale<T>> DetectStale(TimeSpan stalenessPeriod, ISequencer scheduler) =>
@@ -230,7 +230,7 @@ public IObservable<T> ObserveOnSafe(ISequencer? scheduler) =>
 
         /// <summary>Conditionally switch schedulers.</summary>
         /// <param name="condition">if set to <c>true</c> [condition].</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer used while the condition holds.</param>
         /// <returns>An IObservable of T.</returns>
         public IObservable<T> ObserveOnIf(bool condition, ISequencer scheduler) =>
             condition ? new ObserveOnObservable<T>(source, scheduler) : source;
@@ -285,7 +285,7 @@ public IObservable<TAccumulate> ScanWithInitial<TAccumulate>(
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler) =>
@@ -293,7 +293,7 @@ public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler) =>
@@ -301,8 +301,8 @@ public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <param name="action">The action.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
+        /// <param name="action">The work to run.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler, Action<T> action) =>
@@ -310,15 +310,15 @@ public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler, Action<T>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <param name="action">The action.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
+        /// <param name="action">The work to run.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler, Action<T> action) =>
             new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Absolute(scheduler, dueTime).WithAction(action));
 
         /// <summary>Schedules the specified due time.</summary>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <param name="function">The function.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -327,7 +327,7 @@ public IObservable<T> Schedule(ISequencer scheduler, Func<T, T> function) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <param name="function">The function.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -538,7 +538,7 @@ public IObservable<T> ThrottleDistinct(TimeSpan throttle) =>
 
         /// <summary>Throttle but only emit when the value actually changes.</summary>
         /// <param name="throttle">The throttle.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer that times the throttle window.</param>
         /// <returns>A throttled distinct sequence.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> ThrottleDistinct(TimeSpan throttle, ISequencer scheduler) =>
@@ -789,7 +789,7 @@ public IObservable<T> SkipWhileNull()
 
     /// <summary>Operators for an observable source sequence that may emit null values.</summary>
     /// <typeparam name="TSource">The type of the source.</typeparam>
-    /// <param name="source">The source.</param>
+    /// <param name="source">The source observable.</param>
     extension<TSource>(IObservable<TSource?> source)
     {
         /// <summary>Catch exception and return Observable.Empty.</summary>
@@ -993,7 +993,7 @@ public IObservable<TResult> Using<TResult>(Func<T, TResult> function, ISequencer
 
     /// <summary>Change-notification operators for a notifying object.</summary>
     /// <typeparam name="T">The type of the source.</typeparam>
-    /// <param name="source">The source.</param>
+    /// <param name="source">The notifying object.</param>
     extension<T>(T source)
         where T : INotifyPropertyChanged
     {
@@ -1032,7 +1032,7 @@ public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler) =>
@@ -1040,8 +1040,8 @@ public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <param name="action">The action.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
+        /// <param name="action">The work to run.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler, Action<T> action) =>
@@ -1049,15 +1049,15 @@ public IObservable<T> Schedule(TimeSpan dueTime, ISequencer scheduler, Action<T>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <param name="action">The action.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
+        /// <param name="action">The work to run.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IObservable<T> Schedule(DateTimeOffset dueTime, ISequencer scheduler, Action<T> action) =>
             new ScheduledValueObservable<T>(value, scheduler, null, dueTime, null, action);
 
         /// <summary>Schedules the specified due time.</summary>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <param name="function">The function.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1066,7 +1066,7 @@ public IObservable<T> Schedule(ISequencer scheduler, Func<T, T> function) =>
 
         /// <summary>Schedules the specified due time.</summary>
         /// <param name="dueTime">The due time.</param>
-        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="scheduler">The sequencer the work runs on.</param>
         /// <param name="function">The function.</param>
         /// <returns>An IObservable of T.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
index d6a352d6..68317e9f 100644
--- a/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
+++ b/src/ReactiveUI.Primitives.Extensions.Core/Operators/PartitionObservable.cs
@@ -55,7 +55,7 @@ public PartitionObservable(IObservable<T> source, Func<T, bool> predicate)
     public IObservable<T> False { get; }
 
     /// <summary>Subscribes an observer to the specified side of the partition.</summary>
-    /// <param name="observer">The observer.</param>
+    /// <param name="observer">The observer receiving that side's elements.</param>
     /// <param name="side">The side (true or false).</param>
     /// <returns>A disposable to unsubscribe.</returns>
     private Subscription Subscribe(IObserver<T> observer, bool side)
@@ -77,14 +77,14 @@ private Subscription Subscribe(IObserver<T> observer, bool side)
 
     /// <summary>Represents a subscription to the partition.</summary>
     /// <param name="parent">The parent observable.</param>
-    /// <param name="observer">The observer.</param>
+    /// <param name="observer">The observer receiving that side's elements.</param>
     /// <param name="side">The side.</param>
     private sealed class Subscription(PartitionObservable<T> parent, IObserver<T> observer, bool side) : IDisposable
     {
         /// <summary>The parent observable.</summary>
         private readonly PartitionObservable<T> _parent = parent;
 
-        /// <summary>The observer.</summary>
+        /// <summary>The observer receiving this side's elements.</summary>
         private readonly IObserver<T> _observer = observer;
 
         /// <summary>The side.</summary>

From afd5a199871d81b3d9a5ce15d8c17a85d88e58f3 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 13 Sep 2026 01:24:09 +1000
Subject: [PATCH 10/11] Add further tests

---
 src/Primitives.Shared/Advanced/EverySignal.cs |  15 +-
 .../Advanced/FromAsyncSubscription{T}.cs      | 172 ++++++++-------
 .../Advanced/FromAsyncTaskObservation{T}.cs   |  17 +-
 .../SignalOperatorParityMixins.FlatMap.cs     | 196 +++++++++---------
 .../Disposables/OnceDisposable.cs             |  12 +-
 .../PublicAPI/net10.0/PublicAPI.txt           |   1 +
 .../PublicAPI/net11.0/PublicAPI.txt           |   1 +
 .../PublicAPI/net462/PublicAPI.txt            |   1 +
 .../PublicAPI/net472/PublicAPI.txt            |   1 +
 .../PublicAPI/net48/PublicAPI.txt             |   1 +
 .../PublicAPI/net481/PublicAPI.txt            |   1 +
 .../PublicAPI/net8.0/PublicAPI.txt            |   1 +
 .../PublicAPI/net9.0/PublicAPI.txt            |   1 +
 .../Advanced/TaskResultCompletionSource.cs    |  21 +-
 .../Operators/ToAsyncEnumerable.cs            |  16 +-
 .../Advanced/BufferWitness.cs                 |   7 +-
 .../Advanced/UseSignal{TResource,T}.cs        |   9 +-
 .../Signals/Signal{T}.cs                      |  13 +-
 .../Concurrency/CurrentThreadSequencer.cs     |   4 +-
 .../BooleanDisposableTests.cs                 |  33 +++
 .../OnceDisposableTests.cs                    |  27 +++
 .../ScopeTests.cs                             |  31 +++
 .../AsyncContextTests.cs                      |  24 +++
 .../ConcurrentSignalAsyncTests.cs             |  29 +++
 .../IntervalSubscriptionTests.cs              |  26 +++
 .../LeadSubscriptionTests.cs                  |  32 +++
 .../ReattemptSubscriptionTests.cs             |  39 ++++
 .../RefCountSignalTests.cs                    |  31 +++
 .../SerialBroadcastHelpersTests.cs            |  37 ++++
 .../SignalAsyncExtensionsTests.cs             | 111 ++++++++++
 .../SignalAsyncTests.cs                       |  33 +++
 .../TaskResultCompletionSourceTests.cs        | 102 +++++++++
 .../YieldSignalTests.cs                       |  46 ++++
 .../AvaloniaSchedulerTests.cs                 |  15 ++
 .../BlazorRendererSequencerTests.cs           |  39 ++++
 .../ReactiveComponentBaseTests.cs             |  18 ++
 .../WhileObservableTests.cs                   |  68 ++++++
 ...FirstMatchFromCandidatesObservableTests.cs |  39 ++++
 ...activeExtensionsTests.DefaultSchedulers.cs |  67 ++++++
 .../ReactiveExtensionsTests.RetryDefaults.cs  |  99 +++++++++
 .../EverySignalTests.cs                       |  73 +++++++
 .../AwaitWitnessTests.cs                      |  24 +++
 .../BehaviorSignalTests.cs                    |  33 +++
 .../BufferSignalTests.cs                      |  30 +++
 .../BufferWitnessTests.cs                     |  34 +++
 .../CollectArrayWitnessTests.cs               |  31 +++
 .../CollectListWitnessTests.cs                |  31 +++
 .../CurrentThreadSequencerTests.cs            |  58 ++++++
 .../DeferSignalTests.cs                       |  35 ++++
 .../DelayableNotificationSignalTests.cs       |  26 +++
 .../DisposedMarkerTests.cs                    |  24 +++
 .../DistinctByWitnessTests.cs                 |  46 ++++
 .../EmitIfQuietSignalTests.cs                 |  28 +++
 .../EmptySignalTests.cs                       |  27 +++
 .../FromAsyncSubscriptionTests.cs             | 103 +++++++++
 .../FromAsyncTaskObservationTests.cs          |  42 ++++
 .../FromEnumerableSignalTests.cs              |  19 ++
 .../IgnoreValuesWitnessTests.cs               |  31 +++
 .../KeepNotNullWitnessTests.cs                |  42 ++++
 .../KeepTypeWitnessTests.cs                   |  42 ++++
 ...inqExtensionsTests.SubscriptionDisposal.cs | 146 +++++++++++++
 .../LinqExtensionsTests.cs                    |  21 ++
 .../LoopSignalTests.cs                        |  22 ++
 .../ObserverHandlerTests.cs                   |  33 +++
 .../ReadOnlyStateTests.cs                     |  62 ++++++
 .../RxVoidTests.cs                            |  27 +++
 .../SequencerQueueTests.cs                    |  45 ++++
 .../SequencerTests.Durations.cs               |  38 ++++
 .../SequencerTests.WorkItems.cs               |   1 +
 .../SignalExtensionsTests.cs                  |  45 ++++
 .../SignalFactoriesTests.DefaultSequencer.cs  |  23 ++
 .../StateSignalTests.cs                       |  33 +++
 .../SynchronizedSequencerQueueTests.cs        |  30 +++
 .../ThrowSignalTests.cs                       |  29 +++
 .../TimeIntervalWitnessTests.cs               |  32 +++
 .../UnsparkWitnessTests.cs                    |  30 +++
 .../VirtualTimeSequencerExtensionsTests.cs    |  30 +++
 .../ControlSequencerTests.cs                  |  12 ++
 .../ControlSequencerTests.cs                  |  25 +++
 .../DispatcherQueueSequencerTests.cs          |  23 ++
 .../DispatcherQueueSequencerTests.cs          |  28 +++
 .../DispatcherSequencerTests.cs               |  14 ++
 82 files changed, 2703 insertions(+), 261 deletions(-)
 create mode 100644 src/tests/ReactiveUI.Disposables.Tests/BooleanDisposableTests.cs
 create mode 100644 src/tests/ReactiveUI.Disposables.Tests/OnceDisposableTests.cs
 create mode 100644 src/tests/ReactiveUI.Disposables.Tests/ScopeTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/AsyncContextTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalAsyncTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/LeadSubscriptionTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/ReattemptSubscriptionTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/RefCountSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/SerialBroadcastHelpersTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncExtensionsTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/TaskResultCompletionSourceTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Async.Tests/YieldSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/WhileObservableTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesObservableTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.DefaultSchedulers.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.RetryDefaults.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Reactive.Tests/EverySignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/AwaitWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/BufferSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/BufferWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/CollectArrayWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/CollectListWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/DeferSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/DisposedMarkerTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/DistinctByWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/EmitIfQuietSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/EmptySignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/IgnoreValuesWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/KeepNotNullWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/KeepTypeWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.SubscriptionDisposal.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/ObserverHandlerTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/RxVoidTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Durations.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SignalExtensionsTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/SynchronizedSequencerQueueTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/ThrowSignalTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/TimeIntervalWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/UnsparkWitnessTests.cs
 create mode 100644 src/tests/ReactiveUI.Primitives.Tests/VirtualTimeSequencerExtensionsTests.cs

diff --git a/src/Primitives.Shared/Advanced/EverySignal.cs b/src/Primitives.Shared/Advanced/EverySignal.cs
index a958d980..fac0681c 100644
--- a/src/Primitives.Shared/Advanced/EverySignal.cs
+++ b/src/Primitives.Shared/Advanced/EverySignal.cs
@@ -31,20 +31,7 @@ public IDisposable Subscribe(IObserver<long> observer)
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
         EveryCoordinator coordinator = new(observer, _scheduler, _period);
-        if (!IsRequiredSubscribeOnCurrentThread() || !CurrentThreadSequencer.IsScheduleRequired)
-        {
-            return coordinator.Run();
-        }
-
-        SingleDisposable subscription = new();
-        _ = Sequencer.CurrentThread.Schedule(
-            (subscription, coordinator),
-            static (_, s) =>
-            {
-                s.subscription.Create(s.coordinator.Run());
-                return EmptyDisposable.Instance;
-            });
-        return subscription;
+        return coordinator.Run();
     }
 
     /// <summary>Emits each tick and re-arms the schedule for the following one.</summary>
diff --git a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
index 5ac15f6f..4b1aad92 100644
--- a/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
+++ b/src/Primitives.Shared/Advanced/FromAsyncSubscription{T}.cs
@@ -59,6 +59,88 @@ public void Dispose()
         ExternalCancellation.Dispose();
     }
 
+    /// <summary>Forwards a successful task result.</summary>
+    /// <param name="value">The task result.</param>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="lifetime">The subscription lifetime.</param>
+    /// <param name="externalCancellation">The external cancellation forwarder.</param>
+    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
+    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
+    internal static bool CompleteSynchronously(
+        T value,
+        IObserver<T> observer,
+        AsyncSubscriptionLifetime lifetime,
+        FromAsyncExternalCancellation<T> externalCancellation,
+        CancellationTokenSource? linkedSource)
+    {
+        linkedSource?.Dispose();
+        externalCancellation.Dispose();
+        if (!lifetime.TryComplete())
+        {
+            return true;
+        }
+
+        observer.OnNext(value);
+        observer.OnCompleted();
+        return true;
+    }
+
+    /// <summary>Forwards a canceled task result.</summary>
+    /// <param name="task">The canceled task to observe.</param>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="lifetime">The subscription lifetime.</param>
+    /// <param name="externalCancellation">The external cancellation forwarder.</param>
+    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
+    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
+    internal static bool CancelSynchronously(
+        Task<T> task,
+        IObserver<T> observer,
+        AsyncSubscriptionLifetime lifetime,
+        FromAsyncExternalCancellation<T> externalCancellation,
+        CancellationTokenSource? linkedSource)
+    {
+        linkedSource?.Dispose();
+        if (externalCancellation.TryForwardCancellation())
+        {
+            externalCancellation.Dispose();
+            return true;
+        }
+
+        externalCancellation.Dispose();
+        if (!lifetime.TryComplete())
+        {
+            return true;
+        }
+
+        observer.OnError(new TaskCanceledException(task));
+        return true;
+    }
+
+    /// <summary>Forwards a faulted task result.</summary>
+    /// <param name="task">The faulted task to observe.</param>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="lifetime">The subscription lifetime.</param>
+    /// <param name="externalCancellation">The external cancellation forwarder.</param>
+    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
+    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
+    internal static bool FaultSynchronously(
+        Task<T> task,
+        IObserver<T> observer,
+        AsyncSubscriptionLifetime lifetime,
+        FromAsyncExternalCancellation<T> externalCancellation,
+        CancellationTokenSource? linkedSource)
+    {
+        linkedSource?.Dispose();
+        externalCancellation.Dispose();
+        if (!lifetime.TryComplete())
+        {
+            return true;
+        }
+
+        observer.OnError(task.Exception!.InnerException!);
+        return true;
+    }
+
     /// <summary>Starts the task factory and returns the active subscription lifetime.</summary>
     /// <returns>The active subscription, or an empty disposable when the task completed synchronously.</returns>
     internal IDisposable Start()
@@ -151,94 +233,4 @@ private static bool TryCompleteSynchronously(
             ? CancelSynchronously(task, observer, lifetime, externalCancellation, linkedSource)
             : task.IsFaulted && FaultSynchronously(task, observer, lifetime, externalCancellation, linkedSource);
     }
-
-    /// <summary>Forwards a successful task result.</summary>
-    /// <param name="value">The task result.</param>
-    /// <param name="observer">The downstream observer.</param>
-    /// <param name="lifetime">The subscription lifetime.</param>
-    /// <param name="externalCancellation">The external cancellation forwarder.</param>
-    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
-    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
-    private static bool CompleteSynchronously(
-        T value,
-        IObserver<T> observer,
-        AsyncSubscriptionLifetime lifetime,
-        FromAsyncExternalCancellation<T> externalCancellation,
-        CancellationTokenSource? linkedSource)
-    {
-        linkedSource?.Dispose();
-        externalCancellation.Dispose();
-        if (!lifetime.TryComplete())
-        {
-            return true;
-        }
-
-        observer.OnNext(value);
-        observer.OnCompleted();
-        return true;
-    }
-
-    /// <summary>Forwards a canceled task result.</summary>
-    /// <param name="task">The task to observe.</param>
-    /// <param name="observer">The downstream observer.</param>
-    /// <param name="lifetime">The subscription lifetime.</param>
-    /// <param name="externalCancellation">The external cancellation forwarder.</param>
-    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
-    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
-    private static bool CancelSynchronously(
-        Task<T> task,
-        IObserver<T> observer,
-        AsyncSubscriptionLifetime lifetime,
-        FromAsyncExternalCancellation<T> externalCancellation,
-        CancellationTokenSource? linkedSource)
-    {
-        linkedSource?.Dispose();
-        if (externalCancellation.TryForwardCancellation())
-        {
-            externalCancellation.Dispose();
-            return true;
-        }
-
-        externalCancellation.Dispose();
-        if (!lifetime.TryComplete())
-        {
-            return true;
-        }
-
-        observer.OnError(new TaskCanceledException(task));
-        return true;
-    }
-
-    /// <summary>Forwards a faulted task result.</summary>
-    /// <param name="task">The task to observe.</param>
-    /// <param name="observer">The downstream observer.</param>
-    /// <param name="lifetime">The subscription lifetime.</param>
-    /// <param name="externalCancellation">The external cancellation forwarder.</param>
-    /// <param name="linkedSource">The linked token source, when an external token was supplied.</param>
-    /// <returns><see langword="true"/> because the task was completed synchronously.</returns>
-    private static bool FaultSynchronously(
-        Task<T> task,
-        IObserver<T> observer,
-        AsyncSubscriptionLifetime lifetime,
-        FromAsyncExternalCancellation<T> externalCancellation,
-        CancellationTokenSource? linkedSource)
-    {
-        linkedSource?.Dispose();
-        externalCancellation.Dispose();
-        if (!lifetime.TryComplete())
-        {
-            return true;
-        }
-
-        if (task.Exception is { InnerException: { } innerException })
-        {
-            observer.OnError(innerException);
-        }
-        else if (task.Exception is { } exception)
-        {
-            observer.OnError(exception);
-        }
-
-        return true;
-    }
 }
diff --git a/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs b/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
index b58d328e..c27e9a4a 100644
--- a/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
+++ b/src/Primitives.Shared/Advanced/FromAsyncTaskObservation{T}.cs
@@ -48,17 +48,13 @@ public FromAsyncTaskObservation(
     private CancellationTokenSource? LinkedSource { get; }
 
     /// <summary>Observes the completed task and forwards its terminal result unless the subscription was disposed.</summary>
-    /// <param name="task">The task to observe.</param>
+    /// <param name="task">The completed task to observe.</param>
     internal void Observe(Task<T> task)
     {
         try
         {
             ObserveCore(task);
         }
-        catch (Exception) when (Lifetime.IsCancellationRequested)
-        {
-            // Subscription cancellation does not send a terminal notification.
-        }
         catch (Exception error)
         {
             OnError(error);
@@ -73,7 +69,7 @@ internal void Observe(Task<T> task)
     }
 
     /// <summary>Forwards the task terminal state.</summary>
-    /// <param name="task">The task to observe.</param>
+    /// <param name="task">The completed task to observe.</param>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Concurrency",
         "PSH1315:A blocking wait on an awaitable that may not be done",
@@ -92,14 +88,7 @@ private void ObserveCore(Task<T> task)
             return;
         }
 
-        if (task.Exception is { InnerException: { } innerException })
-        {
-            OnError(innerException);
-        }
-        else if (task.Exception is { } exception)
-        {
-            OnError(exception);
-        }
+        OnError(task.Exception!.InnerException!);
     }
 
     /// <summary>Forwards a successful task result.</summary>
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
index 5e1aa6b1..896ff974 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.FlatMap.cs
@@ -14,71 +14,10 @@ namespace ReactiveUI.Primitives;
 /// <summary>FlatMap helper implementations.</summary>
 public static partial class LinqExtensions
 {
-    /// <summary>FlatMap signal that subscribes the projected inner observables in source order.</summary>
-    /// <typeparam name="TSource">The source value type.</typeparam>
-    /// <typeparam name="TResult">The result value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="selector">Projects source values to inner observables.</param>
-    private sealed class FlatMapSignal<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector) : IObservable<TResult>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<TSource> _source = source;
-
-        /// <summary>Projects source values to inner observables.</summary>
-        private readonly Func<TSource, IObservable<TResult>> _selector = selector;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<TResult> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            return new FlatMapCoordinator<TSource, TResult>(_source, _selector, observer).Run();
-        }
-    }
-
-    /// <summary>Chaining FlatMap signal with an outer/inner result selector.</summary>
-    /// <typeparam name="TSource">The source value type.</typeparam>
-    /// <typeparam name="TCollection">The inner value type.</typeparam>
-    /// <typeparam name="TResult">The result value type.</typeparam>
-    /// <param name="source">The source observable.</param>
-    /// <param name="collectionSelector">Projects source values to inner observables.</param>
-    /// <param name="resultSelector">Projects outer and inner values to result values.</param>
-    private sealed class FlatMapResultSignal<TSource, TCollection, TResult>(
-        IObservable<TSource> source,
-        Func<TSource, IObservable<TCollection>> collectionSelector,
-        Func<TSource, TCollection, TResult> resultSelector) : IObservable<TResult>
-    {
-        /// <summary>The source observable.</summary>
-        private readonly IObservable<TSource> _source = source;
-
-        /// <summary>Projects source values to inner observables.</summary>
-        private readonly Func<TSource, IObservable<TCollection>> _collectionSelector = collectionSelector;
-
-        /// <summary>Projects outer and inner values to result values.</summary>
-        private readonly Func<TSource, TCollection, TResult> _resultSelector = resultSelector;
-
-        /// <inheritdoc/>
-        public IDisposable Subscribe(IObserver<TResult> observer)
-        {
-            ArgumentExceptionHelper.ThrowIfNull(observer);
-
-            var collectionSelector = _collectionSelector;
-            var resultSelector = _resultSelector;
-
-            return new FlatMapCoordinator<TSource, TResult>(
-                _source,
-                value => new FlatMapResultInnerSignal<TSource, TCollection, TResult>(
-                    value,
-                    collectionSelector(value),
-                    resultSelector),
-                observer).Run();
-        }
-    }
-
     /// <summary>Coordinates chain-style FlatMap subscriptions.</summary>
     /// <typeparam name="TSource">The source value type.</typeparam>
     /// <typeparam name="TResult">The result value type.</typeparam>
-    private sealed class FlatMapCoordinator<TSource, TResult> : IDisposable
+    internal sealed class FlatMapCoordinator<TSource, TResult> : IDisposable
     {
         /// <summary>Synchronizes subscription state.</summary>
         private readonly Lock _gate = new();
@@ -184,6 +123,42 @@ internal IDisposable Run()
             }
         }
 
+        /// <summary>Subscribes to an inner source.</summary>
+        /// <param name="inner">The inner source.</param>
+        internal void SubscribeInner(IObservable<TResult> inner)
+        {
+            lock (_gate)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                _subscribingInner = true;
+                _completedInnerWhileSubscribing = false;
+            }
+
+            IDisposable subscription;
+            try
+            {
+                subscription = inner.Subscribe(_innerObserver);
+            }
+            catch (Exception error)
+            {
+                CompleteSubscribe(error);
+                return;
+            }
+
+            var completed = CompleteSubscribe(subscription);
+            if (!completed)
+            {
+                return;
+            }
+
+            subscription.Dispose();
+            Drain();
+        }
+
         /// <summary>Handles a source value.</summary>
         /// <param name="value">The source value.</param>
         /// <exception cref="InvalidOperationException">The selector returned a <see langword="null"/> inner observable.</exception>
@@ -312,42 +287,6 @@ private bool TryStartOrQueue(IObservable<TResult> inner)
             }
         }
 
-        /// <summary>Subscribes to an inner source.</summary>
-        /// <param name="inner">The inner source.</param>
-        private void SubscribeInner(IObservable<TResult> inner)
-        {
-            lock (_gate)
-            {
-                if (_disposed)
-                {
-                    return;
-                }
-
-                _subscribingInner = true;
-                _completedInnerWhileSubscribing = false;
-            }
-
-            IDisposable subscription;
-            try
-            {
-                subscription = inner.Subscribe(_innerObserver);
-            }
-            catch (Exception error)
-            {
-                CompleteSubscribe(error);
-                return;
-            }
-
-            var completed = CompleteSubscribe(subscription);
-            if (!completed)
-            {
-                return;
-            }
-
-            subscription.Dispose();
-            Drain();
-        }
-
         /// <summary>Completes an inner subscribe call that threw.</summary>
         /// <param name="error">The subscribe error.</param>
         private void CompleteSubscribe(Exception error)
@@ -467,6 +406,67 @@ private sealed class InnerWitness : IObserver<TResult>
         }
     }
 
+    /// <summary>FlatMap signal that subscribes the projected inner observables in source order.</summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="selector">Projects source values to inner observables.</param>
+    private sealed class FlatMapSignal<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector) : IObservable<TResult>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<TSource> _source = source;
+
+        /// <summary>Projects source values to inner observables.</summary>
+        private readonly Func<TSource, IObservable<TResult>> _selector = selector;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<TResult> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            return new FlatMapCoordinator<TSource, TResult>(_source, _selector, observer).Run();
+        }
+    }
+
+    /// <summary>Chaining FlatMap signal with an outer/inner result selector.</summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TCollection">The inner value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="collectionSelector">Projects source values to inner observables.</param>
+    /// <param name="resultSelector">Projects outer and inner values to result values.</param>
+    private sealed class FlatMapResultSignal<TSource, TCollection, TResult>(
+        IObservable<TSource> source,
+        Func<TSource, IObservable<TCollection>> collectionSelector,
+        Func<TSource, TCollection, TResult> resultSelector) : IObservable<TResult>
+    {
+        /// <summary>The source observable.</summary>
+        private readonly IObservable<TSource> _source = source;
+
+        /// <summary>Projects source values to inner observables.</summary>
+        private readonly Func<TSource, IObservable<TCollection>> _collectionSelector = collectionSelector;
+
+        /// <summary>Projects outer and inner values to result values.</summary>
+        private readonly Func<TSource, TCollection, TResult> _resultSelector = resultSelector;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<TResult> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            var collectionSelector = _collectionSelector;
+            var resultSelector = _resultSelector;
+
+            return new FlatMapCoordinator<TSource, TResult>(
+                _source,
+                value => new FlatMapResultInnerSignal<TSource, TCollection, TResult>(
+                    value,
+                    collectionSelector(value),
+                    resultSelector),
+                observer).Run();
+        }
+    }
+
     /// <summary>Maps inner values with a captured outer value.</summary>
     /// <typeparam name="TSource">The source value type.</typeparam>
     /// <typeparam name="TCollection">The inner value type.</typeparam>
diff --git a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
index 6e572e77..cb00cc17 100644
--- a/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
+++ b/src/ReactiveUI.Disposables/Disposables/OnceDisposable.cs
@@ -54,16 +54,8 @@ public IDisposable? Disposable
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
     /// <inheritdoc/>
-    public void Dispose()
-    {
-        var previous = Interlocked.Exchange(ref _current, DisposedSentinel);
-        if (previous is null || ReferenceEquals(previous, DisposedSentinel))
-        {
-            return;
-        }
-
-        previous.Dispose();
-    }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    public void Dispose() => Interlocked.Exchange(ref _current, DisposedSentinel)?.Dispose();
 
     /// <summary>Disposable marker for disposed instances.</summary>
     private sealed class DisposedMarker : IDisposable
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net10.0/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net10.0/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net11.0/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net11.0/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net462/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net462/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net472/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net472/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net48/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net48/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net481/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net481/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net8.0/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net8.0/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Disposables/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Disposables/PublicAPI/net9.0/PublicAPI.txt
index 27a3172d..cc903483 100644
--- a/src/ReactiveUI.Disposables/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Disposables/PublicAPI/net9.0/PublicAPI.txt
@@ -98,6 +98,7 @@ public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDispose
     public System.IDisposable? Disposable { get; set; }
     public bool IsAssigned { get; }
     public bool IsDisposed { get; }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
     public void Dispose() { }
 }
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
diff --git a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
index 6a6f89d9..2f7a731e 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Advanced/TaskResultCompletionSource.cs
@@ -23,19 +23,26 @@ public sealed class TaskResultCompletionSource<T>(CancellationToken cancellation
     /// <returns>The terminal result value.</returns>
     public async ValueTask<T> AwaitResultAsync(IAsyncDisposable owner)
     {
+        CancellationTokenRegistration cancellationRegistration = default;
         try
         {
-#if NET8_0_OR_GREATER
-            await using var cancellationRegistration = RegisterCancellation();
-#else
-            using var cancellationRegistration = RegisterCancellation();
-#endif
-
+            cancellationRegistration = RegisterCancellation();
             return await _taskSource.Task.ConfigureAwait(false);
         }
         finally
         {
-            await owner.DisposeAsync().ConfigureAwait(false);
+            try
+            {
+#if NET8_0_OR_GREATER
+                await cancellationRegistration.DisposeAsync().ConfigureAwait(false);
+#else
+                cancellationRegistration.Dispose();
+#endif
+            }
+            finally
+            {
+                await owner.DisposeAsync().ConfigureAwait(false);
+            }
         }
     }
 
diff --git a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
index f901a5d8..aa6983c9 100644
--- a/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async.Core/Operators/ToAsyncEnumerable.cs
@@ -60,7 +60,7 @@ static async IAsyncEnumerable<T> ReadObservableValuesAsync(
                     return default;
                 });
 
-                await using var subscription = await source.SubscribeAsync(
+                var subscription = await source.SubscribeAsync(
                     channel.Writer.WriteAsync,
                     onErrorResumeAsync,
                     result =>
@@ -70,9 +70,19 @@ static async IAsyncEnumerable<T> ReadObservableValuesAsync(
                     },
                     cancellationToken).ConfigureAwait(false);
 
-                await foreach (var x in channel.Reader.ReadAllAsync(cancellationToken))
+                try
                 {
-                    yield return x;
+                    await foreach (var x in channel.Reader.ReadAllAsync(cancellationToken))
+                    {
+                        yield return x;
+                    }
+                }
+                finally
+                {
+                    if (subscription is not null)
+                    {
+                        await subscription.DisposeAsync().ConfigureAwait(false);
+                    }
                 }
             }
         }
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
index 2b05786c..2df299dd 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/BufferWitness.cs
@@ -121,17 +121,12 @@ public void Dispose()
         SinkSubscription.Dispose(ref _subscription);
     }
 
-    /// <summary>Returns the window array, copying to an exact-size array only for a partial trailing window.</summary>
+    /// <summary>Copies the partial trailing window into an exact-size array.</summary>
     /// <param name="buffer">The window buffer.</param>
     /// <param name="length">The number of filled elements.</param>
     /// <returns>The window array.</returns>
     private static T[] Trim(T[] buffer, int length)
     {
-        if (length == buffer.Length)
-        {
-            return buffer;
-        }
-
         var exact = new T[length];
         Array.Copy(buffer, exact, length);
         return exact;
diff --git a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
index 8eba8a96..3aebb749 100644
--- a/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Advanced/UseSignal{TResource,T}.cs
@@ -75,18 +75,13 @@ private sealed class UseWitness(IObserver<T> observer, TResource resource) : IOb
         /// <summary>Non-zero once stopped.</summary>
         private int _stopped;
 
-        /// <summary>Stores the inner subscription, disposing it when the sink has stopped or holds one.</summary>
+        /// <summary>Publishes the single inner subscription, disposing it if the sink has already stopped.</summary>
         /// <param name="subscription">Inner subscription.</param>
         public void SetSubscription(IDisposable subscription)
         {
             ArgumentExceptionHelper.ThrowIfNull(subscription);
 
-            if (Interlocked.CompareExchange(ref _subscription, subscription, null) is not null)
-            {
-                subscription.Dispose();
-                return;
-            }
-
+            Volatile.Write(ref _subscription, subscription);
             if (Volatile.Read(ref _stopped) == 0)
             {
                 return;
diff --git a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
index 1bfcf994..c7948474 100644
--- a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
+++ b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs
@@ -485,16 +485,9 @@ private void Remove(SignalSubscription subscription)
     /// <summary>Removes a subscription from its owning slot array.</summary>
     /// <param name="slots">The active slot array.</param>
     /// <param name="subscription">The subscription to clear.</param>
-    private void RemoveFromSlotsLocked(SignalSubscription?[] slots, SignalSubscription subscription)
-    {
-        var index = Array.IndexOf(slots, subscription);
-        if (index < 0)
-        {
-            return;
-        }
-
-        ClearSlotLocked(slots, index);
-    }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private void RemoveFromSlotsLocked(SignalSubscription?[] slots, SignalSubscription subscription) =>
+        ClearSlotLocked(slots, Array.IndexOf(slots, subscription));
 
     /// <summary>Vacates one slot and drops back to the empty shape when it was the last live subscription.</summary>
     /// <param name="slots">The active slot array.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index 8e17ef32..652b2cd8 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -110,10 +110,10 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         {
             SetRunning(true);
 
-            WaitIfNeeded(Sequencer.TimeUntil(dueTimestamp), Wait);
-
             try
             {
+                WaitIfNeeded(Sequencer.TimeUntil(dueTimestamp), Wait);
+
                 if (!Sequencer.IsCancelled(item))
                 {
                     item.Execute();
diff --git a/src/tests/ReactiveUI.Disposables.Tests/BooleanDisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/BooleanDisposableTests.cs
new file mode 100644
index 00000000..05af936c
--- /dev/null
+++ b/src/tests/ReactiveUI.Disposables.Tests/BooleanDisposableTests.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Disposables.Tests;
+
+/// <summary>Tests the boolean disposal latch.</summary>
+public class BooleanDisposableTests
+{
+    /// <summary>The debugger can display both live and disposed instances without altering their state.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_PreservesDisposalState()
+    {
+        BooleanDisposable disposable = new();
+        await Assert.That(GetDebuggerDisplay(disposable)).IsEqualTo(disposable.ToString());
+        await Assert.That(disposable.IsDisposed).IsFalse();
+
+        disposable.Dispose();
+
+        await Assert.That(GetDebuggerDisplay(disposable)).IsEqualTo(disposable.ToString());
+        await Assert.That(disposable.IsDisposed).IsTrue();
+    }
+
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="disposable">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(BooleanDisposable disposable);
+}
diff --git a/src/tests/ReactiveUI.Disposables.Tests/OnceDisposableTests.cs b/src/tests/ReactiveUI.Disposables.Tests/OnceDisposableTests.cs
new file mode 100644
index 00000000..1f4bfcdf
--- /dev/null
+++ b/src/tests/ReactiveUI.Disposables.Tests/OnceDisposableTests.cs
@@ -0,0 +1,27 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Disposables.Tests;
+
+/// <summary>Tests repeated disposal of a single-assignment holder.</summary>
+public class OnceDisposableTests
+{
+    /// <summary>The terminal marker tolerates repeated disposal without releasing the resource again.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Dispose_Repeated_ReleasesAssignedResourceOnce()
+    {
+        int[] counts = [0];
+        OnceDisposable holder = new() { Disposable = Scope.Create(counts, static state => state[0]++) };
+
+        holder.Dispose();
+        holder.Dispose();
+
+        await Assert.That(counts[0]).IsEqualTo(1);
+        await Assert.That(holder.IsDisposed).IsTrue();
+        await Assert.That(holder.Disposable).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Disposables.Tests/ScopeTests.cs b/src/tests/ReactiveUI.Disposables.Tests/ScopeTests.cs
new file mode 100644
index 00000000..01861a81
--- /dev/null
+++ b/src/tests/ReactiveUI.Disposables.Tests/ScopeTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Disposables.Tests;
+
+/// <summary>Tests grouped resource ownership.</summary>
+public class ScopeTests
+{
+    /// <summary>Both combination overloads release every resource once.</summary>
+    /// <param name="useArray">Whether to use the array overload instead of the pair overload.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Combine_DisposeTwice_ReleasesBothResourcesOnce(bool useArray)
+    {
+        int[] counts = [0, 0];
+        using var first = Scope.Create(counts, static state => state[0]++);
+        using var second = Scope.Create(counts, static state => state[1]++);
+        var combined = useArray ? Scope.Combine([first, second]) : Scope.Combine(first, second);
+
+        combined.Dispose();
+        combined.Dispose();
+
+        await Assert.That(counts[0]).IsEqualTo(1);
+        await Assert.That(counts[1]).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncContextTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncContextTests.cs
new file mode 100644
index 00000000..69287e9e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncContextTests.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests continuation dispatch through asynchronous contexts.</summary>
+public sealed class AsyncContextTests
+{
+    /// <summary>A forced default-context switch dispatches its continuation to the thread pool.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task SwitchContextAsync_DefaultContext_QueuesContinuation()
+    {
+        TaskCompletionSource<bool> completed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var awaiter = AsyncContext.Default.SwitchContextAsync(true, CancellationToken.None).GetAwaiter();
+
+        await Assert.That(awaiter.IsCompleted).IsFalse();
+        awaiter.OnCompleted(() => completed.SetResult(Thread.CurrentThread.IsThreadPoolThread));
+
+        await Assert.That(await completed.Task).IsTrue();
+        awaiter.GetResult();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalAsyncTests.cs
new file mode 100644
index 00000000..2244258e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ConcurrentSignalAsyncTests.cs
@@ -0,0 +1,29 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests the independent lifetimes of concurrent signals and observer leases.</summary>
+public sealed class ConcurrentSignalAsyncTests
+{
+    /// <summary>Signal disposal preserves subscriptions until their own leases are disposed.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DisposeAsync_ActiveSubscription_DoesNotDisposeObserverLease()
+    {
+        const int IgnoredValue = 2;
+        ConcurrentSignalAsync<int> signal = new();
+        List<int> values = [];
+        await using var subscription = await signal.SubscribeAsync(values.Add);
+
+        await signal.DisposeAsync();
+        await signal.OnNextAsync(1, CancellationToken.None);
+        await subscription.DisposeAsync();
+        await signal.OnNextAsync(IgnoredValue, CancellationToken.None);
+
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
index 0db42ad6..ad66b496 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/IntervalSubscriptionTests.cs
@@ -7,6 +7,32 @@ namespace ReactiveUI.Primitives.Async.Tests;
 /// <summary>Tests interval cancellation and notification ordering with a controlled clock.</summary>
 public sealed class IntervalSubscriptionTests
 {
+    /// <summary>A zero period uses the system-clock path without waiting for wall-clock time.</summary>
+    /// <param name="explicitSystemProvider">Whether the system provider is supplied explicitly.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task ExecuteAsync_ZeroPeriod_StopsAfterObserverCancellation(bool explicitSystemProvider)
+    {
+        using CancellationTokenSource cancellation = new();
+        List<long> ticks = [];
+        CallbackWitnessAsync<long> observer = new((tick, _) =>
+        {
+            ticks.Add(tick);
+            cancellation.Cancel();
+            return default;
+        });
+        await using IntervalSubscription subscription = new(
+            observer,
+            TimeSpan.Zero,
+            explicitSystemProvider ? TimeProvider.System : null);
+
+        await subscription.ExecuteAsync(cancellation.Token);
+
+        await Assert.That(ticks).IsCollectionEqualTo([1L]);
+    }
+
     /// <summary>Cancellation while waiting prevents the pending tick from being delivered.</summary>
     /// <returns>The test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/LeadSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/LeadSubscriptionTests.cs
new file mode 100644
index 00000000..3d1887af
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/LeadSubscriptionTests.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Disposables;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests ownership of the subscription following leading values.</summary>
+public sealed class LeadSubscriptionTests
+{
+    /// <summary>Repeated disposal releases the upstream subscription once.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DisposeAsync_Twice_DisposesSourceOnce()
+    {
+        List<int> disposals = [];
+        var source = SignalAsync.Create<int>((_, _) => new(DisposableAsync.Create(disposals, static state =>
+        {
+            state.Add(1);
+            return default;
+        })));
+        CallbackWitnessAsync<int> observer = new(static (_, _) => default);
+        await using LeadSubscription<int> subscription = new(source, [], observer, CancellationToken.None);
+        subscription.Start();
+
+        await subscription.DisposeAsync();
+        await subscription.DisposeAsync();
+
+        await Assert.That(disposals).Count().IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ReattemptSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ReattemptSubscriptionTests.cs
new file mode 100644
index 00000000..ad7d3489
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ReattemptSubscriptionTests.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests forwarding of recoverable errors through retry subscriptions.</summary>
+public sealed class ReattemptSubscriptionTests
+{
+    /// <summary>A recoverable error preserves the source connection and subsequent values.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task RelayErrorAsync_RecoverableError_ForwardsErrorAndContinues()
+    {
+        DirectSource<int> source = new();
+        List<int> values = [];
+        List<Exception> errors = [];
+        Exception expected = new InvalidOperationException("recoverable");
+        CallbackWitnessAsync<int> observer = new(
+            (value, _) =>
+            {
+                values.Add(value);
+                return default;
+            },
+            (error, _) =>
+            {
+                errors.Add(error);
+                return default;
+            });
+        await using ReattemptSubscription<int> subscription = new(source, observer, 1, CancellationToken.None);
+        await subscription.SubscribeOnceAsync();
+
+        await source.EmitError(expected);
+        await source.EmitNext(1);
+
+        await Assert.That(errors).IsCollectionEqualTo([expected]);
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/RefCountSignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/RefCountSignalTests.cs
new file mode 100644
index 00000000..18b10ae4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/RefCountSignalTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests managed connection ownership during reference-counted disposal.</summary>
+public sealed class RefCountSignalTests
+{
+    /// <summary>Finalizer-style disposal leaves managed subscriptions available to their owners.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Dispose_UnmanagedOnly_PreservesManagedConnection()
+    {
+        const int IgnoredValue = 2;
+        var source = Signal.Create<int>();
+        var connected = source.Values.Publish();
+        using SignalAsyncExtensions.RefCountSignal<int> signal = new(connected);
+        List<int> values = [];
+        await using var subscription = await ((IObservableAsync<int>)signal).SubscribeAsync(values.Add);
+
+        signal.Dispose(false);
+        await source.OnNextAsync(1, CancellationToken.None);
+        await subscription.DisposeAsync();
+        await source.OnNextAsync(IgnoredValue, CancellationToken.None);
+
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SerialBroadcastHelpersTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SerialBroadcastHelpersTests.cs
new file mode 100644
index 00000000..b526ea89
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SerialBroadcastHelpersTests.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests ordering across asynchronous serial observer notifications.</summary>
+public sealed class SerialBroadcastHelpersTests
+{
+    /// <summary>A pending first observer prevents the second observer from receiving the value early.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task BroadcastOnNextAsync_PendingFirstObserver_WaitsBeforeNotifyingSecond()
+    {
+        var source = Signal.Create<int>();
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        List<int> firstValues = [];
+        List<int> secondValues = [];
+        await using var first = await source.Values.SubscribeAsync(async (value, _) =>
+        {
+            firstValues.Add(value);
+            await release.Task;
+        });
+        await using var second = await source.Values.SubscribeAsync(secondValues.Add);
+
+        var pending = source.OnNextAsync(1, CancellationToken.None).AsTask();
+        await Assert.That(firstValues).IsCollectionEqualTo([1]);
+        await Assert.That(secondValues).IsEmpty();
+        await Assert.That(pending.IsCompleted).IsFalse();
+        release.SetResult();
+        await pending;
+
+        await Assert.That(secondValues).IsCollectionEqualTo([1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncExtensionsTests.cs
new file mode 100644
index 00000000..43facb28
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncExtensionsTests.cs
@@ -0,0 +1,111 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Threading.Channels;
+using ReactiveUI.Primitives.Async.Disposables;
+using ReactiveUI.Primitives.Async.Signals;
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests asynchronous signal extension overloads and enumeration disposal.</summary>
+public sealed class SignalAsyncExtensionsTests
+{
+    /// <summary>The second distinct value in an ordered sequence.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Chaining an enumerable preserves source order.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Chain_Enumerable_EmitsSourcesInOrder()
+    {
+        IEnumerable<IObservableAsync<int>> sources = [SignalAsync.Return(1), SignalAsync.Return(SecondValue)];
+
+        await Assert.That(await sources.Chain().ToListAsync()).IsCollectionEqualTo([1, SecondValue]);
+    }
+
+    /// <summary>Zero-duration throttling on the system clock still removes consecutive duplicates.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ThrottleDistinct_ZeroDuration_EmitsDistinctValues()
+    {
+        var source = Signal.Create<int>();
+        List<int> values = [];
+        await using var subscription = await source.Values.ThrottleDistinct(TimeSpan.Zero)
+            .SubscribeAsync(values.Add);
+
+        await source.OnNextAsync(1, CancellationToken.None);
+        await source.OnNextAsync(1, CancellationToken.None);
+        await source.OnNextAsync(SecondValue, CancellationToken.None);
+        await source.OnCompletedAsync(Result.Success);
+
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue]);
+    }
+
+    /// <summary>Timeout without an explicit clock selects the system-clock signal.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Timeout_DefaultClock_CreatesTimeoutSignal()
+    {
+        var source = SignalAsync.Never<int>().Timeout(TimeSpan.FromSeconds(1));
+
+        await Assert.That(source).IsTypeOf<SignalAsyncExtensions.TimeoutSignal<int>>();
+    }
+
+    /// <summary>Timeout with a fallback selects the system-clock fallback signal.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Timeout_DefaultClockAndFallback_CreatesFallbackSignal()
+    {
+        var source = SignalAsync.Never<int>().Timeout(TimeSpan.FromSeconds(1), SignalAsync.Return(1));
+
+        await Assert.That(source).IsTypeOf<SignalAsyncExtensions.TimeoutWithFallbackSignal<int>>();
+    }
+
+    /// <summary>Stopping enumeration awaits disposal of the upstream subscription.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ToAsyncEnumerable_DisposeWhileSourceIsActive_AwaitsUpstreamDisposal()
+    {
+        TaskCompletionSource disposing = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = SignalAsync.Create<int>(async (observer, token) =>
+        {
+            await observer.OnNextAsync(1, token);
+            return DisposableAsync.Create((disposing, release), static async state =>
+            {
+                state.disposing.SetResult();
+                await state.release.Task;
+            });
+        });
+        var enumerator = source.ToAsyncEnumerable(Channel.CreateUnbounded<int>).GetAsyncEnumerator();
+        await Assert.That(await enumerator.MoveNextAsync()).IsTrue();
+        await Assert.That(enumerator.Current).IsEqualTo(1);
+
+        var pending = enumerator.DisposeAsync().AsTask();
+        await disposing.Task;
+        await Assert.That(pending.IsCompleted).IsFalse();
+        release.SetResult();
+        await pending;
+    }
+
+    /// <summary>Stopping enumeration propagates an upstream disposal failure.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ToAsyncEnumerable_UpstreamDisposalFails_PropagatesFailure()
+    {
+        InvalidOperationException expected = new("upstream disposal failed");
+        var source = SignalAsync.Create<int>(async (observer, token) =>
+        {
+            await observer.OnNextAsync(1, token);
+            return DisposableAsync.Create(expected, ValueTask.FromException);
+        });
+        var enumerator = source.ToAsyncEnumerable(Channel.CreateUnbounded<int>).GetAsyncEnumerator();
+        await Assert.That(await enumerator.MoveNextAsync()).IsTrue();
+
+        var error = await Assert.That(async () => await enumerator.DisposeAsync())
+            .ThrowsExactly<InvalidOperationException>();
+
+        await Assert.That(error).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncTests.cs
new file mode 100644
index 00000000..eb114164
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalAsyncTests.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests asynchronous signal factories using their default execution settings.</summary>
+public sealed class SignalAsyncTests
+{
+    /// <summary>The default background-job overload forwards the job's value and completion.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task CreateAsBackgroundJob_DefaultSettings_ForwardsJobResult()
+    {
+        var source = SignalAsync.CreateAsBackgroundJob<int>(static async (observer, token) =>
+        {
+            await observer.OnNextAsync(1, token);
+            await observer.OnCompletedAsync(Result.Success);
+        });
+
+        await Assert.That(await source.ToListAsync()).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>The default interval factory creates a system-clock interval.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Interval_DefaultSettings_CreatesIntervalSignal()
+    {
+        var source = SignalAsync.Interval(TimeSpan.FromSeconds(1));
+
+        await Assert.That(source).IsTypeOf<IntervalSignal>();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TaskResultCompletionSourceTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TaskResultCompletionSourceTests.cs
new file mode 100644
index 00000000..b2634f3c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TaskResultCompletionSourceTests.cs
@@ -0,0 +1,102 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests ownership cleanup before terminal task results are returned.</summary>
+public sealed class TaskResultCompletionSourceTests
+{
+    /// <summary>A successful result is returned only after asynchronous owner disposal completes.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task AwaitResultAsync_Success_AwaitsOwnerDisposal()
+    {
+        using CancellationTokenSource cancellation = new();
+        TaskResultCompletionSource<int> source = new(cancellation.Token);
+        ControlledOwner owner = new();
+        var pending = source.AwaitResultAsync(owner).AsTask();
+
+        await source.SetResultAndDisposeAsync(1, owner);
+        await owner.Disposing.Task;
+        await Assert.That(pending.IsCompleted).IsFalse();
+        owner.Release.SetResult();
+
+        await Assert.That(await pending).IsEqualTo(1);
+        await Assert.That(owner.ReentrantDisposalCount).IsEqualTo(1);
+    }
+
+    /// <summary>Cancellation also waits for asynchronous owner disposal before reporting cancellation.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task AwaitResultAsync_Canceled_AwaitsOwnerDisposal()
+    {
+        using CancellationTokenSource cancellation = new();
+        TaskResultCompletionSource<int> source = new(cancellation.Token);
+        ControlledOwner owner = new();
+        var pending = source.AwaitResultAsync(owner).AsTask();
+
+        await cancellation.CancelAsync();
+        await owner.Disposing.Task;
+        await Assert.That(pending.IsCompleted).IsFalse();
+        owner.Release.SetResult();
+
+        var error = await Assert.That(async () => await pending).Throws<OperationCanceledException>();
+        await Assert.That(error!.CancellationToken).IsEqualTo(cancellation.Token);
+    }
+
+    /// <summary>An owner disposal failure takes precedence over either a result or the original task failure.</summary>
+    /// <param name="sourceFails">Whether the task result itself fails.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task AwaitResultAsync_OwnerDisposalFails_PropagatesDisposalFailure(bool sourceFails)
+    {
+        TaskResultCompletionSource<int> source = new(CancellationToken.None);
+        ControlledOwner owner = new();
+        InvalidOperationException expected = new("owner disposal failed");
+        var pending = source.AwaitResultAsync(owner).AsTask();
+        if (sourceFails)
+        {
+            await source.SetExceptionAndDisposeAsync(new ArgumentException("source failed"), owner);
+        }
+        else
+        {
+            await source.SetResultAndDisposeAsync(1, owner);
+        }
+
+        await owner.Disposing.Task;
+        owner.Release.SetException(expected);
+
+        var error = await Assert.That(async () => await pending).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(error).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Separates notification disposal from externally awaited cleanup.</summary>
+    private sealed class ControlledOwner : IAsyncDisposable, IReentrantAsyncDisposable
+    {
+        /// <summary>Gets the signal that external disposal has started.</summary>
+        internal TaskCompletionSource Disposing { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        /// <summary>Gets the gate controlling completion of external disposal.</summary>
+        internal TaskCompletionSource Release { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        /// <summary>Gets the count of notification-side disposals.</summary>
+        internal int ReentrantDisposalCount { get; private set; }
+
+        /// <inheritdoc/>
+        public async ValueTask DisposeAsync()
+        {
+            Disposing.SetResult();
+            await Release.Task;
+        }
+
+        /// <inheritdoc/>
+        public ValueTask DisposeFromNotificationAsync()
+        {
+            ReentrantDisposalCount++;
+            return default;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/YieldSignalTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/YieldSignalTests.cs
new file mode 100644
index 00000000..a24ef080
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/YieldSignalTests.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Async.Tests;
+
+/// <summary>Tests yielding to the scheduler captured during subscription.</summary>
+public sealed class YieldSignalTests
+{
+    /// <summary>Each value waits for the captured scheduler before reaching its observer.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task SubscribeAsync_CustomScheduler_DefersValuesUntilScheduled()
+    {
+        ManualTaskScheduler scheduler = new();
+        DirectSource<int> source = new();
+        List<int> values = [];
+        CallbackWitnessAsync<int> observer = new((value, _) =>
+        {
+            values.Add(value);
+            return default;
+        });
+        var subscribing = Task.Factory.StartNew(
+            static state =>
+            {
+                var (source, observer) = ((DirectSource<int>, CallbackWitnessAsync<int>))state!;
+                return ((IObservableAsync<int>)source).Yield().SubscribeAsync(observer, CancellationToken.None);
+            },
+            (source, observer),
+            CancellationToken.None,
+            TaskCreationOptions.DenyChildAttach,
+            scheduler);
+        scheduler.RunNext();
+        var scheduledSubscription = await subscribing;
+        await using var subscription = await scheduledSubscription;
+
+        var pending = source.EmitNext(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(scheduler.PendingCount).IsEqualTo(1);
+
+        scheduler.RunNext();
+        await pending;
+
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
index 91bc96be..e48030bc 100644
--- a/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Avalonia.Tests/AvaloniaSchedulerTests.cs
@@ -43,6 +43,21 @@ public async Task ConstructorsAndSingletonPreserveDispatcherAndPriority()
         await Assert.That(AvaloniaScheduler.Instance.Priority).IsEqualTo(DispatcherPriority.Background);
     }
 
+    /// <summary>The scheduler exposes UTC time and the shared monotonic timestamp scale.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ClockProperties_UseSharedSequencerClock()
+    {
+        AvaloniaScheduler scheduler = new(Dispatcher.UIThread);
+        var before = System.Diagnostics.Stopwatch.GetTimestamp();
+        var timestamp = scheduler.Timestamp;
+        var after = System.Diagnostics.Stopwatch.GetTimestamp();
+
+        await Assert.That(scheduler.Now.Offset).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(timestamp).IsGreaterThanOrEqualTo(before);
+        await Assert.That(timestamp).IsLessThanOrEqualTo(after);
+    }
+
     /// <summary>Immediate and already-due items share an ordered batch that skips cancelled work.</summary>
     /// <returns>The test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
index 19d9f2fd..22ad2c33 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/BlazorRendererSequencerTests.cs
@@ -54,6 +54,39 @@ public async Task DispatcherSequencerExecutesWork()
         await Assert.That(renderer.InvokeCount).IsEqualTo(1);
     }
 
+    /// <summary>Already-due timestamp work is delivered through the renderer with the shared clock scale.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Schedule_AlreadyDueTimestamp_UsesRendererDispatch()
+    {
+        FakeRenderer renderer = new();
+        BlazorRendererSequencer sequencer = new(renderer);
+        var before = Sequencer.Timestamp;
+        var timestamp = sequencer.Timestamp;
+        var after = Sequencer.Timestamp;
+        var calls = 0;
+
+        sequencer.Schedule(new DelegateWorkItem(() => calls++), timestamp);
+
+        await Assert.That(calls).IsEqualTo(1);
+        await Assert.That(renderer.InvokeCount).IsEqualTo(1);
+        await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(timestamp).IsGreaterThanOrEqualTo(before);
+        await Assert.That(timestamp).IsLessThanOrEqualTo(after);
+    }
+
+    /// <summary>The debugger identifies the renderer sequencer without posting renderer work.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_IdentifiesSequencerWithoutDispatch()
+    {
+        FakeRenderer renderer = new();
+        BlazorRendererSequencer sequencer = new(renderer);
+
+        await Assert.That(GetDebuggerDisplay(sequencer)).IsEqualTo(sequencer.ToString());
+        await Assert.That(renderer.InvokeCount).IsEqualTo(0);
+    }
+
     /// <summary>Verifies renderer-task faults reach the unhandled-exception handler instead of vanishing.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -239,6 +272,12 @@ public async Task ImmediateBurstExecutesInOrder()
         await Assert.That(values).IsEquivalentTo(ExpectedBurst, EqualityComparer<int>.Default, TUnit.Assertions.Enums.CollectionOrdering.Matching);
     }
 
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="sequencer">The sequencer to display.</param>
+    /// <returns>The debugger display text.</returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(BlazorRendererSequencer sequencer);
+
     /// <summary>Work item that invokes a delegate when executed.</summary>
     private sealed class DelegateWorkItem : IWorkItem
     {
diff --git a/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs b/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
index beb81f7f..936d0166 100644
--- a/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveComponentBaseTests.cs
@@ -17,6 +17,18 @@ public sealed class ReactiveComponentBaseTests
     /// <summary>The first value pushed to a source.</summary>
     private const int FirstValue = 1;
 
+    /// <summary>The debugger reflects disposal without attaching the component to a renderer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_ReportsCurrentDisposalState()
+    {
+        HarnessComponent component = new();
+
+        await Assert.That(GetDebuggerDisplay(component)).IsEqualTo("IsDisposed = False");
+        component.Dispose();
+        await Assert.That(GetDebuggerDisplay(component)).IsEqualTo("IsDisposed = True");
+    }
+
     /// <summary>Verifies an observed value reaches the callback and refreshes the component.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
@@ -139,6 +151,12 @@ public async Task SecondDisposalIsANoOp()
         await Assert.That(component.IsDisposedState).IsTrue();
     }
 
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="component">The component to display.</param>
+    /// <returns>The debugger display text.</returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(ReactiveComponentBase component);
+
     /// <summary>A source whose observer the test drives directly.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     private sealed class ManualSource<T> : IObservable<T>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/WhileObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/WhileObservableTests.cs
new file mode 100644
index 00000000..4f4c5918
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Reactive.Tests/WhileObservableTests.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Reactive.Tests;
+
+/// <summary>Tests scheduled loop cancellation after a scheduler has accepted its callback.</summary>
+public class WhileObservableTests
+{
+    /// <summary>A callback already accepted by the scheduler does not invoke the action after disposal.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task While_DisposedBeforeAcceptedCallbackRuns_DoesNotInvokeAction()
+    {
+        AcceptedCallbackScheduler scheduler = new();
+        var actions = 0;
+        var values = 0;
+        var completed = false;
+        var subscription = ReactiveExtensions.While(static () => true, () => actions++, scheduler)
+            .Subscribe(_ => values++, () => completed = true);
+
+        subscription.Dispose();
+        scheduler.RunAcceptedCallback();
+
+        await Assert.That(actions).IsEqualTo(0);
+        await Assert.That(values).IsEqualTo(0);
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Models best-effort cancellation after dispatch has accepted a callback for execution.</summary>
+    private sealed class AcceptedCallbackScheduler : IScheduler
+    {
+        /// <summary>The accepted callback, which is no longer cancelable by its subscription.</summary>
+        private Action? _accepted;
+
+        /// <inheritdoc/>
+        public DateTimeOffset Now => DateTimeOffset.UnixEpoch;
+
+        /// <inheritdoc/>
+        public IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
+        {
+            _accepted = () => action(this, state).Dispose();
+            return EmptyDisposable.Instance;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(
+            TState state,
+            TimeSpan dueTime,
+            Func<IScheduler, TState, IDisposable> action) => Schedule(state, action);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(
+            TState state,
+            DateTimeOffset dueTime,
+            Func<IScheduler, TState, IDisposable> action) => Schedule(state, action);
+
+        /// <summary>Executes the accepted callback after the test has disposed its subscription.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void RunAcceptedCallback() => _accepted!();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesObservableTests.cs
new file mode 100644
index 00000000..388460e6
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesObservableTests.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests candidate matching when a user callback ends the subscription.</summary>
+public class FirstMatchFromCandidatesObservableTests
+{
+    /// <summary>Disposal from the match predicate prevents delivery of the value being evaluated.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnNext_PredicateDisposesSubscription_DoesNotDeliverMatch()
+    {
+        using Subject<int> source = new();
+        MutableDisposable subscription = new();
+        List<int> values = [];
+        var completed = false;
+        int[] candidates = [0];
+        subscription.Disposable = candidates.FirstMatchFromCandidates(
+            _ => source,
+            static value => value,
+            _ =>
+            {
+                subscription.Dispose();
+                return true;
+            },
+            -1).Subscribe(values.Add, () => completed = true);
+
+        source.OnNext(1);
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completed).IsFalse();
+        await Assert.That(source.HasObservers).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.DefaultSchedulers.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.DefaultSchedulers.cs
new file mode 100644
index 00000000..0151f816
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.DefaultSchedulers.cs
@@ -0,0 +1,67 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests synchronous behavior of operators that use the default scheduler.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>A value satisfying the predicate bypasses the throttle window and completes synchronously.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ThrottleUntilTrue_DefaultSchedulerMatchingValue_ForwardsImmediately()
+    {
+        List<int> values = [];
+        var completed = false;
+        using var subscription = Observable.Return(SampleValue42)
+            .ThrottleUntilTrue(TimeSpan.FromDays(1), static value => value == SampleValue42)
+            .Subscribe(values.Add, () => completed = true);
+
+        await Assert.That(values).IsCollectionEqualTo([SampleValue42]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>A source error is forwarded without waiting for the default scheduler's debounce window.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebounceImmediate_DefaultSchedulerSourceError_ForwardsImmediately()
+    {
+        InvalidOperationException failure = new("source");
+        Exception? observed = null;
+        using var subscription = Observable.Throw<int>(failure)
+            .DebounceImmediate(TimeSpan.FromDays(1))
+            .Subscribe(static _ => { }, error => observed = error);
+
+        await Assert.That(observed).IsSameReferenceAs(failure);
+    }
+
+    /// <summary>An empty source completes without producing a buffer or waiting for an inactivity timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task BufferUntilInactive_DefaultSchedulerEmptySource_CompletesImmediately()
+    {
+        List<IList<int>> buffers = [];
+        var completed = false;
+        using var subscription = Observable.Empty<int>()
+            .BufferUntilInactive(TimeSpan.FromDays(1))
+            .Subscribe(buffers.Add, () => completed = true);
+
+        await Assert.That(buffers).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>The default overload shares its timer with the explicit default-scheduler overload.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task SyncTimer_DefaultScheduler_ReusesExplicitDefaultTimer()
+    {
+        var period = TimeSpan.FromDays(1);
+        var timer = period.SyncTimer();
+
+        await Assert.That(timer).IsSameReferenceAs(period.SyncTimer(Sequencer.Default));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.RetryDefaults.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.RetryDefaults.cs
new file mode 100644
index 00000000..fc3801bd
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.RetryDefaults.cs
@@ -0,0 +1,99 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests default-scheduler retry overloads with synchronous retries.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>Identifies the original error forwarded by a retry sequence.</summary>
+    private const string RetryFailureMessage = "retry";
+
+    /// <summary>Zero-delay retries notify the error callback only for the requested exception type.</summary>
+    /// <param name="matchingException">Whether the first failure matches the error callback's type.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task OnErrorRetry_DefaultSchedulerZeroDelay_FiltersErrorCallback(bool matchingException)
+    {
+        var attempts = 0;
+        List<InvalidOperationException> errors = [];
+        List<int> values = [];
+        Exception failure = matchingException
+            ? new InvalidOperationException(RetryFailureMessage)
+            : new ArgumentException(RetryFailureMessage);
+        var source = Observable.Defer(() =>
+        {
+            attempts++;
+            return attempts == 1 ? Observable.Throw<int>(failure) : Observable.Return(SampleValue42);
+        });
+
+        using var subscription = source.OnErrorRetry<int, InvalidOperationException>(errors.Add, TimeSpan.Zero)
+            .Subscribe(values.Add);
+
+        await Assert.That(attempts).IsEqualTo(SampleValue2);
+        await Assert.That(values).IsCollectionEqualTo([SampleValue42]);
+        await Assert.That(errors.Count).IsEqualTo(matchingException ? 1 : 0);
+        if (!matchingException)
+        {
+            return;
+        }
+
+        await Assert.That(errors[0]).IsSameReferenceAs(failure);
+    }
+
+    /// <summary>The limited zero-delay overload forwards the final error after spending its retry budget.</summary>
+    /// <param name="matchingException">Whether failures match the error callback's type.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    [Arguments(true)]
+    [Arguments(false)]
+    public async Task OnErrorRetry_DefaultSchedulerRetryLimit_ForwardsFinalError(bool matchingException)
+    {
+        var attempts = 0;
+        var callbacks = 0;
+        Exception? observed = null;
+        Exception failure = matchingException
+            ? new InvalidOperationException(RetryFailureMessage)
+            : new ArgumentException(RetryFailureMessage);
+        var source = Observable.Defer(() =>
+        {
+            attempts++;
+            return Observable.Throw<int>(failure);
+        });
+
+        using var subscription = source.OnErrorRetry<int, InvalidOperationException>(
+            _ => callbacks++,
+            SampleValue2,
+            TimeSpan.Zero).Subscribe(static _ => { }, error => observed = error);
+
+        await Assert.That(attempts).IsEqualTo(SampleValue3);
+        await Assert.That(callbacks).IsEqualTo(matchingException ? SampleValue3 : 0);
+        await Assert.That(observed).IsSameReferenceAs(failure);
+    }
+
+    /// <summary>Fixed zero-delay retries use the configured budget before forwarding the original error.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task RetryWithFixedDelay_ZeroDelay_ForwardsErrorAfterRetryLimit()
+    {
+        var attempts = 0;
+        InvalidOperationException failure = new(RetryFailureMessage);
+        Exception? observed = null;
+        var source = Observable.Defer(() =>
+        {
+            attempts++;
+            return Observable.Throw<int>(failure);
+        });
+
+        using var subscription = source.RetryWithFixedDelay(SampleValue2, TimeSpan.Zero)
+            .Subscribe(static _ => { }, error => observed = error);
+
+        await Assert.That(attempts).IsEqualTo(SampleValue3);
+        await Assert.That(observed).IsSameReferenceAs(failure);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/EverySignalTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/EverySignalTests.cs
new file mode 100644
index 00000000..82f1e1fb
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/EverySignalTests.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Reactive.Signals;
+
+namespace ReactiveUI.Primitives.Reactive.Tests;
+
+/// <summary>Tests recurring ticks whose scheduler has already accepted a callback at cancellation.</summary>
+public class EverySignalTests
+{
+    /// <summary>A callback delivered after disposal emits no tick and cannot schedule a successor.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Every_DisposedBeforeAcceptedCallback_DoesNotEmitOrReschedule()
+    {
+        AcceptedCallbackScheduler scheduler = new();
+        List<long> values = [];
+        var subscription = Signal.Every(TimeSpan.Zero, scheduler).Subscribe(values.Add);
+
+        subscription.Dispose();
+        scheduler.RunAccepted();
+
+        await Assert.That(values.Count).IsEqualTo(0);
+        await Assert.That(scheduler.ScheduleCount).IsEqualTo(1);
+        await Assert.That(scheduler.HandleDisposed).IsTrue();
+    }
+
+    /// <summary>Retains an accepted callback independently of the scheduling handle's cancellation state.</summary>
+    private sealed class AcceptedCallbackScheduler : IScheduler
+    {
+        /// <summary>The callback accepted by the scheduler.</summary>
+        private Action? _pending;
+
+        /// <inheritdoc/>
+        public DateTimeOffset Now => DateTimeOffset.UnixEpoch;
+
+        /// <summary>Gets the number of accepted schedules.</summary>
+        internal int ScheduleCount { get; private set; }
+
+        /// <summary>Gets whether cancellation reached the scheduler's handle.</summary>
+        internal bool HandleDisposed { get; private set; }
+
+        /// <inheritdoc/>
+        public IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
+        {
+            ScheduleCount++;
+            _pending = () => action(this, state).Dispose();
+            return Disposable.Create(this, static scheduler => scheduler.HandleDisposed = true);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action) =>
+            Schedule(state, action);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IDisposable Schedule<TState>(TState state, DateTimeOffset dueTime, Func<IScheduler, TState, IDisposable> action) =>
+            Schedule(state, dueTime - Now, action);
+
+        /// <summary>Delivers the already accepted callback even if its handle was subsequently cancelled.</summary>
+        internal void RunAccepted()
+        {
+            var callback = _pending;
+            _pending = null;
+            callback!.Invoke();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/AwaitWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/AwaitWitnessTests.cs
new file mode 100644
index 00000000..ca68a176
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/AwaitWitnessTests.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the observer that resumes an awaiting continuation.</summary>
+public class AwaitWitnessTests
+{
+    /// <summary>An error resumes the continuation inline when context capture is disabled.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_WithoutCapturedContext_InvokesContinuationInline()
+    {
+        var calls = 0;
+        AwaitWitness<int> witness = new(() => calls++, false);
+
+        witness.OnError(new InvalidOperationException("source"));
+
+        await Assert.That(calls).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
index 07fc5708..36509ef5 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
@@ -22,6 +22,17 @@ public class BehaviorSignalTests
     /// <summary>Value that should be ignored after completion.</summary>
     private const int IgnoredAfterCompletionValue = 1234;
 
+    /// <summary>The debugger display leaves the latest value and observer set intact.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_PreservesSignalState()
+    {
+        using BehaviorSignal<int> signal = new(InitialValue);
+        await Assert.That(GetDebuggerDisplay(signal)).IsEqualTo(signal.ToString());
+        await Assert.That(signal.Value).IsEqualTo(InitialValue);
+        await Assert.That(signal.HasObservers).IsFalse();
+    }
+
     /// <summary>Verifies a behavior signal rejects a null observer.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Test]
@@ -253,4 +264,26 @@ public async Task Subscribe_ReentrantOnNext_FollowsTheInitialValue()
         });
         await Assert.That(values.SequenceEqual([0, 1])).IsTrue();
     }
+
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="signal">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
+#if NET9_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static string? GetDebuggerDisplay(BehaviorSignal<int> signal) => DebuggerAccessor<int>.Read(signal);
+
+    /// <summary>Matches the target type's generic context required by .NET 9 and later.</summary>
+    /// <typeparam name="T">The signal's value type.</typeparam>
+    private static class DebuggerAccessor<T>
+    {
+        /// <summary>Invokes the getter evaluated by the debugger.</summary>
+        /// <param name="signal">The signal to display.</param>
+        /// <returns>The debugger text.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+        internal static extern string? Read(BehaviorSignal<T> signal);
+    }
+#else
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string? GetDebuggerDisplay(BehaviorSignal<int> signal);
+#endif
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BufferSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BufferSignalTests.cs
new file mode 100644
index 00000000..8449e447
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/BufferSignalTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests time-window buffering.</summary>
+public sealed class BufferSignalTests
+{
+    /// <summary>A zero window emits each source value as a separate buffer without scheduling.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Subscribe_WhenWindowIsZero_ThenEmitsIndividualBuffers()
+    {
+        const int secondValue = 2;
+        RecordingWitness<IList<int>> observer = new();
+        BufferSignal<int> source = new(Signal.Sequence(1, secondValue), TimeSpan.Zero, Sequencer.Immediate);
+
+        using var subscription = source.Subscribe(observer);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(secondValue);
+        await Assert.That(observer.Values[0].SequenceEqual([1])).IsTrue();
+        await Assert.That(observer.Values[1].SequenceEqual([secondValue])).IsTrue();
+        await Assert.That(observer.Completed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BufferWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BufferWitnessTests.cs
new file mode 100644
index 00000000..d2a4e94a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/BufferWitnessTests.cs
@@ -0,0 +1,34 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests buffered observer termination.</summary>
+public class BufferWitnessTests
+{
+    /// <summary>A duplicate error cannot emit a partial batch or notify the observer twice.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_Repeated_ForwardsOnlyFirstError()
+    {
+        const int WindowSize = 2;
+        RecordingWitness<IList<int>> observer = new();
+        RecordingDisposable subscription = new();
+        using BufferWitness<int> witness = new(observer, WindowSize, 0);
+        witness.SetSubscription(subscription);
+        witness.OnNext(1);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+        witness.OnError(new InvalidOperationException("late"));
+        witness.OnCompleted();
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CollectArrayWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CollectArrayWitnessTests.cs
new file mode 100644
index 00000000..c78a2cae
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/CollectArrayWitnessTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests array collection notifications.</summary>
+public class CollectArrayWitnessTests
+{
+    /// <summary>An upstream error is forwarded without emitting a partial array and releases the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_DiscardsPartialResultAndDisposesSubscription()
+    {
+        RecordingWitness<int[]> observer = new();
+        RecordingDisposable subscription = new();
+        using CollectArrayWitness<int> witness = new(observer);
+        witness.SetSubscription(subscription);
+        witness.OnNext(1);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CollectListWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CollectListWitnessTests.cs
new file mode 100644
index 00000000..b3199be6
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/CollectListWitnessTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests list collection notifications.</summary>
+public class CollectListWitnessTests
+{
+    /// <summary>An upstream error is forwarded without emitting a partial list and releases the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_DiscardsPartialResultAndDisposesSubscription()
+    {
+        RecordingWitness<IList<int>> observer = new();
+        RecordingDisposable subscription = new();
+        using CollectListWitness<int> witness = new(observer);
+        witness.SetSubscription(subscription);
+        witness.OnNext(1);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
new file mode 100644
index 00000000..831d03a4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests current-thread scheduling recovery after an interrupted initial wait.</summary>
+public class CurrentThreadSequencerTests
+{
+    /// <summary>An interrupted initial wait clears the trampoline state so later work on that thread still executes.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Schedule_InterruptedInitialWait_AllowsSubsequentWork()
+    {
+        TaskCompletionSource completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var interrupted = false;
+        List<int> firstWorkPending = [1];
+        var subsequentWorkRan = false;
+        var resetAfterInterruption = false;
+        var resetAfterWork = false;
+        Thread thread = new(() =>
+        {
+            try
+            {
+                var sequencer = Sequencer.CurrentThread;
+                Thread.CurrentThread.Interrupt();
+                try
+                {
+                    using var pending = sequencer.Schedule(TimeSpan.FromDays(1), firstWorkPending.Clear);
+                }
+                catch (ThreadInterruptedException)
+                {
+                    interrupted = true;
+                }
+
+                resetAfterInterruption = CurrentThreadSequencer.IsScheduleRequired;
+                using var next = sequencer.Schedule(() => subsequentWorkRan = true);
+                resetAfterWork = CurrentThreadSequencer.IsScheduleRequired;
+                completion.SetResult();
+            }
+            catch (Exception error)
+            {
+                completion.SetException(error);
+            }
+        });
+
+        thread.Start();
+        await completion.Task;
+
+        await Assert.That(interrupted).IsTrue();
+        await Assert.That(firstWorkPending.Count).IsEqualTo(1);
+        await Assert.That(resetAfterInterruption).IsTrue();
+        await Assert.That(subsequentWorkRan).IsTrue();
+        await Assert.That(resetAfterWork).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DeferSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DeferSignalTests.cs
new file mode 100644
index 00000000..0fe5228b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/DeferSignalTests.cs
@@ -0,0 +1,35 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests deferred source creation.</summary>
+public sealed class DeferSignalTests
+{
+    /// <summary>Each subscription creates its source directly without requesting a current-thread trampoline.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Subscribe_WhenRepeated_ThenCreatesOneSourcePerObserver()
+    {
+        const int secondValue = 2;
+        var calls = 0;
+        DeferSignal<int> source = new(() =>
+        {
+            calls++;
+            return Signal.Return(calls);
+        });
+        RecordingWitness<int> first = new();
+        RecordingWitness<int> second = new();
+
+        using var firstSubscription = source.Subscribe(first);
+        using var secondSubscription = source.Subscribe(second);
+
+        await Assert.That(source.IsRequiredSubscribeOnCurrentThread()).IsFalse();
+        await Assert.That(first.Values.SequenceEqual([1])).IsTrue();
+        await Assert.That(second.Values.SequenceEqual([secondValue])).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DelayableNotificationSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DelayableNotificationSignalTests.cs
index cecc592f..2d693213 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/DelayableNotificationSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/DelayableNotificationSignalTests.cs
@@ -103,6 +103,32 @@ public async Task ObserverStateAndDisposal()
         await Assert.That(signal.IsDisposed).IsTrue();
     }
 
+    /// <summary>Completion drops a pending batch, ignores repeated terminals, and is replayed to late subscribers.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnCompleted_Repeated_DropsBufferAndCompletesLateSubscribers()
+    {
+        using DelayableNotificationSignal<int> signal = new(static () => true, static items => items);
+        RecordingWitness<int> observer = new();
+        using var subscription = signal.Subscribe(observer);
+        signal.Flush();
+        signal.OnNext(1);
+        signal.OnCompleted();
+
+        signal.OnCompleted();
+        signal.OnError(new InvalidOperationException("late"));
+        signal.Flush();
+        RecordingWitness<int> late = new();
+        using var lateSubscription = signal.Subscribe(late);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Completed).IsEqualTo(1);
+        await Assert.That(observer.Errors.Count).IsEqualTo(0);
+        await Assert.That(late.Values.Count).IsEqualTo(0);
+        await Assert.That(late.Completed).IsEqualTo(1);
+        await Assert.That(late.Errors.Count).IsEqualTo(0);
+    }
+
     /// <summary>The factory helpers build working signal instances.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DisposedMarkerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DisposedMarkerTests.cs
new file mode 100644
index 00000000..1776a134
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/DisposedMarkerTests.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the terminal subscription marker.</summary>
+public class DisposedMarkerTests
+{
+    /// <summary>Disposing a terminal marker is harmless even when repeated.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Dispose_Repeated_DoesNotThrow()
+    {
+        DisposedMarker marker = new();
+        await Assert.That(() =>
+        {
+            marker.Dispose();
+            marker.Dispose();
+        }).ThrowsNothing();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/DistinctByWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/DistinctByWitnessTests.cs
new file mode 100644
index 00000000..b5499b0e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/DistinctByWitnessTests.cs
@@ -0,0 +1,46 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the distinct-key observer's terminal and failure handling.</summary>
+public class DistinctByWitnessTests
+{
+    /// <summary>A failed value callback propagates its exception and releases the source.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnNext_ObserverThrows_DisposesSubscription()
+    {
+        RecordingDisposable subscription = new();
+        using DistinctByWitness<int, int> witness = new(new ThrowingWitness<int>(throwOnNext: true), static value => value, null);
+        witness.SetSubscription(subscription);
+
+        await Assert.That(() => witness.OnNext(1)).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>The first source error ends distinct-key delivery and releases its subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_ForwardsOnceAndIgnoresLaterNotifications()
+    {
+        RecordingWitness<int> observer = new();
+        RecordingDisposable subscription = new();
+        using DistinctByWitness<int, int> witness = new(observer, static value => value, null);
+        witness.SetSubscription(subscription);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+        witness.OnNext(1);
+        witness.OnError(error);
+        witness.OnCompleted();
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EmitIfQuietSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EmitIfQuietSignalTests.cs
new file mode 100644
index 00000000..c78ce96c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/EmitIfQuietSignalTests.cs
@@ -0,0 +1,28 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests quiet-period value delivery.</summary>
+public sealed class EmitIfQuietSignalTests
+{
+    /// <summary>A zero quiet period forwards every value immediately.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Subscribe_WhenDueTimeIsZero_ThenForwardsEveryValue()
+    {
+        const int secondValue = 2;
+        RecordingWitness<int> observer = new();
+        EmitIfQuietSignal<int> source = new(Signal.Sequence(1, secondValue), TimeSpan.Zero, Sequencer.Immediate);
+
+        using var subscription = source.Subscribe(observer);
+
+        await Assert.That(observer.Values.SequenceEqual([1, secondValue])).IsTrue();
+        await Assert.That(observer.Completed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EmptySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EmptySignalTests.cs
new file mode 100644
index 00000000..ed373f98
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/EmptySignalTests.cs
@@ -0,0 +1,27 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests empty signal completion.</summary>
+public sealed class EmptySignalTests
+{
+    /// <summary>The immediate sequencer completes inline without requesting a current-thread trampoline.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Subscribe_WhenImmediate_ThenCompletesInline()
+    {
+        EmptySignal<int> source = new(Sequencer.Immediate);
+        RecordingWitness<int> observer = new();
+
+        using var subscription = source.Subscribe(observer);
+
+        await Assert.That(source.IsRequiredSubscribeOnCurrentThread()).IsFalse();
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
index e0289f27..ff94fc3d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncSubscriptionTests.cs
@@ -36,4 +36,107 @@ public async Task ExternalCancellationDuringTheFactoryForwardsCancellationAndDro
         await Assert.That(witness.Errors.Count).IsEqualTo(1);
         await Assert.That(witness.Errors[0]).IsTypeOf<TaskCanceledException>();
     }
+
+    /// <summary>A canceled factory task forwards external cancellation even if another callback interrupted notification.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task Start_InterruptedCancellationCallbacks_ForwardsCancellationOnce()
+    {
+        using CancellationTokenSource externalCancellation = new();
+        RecordingWitness<int> witness = new();
+        InvalidOperationException expected = new("cancellation callback failed");
+        Exception? callbackFailure = null;
+        using FromAsyncSubscription<int> subscription = new(
+            witness,
+            _ =>
+            {
+                using var registration = externalCancellation.Token.UnsafeRegister(static state => throw (Exception)state!, expected);
+                try
+                {
+                    externalCancellation.Cancel(true);
+                }
+                catch (InvalidOperationException error)
+                {
+                    callbackFailure = error;
+                }
+
+                return Task.FromCanceled<int>(externalCancellation.Token);
+            },
+            externalCancellation.Token);
+
+        using var handle = subscription.Start();
+
+        await Assert.That(callbackFailure).IsSameReferenceAs(expected);
+        await Assert.That(witness.Values).IsEmpty();
+        await Assert.That(witness.Completed).IsEqualTo(0);
+        await Assert.That(witness.Errors).Count().IsEqualTo(1);
+        await Assert.That(witness.Errors[0]).IsTypeOf<TaskCanceledException>();
+    }
+
+    /// <summary>A completion helper cannot send a second terminal notification after external cancellation won.</summary>
+    /// <param name="status">The terminal status of the factory task.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(TaskStatus.RanToCompletion)]
+    [Arguments(TaskStatus.Canceled)]
+    [Arguments(TaskStatus.Faulted)]
+    public async Task CompleteSynchronously_ExternalCancellationAlreadyWon_DoesNotNotifyAgain(TaskStatus status)
+    {
+        using CancellationTokenSource externalSource = new();
+        using AsyncSubscriptionLifetime lifetime = new();
+        RecordingWitness<int> observer = new();
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, externalSource.Token);
+        using var linkedSource = cancellation.CreateLinkedSource(lifetime.Token);
+        _ = cancellation.Start();
+        await externalSource.CancelAsync();
+
+        var completed = status switch
+        {
+            TaskStatus.RanToCompletion => FromAsyncSubscription<int>.CompleteSynchronously(
+                FactoryValue,
+                observer,
+                lifetime,
+                cancellation,
+                linkedSource),
+            TaskStatus.Canceled => FromAsyncSubscription<int>.CancelSynchronously(
+                Task.FromCanceled<int>(externalSource.Token),
+                observer,
+                lifetime,
+                cancellation,
+                linkedSource),
+            TaskStatus.Faulted => FromAsyncSubscription<int>.FaultSynchronously(
+                Task.FromException<int>(new InvalidOperationException("task failed")),
+                observer,
+                lifetime,
+                cancellation,
+                linkedSource),
+            _ => false
+        };
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsTypeOf<TaskCanceledException>();
+    }
+
+    /// <summary>Synchronous fault forwarding preserves the original exception, including an empty aggregate.</summary>
+    /// <param name="aggregate">Whether the original failure is an aggregate with no inner exceptions.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task FaultSynchronously_FaultedTask_PreservesOriginalException(bool aggregate)
+    {
+        RecordingWitness<int> observer = new();
+        Exception expected = aggregate ? new AggregateException() : new InvalidOperationException("task failed");
+        using FromAsyncSubscription<int> subscription = new(observer, _ => Task.FromException<int>(expected));
+
+        using var handle = subscription.Start();
+
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(expected);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
index f1d3ab39..026d9524 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromAsyncTaskObservationTests.cs
@@ -44,6 +44,48 @@ public async Task UncancelableTokenRunsFactory()
         await Assert.That(observer.Error).IsNull();
     }
 
+    /// <summary>A task fault is forwarded once and completes the subscription lifetime.</summary>
+    /// <param name="aggregate">Whether the supplied failure is an aggregate with no inner exceptions.</param>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Observe_FaultedTask_ForwardsOriginalFailure(bool aggregate)
+    {
+        using AsyncSubscriptionLifetime lifetime = new();
+        RecordingWitness<int> observer = new();
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, CancellationToken.None);
+        FromAsyncTaskObservation<int> observation = new(observer, lifetime, cancellation, null);
+        Exception expected = aggregate ? new AggregateException() : new InvalidOperationException("task failed");
+
+        observation.Observe(Task.FromException<int>(expected));
+
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(expected);
+        await Assert.That(lifetime.IsCompleted).IsTrue();
+    }
+
+    /// <summary>A fault arriving after disposal does not notify the canceled observer.</summary>
+    /// <returns>The asynchronous test.</returns>
+    [Test]
+    public async Task Observe_DisposedLifetime_DropsTaskFailure()
+    {
+        AsyncSubscriptionLifetime lifetime = new();
+        RecordingWitness<int> observer = new();
+        using FromAsyncExternalCancellation<int> cancellation = new(observer, lifetime, CancellationToken.None);
+        FromAsyncTaskObservation<int> observation = new(observer, lifetime, cancellation, null);
+        lifetime.Dispose();
+
+        observation.Observe(Task.FromException<int>(new InvalidOperationException("task failed")));
+
+        await Assert.That(observer.Values).IsEmpty();
+        await Assert.That(observer.Errors).IsEmpty();
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(lifetime.IsCompleted).IsTrue();
+    }
+
     /// <summary>Throws after recording a value and optionally disposing its lifetime.</summary>
     /// <param name="lifetime">The subscription lifetime.</param>
     /// <param name="dispose">Whether to dispose before throwing.</param>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
index 2b0d01fa..ad551735 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FromEnumerableSignalTests.cs
@@ -69,6 +69,25 @@ public async Task FromEnumerableSignalCoversAllSynchronousFastPaths()
         _ = Assert.Throws<ArgumentNullException>(() => arraySignal.Subscribe(static _ => { }, static ex => { }, null!));
     }
 
+    /// <summary>A cancelled enumeration delivers neither values nor completion and cannot expose an uncancellable fast path.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Subscribe_CancelledToken_StopsBeforeFirstValue()
+    {
+        using CancellationTokenSource cancellation = new();
+        await cancellation.CancelAsync();
+        FromEnumerableSignal<int> signal = new(ExpectedOneTwo, cancellation.Token);
+        RecordingWitness<int> observer = new();
+
+        using var subscription = signal.Subscribe(observer);
+        var canReadDirectly = signal.TryGetReadOnlyValues(out var values);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(canReadDirectly).IsFalse();
+        await Assert.That(values.Count).IsEqualTo(0);
+    }
+
     /// <summary>Creates an iterator-backed enumerable that cannot be indexed.</summary>
     /// <returns>The yielded values.</returns>
     private static IEnumerable<int> YieldValues()
diff --git a/src/tests/ReactiveUI.Primitives.Tests/IgnoreValuesWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/IgnoreValuesWitnessTests.cs
new file mode 100644
index 00000000..be419801
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/IgnoreValuesWitnessTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests forwarding terminal notifications while dropping values.</summary>
+public class IgnoreValuesWitnessTests
+{
+    /// <summary>Errors still reach the observer when values are ignored, and release the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_ForwardsErrorAndDisposesSubscription()
+    {
+        RecordingWitness<int> observer = new();
+        RecordingDisposable subscription = new();
+        using IgnoreValuesWitness<int> witness = new(observer);
+        witness.SetSubscription(subscription);
+        witness.OnNext(1);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/KeepNotNullWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/KeepNotNullWitnessTests.cs
new file mode 100644
index 00000000..e0ec692f
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/KeepNotNullWitnessTests.cs
@@ -0,0 +1,42 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the non-null filter's failure handling.</summary>
+public class KeepNotNullWitnessTests
+{
+    /// <summary>A failed value callback propagates its exception and releases the source.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnNext_ObserverThrows_DisposesSubscription()
+    {
+        RecordingDisposable subscription = new();
+        using KeepNotNullWitness<string> witness = new(new ThrowingWitness<string>(throwOnNext: true));
+        witness.SetSubscription(subscription);
+
+        await Assert.That(() => witness.OnNext("value")).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Errors pass through the filter and release the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_ForwardsErrorAndDisposesSubscription()
+    {
+        RecordingWitness<string> observer = new();
+        RecordingDisposable subscription = new();
+        using KeepNotNullWitness<string> witness = new(observer);
+        witness.SetSubscription(subscription);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/KeepTypeWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/KeepTypeWitnessTests.cs
new file mode 100644
index 00000000..5b262208
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/KeepTypeWitnessTests.cs
@@ -0,0 +1,42 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the type filter's failure handling.</summary>
+public class KeepTypeWitnessTests
+{
+    /// <summary>A failed value callback propagates its exception and releases the source.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnNext_ObserverThrows_DisposesSubscription()
+    {
+        RecordingDisposable subscription = new();
+        using KeepTypeWitness<int> witness = new(new ThrowingWitness<int>(throwOnNext: true));
+        witness.SetSubscription(subscription);
+
+        await Assert.That(() => witness.OnNext(1)).ThrowsExactly<InvalidOperationException>();
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Errors pass through the filter and release the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OnError_ForwardsErrorAndDisposesSubscription()
+    {
+        RecordingWitness<int> observer = new();
+        RecordingDisposable subscription = new();
+        using KeepTypeWitness<int> witness = new(observer);
+        witness.SetSubscription(subscription);
+        InvalidOperationException error = new("source");
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+        await Assert.That(subscription.DisposeCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.SubscriptionDisposal.cs b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.SubscriptionDisposal.cs
new file mode 100644
index 00000000..f67bb4fb
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.SubscriptionDisposal.cs
@@ -0,0 +1,146 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests disposal during scheduled operator callbacks.</summary>
+public partial class LinqExtensionsTests
+{
+    /// <summary>Disposal before an accepted inner subscription starts prevents subscribing to that source.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task FlatMap_DisposedBeforeInnerSubscribe_DoesNotAttachInnerSource()
+    {
+        using Signal<int> source = new();
+        using Signal<int> inner = new();
+        RecordingWitness<int> observer = new();
+        LinqExtensions.FlatMapCoordinator<int, int> coordinator = new(source, _ => inner, observer);
+        using var subscription = coordinator.Run();
+
+        coordinator.Dispose();
+        coordinator.SubscribeInner(inner);
+        inner.OnNext(1);
+
+        await Assert.That(source.HasObservers).IsFalse();
+        await Assert.That(inner.HasObservers).IsFalse();
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+    }
+
+    /// <summary>A probe disposes the timer returned after an inline callback has already disposed the subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Probe_DisposedDuringInlineTick_DisposesLateTimerHandle()
+    {
+        const int IgnoredValue = 2;
+        InlineProbeSequencer sequencer = new();
+        using Signal<int> source = new();
+        List<int> values = [];
+        IDisposable? subscription = null;
+        subscription = source.Probe(TimeSpan.Zero, sequencer).Subscribe(value =>
+        {
+            values.Add(value);
+            subscription!.Dispose();
+        });
+        using var cleanup = subscription;
+
+        source.OnNext(1);
+        source.OnNext(IgnoredValue);
+
+        await Assert.That(values.SequenceEqual([1])).IsTrue();
+        await Assert.That(source.HasObservers).IsFalse();
+        await Assert.That(sequencer.ScheduledItemDisposed).IsTrue();
+    }
+
+    /// <summary>A terminal callback during a timer's clock read prevents the captured value from following the error.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Calm_SourceErrorsDuringClockRead_DropsCapturedValue()
+    {
+        ClockCallbackSequencer sequencer = new();
+        using Signal<int> source = new();
+        RecordingWitness<int> observer = new();
+        using var subscription = source.Calm(TimeSpan.Zero, sequencer).Subscribe(observer);
+        source.OnNext(1);
+        InvalidOperationException error = new("source");
+        sequencer.OnClockRead = () => source.OnError(error);
+
+        sequencer.RunPending();
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+        await Assert.That(observer.Errors.Single()).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+    }
+
+    /// <summary>Runs the scheduled probe immediately and retains its cancellation state for inspection.</summary>
+    private sealed class InlineProbeSequencer : ISequencer
+    {
+        /// <summary>The item executed inline.</summary>
+        private IWorkItem? _item;
+
+        /// <inheritdoc/>
+        public DateTimeOffset Now => DateTimeOffset.UnixEpoch;
+
+        /// <inheritdoc/>
+        public long Timestamp => 0;
+
+        /// <summary>Gets whether the executed item was cancelled after scheduling returned.</summary>
+        internal bool ScheduledItemDisposed => _item is IsDisposed { IsDisposed: true };
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item)
+        {
+            _item = item;
+            item.Execute();
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Schedule(IWorkItem item, long dueTimestamp) => Schedule(item);
+    }
+
+    /// <summary>Runs a source terminal callback during the next clock read inside a manually driven timer.</summary>
+    private sealed class ClockCallbackSequencer : ISequencer
+    {
+        /// <summary>The timer waiting for explicit execution.</summary>
+        private IWorkItem? _pending;
+
+        /// <inheritdoc/>
+        public DateTimeOffset Now
+        {
+            get
+            {
+                var callback = OnClockRead;
+                OnClockRead = null;
+                callback?.Invoke();
+                return DateTimeOffset.UnixEpoch;
+            }
+        }
+
+        /// <inheritdoc/>
+        public long Timestamp => 0;
+
+        /// <summary>Gets or sets the callback run on the next clock read.</summary>
+        internal Action? OnClockRead { get; set; }
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item) => _pending = item;
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Schedule(IWorkItem item, long dueTimestamp) => Schedule(item);
+
+        /// <summary>Executes the pending timer once.</summary>
+        internal void RunPending()
+        {
+            var item = _pending;
+            _pending = null;
+            item!.Execute();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.cs
index 5cd7c3db..29b0ef57 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/LinqExtensionsTests.cs
@@ -9,6 +9,27 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Verifies miscellaneous Primitives extension contracts.</summary>
 public partial class LinqExtensionsTests
 {
+    /// <summary>The wrapper owns its disposable and invokes its optional callback before releasing it.</summary>
+    /// <param name="withCallback">Whether the wrapper includes a disposal callback.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task DisposeWith_WhenDisposedTwice_ThenReleasesTheResourceOnce(bool withCallback)
+    {
+        const string disposalEvent = "dispose";
+        List<string> events = [];
+        ActionDisposable resource = new(() => events.Add(disposalEvent));
+        var wrapper = withCallback
+            ? resource.DisposeWith(() => events.Add("callback"))
+            : resource.DisposeWith();
+
+        wrapper.Dispose();
+        wrapper.Dispose();
+
+        await Assert.That(events.SequenceEqual(withCallback ? ["callback", disposalEvent] : [disposalEvent])).IsTrue();
+    }
+
     /// <summary>Verifies DisposeWith preserves the concrete type and tracks the original disposable.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
index 2adea242..7a49592f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/LoopSignalTests.cs
@@ -2,6 +2,8 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Signals;
 
 namespace ReactiveUI.Primitives.Tests;
@@ -31,4 +33,24 @@ public async Task LoopBoundedByTakeRepeatsTheValueAndStops()
         await Assert.That(values.SequenceEqual(ExpectedValues)).IsTrue();
         await Assert.That(completions).IsEqualTo(1);
     }
+
+    /// <summary>A direct subscription stops recursion when its observer disposes it during the first value.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Subscribe_DisposedDuringValue_StopsRecursiveLoop()
+    {
+        List<int> values = [];
+        IDisposable? subscription = null;
+        using var scheduled = Sequencer.CurrentThread.Schedule(() =>
+        {
+            subscription = new LoopSignal<int>(RepeatedValue).Subscribe(Witness.Create<int>(value =>
+            {
+                values.Add(value);
+                subscription!.Dispose();
+            }));
+        });
+        using var cleanup = subscription;
+
+        await Assert.That(values.SequenceEqual([RepeatedValue])).IsTrue();
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ObserverHandlerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ObserverHandlerTests.cs
new file mode 100644
index 00000000..5b129057
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ObserverHandlerTests.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests observer detachment from an asynchronous signal.</summary>
+public class ObserverHandlerTests
+{
+    /// <summary>A subscription handle can be disposed repeatedly without detaching another observer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Dispose_Repeated_PreservesOtherSubscriptions()
+    {
+        using AsyncSignal<int> signal = new();
+        RecordingWitness<int> detached = new();
+        RecordingWitness<int> remaining = new();
+        var first = signal.Subscribe(detached);
+        using var second = signal.Subscribe(remaining);
+
+        first.Dispose();
+        first.Dispose();
+        signal.OnNext(1);
+        signal.OnCompleted();
+
+        await Assert.That(detached.Values.Count).IsEqualTo(0);
+        await Assert.That(detached.Completed).IsEqualTo(0);
+        await Assert.That(remaining.Values.Single()).IsEqualTo(1);
+        await Assert.That(remaining.Completed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
new file mode 100644
index 00000000..135f7cb4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests read-only state mirroring.</summary>
+public class ReadOnlyStateTests
+{
+    /// <summary>The changed stream replays the initial state and forwards subsequent updates.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Changed_ReplaysInitialValueAndTracksSource()
+    {
+        const int UpdatedValue = 2;
+        using Signal<int> source = new();
+        using ReadOnlyState<int> state = new(source, 1);
+        RecordingWitness<int> observer = new();
+        using var subscription = state.Changed.Subscribe(observer);
+
+        source.OnNext(UpdatedValue);
+
+        await Assert.That(observer.Values.SequenceEqual([1, UpdatedValue])).IsTrue();
+        await Assert.That(state.Value).IsEqualTo(UpdatedValue);
+    }
+
+    /// <summary>The debugger display leaves the cached value intact.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_PreservesCachedValue()
+    {
+        using Signal<int> source = new();
+        using ReadOnlyState<int> state = new(source, 1);
+        await Assert.That(GetDebuggerDisplay(state)).IsEqualTo(state.ToString());
+        await Assert.That(state.Value).IsEqualTo(1);
+    }
+
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="state">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
+#if NET9_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static string GetDebuggerDisplay(ReadOnlyState<int> state) => DebuggerAccessor<int>.Read(state);
+
+    /// <summary>Matches the target type's generic context required by .NET 9 and later.</summary>
+    /// <typeparam name="T">The state's value type.</typeparam>
+    private static class DebuggerAccessor<T>
+    {
+        /// <summary>Invokes the getter evaluated by the debugger.</summary>
+        /// <param name="state">The state to display.</param>
+        /// <returns>The debugger text.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+        internal static extern string Read(ReadOnlyState<T> state);
+    }
+#else
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(ReadOnlyState<int> state);
+#endif
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxVoidTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxVoidTests.cs
new file mode 100644
index 00000000..8dab8683
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/RxVoidTests.cs
@@ -0,0 +1,27 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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 ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the unit value's debugger representation.</summary>
+public sealed class RxVoidTests
+{
+    /// <summary>The debugger renders the unit value using its normal textual representation.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DebuggerDisplay_WhenDefault_ThenShowsUnit()
+    {
+        var value = RxVoid.Default;
+
+        await Assert.That(ReadDebuggerDisplay(ref value)).IsEqualTo("()");
+    }
+
+    /// <summary>Reads the property evaluated by the debugger.</summary>
+    /// <param name="value">The unit value.</param>
+    /// <returns>The debugger representation.</returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string ReadDebuggerDisplay(ref RxVoid value);
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
new file mode 100644
index 00000000..638454ed
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated 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;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests the scheduled queue's debugger representation.</summary>
+public sealed class SequencerQueueTests
+{
+    /// <summary>The debugger can render an empty queue without inspecting any scheduled items.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task DebuggerDisplay_WhenEmpty_ThenShowsTheQueue()
+    {
+        SequencerQueue<int> queue = new();
+
+        await Assert.That(ReadDebuggerDisplay(queue)).IsEqualTo(queue.ToString());
+    }
+
+    /// <summary>Reads the property evaluated by the debugger.</summary>
+    /// <param name="queue">The scheduled queue.</param>
+    /// <returns>The debugger representation.</returns>
+#if NET9_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static string ReadDebuggerDisplay(SequencerQueue<int> queue) => DebuggerAccessor<int>.Read(queue);
+
+    /// <summary>Matches the target type's generic context required by .NET 9 and later.</summary>
+    /// <typeparam name="T">The queue's absolute time type.</typeparam>
+    private static class DebuggerAccessor<T>
+        where T : IComparable<T>
+    {
+        /// <summary>Invokes the getter evaluated by the debugger.</summary>
+        /// <param name="queue">The scheduled queue.</param>
+        /// <returns>The debugger text.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+        internal static extern string Read(SequencerQueue<T> queue);
+    }
+#else
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string ReadDebuggerDisplay(SequencerQueue<int> queue);
+#endif
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Durations.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Durations.cs
new file mode 100644
index 00000000..5f5e28de
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.Durations.cs
@@ -0,0 +1,38 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests monotonic duration conversion.</summary>
+public partial class SequencerTests
+{
+    /// <summary>The largest timestamp duration saturates when it exceeds TimeSpan's range.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task ToTimeSpanDelta_WhenTimestampIsMaximum_ThenClampsToTheDurationRange()
+    {
+        var ticks = decimal.Ceiling(((decimal)long.MaxValue * TimeSpan.TicksPerSecond) / System.Diagnostics.Stopwatch.Frequency);
+        var expected = TimeSpan.FromTicks((long)Math.Min(ticks, TimeSpan.MaxValue.Ticks));
+
+        await Assert.That(Sequencer.ToTimeSpanDelta(long.MaxValue)).IsEqualTo(expected);
+    }
+
+    /// <summary>The absolute action overload queues work until its virtual deadline.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Schedule_WhenAbsoluteDeadlineArrives_ThenRunsTheAction()
+    {
+        VirtualClock clock = new();
+        ISequencer sequencer = clock;
+        List<int> pending = [1];
+        var due = clock.Now.AddTicks(1);
+        using var subscription = sequencer.Schedule(due, pending.Clear);
+
+        await Assert.That(pending.Count).IsEqualTo(1);
+        clock.AdvanceTo(due);
+        await Assert.That(pending.Count).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
index e387c2d7..ff8a1ccf 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerTests.WorkItems.cs
@@ -60,6 +60,7 @@ public async Task ActionWorkItemDoesNotRunAfterCancellation()
 
         item.Execute();
         item.Dispose();
+        item.Dispose();
         item.Execute();
 
         await Assert.That(ran).IsEqualTo(1);
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalExtensionsTests.cs
new file mode 100644
index 00000000..502ffc24
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalExtensionsTests.cs
@@ -0,0 +1,45 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests task cancellation and result delivery.</summary>
+public sealed class SignalExtensionsTests
+{
+    /// <summary>The action-free overload consumes cancellation from a task without a result.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task HandleCancellation_WhenTaskIsCanceled_ThenCompletesNormally()
+    {
+        using CancellationTokenSource cancellation = new();
+        await cancellation.CancelAsync();
+        var task = Task.FromCanceled(cancellation.Token);
+
+        var handled = task.HandleCancellation();
+        await handled;
+
+        await Assert.That(handled.IsCompletedSuccessfully).IsTrue();
+    }
+
+    /// <summary>Cancellation ends the wait while the original task remains free to finish later.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task WhenCancelled_WhenTokenWins_ThenPreservesTheTokenAndOriginalTask()
+    {
+        const int result = 7;
+        using CancellationTokenSource cancellation = new();
+        TaskCompletionSource<int> source = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        var waiting = source.Task.WhenCancelled(cancellation.Token);
+
+        await cancellation.CancelAsync();
+        var error = await Assert.That(async () => await waiting).Throws<TaskCanceledException>();
+
+        await Assert.That(error!.CancellationToken).IsEqualTo(cancellation.Token);
+        await Assert.That(source.Task.IsCompleted).IsFalse();
+        source.SetResult(result);
+        await Assert.That(await source.Task).IsEqualTo(result);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
index 40be6267..733fc91a 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFactoriesTests.DefaultSequencer.cs
@@ -91,4 +91,27 @@ public async Task EveryTicksWhenTheSequencerRuns()
         sequencer.RunPending();
         await Assert.That(witness.Values.SequenceEqual([0L, 1L])).IsTrue();
     }
+
+    /// <summary>The recurring factory without a scheduler creates a lazy thread-pool signal.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Every_WithoutScheduler_CreatesLazyRecurringSignal()
+    {
+        var signal = await Assert.That(Signal.Every(ShortExpiry)).IsTypeOf<EverySignal>().And.IsNotNull();
+
+        await Assert.That(signal.IsRequiredSubscribeOnCurrentThread()).IsFalse();
+    }
+
+    /// <summary>The expiry factory without a scheduler validates its source and preserves lazy subscription.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Expire_WithoutScheduler_CreatesLazyTimeoutSignal()
+    {
+        using Signal<int> source = new();
+        var signal = await Assert.That(Signal.Expire(source, ShortExpiry)).IsTypeOf<ExpireSignal<int>>().And.IsNotNull();
+
+        await Assert.That(signal.IsRequiredSubscribeOnCurrentThread()).IsFalse();
+        await Assert.That(source.HasObservers).IsFalse();
+        await Assert.That(static () => Signal.Expire<int>(null!, ShortExpiry)).ThrowsExactly<ArgumentNullException>();
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
index 3252fc17..55733658 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
@@ -34,6 +34,17 @@ public class StateSignalTests
     /// <summary>Expected projected read-only state values.</summary>
     private static readonly string[] ExpectedReadOnlyValues = ["v:10", "v:11", "v:11"];
 
+    /// <summary>The debugger display leaves the latest value and observer set intact.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DebuggerDisplay_PreservesSignalState()
+    {
+        using StateSignal<int> signal = new(InitialStateValue);
+        await Assert.That(GetDebuggerDisplay(signal)).IsEqualTo(signal.ToString());
+        await Assert.That(signal.Value).IsEqualTo(InitialStateValue);
+        await Assert.That(signal.HasObservers).IsFalse();
+    }
+
     /// <summary>A read-only projection rejects a null error.</summary>
     [Test]
     public void ReadOnlyStateProjectionValidatesError()
@@ -223,6 +234,28 @@ public async Task DisposedReadOnlyStateProjectionRejectsReadsAndSubscriptions()
         await Assert.That(source.Value).IsEqualTo(UpdatedStateValue);
     }
 
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="signal">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
+#if NET9_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static string GetDebuggerDisplay(StateSignal<int> signal) => DebuggerAccessor<int>.Read(signal);
+
+    /// <summary>Matches the target type's generic context required by .NET 9 and later.</summary>
+    /// <typeparam name="T">The signal's value type.</typeparam>
+    private static class DebuggerAccessor<T>
+    {
+        /// <summary>Invokes the getter evaluated by the debugger.</summary>
+        /// <param name="signal">The signal to display.</param>
+        /// <returns>The debugger text.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+        internal static extern string Read(StateSignal<T> signal);
+    }
+#else
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(StateSignal<int> signal);
+#endif
+
     /// <summary>Records observer notifications.</summary>
     /// <typeparam name="T">The observed value type.</typeparam>
     private sealed class Recorder<T> : IObserver<T>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SynchronizedSequencerQueueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SynchronizedSequencerQueueTests.cs
new file mode 100644
index 00000000..040c7015
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SynchronizedSequencerQueueTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests cancellation-aware queue traversal.</summary>
+public sealed class SynchronizedSequencerQueueTests
+{
+    /// <summary>Cancelled head entries are discarded while live work remains queued.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task GetNextLive_WhenHeadIsCanceled_ThenSkipsItWithoutRemovingLiveWork()
+    {
+        SynchronizedSequencerQueue<int> queue = new();
+        var canceled = ScheduledItem.Create(Sequencer.Immediate, 0, static (_, _) => EmptyDisposable.Instance, 0);
+        var live = ScheduledItem.Create(Sequencer.Immediate, 0, static (_, _) => EmptyDisposable.Instance, 1);
+        queue.Enqueue(canceled);
+        queue.Enqueue(live);
+        canceled.Cancel();
+
+        await Assert.That(queue.GetNextLive()).IsSameReferenceAs(live);
+        await Assert.That(queue.GetNextLive()).IsSameReferenceAs(live);
+        queue.Remove(live);
+        await Assert.That(queue.GetNextLive()).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ThrowSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ThrowSignalTests.cs
new file mode 100644
index 00000000..c65bd6b3
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ThrowSignalTests.cs
@@ -0,0 +1,29 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests scheduled error delivery.</summary>
+public sealed class ThrowSignalTests
+{
+    /// <summary>An immediate error is forwarded inline without a second terminal notification.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task Subscribe_WhenImmediate_ThenForwardsTheErrorInline()
+    {
+        InvalidOperationException error = new("source failure");
+        ThrowSignal<int> source = new(error, Sequencer.Immediate);
+        RecordingWitness<int> observer = new();
+
+        using var subscription = source.Subscribe(observer);
+
+        await Assert.That(source.IsRequiredSubscribeOnCurrentThread()).IsFalse();
+        await Assert.That(observer.Errors.Count).IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
+        await Assert.That(observer.Completed).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalWitnessTests.cs
new file mode 100644
index 00000000..33208c88
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/TimeIntervalWitnessTests.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Core;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests timestamped notification teardown.</summary>
+public sealed class TimeIntervalWitnessTests
+{
+    /// <summary>A source error is forwarded unchanged and releases its subscription.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task OnError_WhenSubscribed_ThenForwardsTheErrorAndDisposes()
+    {
+        RecordingWitness<TimeInterval<int>> observer = new();
+        using TimeIntervalWitness<int> witness = new(observer, new VirtualClock());
+        BooleanDisposable subscription = new();
+        InvalidOperationException error = new("source failure");
+        witness.SetSubscription(subscription);
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Errors.Count).IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
+        await Assert.That(subscription.IsDisposed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/UnsparkWitnessTests.cs b/src/tests/ReactiveUI.Primitives.Tests/UnsparkWitnessTests.cs
new file mode 100644
index 00000000..d3329b38
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/UnsparkWitnessTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests dematerialized notification teardown.</summary>
+public sealed class UnsparkWitnessTests
+{
+    /// <summary>An error in the notification source is forwarded and releases its subscription.</summary>
+    /// <returns>The test operation.</returns>
+    [Test]
+    public async Task OnError_WhenSubscribed_ThenForwardsTheErrorAndDisposes()
+    {
+        RecordingWitness<int> observer = new();
+        using UnsparkWitness<int> witness = new(observer);
+        BooleanDisposable subscription = new();
+        InvalidOperationException error = new("source failure");
+        witness.SetSubscription(subscription);
+
+        witness.OnError(error);
+
+        await Assert.That(observer.Errors.Count).IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(error);
+        await Assert.That(subscription.IsDisposed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/VirtualTimeSequencerExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/VirtualTimeSequencerExtensionsTests.cs
new file mode 100644
index 00000000..4b208e03
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/VirtualTimeSequencerExtensionsTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests action scheduling through the generic virtual-time interface.</summary>
+public sealed class VirtualTimeSequencerExtensionsTests
+{
+    /// <summary>Both generic overloads deliver actions at the requested virtual time.</summary>
+    /// <param name="absolute">Whether to use the absolute-time overload.</param>
+    /// <returns>The test operation.</returns>
+    [Test]
+    [Arguments(false)]
+    [Arguments(true)]
+    public async Task Schedule_WhenDeadlineArrives_ThenInvokesTheAction(bool absolute)
+    {
+        var sequencer = MinimalVirtualClock.Create();
+        List<int> pending = [1];
+        using var subscription = absolute
+            ? sequencer.ScheduleAbsolute(1L, pending.Clear)
+            : sequencer.ScheduleRelative(1L, pending.Clear);
+
+        await Assert.That(pending.Count).IsEqualTo(1);
+        sequencer.AdvanceBy(1L);
+        await Assert.That(pending.Count).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
index 65079628..3f0c0ca9 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Reactive.Tests/ControlSequencerTests.cs
@@ -22,6 +22,18 @@ public sealed class ControlSequencerTests
     public async Task ConstructorRejectsNullControl() =>
         await Assert.That(static () => new ControlSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
+    /// <summary>The public constructor retains the control without creating its native window handle.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Constructor_RetainsControlWithoutCreatingHandle()
+    {
+        using var control = CreateControl();
+        ControlSequencer scheduler = new(control);
+
+        await Assert.That(scheduler.Control).IsSameReferenceAs(control);
+        await Assert.That(control.IsHandleCreated).IsFalse();
+    }
+
     /// <summary>Work rejected before handle creation is retried in order when the handle becomes ready.</summary>
     /// <returns>The test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
index ca1b0fee..d5a8b5da 100644
--- a/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinForms.Tests/ControlSequencerTests.cs
@@ -22,6 +22,25 @@ public sealed class ControlSequencerTests
     public async Task ConstructorRejectsNullControl() =>
         await Assert.That(static () => new ControlSequencer(null!)).ThrowsExactly<ArgumentNullException>();
 
+    /// <summary>The public constructor retains the control and exposes its clock without creating a handle.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Constructor_RetainsControlWithoutCreatingHandle()
+    {
+        using var control = CreateControl();
+        ControlSequencer sequencer = new(control);
+        var before = System.Diagnostics.Stopwatch.GetTimestamp();
+        var timestamp = sequencer.Timestamp;
+        var after = System.Diagnostics.Stopwatch.GetTimestamp();
+
+        await Assert.That(sequencer.Control).IsSameReferenceAs(control);
+        await Assert.That(control.IsHandleCreated).IsFalse();
+        await Assert.That(sequencer.Now.Offset).IsEqualTo(TimeSpan.Zero);
+        await Assert.That(timestamp).IsGreaterThanOrEqualTo(before);
+        await Assert.That(timestamp).IsLessThanOrEqualTo(after);
+        await Assert.That(GetDebuggerDisplay(sequencer)).IsEqualTo(sequencer.ToString());
+    }
+
     /// <summary>Work rejected before handle creation is retried in order when the handle becomes ready.</summary>
     /// <returns>The test operation.</returns>
     [Test]
@@ -163,6 +182,12 @@ public async Task DelayedScheduleWaitsForItsCallback(bool cancel)
         await Assert.That(calls).IsEqualTo(cancel ? 0 : 1);
     }
 
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="sequencer">The sequencer to display.</param>
+    /// <returns>The debugger display text.</returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
+    private static extern string GetDebuggerDisplay(ControlSequencer sequencer);
+
     /// <summary>Creates a control without changing the caller's synchronization context.</summary>
     /// <returns>The control.</returns>
     private static Control CreateControl()
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
index bf09a77b..ca82101c 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/DispatcherQueueSequencerTests.cs
@@ -32,6 +32,29 @@ public async Task ConstructorRejectsNullDispatcherQueue()
             .ThrowsExactly<ArgumentNullException>();
     }
 
+    /// <summary>Public constructors retain a live queue and the selected priority.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Constructors_RetainDispatcherQueueAndPriority()
+    {
+        var controller = DispatcherQueueController.CreateOnDedicatedThread();
+        try
+        {
+            var queue = controller.DispatcherQueue;
+            DispatcherQueueSequencer defaults = new(queue);
+            DispatcherQueueSequencer selected = new(queue, DispatcherQueuePriority.High);
+
+            await Assert.That(defaults.DispatcherQueue).IsSameReferenceAs(queue);
+            await Assert.That(defaults.Priority).IsEqualTo(DispatcherQueuePriority.Normal);
+            await Assert.That(selected.DispatcherQueue).IsSameReferenceAs(queue);
+            await Assert.That(selected.Priority).IsEqualTo(DispatcherQueuePriority.High);
+        }
+        finally
+        {
+            await controller.ShutdownQueueAsync();
+        }
+    }
+
     /// <summary>Queued actions preserve order and cancellation until the drain runs.</summary>
     /// <returns>The test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
index 658a1383..8f903a21 100644
--- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/DispatcherQueueSequencerTests.cs
@@ -33,6 +33,34 @@ public async Task ConstructorRejectsNullDispatcherQueue()
             .ThrowsExactly<ArgumentNullException>();
     }
 
+    /// <summary>Public constructors retain a live queue and the selected priority.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Constructors_RetainDispatcherQueueAndPriority()
+    {
+        var controller = DispatcherQueueController.CreateOnDedicatedThread();
+        try
+        {
+            var queue = controller.DispatcherQueue;
+            DispatcherQueueSequencer defaults = new(queue);
+            DispatcherQueueSequencer selected = new(queue, DispatcherQueuePriority.High);
+            var before = System.Diagnostics.Stopwatch.GetTimestamp();
+            var timestamp = selected.Timestamp;
+            var after = System.Diagnostics.Stopwatch.GetTimestamp();
+
+            await Assert.That(defaults.DispatcherQueue).IsSameReferenceAs(queue);
+            await Assert.That(defaults.Priority).IsEqualTo(DispatcherQueuePriority.Normal);
+            await Assert.That(selected.DispatcherQueue).IsSameReferenceAs(queue);
+            await Assert.That(selected.Priority).IsEqualTo(DispatcherQueuePriority.High);
+            await Assert.That(timestamp).IsGreaterThanOrEqualTo(before);
+            await Assert.That(timestamp).IsLessThanOrEqualTo(after);
+        }
+        finally
+        {
+            await controller.ShutdownQueueAsync();
+        }
+    }
+
     /// <summary>Queued work preserves order and cancellation until the drain runs.</summary>
     /// <returns>The test operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
index ee1bedec..ebd787c7 100644
--- a/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Wpf.Tests/DispatcherSequencerTests.cs
@@ -41,6 +41,20 @@ public async Task ConstructorRetainsDispatcherAndPriority()
         await Assert.That(sequencer.DebuggerDisplay).IsEqualTo(typeof(DispatcherSequencer).FullName);
     }
 
+    /// <summary>The dispatcher sequencer shares the monotonic timestamp scale used by scheduled work.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task Timestamp_UsesSharedSequencerClock()
+    {
+        DispatcherSequencer sequencer = new(Dispatcher.CurrentDispatcher);
+        var before = System.Diagnostics.Stopwatch.GetTimestamp();
+        var timestamp = sequencer.Timestamp;
+        var after = System.Diagnostics.Stopwatch.GetTimestamp();
+
+        await Assert.That(timestamp).IsGreaterThanOrEqualTo(before);
+        await Assert.That(timestamp).IsLessThanOrEqualTo(after);
+    }
+
     /// <summary>A posted batch preserves order and skips cancelled work.</summary>
     /// <returns>The test operation.</returns>
     [Test]

From 38138a2b0e93db240211151d752ed8e4c926a7bb Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 13 Sep 2026 01:39:56 +1000
Subject: [PATCH 11/11] Fix build issue

---
 src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs | 5 ++++-
 src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs  | 5 ++++-
 src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs | 5 ++++-
 src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs    | 5 ++++-
 4 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
index 36509ef5..27013882 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BehaviorSignalTests.cs
@@ -265,10 +265,10 @@ public async Task Subscribe_ReentrantOnNext_FollowsTheInitialValue()
         await Assert.That(values.SequenceEqual([0, 1])).IsTrue();
     }
 
+#if NET9_0_OR_GREATER
     /// <summary>Invokes the getter used by the debugger without reflection.</summary>
     /// <param name="signal">The instance to display.</param>
     /// <returns>The debugger display text.</returns>
-#if NET9_0_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static string? GetDebuggerDisplay(BehaviorSignal<int> signal) => DebuggerAccessor<int>.Read(signal);
 
@@ -283,6 +283,9 @@ private static class DebuggerAccessor<T>
         internal static extern string? Read(BehaviorSignal<T> signal);
     }
 #else
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="signal">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
     private static extern string? GetDebuggerDisplay(BehaviorSignal<int> signal);
 #endif
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
index 135f7cb4..4b9fea5e 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReadOnlyStateTests.cs
@@ -38,10 +38,10 @@ public async Task DebuggerDisplay_PreservesCachedValue()
         await Assert.That(state.Value).IsEqualTo(1);
     }
 
+#if NET9_0_OR_GREATER
     /// <summary>Invokes the getter used by the debugger without reflection.</summary>
     /// <param name="state">The instance to display.</param>
     /// <returns>The debugger display text.</returns>
-#if NET9_0_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static string GetDebuggerDisplay(ReadOnlyState<int> state) => DebuggerAccessor<int>.Read(state);
 
@@ -56,6 +56,9 @@ private static class DebuggerAccessor<T>
         internal static extern string Read(ReadOnlyState<T> state);
     }
 #else
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="state">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
     private static extern string GetDebuggerDisplay(ReadOnlyState<int> state);
 #endif
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
index 638454ed..ee7d125d 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerQueueTests.cs
@@ -20,10 +20,10 @@ public async Task DebuggerDisplay_WhenEmpty_ThenShowsTheQueue()
         await Assert.That(ReadDebuggerDisplay(queue)).IsEqualTo(queue.ToString());
     }
 
+#if NET9_0_OR_GREATER
     /// <summary>Reads the property evaluated by the debugger.</summary>
     /// <param name="queue">The scheduled queue.</param>
     /// <returns>The debugger representation.</returns>
-#if NET9_0_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static string ReadDebuggerDisplay(SequencerQueue<int> queue) => DebuggerAccessor<int>.Read(queue);
 
@@ -39,6 +39,9 @@ private static class DebuggerAccessor<T>
         internal static extern string Read(SequencerQueue<T> queue);
     }
 #else
+    /// <summary>Reads the property evaluated by the debugger.</summary>
+    /// <param name="queue">The scheduled queue.</param>
+    /// <returns>The debugger representation.</returns>
     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
     private static extern string ReadDebuggerDisplay(SequencerQueue<int> queue);
 #endif
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
index 55733658..8f6ca1d6 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StateSignalTests.cs
@@ -234,10 +234,10 @@ public async Task DisposedReadOnlyStateProjectionRejectsReadsAndSubscriptions()
         await Assert.That(source.Value).IsEqualTo(UpdatedStateValue);
     }
 
+#if NET9_0_OR_GREATER
     /// <summary>Invokes the getter used by the debugger without reflection.</summary>
     /// <param name="signal">The instance to display.</param>
     /// <returns>The debugger display text.</returns>
-#if NET9_0_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static string GetDebuggerDisplay(StateSignal<int> signal) => DebuggerAccessor<int>.Read(signal);
 
@@ -252,6 +252,9 @@ private static class DebuggerAccessor<T>
         internal static extern string Read(StateSignal<T> signal);
     }
 #else
+    /// <summary>Invokes the getter used by the debugger without reflection.</summary>
+    /// <param name="signal">The instance to display.</param>
+    /// <returns>The debugger display text.</returns>
     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_DebuggerDisplay")]
     private static extern string GetDebuggerDisplay(StateSignal<int> signal);
 #endif