diff --git a/README.md b/README.md
index ccd141f..f72c24b 100644
--- a/README.md
+++ b/README.md
@@ -129,15 +129,15 @@ _Using `<template>` to produce DOM structures:_
 
 MDV is designed to as two primitives which could eventually become standardized and implemented natively in browsers. The following two documents specify their behavior, API and use.
 
-* [`Node.bind`](https://github.com/Polymer/mdv/blob/master/docs/node_bind.md): Which describes how DOM nodes are bound to data values
-* [`<template>` instantiation](https://github.com/Polymer/mdv/blob/master/docs/template.md): Which describes how `<template>` manages instance fragments.
+* [`Node.bind`](http://www.polymer-project.org/platform/mdv/node_bind.html): Which describes how DOM nodes are bound to data values
+* [`<template>` instantiation](http://www.polymer-project.org/platform/mdv/template.html): Which describes how `<template>` manages instance fragments.
 
 ### Extending MDV
 
 MDV is mainly concerned with being robust and efficient in interacting with application data and keeping the DOM in sync , but more advanced behaviors can be accomplished via one or both of the following:
 
-* [A Binding Delegate API](https://github.com/Polymer/mdv/blob/master/docs/syntax_api.md)
-* [Expression Syntax](https://github.com/Polymer/mdv/blob/master/docs/expression_syntax.md)
+* [A Binding Delegate API](http://www.polymer-project.org/platform/mdv/syntax_api.html)
+* [Expression Syntax](http://www.polymer-project.org/platform/mdv/expression_syntax.html)
 
 ### Advanced Topics
 
diff --git a/docs/expression_syntax.md b/docs/expression_syntax.md
index ce3965b..0945e79 100644
--- a/docs/expression_syntax.md
+++ b/docs/expression_syntax.md
@@ -1,99 +1,5 @@
 ## Expression Syntax
 
-An ExpressionSyntax is provided as an example of a syntax which is implemented in script using the template element's [Syntax API](https://github.com/Polymer/mdv/blob/master/docs/syntax_api.md). It allows the use of named scopes within template `bind` and `repeat` and simple inline expressions within bindings.
+This doc has been moved to https://github.com/Polymer/docs/blob/master/platform/mdv/expression_syntax.md
 
- * Include the implementation:
-
-```HTML
-<script src="util/expression_syntax.js"></script>
-```
-
- * Register the syntax for use on the template element (sub-templates will inherit its use).
-
-```JavaScript
-templateElement.bindingDelegate = new ExpressionSyntax();
-```
-
- * Use the syntax in your templates
-
-```HTML
-<template bind>
-  <template repeat="{{ user in users }}">
-    {{ user.name }} <template if="{{ user.age >= 21 }}"> Can have a drink!</template>
-  </template>
-</template>
-```
-
-## Features
-
-### Inline expressions
-
-The ExpressionSyntax allows for inline expressions within bindings which support a strict subset of the JavaScript language. In order to use this feature, it's important to understand its behavior and limitations:
-
- * The goal for inline expressions is to allow the expression of simple value concepts and relationships. It is generally bad practice to put complex logic into your HTML (view).
- * Expressions are never run (e.g. eval) as page script. They cannot access any global state (e.g. window). They are parsed and converted to a simple interpretted form which is provided the present values of paths contained in the expression.
-
-The specific subset of JavaScript which is supported is:
-
- * Identifiers & paths, e.g. 'foo', 'foo.bar.baz'. These values are treated as relative to the local model, extracted, observed for changes and cause the expression to be re-evaluated if one or more has changed.
- * The logical not operator: !
- * The unary operators: + (Convert to Number), - (Convert to Number and negate).
- * The binary operators: + (Addition), - (Subtraction), * (Multiplication), / (Division), % (Modulo).
- * Comparators: < (less than), > (greater than), <= (less than or equal), >= (greater then or equal), == (equal), != (not equal), === (identity equally), !== (identity inequality)
- * Logical comparators: || (or), && (and)
- * Conditional statements: ?. e.g. 'a ? b : c'.
- * Grouping (parenthesis): e.g. '(a + b) * (c + d)'
- * Literal values: e.g. numbers, strings, null, undefined. Note that escaped strings and non-decimal numbers are not supported.
- * Array & Object initializers: e.g. '[foo, 1]', '{ id: 1, foo: bar }'
- * Labeled statements: e.g. 'foo: bar.baz; bat: boo > 2'
- 
-When an expression is used within a mustach (`{{` `}}`), it is parsed. The expression should be a single statement, or multiple labeled statements.
-
-* If the result is a single unlabeled statement, whenever the value of one or more paths in the expression change, the value of the expression re-evaluated and the result inserted as the value of the mustache. e.g.
-
-```HTML
-<div>Jill has {{ daughter.children.length + son.children.length }} grandchildren</div>
-```
-
-* If the result is one or more labeled statements, the value of the mustache will include the set of space-separated label identifiers whose corresponding expressions are truthy. e.g.
-
-```HTML
-<div class="{{ active: user.selected; big: user.type == 'super' }}"> 
-```
-
-### Named scope
-
-Named scopes are the solution to wanting to reference a model value from an "outer" model "scope". e.g.
-
-```HTML
-<template repeat="{{ user in users }}">
-  {{ user.name }}
-  <template repeat="{{ file in user.files }}">
-    {{ user.name }} owners {{ file.name }}
-  </template>
-</template>
-```
-
-The scope naming is available (but optional) inside `template` `bind` and `repeat` directives.
-
- * `bind` syntax: `<template bind="{{ expression as identifier }}">`
- * `repeat` syntax: `<template repeat="{{ identifier in expression }}">`
-
-Note that `expression` can be a simple identifier, a path or a full expression (including Object and Array literals).
-
-Within a `template` instance produced by a template using a named scope, all ancestor scopes are visible, up-to and including the first ancestor NOT using a named scope. e.g.
-
-```HTML
-<template bind="{{ foo as foo }}">
-  <!-- foo.* available -->
-  <template bind="{{ foo.bar as bar }}">
-    <!-- foo.* & bar.* available -->
-    <template bind="{{ bar.bat }}">
-      <!-- only properties of bat are available -->
-      <template bind="{{ boo as bot }}">
-        <!-- bot.* and properties of bat are available. NOT foo.* or bar.* -->
-      </template>
-    </template>
-  </template>
-</template>
-```
+and is viewable at http://www.polymer-project.org/platform/mdv/expression_syntax.html
diff --git a/docs/node_bind.md b/docs/node_bind.md
index c97a97d..987eb24 100644
--- a/docs/node_bind.md
+++ b/docs/node_bind.md
@@ -1,72 +1,3 @@
-## Learn the tech
-
-### Why Node.prototype.bind?
-
-MDV adds a `bind()` method to all DOM nodes which instructs them bind the named value to the data provided. The meaning of the binding name is interpreted by the node on which it is called.
-
-`Text` node only handles the 'textContent' binding. `HTMLInputElement` handles the 'value' and 'checked' bindings as two-way. All other elements handles bindings as to attributes. 
-### Basic usage
-
-#### Text
-
-```JavaScript
-textNode.bind('textContent', someObj, 'path.to.value');
-```
-
-Instructs the `Text` node to make its `textContent` dependent on the value `someObj.path.to.value`. Initially, and whenever the value changes, `textContent` will set to `String(someObj.path.to.value)`, or the empty string if the path is `null`, `undefined` or unreachable.
-
-####Element attribute value
-
-```JavaScript
-myElement.bind('title', someObj, 'path.to.value');
-```
-
-Instructs the element to make the value its `title` attribute dependent on the value `someObj.path.to.value`. Initially, and whenever the value changes, the attribute value will be set to `String(someObj.path.to.value)`, or the empty string if the path is `null`, `undefined` or unreachable.
-
-####Element attribute presence
-
-```JavaScript
-myElement.bind('hidden?', someObj, 'path.to.value');
-```
-
-Instructs the element to make the presence of its `hidden` attribute dependent on the vaue `someObj.path.to.value`. Initially, and whenever the value changes, the attribute will be set to the empty string if the value `someObj.path.to.value` is reachable and truthy, otherwise the attribute will be removed.
-
-
-#### Input Element value and checked properties
-
-```JavaScript
-myValueInput.bind('value', someObj, 'path.to.value');
-```
-
-Instructs the `input` to ensure the its `value` property is equal to `String(someObje.path.to.value)`. The binding is two-way. Upon binding, if the path reachable, `value` is set to the path value. If the path is unreachable but can be made reachable by setting a single property on the final object, the property is set to `value`.
-
-
-```JavaScript
-myCheckboxOrRadioInput.bind('checked', someObj, 'path.to.value');
-```
-Instructs the `input` to ensure the its `checked` property is equal to `Boolean(someObje.path.to.value)`. The binding is two-way. Upon binding, if the path reachable, `checked` is set to the path value. If the path is unreachable but can be made reachable by setting a single property on the final object, the property is set to `checked`.
-
-### Custom Element bindings
-
-[Custem Elements](https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/index.html) may choose to interpret bindings as they wish. The do this by overriding the `bind` method.
-
-```JavaScript
-HTMLMyFancyWidget.prototype.bind = function(name, obj, path) {
-  if (name == 'myBinding')
-    // interpret the binding meaning
-  else
-    HTMLElement.prototype.bind.call(this, name, obj, path);
-}
-```
-
-If the element does not handle the binding, it should give its super class the opportunity to by invoking its `bind` method.
-
-
-### API
-
-Note yet written. Please refer to the [HowTo examples](https://github.com/Polymer/mdv/tree/master/examples/how_to).
-
-### Specification
-
-Note yet written. Please refer to the [HowTo examples](https://github.com/Polymer/mdv/tree/master/examples/how_to).
+This doc has been moved to https://github.com/Polymer/docs/blob/master/platform/mdv/node_bind.md
 
+Viewable at http://www.polymer-project.org/platform/mdv/node_bind.html
diff --git a/docs/syntax_api.md b/docs/syntax_api.md
index 9b8c207..752dee7 100644
--- a/docs/syntax_api.md
+++ b/docs/syntax_api.md
@@ -1,103 +1,3 @@
-## Learn the tech
+This doc has been moved to https://github.com/Polymer/docs/blob/master/platform/mdv/syntax_api.md
 
-### Why MDV Pluggable Syntax?
-
-MDV's native features enables a wide-range of use cases, but (by design) don't attempt to implement many specialized behaviors that some MV* frameworks suport. For example:
-
-* Inline-expressions within mustaches, e.g.:
-
-```html
-<span>{{ foo + bar ? foo : bar }}</span>
-```
-
-* "Named scopes" for iterators, e.g.:
-
-```html
-<template repeat="{{ user in users }}">
-  {{ user.name }}
-</template>
-```
-
-* ... And anything else you'd like.
-
-Enabling these features in MDV is a matter of implementing and registering a binding delegate.
-
-### Basic usage
-
-```JavaScript
-templateElement.bindingDelegate = {
-  getBinding: function(model, path, name, node) {
-    // If this function is defined, the syntax can override
-    // the default binding behavior
-  },
-  getInstanceModel: function(template, model) {
-    // If this function is defined, the syntax can override
-    // what model is used for each template instance which is
-    // produced.
-  }
-}
-```
-
-### getBinding
-
-The `getBinding` method allows for a custom interpretation of the contents of mustaches (`{{` ... `}}`).
-
-When a template is inserting an instance, it will invoke the `getBinding` method (if it is implemented by the syntax) for each mustache which is encountered. The function is invoked with four arguments:
-
-```JavaScript
-syntax.getBinding = function(model, path, name, node);
-```
-
-* `model`: The data context for which this instance is being created.
-* `path`: The text contents (trimmed of outer whitespace) of the mustache.
-* `name`: The context in which the mustache occurs. Within element attributes, this will be the name of the attribute. Within text, this will be 'textContent'.
-* `node`: A reference to the node to which this binding will be created.
-
-If the `getBinding` method wishes to handle binding, it is required to return an object which has at least a `value` property. If it does, then MDV will call
-
-```JavaScript
-node.bind(name, retval, 'value');
-```
-
-...on the node.
-
-If the 'getBinding' wishes to decline to override, it should not return a value.
-
-### getInstanceModel
-
-The `getInstanceModel` method allows a syntax to provide an alterate model than the one the template would otherwise use when producing an instance.
-
-When a template is about to create an instance, it will invoke the `getInstanceModel` method (if it is implemented by the syntax). The function is invoked with two arguments:
-
-```JavaScript
-syntax.getBinding = function(template, model);
-```
-* `template`: The template element which is about to create and insert an instance.
-* `model`: The data context for which this instance is being created.
-
-The template element will always use the return value of `getInstanceModel` as the model for the new instance. If the syntax does not wish to override the value, it should simply return the `model` value it was passed.
-
-### CompoundBinding
-
-MDV contains a helper object which is useful for the implementation of a Binding Delegate.
-
-```JavaScript
-var combinatorFunction = function(values) {
-  var combinedValue;
-  // compute combinedValue based on the current values which are provided
-  return combinedValue;
-};
-
-var binding = new CompoundBinding(combinatorFunction);
-
-binding.bind('name1', obj1, path1);
-binding.bind('name2', obj2, path2);
-//...
-binding.bind('nameN', objN, pathN);
-```
-
-`CompoundBinding` is an object which knows how to listen to multiple path values (registered via `bind`) and invoke its `combinatorFunction` when one or more of the values have changed and set its `value` property to the return value of the function. When any value has changed, all current values are provided to the `combinatorFunction` in the single `values` argument.
-
-## Not-yet-implemented delegation functions
-
-* `getInstanceFragment`: used to override the DOM of the instance fragent which is a produced for a new instance.
+Viewable at http://www.polymer-project.org/platform/mdv/syntax_api.html
diff --git a/docs/template.md b/docs/template.md
index 47efc6c..e3882f1 100644
--- a/docs/template.md
+++ b/docs/template.md
@@ -1,65 +1,3 @@
-## Learn the tech
-
-### Why Template Instantiation?
-
-MDV extends the capabilities of the [HTML Template Element](http://www.w3.org/TR/html-templates/). It enables `<template>` to create, manage and remove instances of its content by being bound to JavaScript data.
-
-### Basic usage
-
-#### bind
-
-```html
-<template bind="{{ singleton }}">
-  Will create a single instance with {{ bindings }} when singleton model data is provided.
-</template>
-```
-
-#### repeat
-
-```html
-<template repeat="{{ collection }}">
-  Will create maintain exactly instance with {{ bindings }} for every element in the array collection, when it is provided.
-</template>
-```
-
-#### if
-
-```html
-<template bind if="{{ conditionalValue }}">
-  Will bind if and only if conditionalValue is truthy.
-</template>
-
-<template if="{{ conditionalValue }}">
-  Will bind if and only if conditionalValue is truthy. (same as *bind if*)
-</template>
-
-<template repeat if="{{ conditionalValue }}">
-  Will repeat if and only if conditionalValue is truthy.
-</template>
-```
-
-#### ref
-
-```html
-<template id="myTemplate">
-  Will be used by any template which refers to this one by the ref attribute
-</template>
-
-<template bind ref="myTemplate">
-  When creating instance, the content of this template will be ignored, and the contnet of #myTemplate will be used instead.
-</template>
-```
-
-```JavaScript
-// Causes any bind, repeat or if attribute directives on #myTemplate to begin acting.
-document.getElementById('myTemplate').model = jsData;
-```
-
-### API
-
-Note yet written. Please refer to the [HowTo examples](https://github.com/Polymer/mdv/tree/master/examples/how_to).
-
-### Specification
-
-Note yet written. Please refer to the [HowTo examples](https://github.com/Polymer/mdv/tree/master/examples/how_to).
+This doc has been moved to https://github.com/Polymer/docs/blob/master/platform/mdv/template.md
 
+Viewable at http://www.polymer-project.org/platform/mdv/template.html
diff --git a/src/template_element.js b/src/template_element.js
index 512bbe8..08229e7 100644
--- a/src/template_element.js
+++ b/src/template_element.js
@@ -131,33 +131,14 @@
   }
 
   Node.prototype.bind = function(name, model, path) {
-    this.bindings = this.bindings || {};
-    var binding = this.bindings[name];
-    if (binding)
-      binding.close();
-
-    binding = this.createBinding(name, model, path);
-    this.bindings[name] = binding;
-    if (!binding) {
-      console.error('Unhandled binding to Node: ', this, name, model, path);
-      return;
-    }
-
-    return binding;
+    console.error('Unhandled binding to Node: ', this, name, model, path);
   };
 
-  // TODO(rafaelw): This isn't really the right design. If node.bind() is
-  // specified, there's no way to host objects to invoke a "virtual"
-  // createBinding on custom elements.
-  Node.prototype.createBinding = function() {};
-
   Node.prototype.unbind = function(name) {
-    if (!this.bindings)
-      return;
+    this.bindings = this.bindings || {};
     var binding = this.bindings[name];
-    if (!binding)
-      return;
-    binding.close();
+    if (binding && typeof binding.close === 'function')
+      binding.close();
     delete this.bindings[name];
   };
 
@@ -179,9 +160,10 @@
     this.node = node;
     this.property = property;
     this.model = model;
-    this.path = path;
-    this.observer = new PathObserver(model, path,
-                                     this.boundValueChanged, this);
+    this.path = path || '';
+    this.observer = new PathObserver(this.model, this.path,
+                                     this.boundValueChanged,
+                                     this);
     this.boundValueChanged(this.value);
   }
 
@@ -217,11 +199,12 @@
     }
   };
 
-  Text.prototype.createBinding = function(name, model, path) {
-    if (name === 'textContent')
-      return new NodeBinding(this, 'data', model, path);
+  Text.prototype.bind = function(name, model, path) {
+    if (name !== 'textContent')
+      return Node.prototype.bind.call(this, name, model, path);
 
-    return Node.prototype.createBinding.call(this, name, model, path);
+    this.unbind(name);
+    return this.bindings[name] = new NodeBinding(this, 'data', model, path);
   }
 
   function AttributeBinding(element, attributeName, model, path) {
@@ -250,8 +233,9 @@
     }
   });
 
-  Element.prototype.createBinding = function(name, model, path) {
-    return new AttributeBinding(this, name, model, path);
+  Element.prototype.bind = function(name, model, path) {
+    this.unbind(name);
+    return this.bindings[name] = new AttributeBinding(this, name, model, path);
   };
 
   var checkboxEventType;
@@ -381,29 +365,24 @@
     }
   });
 
-  HTMLInputElement.prototype.createBinding = function(name, model, path) {
-    if (name === 'value') {
-      // TODO(rafaelw): Maybe template should remove all binding instructions.
-      this.removeAttribute(name);
-      return new InputBinding(this, 'value', model, path)
-    }
-
-    if (name === 'checked') {
-      this.removeAttribute(name);
-      return new CheckedBinding(this, model, path);
-    }
+  HTMLInputElement.prototype.bind = function(name, model, path) {
+    if (name !== 'value' && name !== 'checked')
+      return HTMLElement.prototype.bind.call(this, name, model, path);
 
-    return HTMLElement.prototype.createBinding.call(this, name, model, path);
+    this.unbind(name);
+    this.removeAttribute(name);
+    return this.bindings[name] = name === 'value' ?
+        new InputBinding(this, 'value', model, path) :
+        new CheckedBinding(this, model, path);
   }
 
-  HTMLTextAreaElement.prototype.createBinding = function(name, model, path) {
-    if (name === 'value') {
-      // TODO(rafaelw): Maybe template should remove all binding instructions.
-      this.removeAttribute(name);
-      return new InputBinding(this, name, model, path)
-    }
+  HTMLTextAreaElement.prototype.bind = function(name, model, path) {
+    if (name !== 'value')
+      return HTMLElement.prototype.bind.call(this, name, model, path);
 
-    return HTMLElement.prototype.createBinding.call(this, name, model, path);
+    this.unbind(name);
+    this.removeAttribute(name);
+    return this.bindings[name] = new InputBinding(this, name, model, path);
   }
 
   function SelectedIndexBinding(element, model, path) {
@@ -435,14 +414,13 @@
     }
   });
 
-  HTMLSelectElement.prototype.createBinding = function(name, model, path) {
-    if (name.toLowerCase() === 'selectedindex') {
-      // TODO(rafaelw): Maybe template should remove all binding instructions.
-      this.removeAttribute(name);
-      return new SelectedIndexBinding(this, model, path);
-    }
+  HTMLSelectElement.prototype.bind = function(name, model, path) {
+    if (name.toLowerCase() !== 'selectedindex')
+      return HTMLElement.prototype.bind.call(this, name, model, path);
 
-    return HTMLElement.prototype.createBinding.call(this, name, model, path);
+    this.unbind(name);
+    this.removeAttribute(name);
+    return this.bindings[name] = new SelectedIndexBinding(this, model, path);
   }
 
   var BIND = 'bind';
@@ -785,13 +763,14 @@
     ensureScheduled(setModelFn);
   }
 
-  function TemplateBinding(node, property, model, path) {
+  function TemplateBinding(node, property, model, path, iterator) {
     this.closed = false;
     this.node = node;
     this.property = property;
     this.model = model;
-    this.path = path;
-    this.node.inputs.bind(this.property, model, path || '');
+    this.path = path || ''
+    this.iterator = iterator;
+    this.iterator.inputs.bind(this.property, this.model, this.path);
   }
 
   TemplateBinding.prototype = createObject({
@@ -801,7 +780,8 @@
     close: function() {
       if (this.closed)
         return;
-      this.node.inputs.unbind(this.property);
+      this.iterator.inputs.unbind(this.property);
+      this.iterator = undefined;
       this.node = undefined;
       this.model = undefined;
       this.closed = true;
@@ -809,18 +789,16 @@
   });
 
   mixin(HTMLTemplateElement.prototype, {
-    createBinding: function(name, model, path) {
-      if (name === BIND || name === REPEAT || name === IF) {
-        var iterator = templateIteratorTable.get(this);
-        if (!iterator) {
-          iterator = new TemplateIterator(this);
-          templateIteratorTable.set(this, iterator);
-        }
+    bind: function(name, model, path) {
+      if (name !== BIND && name !== REPEAT && name !== IF)
+        return HTMLElement.prototype.bind.call(this, name, model, path);
 
-        return new TemplateBinding(iterator, name, model, path || '');
-      }
 
-      return HTMLElement.prototype.createBinding.call(this, name, model, path);
+      var iterator = TemplateIterator.getOrCreate(this);
+      this.unbind(name);
+
+      return this.bindings[name] =
+          new TemplateBinding(this, name, model, path, iterator);
     },
 
     createInstance: function(model, delegate, bound) {
@@ -879,6 +857,12 @@
 
       var nextRef = ref.ref;
       return nextRef ? nextRef : ref;
+    },
+
+    clear: function() {
+      this.unbind('bind');
+      this.unbind('if');
+      this.unbind('repeat');
     }
   });
 
@@ -991,6 +975,7 @@
       if (isTemplateNode) {
         if (name === IF) {
           ifFound = true;
+          value = value || '{{}}';  // Accept 'naked' if.
         } else if (name === BIND || name === REPEAT) {
           bindFound = true;
           value = value || '{{}}';  // Accept 'naked' bind & repeat.
@@ -1025,18 +1010,6 @@
     }
   }
 
-  function TemplateCloser(node) {
-    this.node = node;
-  }
-
-  TemplateCloser.prototype = {
-    close: function() {
-      var iterator = templateIteratorTable.get(this.node);
-      if (iterator)
-        iterator.close();
-    }
-  }
-
   function addMapBindings(node, bindings, model, delegate, bound) {
     if (!bindings)
       return;
@@ -1046,9 +1019,6 @@
       if (delegate) {
         templateBindingDelegateTable.set(node, delegate);
       }
-      if (bound) {
-        bound.push(new TemplateCloser(node));
-      }
     }
 
     if (bindings.length)
@@ -1236,8 +1206,20 @@
     this.iteratedValue = undefined;
     this.arrayObserver = undefined;
     this.inputs = new CompoundBinding(this.resolveInputs.bind(this));
+    TemplateIterator.templateTable.set(this.templateElement_, this);
+  }
+
+  // "private"
+  TemplateIterator.templateTable = new SideTable();
+
+  TemplateIterator.get = function(template) {
+    return TemplateIterator.templateTable.get(template);
   }
 
+  TemplateIterator.getOrCreate = function(template) {
+    return TemplateIterator.get(template) || new TemplateIterator(template);
+  };
+
   TemplateIterator.prototype = {
     resolveInputs: function(values) {
       if (this.closed)
@@ -1272,11 +1254,8 @@
       if (splices.length)
         this.handleSplices(splices);
 
-      if (!this.inputs.size) {
-        // End iteration
-        templateIteratorTable.delete(this.templateElement_);
+      if (!this.inputs.size)
         this.close();
-      }
     },
 
     getTerminatorAt: function(index) {
@@ -1288,7 +1267,7 @@
         return terminator;
       }
 
-      var subIterator = templateIteratorTable.get(terminator);
+      var subIterator = TemplateIterator.get(terminator);
       if (!subIterator)
         return terminator;
 
@@ -1350,7 +1329,6 @@
       var template = this.templateElement_;
       if (!template.parentNode || !template.ownerDocument.defaultView) {
         this.close();
-        templateIteratorTable.delete(this);
         return;
       }
 
@@ -1391,12 +1369,14 @@
       }, this);
 
       instanceCache.forEach(function(instanceNodes) {
-        var bound = instanceNodes.bound;
+        this.closeInstanceBindings(instanceNodes.bound);
+      }, this);
+    },
 
-        for (var i = 0; i < bound.length; i++) {
-          bound[i].close();
-        }
-      });
+    closeInstanceBindings: function(bound) {
+      for (var i = 0; i < bound.length; i++) {
+        bound[i].close();
+      }
     },
 
     unobserve: function() {
@@ -1412,19 +1392,16 @@
         return;
       this.unobserve();
       for (var i = 1; i < this.terminators.length; i += 2) {
-        var bound = this.terminators[i];
-        for (var j = 0; j < bound.length; j++)
-          bound[j].close();
+        this.closeInstanceBindings(this.terminators[i]);
       }
 
       this.terminators.length = 0;
       this.inputs.close();
+      TemplateIterator.templateTable.delete(this.templateElement_);
       this.closed = true;
     }
   };
 
-  var templateIteratorTable = new SideTable();
-
   global.CompoundBinding = CompoundBinding;
 
   // Polyfill-specific API.
diff --git a/tests/node_bindings.js b/tests/node_bindings.js
index 439c3aa..b77a6cb 100644
--- a/tests/node_bindings.js
+++ b/tests/node_bindings.js
@@ -65,6 +65,13 @@ suite('Text bindings', function() {
     // TODO(rafaelw): Throw on binding to unavailable property?
   });
 
+  test('Text - No Path', function() {
+    var text = document.createTextNode('hi');
+    var model = 1;
+    text.bind('textContent', model);
+    assert.strictEqual('1', text.data);
+  });
+
   test('Path unreachable', function() {
     var text = testDiv.appendChild(document.createTextNode('hi'));
     var model = {};
@@ -106,6 +113,14 @@ suite('Element attribute bindings', function() {
     assert.strictEqual('', el.getAttribute('foo'));
   });
 
+  test('No path', function() {
+    var el = testDiv.appendChild(document.createElement('div'));
+    var model = 1;
+    el.bind('foo', model);
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual('1', el.getAttribute('foo'));
+  });
+
   test('Dashes', function() {
     var el = testDiv.appendChild(document.createElement('div'));
     var model = {a: '1'};
diff --git a/tests/template_element.js b/tests/template_element.js
index 7246acb..ede99d2 100644
--- a/tests/template_element.js
+++ b/tests/template_element.js
@@ -84,6 +84,10 @@ suite('Template Element', function() {
     Platform.performMicrotaskCheckpoint();
     assert.strictEqual(2, div.childNodes.length);
     assert.strictEqual('text', div.lastChild.textContent);
+
+    div.firstChild.clear();
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
   });
 
   test('Template bind, no parent', function() {
@@ -132,6 +136,10 @@ suite('Template Element', function() {
     Platform.performMicrotaskCheckpoint();
     assert.strictEqual(2, div.childNodes.length);
     assert.strictEqual('text', div.lastChild.textContent);
+
+    div.firstChild.clear();
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
   });
 
   test('Template Bind If, 2', function() {
@@ -160,6 +168,24 @@ suite('Template Element', function() {
     Platform.performMicrotaskCheckpoint();
     assert.strictEqual(2, div.childNodes.length);
     assert.strictEqual('foo', div.lastChild.textContent);
+
+    div.firstChild.clear();
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
+  });
+
+  test('Template-Empty If', function() {
+    var div = createTestHtml(
+        '<template if>{{ value }}</template>');
+    var m = { value: 'foo' };
+    recursivelySetTemplateModel(div, null);
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
+
+    recursivelySetTemplateModel(div, m);
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(2, div.childNodes.length);
+    assert.strictEqual('foo', div.lastChild.textContent);
   });
 
   test('Template Repeat If', function() {
@@ -176,6 +202,10 @@ suite('Template Element', function() {
     assert.strictEqual('1', div.childNodes[1].textContent);
     assert.strictEqual('2', div.childNodes[2].textContent);
     assert.strictEqual('3', div.childNodes[3].textContent);
+
+    div.firstChild.clear();
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
   });
 
   test('TextTemplateWithNullStringBinding', function() {
@@ -328,6 +358,11 @@ suite('Template Element', function() {
     model.splice(1, 1);
     Platform.performMicrotaskCheckpoint();
     assert.strictEqual(3, div.childNodes.length);
+
+
+    div.firstChild.clear();
+    Platform.performMicrotaskCheckpoint();
+    assert.strictEqual(1, div.childNodes.length);
   });
 
   test('Repeat - Reuse Instances', function() {
diff --git a/third_party/ChangeSummary b/third_party/ChangeSummary
index df45ea3..a799821 160000
--- a/third_party/ChangeSummary
+++ b/third_party/ChangeSummary
@@ -1 +1 @@
-Subproject commit df45ea3e6469fa8ae0c07d82b5041f2aaffaeec7
+Subproject commit a799821f1138c06884dec90c685bd05501611e78