anchor.diff:    }
   }
   
  +EventMap _emptyEventMap = new EventMap();
  +
   abstract class Component extends Node {
  -  bool _dirty = true; // components begin dirty because they haven't built.
  -  Node _vdom = null;
  +  bool get _isBuilding => _currentlyBuilding == this;
  +  bool _dirty = true;
  +
  +  Node _built;
     final int _order;
     static int _currentOrder = 0;
     bool _stateful;
  -  static Component _currentlyRendering;
  +  static Component _currentlyBuilding;
   
     Component({ Object key, bool stateful })
         : _stateful = stateful != null ? stateful : false,
  
positive.code:   // needed to get sizing info.
    sky.Node getRoot() => _root;
  
    void _mount(Node parent, sky.ParentNode host, sky.Node insertBefore) {
      _parent = parent;
  
      _syncInternal(host, insertBefore);
  
      didMount();
    }
  
    void _unmount() {
      assert(_vdom != null);
      assert(_root != null);
      _vdom._unmount();
      _vdom = null;
      _root = null;
      _parent = null;
      _defunct = true;
      didUnmount();
    }
  
    bool _syncNode(Node old) {
      Component oldComponent = old as Component;
  
      if (!oldComponent._stateful) {
        _vdom = oldComponent._vdom;
        _syncInternal();
  
        return false;
      }
  
      _stateful = false; // prevent iloop from _syncInternal below.
  
      reflect.copyPublicFields(this, oldComponent);
  
      oldComponent._dirty = true;
      _dirty = false;
  
      oldComponent._syncInternal();
      return true;  // Retain old component
    }
  
    void _syncInternal([sky.Node host, sky.Node insertBefore]) {
      if (!_dirty) {
        assert(_vdom != null);
        return;
      }
  
      var oldRendered = _vdom;
      bool mounting = oldRendered == null;
  
      int lastOrder = _currentOrder;
      _currentOrder = _order;
      _currentlyRendering = this;
      _vdom = build();
      _currentlyRendering = null;
      _currentOrder = lastOrder;
  
      _vdom.events.addAll(events);
  
      _dirty = false;
  
      // TODO(rafaelw): This eagerly removes the old DOM. It may be that a
      // new component was built that could re-use some of it. Consider
      // syncing the new VDOM against the old one.
      if (oldRendered != null &&
          _vdom.runtimeType != oldRendered.runtimeType) {
        var oldRoot = oldRendered._root;
        host = oldRoot.parentNode;
        insertBefore = oldRoot.nextSibling;
        oldRendered._unmount();
        oldRendered = null;
      }
  
      if (_vdom._sync(oldRendered, this, host, insertBefore)) {
        _vdom = oldRendered; // retain stateful component
      }
  
      _root = _vdom._root;
      assert(_vdom._root is sky.Node);
  
      if (mounting) {
        didMount();
      }
    }
  
    void _buildIfDirty() {
      if (_defunct)
        return;
  
      assert(_vdom != null);
  
      var vdom = _vdom;
      while (vdom is Component) {
        vdom = vdom._vdom;
      }
  
      assert(vdom._root != null);
      _syncInternal();
    }
  
    void scheduleBuild() {
  
negative.code: 
    static final Image _emptyImage = new Image();
  
    RenderNode get _emptyNode => _emptyImage;
  
    final String src;
    final int width;
    final int height;
  
    Image({
      Object key,
  