anchor.diff:  /// metadata about the entity (Entity.streamy) to be inaccurate, but will
   /// prevent multiple values from being published on [Stream]s when core [Entity]
   /// data has not changed.
  -class EntityDedupTransformer<T extends Entity>
  -    extends StreamEventTransformer<T, T> {
  +class EntityDedupTransformer<T extends Entity> implements StreamTransformer<T, T> {
  +  final StreamController _controller = new StreamController();
     var _last = null;
   
  -  handleData(T data, EventSink<T> sink) {
  -    if (!Entity.deepEquals(data, _last)) {
  -      sink.add(data);
  -    }
  -    _last = data;
  +  Stream<T> bind(Stream<T> stream) {
  +    stream.listen((T data) {
  +      if (!Entity.deepEquals(data, _last)) {
  +        _controller.add(data);
  +      }
  +      _last = data;
  +    }, onError: _controller.addError, onDone: _controller.close);
  +    return _controller.stream;
     }
   }
   
  
positive.code:         postCallbackCompleter.complete();
        }
      });
      
      // Publish a tracking record for this request (synchronously).
      _controller.add(new TrackedRequest._private(
          request, preCallbackCompleter.future, postCallbackCompleter.future));
      
      // To be called when an event has been processed. Only on the first one, this
      // should complete the future sent on the tracking stream, indicating a response
      // has been processed.
  
negative.code: 
  /// Represents a request that was issued, and allows listening for its completion.
  class TrackedRequest {
  
    /// Request that was issued.
    final Request request;
  
    /// A future that completes before the first response for the request is returned
    /// (may be an error).
    final Future beforeFirstResponse;
  
    /// A future that completes when the first response for the request is returned
    /// (may be an error).
    final Future onFirstResponse;
  
    TrackedRequest._private(this.request, this.beforeFirstResponse, this.onFirstResponse);
  }
  
  /// Provides a global notification of when requests are issued and when they receive
  /// their first response.
  class RequestTrackingTransformer extends RequestStreamTransformer {
  
    final _controller = new StreamController<TrackedRequest>.broadcast(sync: true);
  
    Stream<TrackedRequest> get trackingStream => _controller.stream;
  
    RequestTrackingTransformer();
  
    Stream bind(Request request, Stream responseStream) {
      var sub;
      var preCallbackCompleter = new Completer.sync();
  