anchor.diff:    // 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);
  +  void _remove() {
  +    assert(_built != null);
       assert(_root != null);
  -    _vdom._unmount();
  -    _vdom = null;
  -    _root = null;
  -    _parent = null;
  -    _defunct = true;
  -    didUnmount();
  -  }
  -
  -  bool _syncNode(Node old) {
  +    _built._remove();
  +    _built = null;
  +    _unmountedComponents.add(this);
  +    super._remove();
  +  }
  +
  +  bool _willSync(Node old) {
       Component oldComponent = old as Component;
  -
  -    if (!oldComponent._stateful) {
  -      _vdom = oldComponent._vdom;
  -      _syncInternal();
  -
  +    if (oldComponent == null || !oldComponent._stateful)
         return false;
  -    }
  -
  -    _stateful = false; // prevent iloop from _syncInternal below.
  -
  +
  +    // Make |this| the "old" Component
  +    _stateful = false;
  +    _built = oldComponent._built;
  +    assert(_built != null);
  +
  +    // Make |oldComponent| the "new" component
       reflect.copyPublicFields(this, oldComponent);
  -
  +    oldComponent._built = null;
       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;
  +    return true;
  +  }
  +
  +  /* There are three cases here:
  +   * 1) Building for the first time:
  +   *      assert(_built == null && old == null)
  +   * 2) Re-building (because a dirty flag got set):
  +   *      assert(_built != null && old == null)
  +   * 3) Syncing against an old version
  +   *      assert(_built == null && old != null)
  +   */
  +  void _sync(Node old, sky.ParentNode host, sky.Node insertBefore) {
  +    assert(!_defunct);
  +    assert(_built == null || old == null);
  +
  +    Component oldComponent = old as Component;
  +
  +    var oldBuilt;
  +    if (oldComponent == null) {
  +      oldBuilt = _built;
  +    } else {
  +      assert(_built == null);
  +      oldBuilt = oldComponent._built;
  +    }
  +
  +    if (oldBuilt == null)
  +      _mountedComponents.add(this);
   
       int lastOrder = _currentOrder;
       _currentOrder = _order;
  -    _currentlyRendering = this;
  -    _vdom = build();
  -    _currentlyRendering = null;
  +    _currentlyBuilding = this;
  +    _built = build();
  +    _currentlyBuilding = null;
       _currentOrder = lastOrder;
   
  -    _vdom.events.addAll(events);
  -
  +    _built = _syncChild(_built, oldBuilt, host, insertBefore);
       _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();
  -    }
  +    _root = _built._root;
  +
  +    _built.events.addAll(events);
  +    _syncEvents(oldComponent != null ? oldComponent.events : _emptyEventMap);
     }
   
     void _buildIfDirty() {
  -    if (_defunct)
  +    if (!_dirty || _defunct)
         return;
   
  -    assert(_vdom != null);
  -
  -    var vdom = _vdom;
  -    while (vdom is Component) {
  -      vdom = vdom._vdom;
  -    }
  -
  -    assert(vdom._root != null);
  -    _syncInternal();
  +    assert(_root != null);
  +    _sync(null, _root.parentNode, _root.nextSibling);
     }
   
     void scheduleBuild() {
  
positive.code: 
      if (href != oldAnchor.href)
        skyAnchor.href = href;
  
      return false;
    }
  }
  
  List<Component> _dirtyComponents = new List<Component>();
  bool _buildScheduled = false;
  bool _inRenderDirtyComponents = false;
  
  void _buildDirtyComponents() {
    try {
      _inRenderDirtyComponents = true;
      Stopwatch sw = new Stopwatch()..start();
  
      _dirtyComponents.sort((a, b) => a._order - b._order);
      for (var comp in _dirtyComponents) {
  
negative.code:     new Future.microtask(() {
        Stopwatch sw = new Stopwatch()..start();
  
        _sync(null, _host, null);
        assert(_root is sky.Node);
  
        sw.stop();
  