diff --git a/lib/legacy/legacy-element-mixin.html b/lib/legacy/legacy-element-mixin.html
index 8f67b81ee2..8df14be005 100644
--- a/lib/legacy/legacy-element-mixin.html
+++ b/lib/legacy/legacy-element-mixin.html
@@ -291,8 +291,9 @@
        *   template content.
       */
       instanceTemplate(template) {
+        let content = this.constructor._contentForTemplate(template);
         let dom = /** @type {DocumentFragment} */
-          (document.importNode(template._content || template.content, true));
+          (document.importNode(content, true));
         return dom;
       }
 
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index de11cd4df3..2de01ab393 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -646,106 +646,6 @@
     applyBindingValue(inst, info.methodInfo, val);
   }
 
-  /**
-   * Post-processes template bindings (notes for short) provided by the
-   * Bindings library for use by the effects system:
-   * - Parses bindings for methods into method `signature` objects
-   * - Memoizes the root property for path bindings
-   * - Recurses into nested templates and processes those templates and
-   *   extracts any host properties, which are set to the template's
-   *   `_content._hostProps`
-   * - Adds bindings from the host to <template> elements for any nested
-   *   template's lexically bound "host properties"; template handling
-   *   elements can then add accessors to the template for these properties
-   *   to forward host properties into template instances accordingly.
-   *
-   * @param {Array<Object>} notes List of notes to process; the notes are
-   *   modified in place.
-   * @private
-   */
-  function processAnnotations(notes) {
-    if (!notes._processed) {
-      for (let i=0; i<notes.length; i++) {
-        let note = notes[i];
-        // Parse bindings for methods & path roots (models)
-        for (let j=0; j<note.bindings.length; j++) {
-          let b = note.bindings[j];
-          for (let k=0; k<b.parts.length; k++) {
-            let p = b.parts[k];
-            if (!p.literal) {
-              p.signature = parseMethod(p.value);
-              if (!p.signature) {
-                p.rootProperty = Polymer.Path.root(p.value);
-              }
-            }
-          }
-        }
-        // Recurse into nested templates & bind host props
-        if (note.templateContent) {
-          processAnnotations(note.templateContent._notes);
-          let hostProps = note.templateContent._hostProps =
-            discoverTemplateHostProps(note.templateContent._notes);
-          let bindings = [];
-          for (let prop in hostProps) {
-            bindings.push({
-              index: note.index,
-              kind: 'property',
-              name: '_host_' + prop,
-              parts: [{
-                mode: '{',
-                value: prop
-              }]
-            });
-          }
-          note.bindings = note.bindings.concat(bindings);
-        }
-      }
-      notes._processed = true;
-    }
-  }
-
-  /**
-   * Finds all property usage in templates (property/path bindings and function
-   * arguments) and returns the path roots as keys in a map. Each outer template
-   * merges inner _hostProps to propagate inner host property needs to outer
-   * templates.
-   *
-   * @param {Array<Object>} notes List of notes to process for a given template
-   * @return {Object<string,boolean>} Map of host properties that the template
-   *   (or any nested templates) uses
-   * @private
-   */
-  function discoverTemplateHostProps(notes) {
-    let hostProps = {};
-    for (let i=0, n; (i<notes.length) && (n=notes[i]); i++) {
-      // Find all bindings to parent.* and spread them into _parentPropChain
-      for (let j=0, b$=n.bindings, b; (j<b$.length) && (b=b$[j]); j++) {
-        for (let k=0, p$=b.parts, p; (k<p$.length) && (p=p$[k]); k++) {
-          if (p.signature) {
-            let args = p.signature.args;
-            for (let kk=0; kk<args.length; kk++) {
-              let rootProperty = args[kk].rootProperty;
-              if (rootProperty) {
-                hostProps[rootProperty] = true;
-              }
-            }
-            hostProps[p.signature.methodName] = true;
-          } else {
-            if (p.rootProperty) {
-              hostProps[p.rootProperty] = true;
-            }
-          }
-        }
-      }
-      // Merge child _hostProps into this _hostProps
-      if (n.templateContent) {
-        let templateHostProps = n.templateContent._hostProps;
-        Object.assign(hostProps, templateHostProps);
-      }
-    }
-    return hostProps;
-  }
-
   /**
    * Returns true if a binding's metadata meets all the requirements to allow
    * 2-way binding, and therefore a <property>-changed event listener should be
@@ -783,16 +683,9 @@
    * @private
    */
   function addAnnotatedListener(model, index, property, path, event, negate) {
-    let eventName = event ||
-      (CaseMap.camelToDashCase(property) + '-changed');
+    event = event || (CaseMap.camelToDashCase(property) + '-changed');
     model.__notifyListeners = model.__notifyListeners || [];
-    model.__notifyListeners.push({
-      index: index,
-      property: property,
-      path: path,
-      event: eventName,
-      negate: negate
-    });
+    model.__notifyListeners.push({ index, property, path, event, negate });
   }
 
   /**
@@ -811,7 +704,7 @@
   }
 
   /**
-   * On the `inst` element that was previously bound, uses `inst.__templateNotes`
+   * On the `inst` element that was previously bound, uses nodeInfo list
    * to setup compound binding storage structures onto the bound
    * nodes (`inst.__templateNodes`).
    * (`inst._, and 2-way binding event listeners are also added.)
@@ -819,15 +712,15 @@
    * @param {Object} inst Instance that bas been previously bound
    * @private
    */
-  function setupBindings(inst) {
-    let notes = inst.__templateNotes;
-    if (notes.length) {
-      for (let i=0; i < notes.length; i++) {
-        let note = notes[i];
+  function setupBindings(inst, nodeInfo) {
+    if (nodeInfo.length) {
+      for (let i=0; i < nodeInfo.length; i++) {
+        let info = nodeInfo[i];
         let node = inst.__templateNodes[i];
         node.__dataHost = inst;
-        if (note.bindings) {
-          setupCompoundBinding(note, node);
+        let bindings = info.bindings;
+        if (bindings) {
+          setupCompoundBinding(bindings, node);
         }
       }
     }
@@ -905,25 +798,107 @@
 
   const emptyArray = [];
 
+  // Regular expressions used for binding
+  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
+  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
+  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
+  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
+  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
+  const ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
+  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
+  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
+                                '(?:' + ARGUMENTS + '?' + ')' +
+                              '\\)\\s*' + ')';
+  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
+  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
+  const CLOSE_BRACKET = '(?:]]|}})';
+  const NEGATE = '(?:(!)\\s*)?'; // Group 2
+  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+  const bindingRegex = new RegExp(EXPRESSION, "g");
+
+  function parseBindings(text, hostProps) {
+    let parts = [];
+    let lastIndex = 0;
+    let m;
+    // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
+    // Regex matches:
+    //        Iteration 1:  Iteration 2:
+    // m[1]: '{{'          '[['
+    // m[2]: ''            '!'
+    // m[3]: 'prop'        'compute(foo,bar)'
+    while ((m = bindingRegex.exec(text))) {
+      // Add literal part
+      if (m.index > lastIndex) {
+        parts.push({literal: text.slice(lastIndex, m.index)});
+      }
+      // Add binding part
+      // Mode (one-way or two)
+      let mode = m[1][0];
+      let negate = Boolean(m[2]);
+      let value = m[3].trim();
+      let customEvent, event, colon;
+      if (mode == '{' && (colon = value.indexOf('::')) > 0) {
+        event = value.substring(colon + 2);
+        value = value.substring(0, colon);
+        customEvent = true;
+      }
+      let signature = parseMethod(value, hostProps);
+      let rootProperty;
+      if (!signature) {
+        rootProperty = Polymer.Path.root(value);
+        hostProps[rootProperty] = true;
+      }
+      parts.push({
+        value, mode, negate, event, customEvent, signature, rootProperty,
+        compoundIndex: parts.length
+      });
+      lastIndex = bindingRegex.lastIndex;
+    }
+    // Add a final literal part
+    if (lastIndex && lastIndex < text.length) {
+      let literal = text.substring(lastIndex);
+      if (literal) {
+        parts.push({ literal });
+      }
+    }
+    if (parts.length) {
+      return parts;
+    }
+  }
+
+  function literalFromParts(parts) {
+    let s = '';
+    for (let i=0; i<parts.length; i++) {
+      let literal = parts[i].literal;
+      s += literal || '';
+    }
+    return s;
+  }
+
   /**
    * Parses an expression string for a method signature, and returns a metadata
    * describing the method in terms of `methodName`, `static` (whether all the
    * arguments are literals), and an array of `args`
    *
    * @param {string} expression The expression to parse
+   * @param {Object} hostProps A map of host properties that need accessors;
+   *   any parsed arguments or method name will be added to this map.
    * @return {?Object} The method metadata object if a method expression was
    *   found, otherwise `undefined`
    * @private
    */
-  function parseMethod(expression) {
+  function parseMethod(expression, hostProps) {
     // tries to match valid javascript property names
     let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
     if (m) {
       let sig = { methodName: m[1], static: true };
+      if (hostProps) {
+        hostProps[sig.methodName] = true;
+      }
       if (m[2].trim()) {
         // replace escaped commas with comma entity, split on un-escaped commas
         let args = m[2].replace(/\\,/g, '&comma;').split(',');
-        return parseArgs(args, sig);
+        return parseArgs(args, sig, hostProps);
       } else {
         sig.args = emptyArray;
         return sig;
@@ -942,11 +917,14 @@
    * @return {Object} The updated signature metadata object
    * @private
    */
-  function parseArgs(argList, sig) {
+  function parseArgs(argList, sig, hostProps) {
     sig.args = argList.map(function(rawArg) {
       let arg = parseArg(rawArg);
       if (!arg.literal) {
         sig.static = false;
+        if (hostProps) {
+          hostProps[arg.rootProperty] = true;
+        }
       }
       return arg;
     }, this);
@@ -1074,12 +1052,11 @@
    * storage array for that property, and then the array is joined to result in
    * the final value set to the property/attribute.
    *
-   * @param {Object} note Annotation metadata
+   * @param {Object} bindings Binding metadata
    * @param {Node} node Bound node to initialize
    * @private
    */
-  function setupCompoundBinding(note, node) {
-    let bindings = note.bindings;
+  function setupCompoundBinding(bindings, node) {
     for (let i=0; i<bindings.length; i++) {
       let binding = bindings[i];
       if (binding.isCompound) {
@@ -1697,7 +1674,7 @@
        */
       _stampTemplate(template) {
         let dom = super._stampTemplate(template);
-        setupBindings(this);
+        setupBindings(this, template._templateInfo.nodeInfoList);
         return dom;
       }
 
@@ -2178,23 +2155,156 @@
         // Clear any existing propagation effects inherited from superClass
         this.__propagateEffects = {};
         this.__notifyListeners = [];
-        let notes = this._parseTemplateAnnotations(template);
-        processAnnotations(notes);
-        for (let i=0, note; (i<notes.length) && (note=notes[i]); i++)  {
+        let templateInfo = this.constructor._parseTemplate(template);
+        let nodeInfo = templateInfo.nodeInfoList;
+        for (let i=0, info; (i<nodeInfo.length) && (info=nodeInfo[i]); i++)  {
           // where to find the node in the concretized list
-          let b$ = note.bindings;
-          for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
-            if (shouldAddListener(binding)) {
-              addAnnotatedListener(this, i, binding.name,
-                binding.parts[0].value,
-                binding.parts[0].event,
-                binding.parts[0].negate);
+          let b$ = info.bindings;
+          if (b$){
+            for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
+              if (shouldAddListener(binding)) {
+                addAnnotatedListener(this, i, binding.name,
+                  binding.parts[0].value,
+                  binding.parts[0].event,
+                  binding.parts[0].negate);
+              }
+              addBindingEffect(this, binding, i, dynamicFns);
             }
-            addBindingEffect(this, binding, i, dynamicFns);
           }
         }
       }
 
+      /**
+       * Overrides default `TemplateStamp` implementation to add support for
+       * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`
+       * array is added to `nodeInfo` and populated with binding metadata
+       * with information capturing the binding target, and a `parts` array
+       * with one or more metadata objects capturing the source(s) of the
+       * binding.
+       *
+       * @override
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNode(node, templateInfo, nodeInfo) {
+        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
+        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
+        if (node.nodeType === Node.TEXT_NODE) {
+          let parts = parseBindings(node.textContent, hostProps);
+          if (parts) {
+            // Initialize the textContent with any literal parts
+            // NOTE: default to a space here so the textNode remains; some browsers
+            // (IE) evacipate an empty textNode following cloneNode/importNode.
+            node.textContent = literalFromParts(parts) || ' ';
+            nodeInfo.bindings = nodeInfo.bindings || [];
+            nodeInfo.bindings.push({
+              kind: 'text',
+              name: 'textContent',
+              parts,
+              isCompound: parts.length !== 1
+            });
+            noted = true;
+          }
+        }
+        return noted;
+      }
+
+      /**
+       * Overrides default `TemplateStamp` implementation to add support for
+       * parsing bindings from attributes.  A `bindings`
+       * array is added to `nodeInfo` and populated with binding metadata
+       * with information capturing the binding target, and a `parts` array
+       * with one or more metadata objects capturing the source(s) of the
+       * binding.
+       *
+       * @override
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+        let parts = parseBindings(value, templateInfo.hostProps);
+        if (parts) {
+          // Attribute or property
+          let origName = name;
+          let kind = 'property';
+          if (name[name.length-1] == '$') {
+            name = name.slice(0, -1);
+            kind = 'attribute';
+          }
+          // Initialize attribute bindings with any literal parts
+          let literal = literalFromParts(parts);
+          if (literal && kind == 'attribute') {
+            node.setAttribute(name, literal);
+          }
+          // Clear attribute before removing, since IE won't allow removing
+          // `value` attribute if it previously had a value (can't
+          // unconditionally set '' before removing since attributes with `$`
+          // can't be set using setAttribute)
+          if (node.localName === 'input' && origName === 'value') {
+            node.setAttribute(origName, '');
+          }
+          // Remove annotation
+          node.removeAttribute(origName);
+          // Case hackery: attributes are lower-case, but bind targets
+          // (properties) are case sensitive. Gambit is to map dash-case to
+          // camel-case: `foo-bar` becomes `fooBar`.
+          // Attribute bindings are excepted.
+          let propertyName = Polymer.CaseMap.dashToCamelCase(name);
+          if (kind === 'property') {
+            name = propertyName;
+          }
+          nodeInfo.bindings = nodeInfo.bindings || [];
+          nodeInfo.bindings.push({
+            kind, name, propertyName, parts, literal,
+            isCompound: parts.length !== 1
+          });
+          return true;
+        } else {
+          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
+        }
+      }
+
+      /**
+       * Overrides default `TemplateStamp` implementation to add support for
+       * binding the properties that a nested template depends on to the template
+       * as `_host_<property>`.
+       *
+       * @override
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNestedContent(node, templateInfo, nodeInfo) {
+        let noted = super._parseTemplateNestedContent(node, templateInfo, nodeInfo);
+        // Merge host props into outer template and add bindings
+        let hostProps = Object.assign(templateInfo.hostProps, nodeInfo.templateInfo.hostProps);
+        for (let prop in hostProps) {
+          nodeInfo.bindings = nodeInfo.bindings || [];
+          nodeInfo.bindings.push({
+            index: nodeInfo.index,
+            kind: 'property',
+            name: '_host_' + prop,
+            parts: [{
+              mode: '{',
+              value: prop
+            }]
+          });
+          noted = true;
+        }
+        return noted;
+      }
+
     }
 
     return PropertyEffects;
diff --git a/lib/mixins/template-stamp.html b/lib/mixins/template-stamp.html
index ac10e38fdd..acd397171f 100644
--- a/lib/mixins/template-stamp.html
+++ b/lib/mixins/template-stamp.html
@@ -16,198 +16,6 @@
 
   'use strict';
 
-  // null-array (shared empty array to avoid null-checks)
-  const emptyArray = [];
-
-  let bindingRegex = (function() {
-    let IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
-    let NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
-    let SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
-    let DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
-    let STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
-    let ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
-    let ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
-    let ARGUMENT_LIST = '(?:' + '\\(\\s*' +
-                                  '(?:' + ARGUMENTS + '?' + ')' +
-                                '\\)\\s*' + ')';
-    let BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
-    let OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
-    let CLOSE_BRACKET = '(?:]]|}})';
-    let NEGATE = '(?:(!)\\s*)?'; // Group 2
-    let EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
-    return new RegExp(EXPRESSION, "g");
-  })();
-
-  let insertionPointTag = 'slot';
-
-  /**
-   * Scans a template to produce an annotation map that stores expression metadata
-   * and information that associates the metadata to nodes in a template instance.
-   *
-   * Supported annotations are:
-   *   * id attributes
-   *   * binding annotations in text nodes
-   *     * double-mustache expressions: {{expression}}
-   *     * double-bracket expressions: [[expression]]
-   *   * binding annotations in attributes
-   *     * attribute-bind expressions: name="{{expression}} || [[expression]]"
-   *     * property-bind expressions: name*="{{expression}} || [[expression]]"
-   *     * property-bind expressions: name:="expression"
-   *   * event annotations
-   *     * event delegation directives: on-<eventName>="expression"
-   *
-   * Generated data-structure:
-   *   [
-   *     {
-   *       id: '<id>',
-   *       events: [
-   *         {
-   *           mode: ['auto'|''],
-   *           name: '<name>'
-   *           value: '<expression>'
-   *         }, ...
-   *       ],
-   *       bindings: [
-   *         {
-   *           kind: ['text'|'attribute'|'property'],
-   *           mode: ['auto'|''],
-   *           name: '<name>'
-   *           value: '<expression>'
-   *         }, ...
-   *       ],
-   *       parent: <reference to parent annotation>,
-   *       index: <integer index in parent's childNodes collection>
-   *     },
-   *     ...
-   *   ]
-   *
-   * @param {HTMLTemplateElement} template
-   * @param {boolean=} stripWhiteSpace
-   * @return {Array<Object>}
-   */
-  function parseTemplateAnnotations(template, stripWhiteSpace, ownerDocument) {
-    // TODO(kschaaf): File issue and/or remove when fixed
-    // hold a reference to content as _content to prevent odd Chrome gc issue
-    // nested templates also may receive their content as _content
-    let content = (template._content = template._content || template.content);
-    // since a template may be re-used, memo-ize notes.
-    if (!content._notes) {
-      content._notes = [];
-      // TODO(sorvell): whitespace and processAnnotations need to be factored
-      // into plugins
-      ownerDocument = ownerDocument || template.ownerDocument;
-      parseNodeAnnotations(content, content._notes,
-        stripWhiteSpace || template.hasAttribute('strip-whitespace'), ownerDocument);
-    }
-    return content._notes;
-  }
-
-  // add annotations gleaned from subtree at `node` to `list`
-  function parseNodeAnnotations(node, list, stripWhiteSpace, ownerDocument) {
-    return node.nodeType === Node.TEXT_NODE ?
-      parseTextNodeAnnotation(node, list) :
-        parseElementAnnotations(node, list, stripWhiteSpace, ownerDocument);
-  }
-
-  function parseBindings(text) {
-    let parts = [];
-    let lastIndex = 0;
-    let m;
-    // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
-    // Regex matches:
-    //        Iteration 1:  Iteration 2:
-    // m[1]: '{{'          '[['
-    // m[2]: ''            '!'
-    // m[3]: 'prop'        'compute(foo,bar)'
-    while ((m = bindingRegex.exec(text)) !== null) {
-      // Add literal part
-      if (m.index > lastIndex) {
-        parts.push({literal: text.slice(lastIndex, m.index)});
-      }
-      // Add binding part
-      // Mode (one-way or two)
-      let mode = m[1][0];
-      let negate = Boolean(m[2]);
-      let value = m[3].trim();
-      let customEvent, notifyEvent, colon;
-      if (mode == '{' && (colon = value.indexOf('::')) > 0) {
-        notifyEvent = value.substring(colon + 2);
-        value = value.substring(0, colon);
-        customEvent = true;
-      }
-      parts.push({
-        compoundIndex: parts.length,
-        value: value,
-        mode: mode,
-        negate: negate,
-        event: notifyEvent,
-        customEvent: customEvent
-      });
-      lastIndex = bindingRegex.lastIndex;
-    }
-    // Add a final literal part
-    if (lastIndex && lastIndex < text.length) {
-      let literal = text.substring(lastIndex);
-      if (literal) {
-        parts.push({
-          literal: literal
-        });
-      }
-    }
-    if (parts.length) {
-      return parts;
-    }
-  }
-
-  function literalFromParts(parts) {
-    let s = '';
-    for (let i=0; i<parts.length; i++) {
-      let literal = parts[i].literal;
-      s += literal || '';
-    }
-    return s;
-  }
-
-  // add annotations gleaned from TextNode `node` to `list`
-  function parseTextNodeAnnotation(node, list) {
-    let parts = parseBindings(node.textContent);
-    if (parts) {
-      // Initialize the textContent with any literal parts
-      // NOTE: default to a space here so the textNode remains; some browsers
-      // (IE) evacipate an empty textNode following cloneNode/importNode.
-      node.textContent = literalFromParts(parts) || ' ';
-      let note = {
-        bindings: [{
-          kind: 'text',
-          name: 'textContent',
-          parts: parts,
-          isCompound: parts.length !== 1
-        }]
-      };
-      list.push(note);
-      return note;
-    }
-  }
-
-  // add annotations gleaned from Element `node` to `list`
-  function parseElementAnnotations(element, list, stripWhiteSpace, ownerDocument) {
-    let note = {
-      bindings: [],
-      events: []
-    };
-    if (element.localName === insertionPointTag) {
-      list._hasInsertionPoint = true;
-    }
-    parseChildNodesAnnotations(element, note, list, stripWhiteSpace, ownerDocument);
-    if (element.attributes) {
-      parseNodeAttributeAnnotations(element, note);
-    }
-    if (note.bindings.length || note.events.length || note.id) {
-      list.push(note);
-    }
-    return note;
-  }
-
   // 1.x backwards-compatible auto-wrapper for template type extensions
   // This is a clear layering violation and gives favored-nation status to
   // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
@@ -235,159 +43,15 @@
     return node;
   }
 
-  // add annotations gleaned from children of `root` to `list`, `root`'s
-  // `note` is supplied as it is the note.parent of added annotations
-  function parseChildNodesAnnotations(root, note, list, stripWhiteSpace, ownerDocument) {
-    if (root.firstChild) {
-      let node = root.firstChild;
-      let i = 0;
-      while (node) {
-        // Wrap templates
-        if (node.localName == 'template') {
-          node = wrapTemplateExtension(node);
-        }
-        // Recurse
-        if (node.localName == 'template' &&
-          !node.hasAttribute('preserve-content')) {
-          parseTemplate(node, i, list, note, stripWhiteSpace, ownerDocument);
-        }
-        // collapse adjacent textNodes: fixes an IE issue that can cause
-        // text nodes to be inexplicably split =(
-        // note that root.normalize() should work but does not so we do this
-        // manually.
-        let next = node.nextSibling;
-        if (node.nodeType === Node.TEXT_NODE) {
-          let n = next;
-          while (n && (n.nodeType === Node.TEXT_NODE)) {
-            node.textContent += n.textContent;
-            next = n.nextSibling;
-            root.removeChild(n);
-            n = next;
-          }
-          // optionally strip whitespace
-          if (stripWhiteSpace && !node.textContent.trim()) {
-            root.removeChild(node);
-            // decrement index since node is removed
-            i--;
-          }
-        }
-        // if this node didn't get evacipated, parse it.
-        if (node.parentNode) {
-          let childAnnotation = parseNodeAnnotations(node, list,
-            stripWhiteSpace, ownerDocument);
-          if (childAnnotation) {
-            childAnnotation.parent = note;
-            childAnnotation.index = i;
-          }
-        }
-        node = next;
-        i++;
-      }
-    }
-  }
-
-  // 1. Parse annotations from the template and memoize them on
-  //    content._notes (recurses into nested templates)
-  // 2. Remove template.content and store it in annotation list, where it
-  //    will be the responsibility of the host to set it back to the template
-  //    (this is both an optimization to avoid re-stamping nested template
-  //    children and avoids a bug in Chrome where nested template children
-  //    upgrade)
-  function parseTemplate(node, index, list, parent, stripWhiteSpace, ownerDocument) {
-    let content = node.content.ownerDocument.createDocumentFragment();
-    content._notes = parseTemplateAnnotations(node, stripWhiteSpace, ownerDocument);
-    content.appendChild(node.content);
-    list.push({
-      bindings: emptyArray,
-      events: emptyArray,
-      templateContent: content,
-      parent: parent,
-      index: index
-    });
-  }
-
-  // add annotation data from attributes to the `annotation` for node `node`
-  function parseNodeAttributeAnnotations(node, annotation) {
-    // Make copy of original attribute list, since the order may change
-    // as attributes are added and removed
-    let attrs = Array.prototype.slice.call(node.attributes);
-    for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
-      let n = a.name;
-      let v = a.value;
-      let b;
-      // events (on-*)
-      if (n.slice(0, 3) === 'on-') {
-        node.removeAttribute(n);
-        annotation.events.push({
-          name: n.slice(3),
-          value: v
-        });
-      }
-      // bindings (other attributes)
-      else if ((b = parseNodeAttributeAnnotation(node, n, v))) {
-        annotation.bindings.push(b);
-      }
-      // static id
-      else if (n === 'id') {
-        annotation.id = v;
-      }
-    }
-  }
-
-  // construct annotation data from a generic attribute, or undefined
-  function parseNodeAttributeAnnotation(node, name, value) {
-    let parts = parseBindings(value);
-    if (parts) {
-      // Attribute or property
-      let origName = name;
-      let kind = 'property';
-      if (name[name.length-1] == '$') {
-        name = name.slice(0, -1);
-        kind = 'attribute';
-      }
-      // Initialize attribute bindings with any literal parts
-      let literal = literalFromParts(parts);
-      if (literal && kind == 'attribute') {
-        node.setAttribute(name, literal);
-      }
-      // Clear attribute before removing, since IE won't allow removing
-      // `value` attribute if it previously had a value (can't
-      // unconditionally set '' before removing since attributes with `$`
-      // can't be set using setAttribute)
-      if (node.localName === 'input' && origName === 'value') {
-        node.setAttribute(origName, '');
-      }
-      // Remove annotation
-      node.removeAttribute(origName);
-      // Case hackery: attributes are lower-case, but bind targets
-      // (properties) are case sensitive. Gambit is to map dash-case to
-      // camel-case: `foo-bar` becomes `fooBar`.
-      // Attribute bindings are excepted.
-      let propertyName = Polymer.CaseMap.dashToCamelCase(name);
-      if (kind === 'property') {
-        name = propertyName;
-      }
-      return {
-        kind: kind,
-        name: name,
-        propertyName: propertyName,
-        parts: parts,
-        literal: literal,
-        isCompound: parts.length !== 1
-      };
-    }
-  }
-
-  function findTemplateAnnotatedNode(root, note) {
+  function findTemplateNode(root, nodeInfo) {
     // recursively ascend tree until we hit root
-    let parent = note.parent && findTemplateAnnotatedNode(root,
-      note.parent);
+    let parent = nodeInfo.parent && findTemplateNode(root, nodeInfo.parent);
     // unwind the stack, returning the indexed node at each level
     if (parent) {
       // note: marginally faster than indexing via childNodes
       // (http://jsperf.com/childnodes-lookup)
       for (let n=parent.firstChild, i=0; n; n=n.nextSibling) {
-        if (note.index === i++) {
+        if (nodeInfo.index === i++) {
           return n;
         }
       }
@@ -397,25 +61,25 @@
   }
 
   // construct `$` map (from id annotations)
-  function applyIdToMap(inst, map, node, note) {
-    if (note.id) {
-      map[note.id] = node;
+  function applyIdToMap(inst, map, node, nodeInfo) {
+    if (nodeInfo.id) {
+      map[nodeInfo.id] = node;
     }
   }
 
   // install event listeners (from event annotations)
-  function applyEventListener(inst, node, note, host) {
-    if (note.events && note.events.length) {
-      for (let j=0, e$=note.events, e; (j<e$.length) && (e=e$[j]); j++) {
-        inst._addMethodEventListenerToNode(node, e.name, e.value, host);
+  function applyEventListener(inst, node, nodeInfo) {
+    if (nodeInfo.events && nodeInfo.events.length) {
+      for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {
+        inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
       }
     }
   }
 
   // push configuration references at configure time
-  function applyTemplateContent(inst, node, note) {
-    if (note.templateContent) {
-      node._content = note.templateContent;
+  function applyTemplateContent(inst, node, nodeInfo) {
+    if (nodeInfo.templateInfo) {
+      node._templateInfo = nodeInfo.templateInfo;
     }
   }
 
@@ -441,10 +105,6 @@
    * - Map of node id's to stamped node instances (`this.$.id`)
    * - Nested template content caching/removal and re-installation (performance
    *   optimization)
-   * - Relative URL's relative to original template location
-   * - Template binding annotation parsing (note that this library only parses
-   *   template bindings and provides annotation metadata; see
-   *   `Polymer.PropertyEffects` for a full implementation of data-binding)
    *
    * @polymerMixin
    * @memberof Polymer
@@ -458,7 +118,256 @@
         super();
         this.$ = null;
         this.__templateNodes = null;
-        this.__templateNotes = null;
+      }
+
+      /**
+       * Scans a template to produce template metadata.
+       *
+       * Template-specific metadata are stored in the object returned, and node-
+       * specific metadata are stored in objects in its flattened `nodeInfoList`
+       * array.  Only nodes in the template that were parsed as nodes of
+       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
+       * contains an `index` (`childNodes` index in parent) and optionally
+       * `parent`, which points to node info of its parent (including its index).
+       *
+       * The template metadata object returned from this method has the following
+       * structure (many fields optional):
+       *
+       *   {
+       *     // Flattened list of node metadata (for nodes that generated metadata)
+       *     nodeInfoList: [
+       *       {
+       *         // `id` attribute for any nodes with id's for generating `$` map
+       *         id: '<id>',
+       *         // `on-event="handler"` metadata
+       *         events: [
+       *           {
+       *             name: '<name>'
+       *             value: '<handler name>'
+       *           }, ...
+       *         ],
+       *         // Notes when the template contained a `<slot>` for shady DOM
+       *         // optimization purposes
+       *         hasInsertionPoint: <boolean>,
+       *         // For nested <template> nodes, nested template metadata
+       *         templateInfo: <nested template metadata>,
+       *         // Metadata to allow efficient retrieval of instanced node
+       *         // corresponding to this metadata
+       *         parent: <reference to parent nodeInfo>,
+       *         index: <integer index in parent's `childNodes` collection>
+       *       },
+       *       ...
+       *     ],
+       *     // When true, the template had the `strip-whitespace` attribute
+       *     // or was nested in a template with that setting
+       *     stripWhitespace: <boolean>
+       *     // For nested templates, nested template content is moved into
+       *     // a document fragment stored here; this is an optimization to
+       *     // avoid the cost of nested template cloning
+       *     content: <DocumentFragment>
+       *   }
+       *
+       * This method kicks off a recursive treewalk as follows:
+       *
+       *    _parseTemplate <------------------+
+       *      _parseTemplateNode  <-----------|--+
+       *        _parseTemplateNestedContent --+  |
+       *        _parseTemplateChildNodes --------+
+       *        _parseTemplateNodeAttributes
+       *          _parseTemplateNodeAttribute
+       *
+       * These methods may be overridden to add custom metadata about templates
+       * to either `templateInfo` or `nodeInfo`.
+       *
+       * Note that this method may be destructive to the template, in that
+       * e.g. event annotations may be removed after being noted in the
+       * template metadata.
+       *
+       * @param {HTMLTemplateElement} template Template to parse
+       * @param {Object=} outerTemplateInfo Template metadata from the outer
+       *   template, for parsing nested templates
+       * @return {Object} Parsed template metadata
+       */
+      static _parseTemplate(template, outerTemplateInfo) {
+        // since a template may be re-used, memo-ize metadata
+        if (!template._templateInfo) {
+          let templateInfo = template._templateInfo || (template._templateInfo = {});
+          templateInfo.nodeInfoList = [];
+          templateInfo.stripWhiteSpace =
+            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
+            template.hasAttribute('strip-whitespace');
+          this._parseTemplateNode(template.content, templateInfo, {parent: null});
+        }
+        return template._templateInfo;
+      }
+
+      /**
+       * Parses template node and adds template and node metadata based on
+       * the current node, and its `childNodes` and `attributes`.
+       *
+       * This method may be overridden to add custom node or template specific
+       * metadata based on this node.
+       *
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       */
+      static _parseTemplateNode(node, templateInfo, nodeInfo) {
+        let noted;
+        if (node.localName == 'template' && !node.hasAttribute('preserve-content')) {
+          noted = this._parseTemplateNestedContent(node, templateInfo, nodeInfo) || noted;
+        } else if (node.localName === 'slot') {
+          // For ShadyDom optimization, indicating there is an insertion point
+          templateInfo.hasInsertionPoint = true;
+        }
+        if (node.firstChild) {
+          noted = this._parseTemplateChildNodes(node, templateInfo, nodeInfo) || noted;
+        }
+        if (node.hasAttributes && node.hasAttributes()) {
+          noted = this._parseTemplateNodeAttributes(node, templateInfo, nodeInfo) || noted;
+        }
+        return noted;
+      }
+
+      /**
+       * Parses template child nodes for the given root node.
+       *
+       * This method also wraps whitelisted legacy template extensions
+       * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
+       * wrappers, collapses text nodes, and strips whitespace from the template
+       * if the `templateInfo.stripWhitespace` setting was provided.
+       *
+       * @param {Node} root Root node whose `childNodes` will be parsed
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       */
+      static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {
+        for (let node=root.firstChild, index=0, next; node; node=next) {
+          // Wrap templates
+          if (node.localName == 'template') {
+            node = wrapTemplateExtension(node);
+          }
+          // collapse adjacent textNodes: fixes an IE issue that can cause
+          // text nodes to be inexplicably split =(
+          // note that root.normalize() should work but does not so we do this
+          // manually.
+          next = node.nextSibling;
+          if (node.nodeType === Node.TEXT_NODE) {
+            let n = next;
+            while (n && (n.nodeType === Node.TEXT_NODE)) {
+              node.textContent += n.textContent;
+              next = n.nextSibling;
+              root.removeChild(n);
+              n = next;
+            }
+            // optionally strip whitespace
+            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
+              root.removeChild(node);
+              continue;
+            }
+          }
+          let childInfo = { index, parent: nodeInfo };
+          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
+            templateInfo.nodeInfoList.push(childInfo);
+          }
+          index++;
+        }
+      }
+
+      /**
+       * Parses template content for the given nested `<template>`.
+       *
+       * Nested template info is stored as `templateInfo` in the current node's
+       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
+       * It will then be the responsibility of the host to set it back to the
+       * template and for users stamping nested templates to use the
+       * `_contentForTemplate` method to retrieve the content for this template
+       * (an optimization to avoid the cost of cloning nested template content).
+       *
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       */
+      static _parseTemplateNestedContent(node, outerTemplateInfo, nodeInfo) {
+        let templateInfo = this._parseTemplate(node, outerTemplateInfo);
+        let content = templateInfo.content =
+          node.content.ownerDocument.createDocumentFragment();
+        content.appendChild(node.content);
+        nodeInfo.templateInfo = templateInfo;
+        return true;
+      }
+
+      /**
+       * Parses template node attributes and adds node metadata to `nodeInfo`
+       * for nodes of interest.
+       *
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       */
+      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
+        // Make copy of original attribute list, since the order may change
+        // as attributes are added and removed
+        let noted;
+        let attrs = Array.from(node.attributes);
+        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
+          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
+        }
+        return noted;
+      }
+
+      /**
+       * Parses a single template node attribute and adds node metadata to
+       * `nodeInfo` for attributes of interest.
+       *
+       * This implementation adds metadata for `on-event="handler"` attributes
+       * and `id` attributes.
+       *
+       * @param {Node} node Node to parse
+       * @param {Object} templateInfo Template metadata for current template
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @param {string} name Attribute name
+       * @param {string} name Attribute value
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       */
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+        // events (on-*)
+        if (name.slice(0, 3) === 'on-') {
+          node.removeAttribute(name);
+          nodeInfo.events = nodeInfo.events || [];
+          nodeInfo.events.push({
+            name: name.slice(3),
+            value
+          });
+          return true;
+        }
+        // static id
+        else if (name === 'id') {
+          nodeInfo.id = value;
+          return true;
+        }
+      }
+
+      /**
+       * Returns the `content` document fragment for a given template.
+       *
+       * For nested templates, Polymer performs an optimization to cache nested
+       * template content to avoid the cost of cloning deeply nested templates.
+       * This method retrieves the cached content for a given template.
+       *
+       * @param {HTMLTemplateElement} template Template to retrieve `content` for
+       * @return {DocumentFragment} Content fragment
+       */
+      static _contentForTemplate(template) {
+        let templateInfo = template.__templateInfo;
+        return (templateInfo && templateInfo.content) || template.content;
       }
 
       /**
@@ -466,17 +375,13 @@
        * containing the cloned dom.
        *
        * The template is parsed (once and memoized) using this library's
-       * template parsing features, which identify nodes with declarative
-       * event listeners (`on-...``), `id`'s, `<template>`s, and bindings
-       * (`{{...}}` and `[[...]]`).  This template metadata ("notes")
-       * are stored as `this.__templateNotes`, and any nodes identified in
-       * notes are collected for this instance into `__templateNodes` in
-       * the same order as the notes array.
-       *
-       * Finally, this method generates an "id map" for all nodes with id's
-       * under `this.$`, passes template content back to templates as `_content`
-       * (a performance optimization to avoid deep template cloning), and
-       * installs declarative event listeners.
+       * template parsing features, and provides the following value-added
+       * features:
+       * * Adds declarative event listners for `on-event="handler"` attributes
+       * * Generates an "id map" for all nodes with id's under `this.$`
+       * * Passes template info including `content` back to templates as
+       *   `_templateInfo` (a performance optimization to avoid deep template
+       *   cloning)
        *
        * Note that the memoized template parsing process is destructive to the
        * template: attributes for bindings and declarative event listeners are
@@ -487,6 +392,7 @@
        * not support stamping multiple templates per element instance).
        *
        * @param {HTMLTemplateElement} template Template to stamp
+       * @return {DocumentFragment} Cloned template content
        */
       _stampTemplate(template) {
         // Polyfill support: bootstrap the template if it has not already been
@@ -494,32 +400,34 @@
             window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
           HTMLTemplateElement.decorate(template);
         }
-        let notes = this.__templateNotes = this._parseTemplateAnnotations(template);
-        let dom = document.importNode(template._content || template.content, true);
+        let templateInfo = this.constructor._parseTemplate(template);
+        let nodeInfo = templateInfo.nodeInfoList;
+        let content = templateInfo.content || template.content;
+        let dom = document.importNode(content, true);
         // NOTE: ShadyDom optimization indicating there is an insertion point
-        dom.__noInsertionPoint = !notes._hasInsertionPoint;
+        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
         this.$ = {};
-        this.__templateNodes = new Array(notes.length);
-        for (let i=0, l=notes.length, note, node; (i<l) && (note=notes[i]); i++) {
-          node = this.__templateNodes[i] = findTemplateAnnotatedNode(dom, note);
-          applyIdToMap(this, this.$, node, note);
-          applyTemplateContent(this, node, note);
-          applyEventListener(this, node, note, this);
+        this.__templateNodes = new Array(nodeInfo.length);
+        for (let i=0, l=nodeInfo.length, info, node; (i<l) && (info=nodeInfo[i]); i++) {
+          node = this.__templateNodes[i] = findTemplateNode(dom, info);
+          applyIdToMap(this, this.$, node, info);
+          applyTemplateContent(this, node, info);
+          applyEventListener(this, node, info);
         }
         return dom;
       }
 
-      // preprocess-time
-
-      // construct and return a list of annotation records
-      // by scanning `template`'s content
-      //
-      // TODO(sorvell): This should just crawl over a template and call
-      // a supplied list of callbacks.
-      _parseTemplateAnnotations(template) {
-        return parseTemplateAnnotations(template);
-      }
-
+      /**
+       * Adds an event listener by method name for the event provided.
+       *
+       * This method generates a handler function that looks up the method
+       * name at handling time.
+       *
+       * @param {Node} node Node to add listener on
+       * @param {string} eventName Name of event
+       * @param {string} methodName Name of method
+       * @return {Function} Generated handler function
+       */
       _addMethodEventListenerToNode(node, eventName, methodName, context) {
         context = context || node;
         let handler = createNodeEventHandler(context, eventName, methodName);
@@ -527,10 +435,24 @@
         return handler;
       }
 
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param {Node} node Node to add event listener to
+       * @param {string} eventName Name of event
+       * @param {Function} handler Listener function to add
+       */
       _addEventListenerToNode(node, eventName, handler) {
         node.addEventListener(eventName, handler);
       }
 
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param {Node} node Node to remove event listener from
+       * @param {string} eventName Name of event
+       * @param {Function} handler Listener function to remove
+       */
       _removeEventListenerFromNode(node, eventName, handler) {
         node.removeEventListener(eventName, handler);
       }
diff --git a/lib/utils/templatize.html b/lib/utils/templatize.html
index d56b833c3d..051aca976c 100644
--- a/lib/utils/templatize.html
+++ b/lib/utils/templatize.html
@@ -208,17 +208,18 @@
     }
 
     function addPropagateEffects(template, options) {
+      let templateInfo = template._templateInfo;
       let userForwardHostProp = options.forwardHostProp;
       if (userForwardHostProp) {
         // Provide data API and property effects on memoized template class
-        let klass = template._content.__templatizeTemplateClass;
+        let klass = templateInfo.templatizeTemplateClass;
         if (!klass) {
           let base = options.mutableData ? MutableDataTemplate : DataTemplate;
-          klass = template._content.__templatizeTemplateClass =
+          klass = templateInfo.templatizeTemplateClass =
             class TemplatizedTemplate extends base {}
           // Add template - >instances effects
           // and host <- template effects
-          let hostProps = template._content._hostProps;
+          let hostProps = templateInfo.hostProps;
           for (let prop in hostProps) {
             klass.prototype._addPropertyEffect('_host_' + prop,
               klass.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,
@@ -250,7 +251,8 @@
     }
 
     function addNotifyEffects(klass, template, options) {
-      let hostProps = template._content._hostProps || {};
+      let templateInfo = template._templateInfo;
+      let hostProps = templateInfo.hostProps || {};
       for (let iprop in options.instanceProps) {
         delete hostProps[iprop];
         let userNotifyInstanceProp = options.notifyInstanceProp;
@@ -388,14 +390,14 @@
           throw new Error('A <template> can only be templatized once');
         }
         template.__templatizeOwner = owner;
-        // Ensure template has _content
-        template._content = template._content || template.content;
+        let templateInfo = template._templateInfo;
         // Get memoized base class for the prototypical template, which
         // includes property effects for binding template & forwarding
-        let baseClass = template._content.__templatizeInstanceClass;
+        let baseClass = templateInfo && templateInfo.templatizeInstanceClass;
         if (!baseClass) {
-          baseClass = template._content.__templatizeInstanceClass =
-            createTemplatizerClass(template, options);
+          baseClass = createTemplatizerClass(template, options);
+          templateInfo = template._templateInfo;
+          templateInfo.templatizeInstanceClass = baseClass;
         }
         // Host property forwarding must be installed onto template instance
         addPropagateEffects(template, options);
@@ -404,7 +406,7 @@
         klass.prototype._methodHost = findMethodHost(template);
         klass.prototype.__dataHost = template;
         klass.prototype.__templatizeOwner = owner;
-        klass.prototype.__hostProps = template._content._hostProps;
+        klass.prototype.__hostProps = templateInfo.hostProps;
         return klass;
       },