diff --git a/lib/legacy/legacy-element-mixin.html b/lib/legacy/legacy-element-mixin.html
index 6272b1cecf..f3770414aa 100644
--- a/lib/legacy/legacy-element-mixin.html
+++ b/lib/legacy/legacy-element-mixin.html
@@ -286,8 +286,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 259bd86ba3..26a30824fa 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -683,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 });
   }
 
   /**
@@ -711,7 +704,7 @@
   }
 
   /**
-   * On the `inst` element that was previously bound, uses `inst.__templateNotes`
+   * On the `inst` element that was previously bound, uses `inst.__templateNodeInfo`
    * to setup compound binding storage structures onto the bound
    * nodes (`inst.__templateNodes`).
    * (`inst._, and 2-way binding event listeners are also added.)
@@ -720,14 +713,15 @@
    * @private
    */
   function setupBindings(inst) {
-    let notes = inst.__templateNotes;
-    if (notes.length) {
-      for (let i=0; i < notes.length; i++) {
-        let note = notes[i];
+    let nodeInfo = inst.__templateNodeInfo;
+    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);
         }
       }
     }
@@ -833,7 +827,7 @@
     // m[1]: '{{'          '[['
     // m[2]: ''            '!'
     // m[3]: 'prop'        'compute(foo,bar)'
-    while ((m = bindingRegex.exec(text)) !== null) {
+    while ((m = bindingRegex.exec(text))) {
       // Add literal part
       if (m.index > lastIndex) {
         parts.push({literal: text.slice(lastIndex, m.index)});
@@ -843,9 +837,9 @@
       let mode = m[1][0];
       let negate = Boolean(m[2]);
       let value = m[3].trim();
-      let customEvent, notifyEvent, colon;
+      let customEvent, event, colon;
       if (mode == '{' && (colon = value.indexOf('::')) > 0) {
-        notifyEvent = value.substring(colon + 2);
+        event = value.substring(colon + 2);
         value = value.substring(0, colon);
         customEvent = true;
       }
@@ -856,14 +850,8 @@
         hostProps[rootProperty] = true;
       }
       parts.push({
-        compoundIndex: parts.length,
-        value,
-        mode,
-        negate,
-        event: notifyEvent,
-        customEvent,
-        signature,
-        rootProperty
+        value, mode, negate, event, customEvent, signature, rootProperty,
+        compoundIndex: parts.length
       });
       lastIndex = bindingRegex.lastIndex;
     }
@@ -871,9 +859,7 @@
     if (lastIndex && lastIndex < text.length) {
       let literal = text.substring(lastIndex);
       if (literal) {
-        parts.push({
-          literal: literal
-        });
+        parts.push({ literal });
       }
     }
     if (parts.length) {
@@ -935,8 +921,9 @@
       let arg = parseArg(rawArg);
       if (!arg.literal) {
         sig.static = false;
-      } else if (hostProps) {
-        hostProps[arg.rootProperty] = true;
+        if (hostProps) {
+          hostProps[arg.rootProperty] = true;
+        }
       }
       return arg;
     }, this);
@@ -1064,12 +1051,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) {
@@ -2168,10 +2154,11 @@
         // Clear any existing propagation effects inherited from superClass
         this.__propagateEffects = {};
         this.__notifyListeners = [];
-        let notes = this.constructor._prepareTemplate(template);
-        for (let i=0, note; (i<notes.length) && (note=notes[i]); i++)  {
+        let templateInfo = this.constructor._parseTemplate(template);
+        let nodeInfo = templateInfo.nodeInfo;
+        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;
+          let b$ = info.bindings;
           if (b$){
             for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
               if (shouldAddListener(binding)) {
@@ -2186,9 +2173,9 @@
         }
       }
 
-      static _parseTemplateNode(node, note) {
-        let hostProps = note.notes.hostProps = note.notes.hostProps || {};
-        let noted = super._parseTemplateNode(node, note);
+      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) {
@@ -2196,11 +2183,11 @@
             // NOTE: default to a space here so the textNode remains; some browsers
             // (IE) evacipate an empty textNode following cloneNode/importNode.
             node.textContent = literalFromParts(parts) || ' ';
-            note.bindings = note.bindings || [];
-            note.bindings.push({
+            nodeInfo.bindings = nodeInfo.bindings || [];
+            nodeInfo.bindings.push({
               kind: 'text',
               name: 'textContent',
-              parts: parts,
+              parts,
               isCompound: parts.length !== 1
             });
             noted = true;
@@ -2209,8 +2196,8 @@
         return noted;
       }
 
-      static _parseTemplateNodeAttribute(node, note, name, value) {
-        let parts = parseBindings(value, note.notes.hostProps);
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+        let parts = parseBindings(value, templateInfo.hostProps);
         if (parts) {
           // Attribute or property
           let origName = name;
@@ -2241,30 +2228,25 @@
           if (kind === 'property') {
             name = propertyName;
           }
-          note.bindings = note.bindings || [];
-          note.bindings.push({
-            kind: kind,
-            name: name,
-            propertyName: propertyName,
-            parts: parts,
-            literal: literal,
+          nodeInfo.bindings = nodeInfo.bindings || [];
+          nodeInfo.bindings.push({
+            kind, name, propertyName, parts, literal,
             isCompound: parts.length !== 1
           });
           return true;
         } else {
-          return super._parseTemplateNodeAttribute(node, note, name, value);
+          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
         }
       }
 
-      static _parseTemplate(node, note) {
-        super._parseTemplate(node, note);
+      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(note.notes.hostProps,
-          note.templateContent._notes.hostProps);
+        let hostProps = Object.assign(templateInfo.hostProps, nodeInfo.templateInfo.hostProps);
         for (let prop in hostProps) {
-          note.bindings = note.bindings || [];
-          note.bindings.push({
-            index: note.index,
+          nodeInfo.bindings = nodeInfo.bindings || [];
+          nodeInfo.bindings.push({
+            index: nodeInfo.index,
             kind: 'property',
             name: '_host_' + prop,
             parts: [{
@@ -2272,8 +2254,9 @@
               value: prop
             }]
           });
+          noted = true;
         }
-        return true;
+        return noted;
       }
 
     }
diff --git a/lib/mixins/template-stamp.html b/lib/mixins/template-stamp.html
index fbb9aa9d00..0f2a08ae05 100644
--- a/lib/mixins/template-stamp.html
+++ b/lib/mixins/template-stamp.html
@@ -43,16 +43,15 @@
     return node;
   }
 
-  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;
         }
       }
@@ -62,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++) {
+  function applyEventListener(inst, node, nodeInfo, host) {
+    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, host);
       }
     }
   }
 
   // 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;
     }
   }
 
@@ -123,32 +122,26 @@
         super();
         this.$ = null;
         this.__templateNodes = null;
-        this.__templateNotes = null;
+        this.__templateNodeInfo = null;
       }
 
       /**
-       * Scans a template to produce an annotation map that stores expression metadata
-       * and information that associates the metadata to nodes in a template instance.
+       * Scans a template to produce template metadata.
        *
-       * 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"
+       * 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).
+       *
+       * `nodeInfo` metadata captured by this library include the following:
        *
-       * Generated data-structure:
        *   [
        *     {
-       *       id: '<id>',
+       *       id: '<id>',  // `id`
        *       events: [
        *         {
-       *           mode: ['auto'|''],
        *           name: '<name>'
        *           value: '<expression>'
        *         }, ...
@@ -161,134 +154,116 @@
        *           value: '<expression>'
        *         }, ...
        *       ],
-       *       parent: <reference to parent annotation>,
-       *       index: <integer index in parent's childNodes collection>
+       *       parent: <reference to parent nodeInfo>,
+       *       index: <integer index in parent's `childNodes` collection>
        *     },
        *     ...
        *   ]
        *
        * @param {HTMLTemplateElement} template
-       * @param {boolean=} stripWhiteSpace
-       * @param {Document=} ownerDocument
-       * @return {Array<Object>}
+       * @param {Object=} outerTemplateInfo
+       * @return {Object} Template metadata
        */
-      static _prepareTemplate(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);
+      static _parseTemplate(template, outerTemplateInfo) {
         // since a template may be re-used, memo-ize notes.
-        if (!content._notes) {
-          let notes = content._notes = [];
-          notes.ownerDocument = ownerDocument || template.ownerDocument;
-          notes.stripWhiteSpace = stripWhiteSpace || template.hasAttribute('strip-whitespace');
-          this._parseTemplateNode(content, {notes});
+        if (!template._templateInfo) {
+          let templateInfo = template._templateInfo || (template._templateInfo = {});
+          templateInfo.nodeInfo = [];
+          templateInfo.stripWhiteSpace =
+            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
+            template.hasAttribute('strip-whitespace');
+          this._parseTemplateNode(template.content, templateInfo, {parent: null});
         }
-        return content._notes;
+        return template._templateInfo;
       }
 
       // add annotations gleaned from subtree at `node` to `notes`
-      static _parseTemplateNode(node, note) {
+      static _parseTemplateNode(node, templateInfo, nodeInfo) {
         let noted;
-        if (node.localName == 'template' &&
-          !node.hasAttribute('preserve-content')) {
-          noted |= this._parseTemplate(node, note);
+        if (node.localName == 'template' && !node.hasAttribute('preserve-content')) {
+          noted = this._parseTemplateNestedContent(node, templateInfo, nodeInfo) || noted;
         } else if (node.localName === 'slot') {
-          node._hasInsertionPoint = true;
+          // For ShadyDom optimization, indicating there is an insertion point
+          templateInfo.hasInsertionPoint = true;
         }
         if (node.firstChild) {
-          noted |= this._parseTemplateChildNodes(node, note);
+          noted = this._parseTemplateChildNodes(node, templateInfo, nodeInfo) || noted;
         }
-        if (node.attributes) {
-          noted |= this._parseTemplateNodeAttributes(node, note);
+        if (node.hasAttributes && node.hasAttributes()) {
+          noted = this._parseTemplateNodeAttributes(node, templateInfo, nodeInfo) || noted;
         }
         return noted;
       }
 
-      // add annotations gleaned from children of `root` to `list`, `root`'s
-      // `note` is supplied as it is the note.parent of added annotations
-      static _parseTemplateChildNodes(root, note) {
-        let node = root.firstChild;
-        if (node) {
-          let i = 0;
-          while (node) {
-            // 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.
-            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 (note.notes.stripWhiteSpace && !node.textContent.trim()) {
-                root.removeChild(node);
-                // decrement index since node is removed
-                i--;
-              }
+      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;
             }
-            // if this node didn't get evacipated, parse it.
-            if (node.parentNode) {
-              let childNote = {
-                notes: note.notes,
-                parent: note,
-                index: i
-              }
-              if (this._parseTemplateNode(node, childNote)) {
-                note.notes.push(childNote);
-              }
+            // optionally strip whitespace
+            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
+              root.removeChild(node);
+              continue;
             }
-            node = next;
-            i++;
           }
+          let childInfo = { index, parent: nodeInfo };
+          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
+            templateInfo.nodeInfo.push(childInfo);
+          }
+          index++;
         }
       }
 
       // Recurse into nested templates
       // 1. Parse annotations from the template and memoize them on
-      //    content._notes (recurses into nested templates)
+      //    content._templateInfo (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)
-      static _parseTemplate(node, note) {
-        let content = node.content.ownerDocument.createDocumentFragment();
-        content._notes = this._prepareTemplate(node,
-          note.notes.stripWhiteSpace, note.notes.ownerDocument);
+      static _parseTemplateNestedContent(node, outerTemplateInfo, nodeInfo) {
+        let templateInfo = this._parseTemplate(node, outerTemplateInfo);
+        let content = templateInfo.content =
+          node.content.ownerDocument.createDocumentFragment();
         content.appendChild(node.content);
-        note.templateContent = content;
+        nodeInfo.templateInfo = templateInfo;
         return true;
       }
 
       // add annotation data from attributes to the `annotation` for node `node`
-      static _parseTemplateNodeAttributes(node, note) {
+      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
         // 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);
         let noted;
+        let attrs = Array.from(node.attributes);
         for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
-          noted |= this._parseTemplateNodeAttribute(node, note, a.name, a.value)
+          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
         }
         return noted;
       }
 
       // construct annotation data from a generic attribute, or undefined
-      static _parseTemplateNodeAttribute(node, note, name, value) {
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
         // events (on-*)
         if (name.slice(0, 3) === 'on-') {
           node.removeAttribute(name);
-          note.events = note.events || [];
-          note.events.push({
+          nodeInfo.events = nodeInfo.events || [];
+          nodeInfo.events.push({
             name: name.slice(3),
             value
           });
@@ -296,27 +271,28 @@
         }
         // static id
         else if (name === 'id') {
-          note.id = value;
+          nodeInfo.id = value;
           return true;
         }
       }
 
+      static _contentForTemplate(template) {
+        let templateInfo = template.__templateInfo;
+        return (templateInfo && templateInfo.content) || template.content;
+      }
+
       /**
        * Clones the provided template content and returns a document fragment
        * 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
@@ -334,17 +310,19 @@
             window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
           HTMLTemplateElement.decorate(template);
         }
-        let notes = this.__templateNotes = this.constructor._prepareTemplate(template);
-        let dom = document.importNode(template._content || template.content, true);
+        let templateInfo = this.constructor._parseTemplate(template);
+        let nodeInfo = this.__templateNodeInfo = templateInfo.nodeInfo;
+        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, this);
         }
         return dom;
       }
diff --git a/lib/utils/templatize.html b/lib/utils/templatize.html
index adc3febe4b..4698f71bfe 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._notes.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._notes.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._notes.hostProps;
+        klass.prototype.__hostProps = templateInfo.hostProps;
         return klass;
       },