diff --git a/.eslintrc.json b/.eslintrc.json
index 04b84c2059..027f90891b 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -4,7 +4,21 @@
   "rules": {
     "no-console": "off",
     "no-var": "error",
-    "strict": "error"
+    "strict": "error",
+    "valid-jsdoc": ["error", {
+      "requireReturn": false,
+      "prefer": {
+        "arg": "param",
+        "argument": "param",
+        "returns": "return"
+      },
+      "preferType": {
+        "Boolean": "boolean",
+        "Number": "number",
+        "String": "string",
+        "object": "Object"
+      }
+    }]
   },
   "env": {
     "browser": true,
diff --git a/.travis.yml b/.travis.yml
index 6465d133dd..cdb0129741 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,11 +8,14 @@ addons:
     sources:
     - google-chrome
     packages:
-    - google-chrome-stable
+    - google-chrome-beta
 cache:
   directories:
   - node_modules
 before_script:
+- mkdir -p ~/bin
+- ln -s /usr/bin/google-chrome-beta ~/bin/google-chrome
+- export PATH=$HOME/bin:$PATH
 - npm install -g bower gulp-cli@1
 - bower install
 - gulp lint
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 37b25484d7..7747fca641 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-##[v1.8.1-dev](https://github.com/Polymer/polymer/tree/v1.8.1-dev) (2017-02-27)
+## [v1.8.1-dev](https://github.com/Polymer/polymer/tree/v1.8.1-dev) (2017-02-27)
 - Exclude SD polyfill tests for Edge due to lack of workarounds for Edge DocFrag bugs. ([commit](https://github.com/Polymer/polymer/commit/de45ba02))
 
 - [ci skip] Update comment to include reference to problem browser. ([commit](https://github.com/Polymer/polymer/commit/72f21fe6))
@@ -23,7 +23,7 @@
 
 - [ci skip] Update Changelog ([commit](https://github.com/Polymer/polymer/commit/2d804a28))
 
-##[v1.8.0-dev](https://github.com/Polymer/polymer/tree/v1.8.0-dev) (2017-02-06)
+## [v1.8.0-dev](https://github.com/Polymer/polymer/tree/v1.8.0-dev) (2017-02-06)
 - Add comment. ([commit](https://github.com/Polymer/polymer/commit/a42cb209))
 
 - Only keep `disable-upgrade` attribute if it is an attribute binding. ([commit](https://github.com/Polymer/polymer/commit/62e9b84b))
@@ -76,7 +76,7 @@
 
 - Close backtick in ISSUE_TEMPLATE.md ([commit](https://github.com/Polymer/polymer/commit/b0dea8bc))
 
-##[v1.7.1-dev](https://github.com/Polymer/polymer/tree/v1.7.1-dev) (2016-12-14)
+## [v1.7.1-dev](https://github.com/Polymer/polymer/tree/v1.7.1-dev) (2016-12-14)
 - Remove dependency on WebComponets for IE detection ([commit](https://github.com/Polymer/polymer/commit/650c16a9))
 
 - Make sure text nodes are distributed when translating slot to content ([commit](https://github.com/Polymer/polymer/commit/87e312f1))
@@ -121,7 +121,7 @@
 
 - Fix copy&pasted comment ([commit](https://github.com/Polymer/polymer/commit/d595c0cc))
 
-##[v1.7.0](https://github.com/Polymer/polymer/tree/v1.7.0) (2016-09-28)
+## [v1.7.0](https://github.com/Polymer/polymer/tree/v1.7.0) (2016-09-28)
 - Fix IE style cache performance ([commit](https://github.com/Polymer/polymer/commit/d08b694))
 
 - no need for :root to be first in the selector ([commit](https://github.com/Polymer/polymer/commit/63433c8))
@@ -198,7 +198,7 @@
 
 - Revert "Fix _patchMatchesEffect. (#3631)" ([commit](https://github.com/Polymer/polymer/commit/a64f227))
 
-##[v1.6.1](https://github.com/Polymer/polymer/tree/v1.6.1) (2016-08-01)
+## [v1.6.1](https://github.com/Polymer/polymer/tree/v1.6.1) (2016-08-01)
 - Property Shim needs to handle build output from apply shim ([commit](https://github.com/Polymer/polymer/commit/d726a51))
 
 - Do not resolve urls with leading slash and other prototcols ([commit](https://github.com/Polymer/polymer/commit/94f95ec))
@@ -285,7 +285,7 @@
 
 - Ensure fromAbove in _forwardParentProp. ([commit](https://github.com/Polymer/polymer/commit/072dcff))
 
-##[v1.6.0](https://github.com/Polymer/polymer/tree/v1.6.0) (2016-06-29)
+## [v1.6.0](https://github.com/Polymer/polymer/tree/v1.6.0) (2016-06-29)
 - Fix test to account for pseudo element differences x-browser. ([commit](https://github.com/Polymer/polymer/commit/54a462d))
 
 - Restore functionality of selectors like `:host(.foo)::after`. ([commit](https://github.com/Polymer/polymer/commit/ff88e17))
@@ -350,7 +350,7 @@
 
 - [ci skip] update changelog ([commit](https://github.com/Polymer/polymer/commit/adef722))
 
-##[v1.5.0](https://github.com/Polymer/polymer/tree/v1.5.0) (2016-05-31)
+## [v1.5.0](https://github.com/Polymer/polymer/tree/v1.5.0) (2016-05-31)
 - Fix test in Firefox that was hacked to work in Canary (instead filed https://bugs.chromium.org/p/chromium/issues/detail?id=614198). ([commit](https://github.com/Polymer/polymer/commit/1e2aed5))
 
 - remove unneeded argument ([commit](https://github.com/Polymer/polymer/commit/4a99b83))
@@ -419,7 +419,7 @@
 
 - Null debounced callback to set for GC. ([commit](https://github.com/Polymer/polymer/commit/f366c1c))
 
-##[v1.4.0](https://github.com/Polymer/polymer/tree/v1.4.0) (2016-03-18)
+## [v1.4.0](https://github.com/Polymer/polymer/tree/v1.4.0) (2016-03-18)
 - Fast check in createdCallback to see if registration has finished. ([commit](https://github.com/Polymer/polymer/commit/a3fce19))
 
 - even more lazy: defer template lookup and style collection until finish register time. ([commit](https://github.com/Polymer/polymer/commit/103f790))
@@ -448,7 +448,7 @@
 
 - [ci skip] update changelog ([commit](https://github.com/Polymer/polymer/commit/58e6713))
 
-##[v1.3.1](https://github.com/Polymer/polymer/tree/v1.3.1) (2016-03-02)
+## [v1.3.1](https://github.com/Polymer/polymer/tree/v1.3.1) (2016-03-02)
 - Fix lint errors. ([commit](https://github.com/Polymer/polymer/commit/44d06f1))
 
 - Add test. ([commit](https://github.com/Polymer/polymer/commit/02660c1))
@@ -471,7 +471,7 @@
 
 - Updated the README.md for a non-technical user to understand ([commit](https://github.com/Polymer/polymer/commit/0729cef))
 
-##[v1.3.0](https://github.com/Polymer/polymer/tree/v1.3.0) (2016-02-22)
+## [v1.3.0](https://github.com/Polymer/polymer/tree/v1.3.0) (2016-02-22)
 - [ci skip] Add instructions to pull request template ([commit](https://github.com/Polymer/polymer/commit/933c920))
 
 - [ci skip] markdown fail ([commit](https://github.com/Polymer/polymer/commit/a8e01e2))
@@ -610,7 +610,7 @@
 
 - parentProps should not override argument based props ([commit](https://github.com/Polymer/polymer/commit/898fe89))
 
-##[v1.2.4](https://github.com/Polymer/polymer/tree/v1.2.4) (2016-01-27)
+## [v1.2.4](https://github.com/Polymer/polymer/tree/v1.2.4) (2016-01-27)
 - Fixes #3337. When a doc fragment is added, only update the invalidation state of the insertion point list of the shadyRoot IFF it is not already invalid. This fixes an issue that was detected when an a doc fragment that did not include an insertion point was added after one that did but before distribution. ([commit](https://github.com/Polymer/polymer/commit/d26b003))
 
 - fix build output with new vulcanize ([commit](https://github.com/Polymer/polymer/commit/c317711))
@@ -817,7 +817,7 @@
 
 - added missing semicolons, removed some unused variables ([commit](https://github.com/Polymer/polymer/commit/338574d))
 
-##[v1.2.3](https://github.com/Polymer/polymer/tree/v1.2.3) (2015-11-16)
+## [v1.2.3](https://github.com/Polymer/polymer/tree/v1.2.3) (2015-11-16)
 - Call decorate instead of bootstrap for template prepping ([commit](https://github.com/Polymer/polymer/commit/e2a2cfd))
 
 - Fix global leak test. Necessary due to changes to test harness. ([commit](https://github.com/Polymer/polymer/commit/134766f))
@@ -836,7 +836,7 @@
 
 - Fix Formatting ([commit](https://github.com/Polymer/polymer/commit/724e1bc))
 
-##[v1.2.2](https://github.com/Polymer/polymer/tree/v1.2.2) (2015-11-12)
+## [v1.2.2](https://github.com/Polymer/polymer/tree/v1.2.2) (2015-11-12)
 - use local reference for wrap. ([commit](https://github.com/Polymer/polymer/commit/b15e5b9))
 
 - Add Polymer.DomApi.wrap ([commit](https://github.com/Polymer/polymer/commit/6cf974a))
@@ -983,7 +983,7 @@
 
 - Add test for parsing multi-line css comments ([commit](https://github.com/Polymer/polymer/commit/6f21ae6))
 
-##[v1.2.1](https://github.com/Polymer/polymer/tree/v1.2.1) (2015-10-29)
+## [v1.2.1](https://github.com/Polymer/polymer/tree/v1.2.1) (2015-10-29)
 - Fix test for SD polyfill ([commit](https://github.com/Polymer/polymer/commit/dd8b3e9))
 
 - Add pre-condition check for completeness. ([commit](https://github.com/Polymer/polymer/commit/89304dc))
@@ -1000,7 +1000,7 @@
 
 - Fix for mixins declaration with space before colon. Allow any space character or even `{` and `}` (before and after capturing pattern correspondingly) as pattern boundaries instead of new lines only. In minified sources there might be no space, semicolon or line start, so we need to account that as well. ([commit](https://github.com/Polymer/polymer/commit/883aa5c))
 
-##[v1.2.0](https://github.com/Polymer/polymer/tree/v1.2.0) (2015-10-22)
+## [v1.2.0](https://github.com/Polymer/polymer/tree/v1.2.0) (2015-10-22)
 - A simpler travis config ([commit](https://github.com/Polymer/polymer/commit/3338b67))
 
 - Fix #2587: When Polymer.dom(el).appendChild(node) is called, cleanup work must be performed on the existing parent of node. This change fixes a missing case in this cleanup work: if the existing parent has a observer via `Polymer.dom(parent).observeNodes`, it needs to be notified that node is being removed even if the node does not have specific logical info. For example, if an observed node has no Shady DOM and has a child that is removed. A test for this case was added. ([commit](https://github.com/Polymer/polymer/commit/0d4f418))
@@ -1089,7 +1089,7 @@
 
 - Adds `getEffectiveChildNodes`, `getEffectiveChildren`, `getEffectiveTextContent` ([commit](https://github.com/Polymer/polymer/commit/f34fb45))
 
-##[v1.1.5](https://github.com/Polymer/polymer/tree/v1.1.5) (2015-10-08)
+## [v1.1.5](https://github.com/Polymer/polymer/tree/v1.1.5) (2015-10-08)
 - Simplify ([commit](https://github.com/Polymer/polymer/commit/79dfe1f))
 
 - Clean up templatizer _pathEffectorImpl. ([commit](https://github.com/Polymer/polymer/commit/1a89bcf))
@@ -1126,7 +1126,7 @@
 
 - update CHANGELOG to 1.1.4 ([commit](https://github.com/Polymer/polymer/commit/c2b7c31))
 
-##[v1.1.4](https://github.com/Polymer/polymer/tree/v1.1.4) (2015-09-25)
+## [v1.1.4](https://github.com/Polymer/polymer/tree/v1.1.4) (2015-09-25)
 - :memo: Update description ([commit](https://github.com/Polymer/polymer/commit/6afb8be))
 
 - :art: Use npm command bin lookup ([commit](https://github.com/Polymer/polymer/commit/84258d4))
@@ -1155,7 +1155,7 @@
 
 - Fix typos in PRIMER.md ([commit](https://github.com/Polymer/polymer/commit/cf793f4))
 
-##[v1.1.3](https://github.com/Polymer/polymer/tree/v1.1.3) (2015-09-04)
+## [v1.1.3](https://github.com/Polymer/polymer/tree/v1.1.3) (2015-09-04)
 - Fixes #2403 ([commit](https://github.com/Polymer/polymer/commit/a6694b7))
 
 - Only try to decrement gesture dependency counter if dependency exists ([commit](https://github.com/Polymer/polymer/commit/8886e8c))
@@ -1164,7 +1164,7 @@
 
 - prepare v1.1.2 ([commit](https://github.com/Polymer/polymer/commit/e78be4f))
 
-##[v1.1.2](https://github.com/Polymer/polymer/tree/v1.1.2) (2015-08-28)
+## [v1.1.2](https://github.com/Polymer/polymer/tree/v1.1.2) (2015-08-28)
 - Improve composed parent tracking. ([commit](https://github.com/Polymer/polymer/commit/4d15789))
 
 - move the mixing-in of behaviors so that it happens before `register` behaviors are invoked ([commit](https://github.com/Polymer/polymer/commit/637367c))
@@ -1199,7 +1199,7 @@
 
 - Update changelog with v1.1.1 release ([commit](https://github.com/Polymer/polymer/commit/12fa867))
 
-##[v1.1.1](https://github.com/Polymer/polymer/tree/v1.1.1) (2015-08-20)
+## [v1.1.1](https://github.com/Polymer/polymer/tree/v1.1.1) (2015-08-20)
 - Fixes #2263: ensure custom-style can parse variable definitions in supported selectors (e.g. /deep/) without exception due to unknown css. ([commit](https://github.com/Polymer/polymer/commit/894492b))
 
 - Fixes #2311, #2323: when elements are removed from their previous position when they are added elsewhere, make sure to remove them from composed, not logical parent. ([commit](https://github.com/Polymer/polymer/commit/3d93116))
@@ -1226,7 +1226,7 @@
 
 - Support for negative numbers in computed bindings ([commit](https://github.com/Polymer/polymer/commit/fc53f50))
 
-##[v1.1.0](https://github.com/Polymer/polymer/tree/v1.1.0) (2015-08-13)
+## [v1.1.0](https://github.com/Polymer/polymer/tree/v1.1.0) (2015-08-13)
 - Add comment. ([commit](https://github.com/Polymer/polymer/commit/337b54a))
 
 - Add tests for key splice fix. ([commit](https://github.com/Polymer/polymer/commit/4bc055b))
@@ -1257,7 +1257,7 @@
 
 - don-module no longer needs to eagerly upgrade custom elements since the web components polyfills do this automatically. ([commit](https://github.com/Polymer/polymer/commit/051e1bf))
 
-##[v1.0.9](https://github.com/Polymer/polymer/tree/v1.0.9) (2015-08-07)
+## [v1.0.9](https://github.com/Polymer/polymer/tree/v1.0.9) (2015-08-07)
 - Remove undocumented return value. ([commit](https://github.com/Polymer/polymer/commit/1764d0c))
 
 - Add default, update docs. ([commit](https://github.com/Polymer/polymer/commit/ca267a5))
@@ -1340,7 +1340,7 @@
 
 - Fix #2107: improve binding expression parser to match valid javascript property names. ([commit](https://github.com/Polymer/polymer/commit/7560130))
 
-##[v1.0.8](https://github.com/Polymer/polymer/tree/v1.0.8) (2015-07-23)
+## [v1.0.8](https://github.com/Polymer/polymer/tree/v1.0.8) (2015-07-23)
 - Disable tracking if scrolling ([commit](https://github.com/Polymer/polymer/commit/ee5177d))
 
 - Fixes #2125: adds a register method to dom-module to support imperative creation. ([commit](https://github.com/Polymer/polymer/commit/861f4aa))
@@ -1383,7 +1383,7 @@
 
 - Update index.html ([commit](https://github.com/Polymer/polymer/commit/119df98))
 
-##[v1.0.7](https://github.com/Polymer/polymer/tree/v1.0.7) (2015-07-16)
+## [v1.0.7](https://github.com/Polymer/polymer/tree/v1.0.7) (2015-07-16)
 - Replace placeholders backwards to simplify. ([commit](https://github.com/Polymer/polymer/commit/5eda235))
 
 - Remove unnecessary keys bookkeeping. ([commit](https://github.com/Polymer/polymer/commit/3e02bfd))
diff --git a/README.md b/README.md
index f1517d1cae..52bb45ab54 100644
--- a/README.md
+++ b/README.md
@@ -367,9 +367,7 @@ Note that `Polymer.Element` provides a cleaner base class void of a lot of sugar
 
 See below for a visual guide on migrating Polymer 1.0's declarative syntax to the ES6 class syntax in Polymer 2.0:
 
-<a href="">
-![image](img/migration.png)
-</a>
+![Difference in Polymer 1.0 and Polymer 2.0 element definition](img/migration.png)
 
 ## Polyfills
 
@@ -488,7 +486,7 @@ configure the module name. The only supported declarative way set the module
 id is to use `id`.
 * <a name="breaking-getPropertyInfo"></a>`element.getPropertyInfo`: This api returned unexpected information some of the time and was rarely used.
 * <a name="breaking-getNativePrototype"></a>`element.getNativePrototype`: Removed because it is no longer needed for internal code and was unused by users.
-* <a name="breaking-beforeRegister"></a>`element.beforeRegister`: This was originally added for metadata compatibility with ES6 classes. We now prefer users create ES6 classes by extending `Polymer.Element`, specifying metadata in the static `config` property. For legacy use via `Polymer({...})`, dynamic effects may now be added using the `registered` lifecycle method.
+* <a name="breaking-beforeRegister"></a>`element.beforeRegister`: This was originally added for metadata compatibility with ES6 classes. We now prefer users create ES6 classes by extending `Polymer.Element`, specifying metadata in the static `properties`, `observers`, and `is` properties. For legacy use via `Polymer({...})`, dynamic effects may still be added by using `beforeRegister` but it is now equivalent to the `registered` lifecycle method. An element's `is` property cannot be set in `beforeRegister` as it could in Polymer 1.x.
 * <a name="breaking-attributeFollows"></a>`element.attributeFollows`: Removed due to disuse.
 * <a name="breaking-classFollows"></a>`element.classFollows`: Removed due to disuse.
 * <a name="breaking-copyOwnProperty"></a>`element.copyOwnProperty`: Removed due to disuse.
diff --git a/bower.json b/bower.json
index 434ce7e1f2..dd2e1634a2 100644
--- a/bower.json
+++ b/bower.json
@@ -1,6 +1,6 @@
 {
   "name": "polymer",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.5",
   "main": [
     "polymer.html"
   ],
diff --git a/lib/elements/array-selector.html b/lib/elements/array-selector.html
index 3857ddf10f..b020b23a00 100644
--- a/lib/elements/array-selector.html
+++ b/lib/elements/array-selector.html
@@ -202,7 +202,6 @@
       /**
        * Clears the selection state.
        *
-       * @method clearSelection
        */
       clearSelection() {
         // Unbind previous selection
@@ -220,7 +219,6 @@
       /**
        * Returns whether the item is currently selected.
        *
-       * @method isSelected
        * @param {*} item Item from `items` array to test
        * @return {boolean} Whether the item is selected
        */
@@ -231,7 +229,6 @@
       /**
        * Returns whether the item is currently selected.
        *
-       * @method isSelected
        * @param {*} idx Index from `items` array to test
        * @return {boolean} Whether the item is selected
        */
@@ -261,7 +258,6 @@
       /**
        * Deselects the given item if it is already selected.
        *
-       * @method deselect
        * @param {*} item Item from `items` array to deselect
        */
       deselect(item) {
@@ -284,7 +280,6 @@
       /**
        * Deselects the given index if it is already selected.
        *
-       * @method deselect
        * @param {number} idx Index from `items` array to deselect
        */
       deselectIndex(idx) {
@@ -295,7 +290,6 @@
        * Selects the given item.  When `toggle` is true, this will automatically
        * deselect the item if already selected.
        *
-       * @method select
        * @param {*} item Item from `items` array to select
        */
       select(item) {
@@ -306,7 +300,6 @@
        * Selects the given index.  When `toggle` is true, this will automatically
        * deselect the item if already selected.
        *
-       * @method select
        * @param {number} idx Index from `items` array to select
        */
       selectIndex(idx) {
diff --git a/lib/elements/dom-bind.html b/lib/elements/dom-bind.html
index a03379219d..436791d85c 100644
--- a/lib/elements/dom-bind.html
+++ b/lib/elements/dom-bind.html
@@ -10,6 +10,8 @@
 
 <link rel="import" href="../utils/boot.html">
 <link rel="import" href="../mixins/property-effects.html">
+<link rel="import" href="../mixins/mutable-data.html">
+<link rel="import" href="../mixins/gesture-event-listeners.html">
 
 <script>
 
@@ -20,9 +22,13 @@
      * @constructor
      * @implements {Polymer_PropertyEffects}
      * @implements {Polymer_OptionalMutableData}
+     * @implements {Polymer_GestureEventListener}
      * @extends {HTMLElement}
      */
-    const domBindBase = Polymer.OptionalMutableData(Polymer.PropertyEffects(HTMLElement));
+    const domBindBase =
+      Polymer.GestureEventListeners(
+        Polymer.OptionalMutableData(
+          Polymer.PropertyEffects(HTMLElement)));
 
     /**
      * Custom element to allow using Polymer's template features (data binding,
@@ -91,8 +97,8 @@
             observer.observe(this, {childList: true});
             return;
           }
-          this._bindTemplate(template);
           this.root = this._stampTemplate(template);
+          this.$ = this.root.$;
           this.__children = [];
           for (let n=this.root.firstChild; n; n=n.nextSibling) {
             this.__children[this.__children.length] = n;
diff --git a/lib/elements/dom-module.html b/lib/elements/dom-module.html
index 467b857336..99edb7f109 100644
--- a/lib/elements/dom-module.html
+++ b/lib/elements/dom-module.html
@@ -54,13 +54,12 @@
     static get observedAttributes() { return ['id'] }
 
     /**
-     * Retrieves the dom specified by `selector` in the module specified by
-     * `id`. For example, this.import('foo', 'img');
-     * @method register
-     * @param {string} id
-     * @param {string=} selector
-     * @return {Element} Returns the dom which matches `selector` in the module
-     * at the specified `id`.
+     * Retrieves the element specified by the css `selector` in the module
+     * registered by `id`. For example, this.import('foo', 'img');
+     * @param {string} id The id of the dom-module in which to search.
+     * @param {string=} selector The css selector by which to find the element.
+     * @return {Element} Returns the element which matches `selector` in the
+     * module registered at the specified `id`.
      */
     static import(id, selector) {
       if (id) {
@@ -108,7 +107,6 @@
      * Registers the dom-module at a given id. This method should only be called
      * when a dom-module is imperatively created. For
      * example, `document.createElement('dom-module').register('foo')`.
-     * @method register
      * @param {string=} id The id at which to register the dom-module.
      */
     register(id) {
diff --git a/lib/elements/dom-repeat.html b/lib/elements/dom-repeat.html
index 7c8d5300f1..69690143f0 100644
--- a/lib/elements/dom-repeat.html
+++ b/lib/elements/dom-repeat.html
@@ -455,8 +455,8 @@
     }
 
     /**
-     * @param {function()} fn
-     * @param {number=} delay
+     * @param {function()} fn Function to debounce.
+     * @param {number=} delay Delay in ms to debounce by.
      */
     __debounceRender(fn, delay) {
       this.__renderDebouncer = Polymer.Debouncer.debounce(
@@ -633,7 +633,6 @@
      * `modelForElement(el).set('item.<sub-prop>', value)`
      * should be used.
      *
-     * @method itemForElement
      * @param {HTMLElement} el Element for which to return the item.
      * @return {*} Item associated with the element.
      */
@@ -647,7 +646,6 @@
      * If `sort` is provided, the index will reflect the sorted order (rather
      * than the original array order).
      *
-     * @method indexForElement
      * @param {HTMLElement} el Element for which to return the index.
      * @return {*} Row index associated with the element (note this may
      *   not correspond to the array index if a user `sort` is applied).
@@ -670,7 +668,6 @@
      *     model.set('item.checked', true);
      *   }
      *
-     * @method modelForElement
      * @param {HTMLElement} el Element for which to return a template model.
      * @return {TemplateInstanceBase} Model representing the binding scope for
      *   the element.
diff --git a/lib/legacy/class.html b/lib/legacy/class.html
index 108e3d1f4f..a63c6a16a7 100644
--- a/lib/legacy/class.html
+++ b/lib/legacy/class.html
@@ -35,8 +35,10 @@
      * to ensure that any legacy behaviors can rely on legacy Polymer API on
      * the underlying element.
      *
-     * @param {Object|Array} behaviors Behavior object or array of behaviors
-     * @param {HTMLElement} klass Element class
+     * @param {Object|Array} behaviors Behavior object or array of behaviors.
+     * @param {HTMLElement} klass Element class.
+     * @return {HTMLElement} Returns a new Element class extended by the
+     * passed in `behaviors` and also by `Polymer.LegacyElementMixin`.
      * @memberof Polymer
      */
     function mixinBehaviors(behaviors, klass) {
@@ -105,9 +107,10 @@
     }
 
     /**
-     * @param {Array} behaviors
-     * @param {Array=} list
-     * @param {Array=} exclude
+     * @param {Array} behaviors List of behaviors to flatten.
+     * @param {Array=} list Target list to flatten behaviors into.
+     * @param {Array=} exclude List of behaviors to exclude from the list.
+     * @return {Array} Returns the list of flattened behaviors.
      */
     function flattenBehaviors(behaviors, list, exclude) {
       list = list || [];
@@ -162,6 +165,16 @@
 
         _registered() {
           super._registered();
+          /* NOTE: `beforeRegister` is called here for bc, but the behavior
+           is different than in 1.x. In 1.0, the method was called *after*
+           mixing prototypes together but *before* processing of meta-objects.
+           However, dynamic effects can still be set here and can be done either
+           in `beforeRegister` or `registered`. It is no longer possible to set
+           `is` in `beforeRegister` as you could in 1.x.
+          */
+          if (info.beforeRegister) {
+            info.beforeRegister.call(Object.getPrototypeOf(this));
+          }
           if (info.registered) {
             info.registered.call(Object.getPrototypeOf(this));
           }
@@ -311,13 +324,6 @@
         LegacyElementMixin(HTMLElement));
       // decorate klass with registration info
       klass.is = info.is;
-      // NOTE: while we could call `beforeRegister` here to maintain
-      // some BC, the state of the element at this point is not as it was in 1.0
-      // In 1.0, the method was called *after* mixing prototypes together
-      // but before processing of meta-objects. Since this is now done
-      // in 1 step via `GenerateClassFromInfo`, this is no longer possible.
-      // However, *most* work (not setting `is`) that was previously done in
-      // `beforeRegister` should be possible in `registered`.
       return klass;
     }
 
diff --git a/lib/legacy/legacy-element-mixin.html b/lib/legacy/legacy-element-mixin.html
index 5f22752ee7..6555392ed2 100644
--- a/lib/legacy/legacy-element-mixin.html
+++ b/lib/legacy/legacy-element-mixin.html
@@ -72,6 +72,7 @@
 
       constructor() {
         super();
+        this.root = this;
         this.created();
       }
 
@@ -206,6 +207,7 @@
        *
        * @param {string} value String to deserialize
        * @param {*} type Type to deserialize the string to
+       * @return {*} Returns the deserialized value in the `type` given.
        */
       deserialize(value, type) {
         return this._deserializeValue(value, type);
@@ -243,7 +245,6 @@
        * Copies own properties (including accessor descriptors) from a source
        * object to a target object.
        *
-       * @method extend
        * @param {Object} prototype Target object to copy properties to.
        * @param {Object} api Source object to copy properties from.
        * @return {Object} prototype object that was passed as first argument.
@@ -269,7 +270,6 @@
        * properties.  To ensure only `ownProperties` are copied from source
        * to target and that accessor implementations are copied, use `extend`.
        *
-       * @method mixin
        * @param {Object} target Target object to copy properties to.
        * @param {Object} source Source object to copy properties from.
        * @return {Object} Target object that was passed as first argument.
@@ -286,10 +286,15 @@
        *
        * Note this method is provided as backward-compatible legacy API
        * only.  It is not directly called by any Polymer features.
-       */
-      chainObject(object, inherited) {
-        if (object && inherited && object !== inherited) {
-          object.__proto__ = inherited;
+       * @param {Object} object The object on which to set the prototype.
+       * @param {Object} prototype The prototype that will be set on the given
+       * `object`.
+       * @return {Object} Returns the given `object` with its prototype set
+       * to the given `prototype` object.
+       */
+      chainObject(object, prototype) {
+        if (object && prototype && object !== prototype) {
+          object.__proto__ = prototype;
         }
         return object;
       }
@@ -300,14 +305,14 @@
        * Calls `importNode` on the `content` of the `template` specified and
        * returns a document fragment containing the imported content.
        *
-       * @method instanceTemplate
        * @param {HTMLTemplateElement} template HTML template element to instance.
        * @return {DocumentFragment} Document fragment containing the imported
        *   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;
       }
 
@@ -316,7 +321,6 @@
       /**
        * Dispatches a custom event with an optional detail value.
        *
-       * @method fire
        * @param {string} type Name of event type.
        * @param {*=} detail Detail value containing event-specific
        *   payload.
@@ -344,7 +348,6 @@
        * Convenience method to add an event listener on a given element,
        * late bound to a named method on this element.
        *
-       * @method listen
        * @param {Element} node Element to add event listener to.
        * @param {string} eventName Name of event to listen for.
        * @param {string} methodName Name of handler method on `this` to call.
@@ -369,7 +372,6 @@
        * Convenience method to remove an event listener from a given element,
        * late bound to a named method on this element.
        *
-       * @method unlisten
        * @param {Element} node Element to remove event listener from.
        * @param {string} eventName Name of event to stop listening to.
        * @param {string} methodName Name of handler method on `this` to not call
@@ -395,8 +397,7 @@
        *   - 'y': scroll only in the 'y' direction
        *   - 'none': disable scrolling for this node
        *
-       * @method setScrollDirection
-       * @param {String=} direction Direction to allow scrolling
+       * @param {string=} direction Direction to allow scrolling
        * Defaults to `all`.
        * @param {HTMLElement=} node Element to apply scroll direction setting.
        * Defaults to `this`.
@@ -411,7 +412,6 @@
        *
        * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
        *
-       * @method $$
        * @param {string} slctr Selector to run on this local DOM scope
        * @return {Element} Element found by the selector, or null if not found.
        */
@@ -436,7 +436,6 @@
        * a user should call `distributeContent` if distribution has been
        * invalidated due to an element being added or removed from the shadowRoot
        * that contains an insertion point (<slot>) inside its subtree.
-       * @method distributeContent
        */
       distributeContent() {
         if (window.ShadyDOM && this.shadowRoot) {
@@ -450,7 +449,6 @@
        * any `<content>` elements are replaced with the list of nodes distributed
        * to the `<content>`, the result of its `getDistributedNodes` method.
        *
-       * @method getEffectiveChildNodes
        * @return {Array<Node>} List of effctive child nodes.
        */
       getEffectiveChildNodes() {
@@ -461,7 +459,6 @@
        * Returns a list of nodes distributed within this element that match
        * `selector`. These can be dom children or elements distributed to
        * children that are insertion points.
-       * @method queryDistributedElements
        * @param {string} selector Selector to run.
        * @return {Array<Node>} List of distributed elements that match selector.
        */
@@ -475,7 +472,6 @@
        * any `<content>` elements are replaced with the list of elements
        * distributed to the `<content>`.
        *
-       * @method getEffectiveChildren
        * @return {Array<Node>} List of effctive children.
        */
       getEffectiveChildren() {
@@ -490,7 +486,6 @@
        * text content's of the element's effective childNodes (the elements
        * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
        *
-       * @method getEffectiveTextContent
        * @return {string} List of effctive children.
        */
       getEffectiveTextContent() {
@@ -508,7 +503,6 @@
        * Returns the first effective childNode within this element that
        * match `selector`. These can be dom child nodes or elements distributed
        * to children that are insertion points.
-       * @method queryEffectiveChildren
        * @param {string} selector Selector to run.
        * @return {Object<Node>} First effective child node that matches selector.
        */
@@ -521,7 +515,6 @@
        * Returns a list of effective childNodes within this element that
        * match `selector`. These can be dom child nodes or elements distributed
        * to children that are insertion points.
-       * @method queryEffectiveChildren
        * @param {string} selector Selector to run.
        * @return {Array<Node>} List of effective child nodes that match selector.
        */
@@ -535,8 +528,7 @@
        * If this element contains more than one `<slot>` in its local DOM,
        * an optional selector may be passed to choose the desired content.
        *
-       * @method getContentChildNodes
-       * @param {String=} slctr CSS selector to choose the desired
+       * @param {string=} slctr CSS selector to choose the desired
        *   `<slot>`.  Defaults to `content`.
        * @return {Array<Node>} List of distributed nodes for the `<slot>`.
        */
@@ -554,8 +546,7 @@
        * content.  This method differs from `getContentChildNodes` in that only
        * elements are returned.
        *
-       * @method getContentChildNodes
-       * @param {String=} slctr CSS selector to choose the desired
+       * @param {string=} slctr CSS selector to choose the desired
        *   `<content>`.  Defaults to `content`.
        * @return {Array<HTMLElement>} List of distributed nodes for the
        *   `<slot>`.
@@ -569,9 +560,8 @@
       /**
        * Checks whether an element is in this element's light DOM tree.
        *
-       * @method isLightDescendant
        * @param {?Node} node The element to be checked.
-       * @return {Boolean} true if node is in this element's light DOM tree.
+       * @return {boolean} true if node is in this element's light DOM tree.
        */
       isLightDescendant(node) {
         return this !== node && this.contains(node) &&
@@ -581,7 +571,6 @@
       /**
        * Checks whether an element is in this element's local DOM tree.
        *
-       * @method isLocalDescendant
        * @param {HTMLElement=} node The element to be checked.
        * @return {boolean} true if node is in this element's local DOM tree.
        */
@@ -595,8 +584,9 @@
 
       /**
        * Returns the computed style value for the given property.
-       * @param {String} property
-       * @return {String} the computed value
+       * @param {string} property The css property name.
+       * @return {string} Returns the computed css property value for the given
+       * `property`.
        */
       getComputedStyleValue(property) {
         return styleInterface.getComputedStyleValue(this, property);
@@ -617,12 +607,16 @@
        *       } 100);
        *     }
        *
-       * @method debounce
-       * @param {String} jobName String to indentify the debounce job.
+       * @param {string} jobName String to indentify the debounce job.
        * @param {function()} callback Function that is called (with `this`
        *   context) when the wait time elapses.
        * @param {number} wait Optional wait time in milliseconds (ms) after the
        *   last signal that must elapse before invoking `callback`
+       * @return {Object} Returns a debouncer object on which exists the
+       * following methods: `isActive()` returns true if the debouncer is
+       * active; `cancel()` cancels the debouncer if it is active;
+       * `flush()` immediately invokes the debounced callback if the debouncer
+       * is active.
        */
       debounce(jobName, callback, wait) {
         this._debouncers = this._debouncers || {};
@@ -635,8 +629,7 @@
       /**
        * Returns whether a named debouncer is active.
        *
-       * @method isDebouncerActive
-       * @param {String} jobName The name of the debouncer started with `debounce`
+       * @param {string} jobName The name of the debouncer started with `debounce`
        * @return {boolean} Whether the debouncer is active (has not yet fired).
        */
       isDebouncerActive(jobName) {
@@ -648,8 +641,7 @@
       /**
        * Immediately calls the debouncer `callback` and inactivates it.
        *
-       * @method flushDebouncer
-       * @param {String} jobName The name of the debouncer started with `debounce`
+       * @param {string} jobName The name of the debouncer started with `debounce`
        */
       flushDebouncer(jobName) {
         this._debouncers = this._debouncers || {};
@@ -662,8 +654,7 @@
       /**
        * Cancels an active debouncer.  The `callback` will not be called.
        *
-       * @method cancelDebouncer
-       * @param {String} jobName The name of the debouncer started with `debounce`
+       * @param {string} jobName The name of the debouncer started with `debounce`
        */
       cancelDebouncer(jobName) {
         this._debouncers = this._debouncers || {}
@@ -679,7 +670,6 @@
        * By default (if no waitTime is specified), async callbacks are run at
        * microtask timing, which will occur before paint.
        *
-       * @method async
        * @param {Function} callback The callback function to run, bound to `this`.
        * @param {number=} waitTime Time to wait before calling the
        *   `callback`.  If unspecified or 0, the callback will be run at microtask
@@ -694,7 +684,6 @@
       /**
        * Cancels an async operation started with `async`.
        *
-       * @method cancelAsync
        * @param {number} handle Handle returned from original `async` call to
        *   cancel.
        */
@@ -708,7 +697,6 @@
       /**
        * Convenience method for creating an element and configuring it.
        *
-       * @method create
        * @param {string} tag HTML element tag to create.
        * @param {Object} props Object of properties to configure on the
        *    instance.
@@ -736,7 +724,6 @@
        * In the `onload` callback, the `import` property of the `link`
        * element will contain the imported document contents.
        *
-       * @method importHref
        * @param {string} href URL to document to load.
        * @param {Function} onload Callback to notify when an import successfully
        *   loaded.
@@ -756,7 +743,6 @@
        * Polyfill for Element.prototype.matches, which is sometimes still
        * prefixed.
        *
-       * @method elementMatches
        * @param {string} selector Selector to test.
        * @param {Element=} node Element to test the selector against.
        * @return {boolean} Whether the element matches the selector.
@@ -768,8 +754,7 @@
       /**
        * Toggles an HTML attribute on or off.
        *
-       * @method toggleAttribute
-       * @param {String} name HTML attribute name
+       * @param {string} name HTML attribute name
        * @param {boolean=} bool Boolean to force the attribute on or off.
        *    When unspecified, the state of the attribute will be reversed.
        * @param {HTMLElement=} node Node to target.  Defaults to `this`.
@@ -790,8 +775,7 @@
       /**
        * Toggles a CSS class on or off.
        *
-       * @method toggleClass
-       * @param {String} name CSS class name
+       * @param {string} name CSS class name
        * @param {boolean=} bool Boolean to force the class on or off.
        *    When unspecified, the state of the class will be reversed.
        * @param {HTMLElement=} node Node to target.  Defaults to `this`.
@@ -825,7 +809,6 @@
        * Cross-platform helper for setting an element's CSS `translate3d`
        * property.
        *
-       * @method translate3d
        * @param {number} x X offset.
        * @param {number} y Y offset.
        * @param {number} z Z offset.
@@ -847,7 +830,6 @@
        * If the array is passed directly, **no change
        * notification is generated**.
        *
-       * @method arrayDelete
        * @param {string | !Array<number|string>} arrayOrPath Path to array from which to remove the item
        *   (or the array itself).
        * @param {*} item Item to remove.
diff --git a/lib/legacy/templatizer-behavior.html b/lib/legacy/templatizer-behavior.html
index 653e52e5f8..4f3a14aa85 100644
--- a/lib/legacy/templatizer-behavior.html
+++ b/lib/legacy/templatizer-behavior.html
@@ -84,10 +84,9 @@
        * by `stamp` to create new instances of the template.
        *
        * @param {HTMLTemplateElement} template Template to prepare
-       * @param {Boolean=} mutableData When `true`, the generated class will skip
+       * @param {boolean=} mutableData When `true`, the generated class will skip
        *   strict dirty-checking for objects and arrays (always consider them to
        *   be "dirty"). Defaults to false.
-       * @return {TemplateInstance} Description
        */
       templatize(template, mutableData) {
         this._templatizerTemplate = template;
@@ -109,6 +108,8 @@
        *
        * @param {Object=} model Object containing initial property values to
        *   populate into the template bindings.
+       * @return {TemplateInstanceBase} Returns the created instance of
+       * the template prepared by `templatize`.
        */
       stamp(model) {
         return new this.ctor(model);
@@ -120,7 +121,6 @@
        * instance the element is contained in.  A template model should be used
        * to manipulate data associated with this template instance.
        *
-       * @method modelForElement
        * @param {HTMLElement} el Element for which to return a template model.
        * @return {TemplateInstanceBase} Model representing the binding scope for
        *   the element.
diff --git a/lib/mixins/element-mixin.html b/lib/mixins/element-mixin.html
index 2025b5fad0..3d3739481c 100644
--- a/lib/mixins/element-mixin.html
+++ b/lib/mixins/element-mixin.html
@@ -129,12 +129,16 @@
 
     let caseMap = Polymer.CaseMap;
 
+    const DISABLED = 'disable-upgrade';
+
     /**
      * Returns the `properties` object specifically on `klass`. Use for:
      * (1) super chain mixes togther to make `propertiesForClass` which is
      * then used to make `observedAttributes`.
      * (2) properties effects and observers are created from it at `finalize` time.
-     * @param {HTMLElement} klass
+     *
+     * @param {HTMLElement} klass Element class
+     * @return {Object} Object containing own properties for this class
      * @private
      */
     function ownPropertiesForClass(klass) {
@@ -150,7 +154,9 @@
     /**
      * Returns the `observers` array specifically on `klass`. Use for
      * setting up observers.
-     * @param {HTMLElement} klass
+     *
+     * @param {HTMLElement} klass Element class
+     * @return {Array} Array containing own observers for this class
      * @private
      */
     function ownObserversForClass(klass) {
@@ -166,8 +172,10 @@
     /**
      * Mixes `props` into `flattenedProps` but upgrades shorthand type
      * syntax to { type: Type}.
-     * @param {Object} flattenedProps
-     * @param {Object} props
+     *
+     * @param {Object} flattenedProps Bag to collect flattened properties into
+     * @param {Object} props Bag of properties to add to `flattenedProps`
+     * @return {Objecg} The input `flattenedProps` bag
      * @private
      */
     function flattenProperties(flattenedProps, props) {
@@ -186,8 +194,9 @@
      * constructor's `config.properties`. This list is used to create
      * (1) observedAttributes,
      * (2) class property default values
-     * @param {HTMLElement} klass
-     * @return {PolymerElementProperties}
+     *
+     * @param {HTMLElement} klass Element class
+     * @return {PolymerElementProperties} Flattened properties for this class
      * @private
      */
     function propertiesForClass(klass) {
@@ -210,8 +219,10 @@
      * This list is created as an optimization since it is a subset of
      * the list returned from `propertiesForClass`.
      * This list is used in `_initializeProperties` to set property defaults.
-     * @param {HTMLElement} klass
-     * @return {PolymerElementProperties}
+     *
+     * @param {HTMLElement} klass Element class
+     * @return {PolymerElementProperties} Flattened properties for this class
+     *   that have default values
      * @private
      */
     function propertyDefaultsForClass(klass) {
@@ -232,7 +243,9 @@
 
     /**
      * Returns true if a `klass` has finalized. Called in `ElementClass.finalize()`
-     * @param {HTMLElement} klass
+     * @param {HTMLElement} klass Element class
+     * @return {boolean} True if all metaprogramming for this class has been
+     *   completed
      * @private
      */
     function hasClassFinalized(klass) {
@@ -243,7 +256,8 @@
      * Called by `ElementClass.finalize()`. Ensures this `klass` and
      * *all superclasses* are finalized by traversing the prototype chain
      * and calling `klass.finalize()`.
-     * @param {HTMLElement} klass
+     *
+     * @param {HTMLElement} klass Element class
      * @private
      */
     function finalizeClassAndSuper(klass) {
@@ -260,6 +274,9 @@
      * a `template`. This includes creating accessors and effects
      * for properties in `config` and the `template` as well as preparing the
      * `template` for stamping.
+     *
+     * @param {HTMLElement} klass Element class
+     * @private
      */
     function finalizeClass(klass) {
       klass.__finalized = true;
@@ -295,8 +312,10 @@
      * Leverages `PropertyEffects` to create property accessors and effects
      * supporting, observers, reflecting to attributes, change notification,
      * computed properties, and read only properties.
-     * @param {HTMLElement} proto
-     * @param {Object} properties
+     * @param {HTMLElement} proto Element class prototype to add accessors
+     *    and effects to
+     * @param {Object} properties Flattened bag of property descriptors for
+     *    this class
      * @private
      */
     function finalizeProperties(proto, properties) {
@@ -308,13 +327,18 @@
     /**
      * Configures a `proto` based on a `observers` array.
      * Leverages `PropertyEffects` to create observers.
-     * @param {HTMLElement} proto
-     * @param {Array} observers
+     * @param {HTMLElement} proto Element class prototype to add accessors
+     *   and effects to
+     * @param {Object} observers Flattened array of observer descriptors for
+     *   this class
+     * @param {Object} dynamicFns Object containing keys for any properties
+     *   that are functions and should trigger the effect when the function
+     *   reference is changed
      * @private
      */
-    function finalizeObservers(proto, observers, dynamicProperties) {
+    function finalizeObservers(proto, observers, dynamicFns) {
       for (let i=0; i < observers.length; i++) {
-        proto._createMethodObserver(observers[i], dynamicProperties);
+        proto._createMethodObserver(observers[i], dynamicFns);
       }
     }
 
@@ -367,11 +391,12 @@
      * and/or provide an advanced api for manipulating them.
      * Also consider adding warnings when an effect cannot be changed.
      *
-     * @param {HTMLElement} proto
+     * @param {HTMLElement} proto Element class prototype to add accessors
+     *   and effects to
      * @param {string} name Name of the property.
-     * @param {object} info Info object from which to create property effects.
+     * @param {Object} info Info object from which to create property effects.
      * Supported keys:
-     * @param {object} allProps Flattened map of all properties defined in this
+     * @param {Object} allProps Flattened map of all properties defined in this
      *   element (including inherited properties)
      * @private
      */
@@ -407,12 +432,14 @@
      * Configures an element `proto` to function with a given `template`.
      * The element name `is` and extends `ext` must be specified for ShadyCSS
      * style scoping.
-     * @param {Polymer_ElementMixin} proto
-     * @param {HTMLTemplateElement} template
+     *
+     * @param {HTMLElement} proto Element class prototype to add accessors
+     *   and effects to
+     * @param {HTMLTemplateElement} template Template to process and bind
      * @param {string} baseURI URL against which to resolve urls in
-     * style element cssText.
-     * @param {string} is
-     * @param {string} ext
+     *   style element cssText
+     * @param {string} is Tag name (or type extension name) for this element
+     * @param {string=} ext For type extensions, the tag name that was extended
      * @private
      */
     function finalizeTemplate(proto, template, baseURI, is, ext) {
@@ -428,9 +455,11 @@
       if (window.ShadyCSS) {
         window.ShadyCSS.prepareTemplate(template, is, ext);
       }
-      proto._bindTemplate(template, propertiesForClass(proto.constructor));
+      proto._bindTemplate(template);
     }
 
+    function flushPropertiesStub() {}
+
     /**
      * @polymerMixinClass
      * @unrestricted
@@ -448,7 +477,7 @@
        */
       static get observedAttributes() {
         if (!this.hasOwnProperty(JSCompiler_renameProperty('__observedAttributes', this))) {
-          let list = [];
+          let list = [DISABLED];
           let properties = propertiesForClass(this);
           for (let prop in properties) {
             list.push(Polymer.CaseMap.camelToDashCase(prop));
@@ -477,7 +506,7 @@
       }
 
       /**
-       * Returns the template stamped into this element's shadow root.
+       * Returns the template that will be stamped into this element's shadow root.
        *
        * If a `static get is()` getter is defined, the default implementation
        * will return the first `<template>` in a `dom-module` whose `id`
@@ -511,7 +540,7 @@
        *     }
        *   }
        *
-       * @returns {HTMLTemplateElement|string}
+       * @return {HTMLTemplateElement|string} Template to be stamped
        */
       static get template() {
         if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {
@@ -533,7 +562,7 @@
        * matching this element's static `is` property.
        * Note, this path should contain a trailing `/`.
        *
-       * @returns {string}
+       * @return {string} The import path for this element class
        */
       static get importPath() {
         if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {
@@ -544,17 +573,6 @@
         return this._importPath;
       }
 
-      constructor() {
-        super();
-        Polymer.telemetry.instanceCount++;
-        // Stamp template
-        if (this._template) {
-          this.root = this._stampTemplate(this._template);
-        } else {
-          this.root = this;
-        }
-      }
-
       /**
        * Overrides the default `Polymer.PropertyAccessors` to ensure class
        * metaprogramming related to property accessors and effects has
@@ -566,6 +584,8 @@
        * @override
        */
       _initializeProperties() {
+        Polymer.telemetry.instanceCount++;
+        hostStack.registerHost(this);
         this.constructor.finalize();
         const importPath = this.constructor.importPath;
         // note: finalize template when we have access to `localName` to
@@ -592,7 +612,9 @@
             let value = typeof info.value == 'function' ?
               info.value.call(this) :
               info.value;
-            if (this._hasPropertyEffect(p)) {
+            // Set via `_setProperty` if there is an accessor, to enable
+            // initializing readOnly property defaults
+            if (this._hasAccessor(p)) {
               this._setProperty(p, value)
             } else {
               this[p] = value;
@@ -612,10 +634,12 @@
        * @override
        */
       connectedCallback() {
-        if (window.ShadyCSS) {
+        if (window.ShadyCSS && this._template) {
           window.ShadyCSS.styleElement(this);
         }
-        this._flushProperties();
+        if (!this.__dataInitialized) {
+          this._flushProperties();
+        }
       }
 
       /**
@@ -626,6 +650,21 @@
        */
       disconnectedCallback() {}
 
+      /**
+       * Stamps the element template.
+       *
+       * @override
+       */
+      ready() {
+        if (this._template) {
+          hostStack.beginHosting(this);
+          this.root = this._stampTemplate(this._template);
+          hostStack.endHosting(this);
+          this.$ = this.root.$;
+        }
+        super.ready();
+      }
+
       /**
        * Implements `PropertyEffects`'s `_readyClients` call. Attaches
        * element dom by calling `_attachDom` with the dom stamped from the
@@ -649,7 +688,6 @@
        * However, this method may be overridden to allow an element
        * to put its dom in another location.
        *
-       * @method _attachDom
        * @throws {Error}
        * @suppress {missingReturn}
        * @param {NodeList} dom to attach to the element.
@@ -684,7 +722,19 @@
        * @override
        */
       attributeChangedCallback(name, old, value) {
-        if (old !== value) {
+        // process `disable-upgrade` specially:
+        // First we see `disable-upgrade` added and disable `_flushProperties`,
+        // then when it's removed, restore regular flushing and flush.
+        // This should only be allowed before "readying".
+        if (name === DISABLED && !this.__dataInitialized) {
+          if (value !== null) {
+            this.__flushProperties = this._flushProperties;
+            this._flushProperties = flushPropertiesStub;
+          } else {
+            this._flushProperties = this.__flushProperties;
+            this._flushProperties();
+          }
+        } else if (old !== value) {
           let property = caseMap.dashToCamelCase(name);
           let type = propertiesForClass(this.constructor)[property].type;
           if (!this._hasReadOnlyEffect(property)) {
@@ -733,11 +783,71 @@
         return Polymer.ResolveUrl.resolveUrl(url, base);
       }
 
+      /**
+       * Overrides `PropertyAccessors` to add map of dynamic functions on
+       * template info, for consumption by `PropertyEffects` template binding
+       * code. This map determines which method templates should have accessors
+       * created for them.
+       *
+       * @override
+       */
+      static _parseTemplateContent(template, templateInfo, nodeInfo) {
+        templateInfo.dynamicFns = templateInfo.dynamicFns || propertiesForClass(this);
+        return super._parseTemplateContent(template, templateInfo, nodeInfo);
+      }
+
     }
 
     return PolymerElement;
   });
 
+  /**
+   * Helper api for enqueing client dom created by a host element.
+   *
+   * By default elements are flushed via `_flushProperties` when
+   * `connectedCallback` is called. Elements attach their client dom to
+   * themselves at `ready` time which results from this first flush.
+   * This provides an ordering guarantee that the client dom an element
+   * creates is flushed before the element itself (i.e. client `ready`
+   * fires before host `ready`).
+   *
+   * However, if `_flushProperties` is called *before* an element is connected,
+   * as for example `Templatize` does, this ordering guarantee cannot be
+   * satisfied because no elements are connected. (Note: Bound elements that
+   * receive data do become enqueued clients and are properly ordered but
+   * unbound elements are not.)
+   *
+   * To maintain the desired "client before host" ordering guarantee for this
+   * case we rely on the "host stack. Client nodes registers themselves with
+   * the creating host element when created. This ensures that all client dom
+   * is readied in the proper order, maintaining the desired guarantee.
+   *
+   * @private
+   */
+  let hostStack = {
+
+    stack: [],
+
+    registerHost(inst) {
+      if (this.stack.length) {
+        let host = this.stack[this.stack.length-1];
+        host._enqueueClient(inst);
+      }
+    },
+
+    beginHosting(inst) {
+      this.stack.push(inst);
+    },
+
+    endHosting(inst) {
+      let stackLen = this.stack.length;
+      if (stackLen && this.stack[stackLen-1] == inst) {
+        this.stack.pop();
+      }
+    }
+
+  }
+
   /**
    * Provides basic tracking of element definitions (registrations) and
    * instance counts.
@@ -758,6 +868,7 @@
      */
     registrations: [],
     /**
+     * @param {HTMLElement} prototype Element prototype to log
      * @private
      */
     _regLog: function(prototype) {
@@ -765,6 +876,7 @@
     },
     /**
      * Registers a class prototype for telemetry purposes.
+     * @param {HTMLElement} prototype Element prototype to register
      * @protected
      */
     register: function(prototype) {
@@ -793,7 +905,7 @@
    *
    * These properties are retained unless a value of `null` is set.
    *
-   * @param {Object=} properties Bag of custom property key/values to
+   * @param {Object=} props Bag of custom property key/values to
    *   apply to the document.
    */
   Polymer.updateStyles = function(props) {
diff --git a/lib/mixins/mutable-data.html b/lib/mixins/mutable-data.html
index 6e1b50adf6..92d75f0261 100644
--- a/lib/mixins/mutable-data.html
+++ b/lib/mixins/mutable-data.html
@@ -8,6 +8,8 @@
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 
+<link rel="import" href="../utils/mixin.html">
+
 <script>
 (function() {
   'use strict';
diff --git a/lib/mixins/property-accessors.html b/lib/mixins/property-accessors.html
index 7176903953..94adfade87 100644
--- a/lib/mixins/property-accessors.html
+++ b/lib/mixins/property-accessors.html
@@ -79,7 +79,10 @@
    * the standard `static get observedAttributes()`, implement `_propertiesChanged`
    * on the class, and then call `MyClass.createPropertiesForAttributes()` once
    * on the class to generate property accessors for each observed attribute
-   * prior to instancing.  Any `observedAttributes` will automatically be
+   * prior to instancing.  Last, call `this._flushProperties()` once to enable
+   * the accessors.
+   *
+   * Any `observedAttributes` will automatically be
    * deserialized via `attributeChangedCallback` and set to the associated
    * property using `dash-case`-to-`camelCase` convention.
    *
@@ -139,6 +142,7 @@
       _initializeProperties() {
         this.__serializing = false;
         this.__dataCounter = 0;
+        this.__dataInitialized = false;
         this.__dataInvalid = false;
         // initialize data with prototype values saved when creating accessors
         this.__data = {};
@@ -146,6 +150,17 @@
         this.__dataOld = null;
         if (this.__dataProto) {
           this._initializeProtoProperties(this.__dataProto);
+          this.__dataProto = null;
+        }
+        // Capture instance properties; these will be set into accessors
+        // during first flush. Don't set them here, since we want
+        // these to overwrite defaults/constructor assignments
+        for (let p in this.__dataHasAccessor) {
+          if (this.hasOwnProperty(p)) {
+            this.__dataInstanceProps = this.__dataInstanceProps || {};
+            this.__dataInstanceProps[p] = this[p];
+            delete this[p];
+          }
         }
       }
 
@@ -167,12 +182,27 @@
         }
       }
 
+      /**
+       * Called at ready time with bag of instance properties that overwrote
+       * accessors when the element upgraded.
+       *
+       * The default implementation sets these properties back into the
+       * setter at ready time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param {Object} props Bag of property values that were overwritten
+       *   when creating property accessors.
+       * @protected
+       */
+      _initializeInstanceProperties(props) {
+        Object.assign(this, props);
+      }
+
       /**
        * Ensures the element has the given attribute. If it does not,
        * assigns the given value to the attribute.
        *
        *
-       * @method _ensureAttribute
        * @param {string} attribute Name of attribute to ensure is set.
        * @param {string} value of the attribute.
        */
@@ -188,7 +218,6 @@
        * This method calls the `_deserializeValue` method to convert the string to
        * a typed value.
        *
-       * @method _attributeToProperty
        * @param {string} attribute Name of attribute to deserialize.
        * @param {string} value of the attribute.
        * @param {*} type type to deserialize to.
@@ -204,7 +233,6 @@
       /**
        * Serializes a property to its associated attribute.
        *
-       * @method _propertyToAttribute
        * @param {string} property Property name to reflect.
        * @param {string=} attribute Attribute name to reflect.
        * @param {*=} value Property value to refect.
@@ -225,7 +253,6 @@
        * the attribute will be removed (this is the default for boolean
        * type `false`).
        *
-       * @method _valueToNodeAttribute
        * @param {Element} node Element to set attribute to.
        * @param {*} value Value to serialize.
        * @param {string} attribute Attribute name to serialize to.
@@ -246,7 +273,6 @@
        * HTML attributes.  Users may override this method on Polymer element
        * prototypes to provide serialization for custom types.
        *
-       * @method _serializeValue
        * @param {*} value Property value to serialize.
        * @return {string | undefined} String serialized from the provided property value.
        */
@@ -285,7 +311,6 @@
        * Note: The return value of `undefined` is used as a sentinel value to
        * indicate the attribute should be removed.
        *
-       * @method _deserializeValue
        * @param {string} value Attribute value to deserialize.
        * @param {*} type Type to deserialize the string to.
        * @return {*} Typed value deserialized from the provided string.
@@ -317,7 +342,7 @@
               outValue = JSON.parse(value);
             } catch(x) {
               outValue = null;
-              console.warn('Polymer::Attributes: couldn`t decode Array as JSON');
+              console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);
             }
             break;
 
@@ -357,15 +382,31 @@
        * @protected
        */
       _createPropertyAccessor(property, readOnly) {
-        saveAccessorValue(this, property);
-        Object.defineProperty(this, property, {
-          get: function() {
-            return this.__data[property];
-          },
-          set: readOnly ? function() { } : function(value) {
-            this._setProperty(property, value);
-          }
-        });
+        if (!this.hasOwnProperty('__dataHasAccessor')) {
+          this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
+        }
+        if (!this.__dataHasAccessor[property]) {
+          this.__dataHasAccessor[property] = true;
+          saveAccessorValue(this, property);
+          Object.defineProperty(this, property, {
+            get: function() {
+              return this.__data[property];
+            },
+            set: readOnly ? function() { } : function(value) {
+              this._setProperty(property, value);
+            }
+          });
+        }
+      }
+
+      /**
+       * Returns true if this library created an accessor for the given property.
+       *
+       * @param {string} property Property name
+       * @return {boolean} True if an accessor was created
+       */
+      _hasAccessor(property) {
+        return this.__dataHasAccessor && this.__dataHasAccessor[property];
       }
 
       /**
@@ -390,6 +431,7 @@
        *
        * @param {string} property Name of the property
        * @param {*} value Value to set
+       * @return {boolean} Returns true if the property changed
        * @protected
        */
       _setPendingProperty(property, value) {
@@ -427,7 +469,7 @@
        * @protected
        */
       _invalidateProperties() {
-        if (!this.__dataInvalid) {
+        if (!this.__dataInvalid && this.__dataInitialized) {
           this.__dataInvalid = true;
           microtask.run(() => {
             if (this.__dataInvalid) {
@@ -443,15 +485,48 @@
        * pending changes (and old values recorded when pending changes were
        * set), and resets the pending set of changes.
        *
+       * Note that this method must be called once to enable the property
+       * accessors system.  For elements, generally `connectedCallback`
+       * is a normal spot to do so.
+       *
        * @protected
        */
       _flushProperties() {
-        let oldProps = this.__dataOld;
-        let changedProps = this.__dataPending;
-        this.__dataPending = null;
-        this.__dataCounter++;
-        this._propertiesChanged(this.__data, changedProps, oldProps);
-        this.__dataCounter--;
+        if (!this.__dataInitialized) {
+          this.ready()
+        } else if (this.__dataPending) {
+          let changedProps = this.__dataPending;
+          this.__dataPending = null;
+          this.__dataCounter++;
+          this._propertiesChanged(this.__data, changedProps, this.__dataOld);
+          this.__dataCounter--;
+        }
+      }
+
+      /**
+       * Lifecycle callback called the first time properties are being flushed.
+       * Prior to `ready`, all property sets through accessors are queued and
+       * their effects are flushed after this method returns.
+       *
+       * Users may override this function to implement behavior that is
+       * dependent on the element having its properties initialized, e.g.
+       * from defaults (initialized from `constructor`, `_initializeProperties`),
+       * `attributeChangedCallback`, or values propagated from host e.g. via
+       * bindings.  `super.ready()` must be called to ensure the data system
+       * becomes enabled.
+       *
+       * @public
+       */
+      ready() {
+        // Update instance properties that shadowed proto accessors; these take
+        // priority over any defaults set in constructor or attributeChangedCallback
+        if (this.__dataInstanceProps) {
+          this._initializeInstanceProperties(this.__dataInstanceProps);
+          this.__dataInstanceProps = null;
+        }
+        this.__dataInitialized = true;
+        // Run normal flush
+        this._flushProperties();
       }
 
       /**
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index add97a8900..523dfeaf14 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -32,7 +32,6 @@
 
   // Property effect types; effects are stored on the prototype using these keys
   const TYPES = {
-    ANY: '__propertyEffects',
     COMPUTE: '__computeEffects',
     REFLECT: '__reflectEffects',
     NOTIFY: '__notifyEffects',
@@ -87,18 +86,20 @@
    * on an instance.
    *
    * @param {Object} inst The instance with effects to run
-   * @param {Object} effects
+   * @param {string} effects Array of effects to run for this property
    * @param {Object} props Bag of current property changes
    * @param {Object=} oldProps Bag of previous values for changed properties
-   * @param {boolean=} hasPaths
+   * @param {boolean=} hasPaths True with `props` contains one or more paths
+   * @param {*=} extraArgs Additional metadata to pass to effect function
+   * @return {boolean} True if an effect ran for this property
    * @private
    */
-  function runEffects(inst, effects, props, oldProps, hasPaths) {
+  function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {
     if (effects) {
       let ran;
       let id = dedupeId++;
       for (let prop in props) {
-        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths)) {
+        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths, extraArgs)) {
           ran = true;
         }
       }
@@ -110,15 +111,17 @@
    * Runs a list of effects for a given property.
    *
    * @param {Object} inst The instance with effects to run
-   * @param {Object} effects Array of effects
-   * @param {number} dedupeId Effect run id used for de-duping effects
+   * @param {Array} effects Array of effects
+   * @param {number} dedupeId Counter used for de-duping effects
    * @param {string} prop Name of changed property
-   * @param {*} props Value of changed property
-   * @param {*} oldProps Previous value of changed property
-   * @param {boolean=} hasPaths
+   * @param {*} props Changed properties
+   * @param {*} oldProps Old properties
+   * @param {boolean=} hasPaths True with `props` contains one or more paths
+   * @param {*=} extraArgs Additional metadata to pass to effect function
+   * @return {boolean} True if an effect ran for this property
    * @private
    */
-  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths) {
+  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {
     let ran;
     let rootProperty = hasPaths ? Polymer.Path.root(prop) : prop;
     let fxs = effects[rootProperty];
@@ -126,10 +129,10 @@
       for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
         if ((!fx.info || fx.info.lastRun !== dedupeId) &&
             (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
-          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths);
           if (fx.info) {
             fx.info.lastRun = dedupeId;
           }
+          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
           ran = true;
         }
       }
@@ -174,8 +177,8 @@
    *
    * @param {Object} inst The instance the effect will be run on
    * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
    * @private
    */
@@ -200,8 +203,10 @@
    * sent.
    *
    * @param {Element} inst The instance with effects to run
+   * @param {Object} notifyProps Bag of properties to notify
    * @param {Object} props Bag of current property changes
    * @param {Object} oldProps Bag of previous values for changed properties
+   * @param {boolean} hasPaths True with `props` contains one or more paths
    * @private
    */
   function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {
@@ -232,7 +237,8 @@
    *
    * @param {Element} inst The element from which to fire the event
    * @param {string} path The path that was changed
-   * @param {*} value
+   * @param {Object} props Bag of current property changes
+   * @return {boolean} Returns true if the path was notified
    * @private
    */
   function notifyPath(inst, path, props) {
@@ -274,9 +280,10 @@
    *
    * @param {Element} inst The instance the effect will be run on
    * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
+   * @param {boolean} hasPaths True with `props` contains one or more paths
    * @private
    */
   function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {
@@ -289,20 +296,6 @@
     dispatchNotifyEvent(inst, info.eventName, value, path);
   }
 
-  /**
-   * Adds a 2-way binding notification event listener to the node specified
-   *
-   * @param {Object} node Child element to add listener to
-   * @param {Object} inst Host element instance to handle notification event
-   * @param {Object} info Listener metadata stored via addAnnotatedListener
-   * @private
-   */
-  function addNotifyListener(node, inst, info) {
-    node.addEventListener(info.event, function(e) {
-      handleNotification(e, inst, info.property, info.path, info.negate);
-    });
-  }
-
   /**
    * Handler function for 2-way notification events. Receives context
    * information captured in the `addNotifyListener` closure from the
@@ -312,42 +305,29 @@
    * the event contained path information, translate that path to the host
    * scope's name for that path first.
    *
-   * @param {Event} e Notification event (e.g. '<property>-changed')
+   * @param {Event} event Notification event (e.g. '<property>-changed')
    * @param {Object} inst Host element instance handling the notification event
-   * @param {string} property Child element property that was bound
-   * @param {string} path Host property/path that was bound
+   * @param {string} fromProp Child element property that was bound
+   * @param {string} toPath Host property/path that was bound
    * @param {boolean} negate Whether the binding was negated
    * @private
    */
-  function handleNotification(e, inst, property, path, negate) {
+  function handleNotification(event, inst, fromProp, toPath, negate) {
     let value;
-    let targetPath = e.detail && e.detail.path;
-    if (targetPath) {
-      path = Polymer.Path.translate(property, path, targetPath);
-      value = e.detail && e.detail.value;
+    let detail = event.detail;
+    let fromPath = detail && detail.path;
+    if (fromPath) {
+      toPath = Polymer.Path.translate(fromProp, toPath, fromPath);
+      value = detail && detail.value;
     } else {
-      value = e.target[property];
+      value = event.target[fromProp];
     }
     value = negate ? !value : value;
-    setPropertyFromNotification(inst, path, value, e);
-  }
-
-  /**
-   * Called by 2-way binding notification event listeners to set a property
-   * or path to the host based on a notification from a bound child.
-   *
-   * @param {string} path Path on this instance to set
-   * @param {*} value Value to set to given path
-   * @protected
-   */
-  function setPropertyFromNotification(inst, path, value, event) {
-    let detail = event.detail;
-    if (detail && detail.queueProperty) {
-      if (!inst.__readOnly || !inst.__readOnly[path]) {
-        inst._setPendingPropertyOrPath(path, value, true, Boolean(detail.path));
+    if (!inst.__readOnly || !inst.__readOnly[toPath]) {
+      if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath))
+        && (!detail || !detail.queueProperty)) {
+        inst._invalidateProperties();
       }
-    } else {
-      inst.set(path, value);
     }
   }
 
@@ -358,8 +338,8 @@
    *
    * @param {Object} inst The instance the effect will be run on
    * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
    * @private
    */
@@ -384,6 +364,7 @@
    * @param {Element} inst The instance the effect will be run on
    * @param {Object} changedProps Bag of changed properties
    * @param {Object} oldProps Bag of previous values for changed properties
+   * @param {boolean} hasPaths True with `props` contains one or more paths
    * @private
    */
   function runComputedEffects(inst, changedProps, oldProps, hasPaths) {
@@ -406,15 +387,15 @@
    *
    * @param {Object} inst The instance the effect will be run on
    * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
    * @private
    */
   function runComputedEffect(inst, property, props, oldProps, info) {
     let result = runMethodEffect(inst, property, props, oldProps, info);
     let computedProp = info.methodInfo;
-    if (inst.__propertyEffects && inst.__propertyEffects[computedProp]) {
+    if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {
       inst._setPendingProperty(computedProp, result, true);
     } else {
       inst[computedProp] = result;
@@ -427,6 +408,7 @@
    *
    * @param {Element} inst The instance whose props are changing
    * @param {Object} changedProps Bag of changed properties
+   * @param {boolean} hasPaths True with `props` contains one or more paths
    * @private
    */
   function computeLinkedPaths(inst, changedProps, hasPaths) {
@@ -456,44 +438,69 @@
   // -- bindings ----------------------------------------------
 
   /**
-   * Adds "binding" property effects for the template annotation
-   * ("note" for short) and node index specified.  These may either be normal
-   * "binding" effects (property/path bindings) or "method binding"
-   * effects, aka inline computing functions, depending on the type of binding
-   * detailed in the note.
+   * Adds binding metadata to the current `nodeInfo`, and binding effects
+   * for all part dependencies to `templateInfo`.
    *
-   * @param {Object} model Prototype or instance
-   * @param {Object} note Annotation note returned from Annotator
-   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
-   *   note applies to
-   * @param {Object=} dynamicFns Map indicating whether method names should
-   *   be included as a dependency to the effect.
+   * @param {Function} constructor Class that `_parseTemplate` is currently
+   *   running on
+   * @param {Object} templateInfo Template metadata for current template
+   * @param {Object} nodeInfo Node metadata for current template node
+   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'
+   * @param {string} target Target property name
+   * @param {Array<Object>} parts Array of binding part metadata
+   * @param {string} literal Literal text surrounding binding parts (specified
+   *   only for 'property' bindings, since these must be initialized as part
+   *   of boot-up)
    * @private
    */
-  function addBindingEffect(model, note, index, dynamicFns) {
-    for (let i=0; i<note.parts.length; i++) {
-      let part = note.parts[i];
-      if (part.signature) {
-        addMethodBindingEffect(model, note, part, index, dynamicFns);
-      } else if (!part.literal) {
-        if (note.kind === 'attribute' && note.name[0] === '-') {
-          console.warn('Cannot set attribute ' + note.name +
-            ' because "-" is not a valid attribute starting character');
-        } else {
-          model._addPropertyEffect(Polymer.Path.root(part.value), TYPES.PROPAGATE, {
+  function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
+    // Create binding metadata and add to nodeInfo
+    nodeInfo.bindings = nodeInfo.bindings || [];
+    let binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };
+    nodeInfo.bindings.push(binding);
+    // Add listener info to binding metadata
+    if (shouldAddListener(binding)) {
+      let {event, negate} = binding.parts[0];
+      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');
+      binding.listenerNegate = negate;
+    }
+    // Add "propagate" property effects to templateInfo
+    let index = templateInfo.nodeInfoList.length;
+    for (let i=0; i<binding.parts.length; i++) {
+      let part = binding.parts[i];
+      part.compoundIndex = i;
+      addEffectForBindingPart(constructor, templateInfo, binding, part, index);
+    }
+  }
+
+  /**
+   * Adds property effects to the given `templateInfo` for the given binding
+   * part.
+   *
+   * @param {Function} constructor Class that `_parseTemplate` is currently
+   *   running on
+   * @param {Object} templateInfo Template metadata for current template
+   * @param {Object} binding Binding metadata
+   * @param {Object} part Binding part metadata
+   * @param {number} index Index into `nodeInfoList` for this node
+   */
+  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
+    if (!part.literal) {
+      if (binding.kind === 'attribute' && binding.target[0] === '-') {
+        console.warn('Cannot set attribute ' + binding.target +
+          ' because "-" is not a valid attribute starting character');
+      } else {
+        let dependencies = part.dependencies;
+        let info = { index, binding, part, evaluator: constructor };
+        for (let j=0; j<dependencies.length; j++) {
+          let trigger = dependencies[j];
+          if (typeof trigger == 'string') {
+            trigger = parseArg(trigger);
+            trigger.wildcard = true;
+          }
+          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
             fn: runBindingEffect,
-            info:  {
-              kind: note.kind,
-              index: index,
-              name: note.name,
-              propertyName: note.propertyName,
-              value: part.value,
-              isCompound: note.isCompound,
-              compoundIndex: part.compoundIndex,
-              event: part.event,
-              customEvent: part.customEvent,
-              negate: part.negate
-            }
+            info, trigger
           });
         }
       }
@@ -503,41 +510,40 @@
   /**
    * Implements the "binding" (property/path binding) effect.
    *
+   * Note that binding syntax is overridable via `_parseBindings` and
+   * `_evaluateBindings`.  This method will call `_evaluateBinding` for any
+   * non-literal parts returned from `_parseBindings`.  However,
+   * there is no support for _path_ bindings via custom binding parts,
+   * as this is specific to Polymer's path binding syntax.
+   *
    * @param {Element} inst The instance the effect will be run on
    * @param {string} path Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
+   * @param {boolean} hasPaths True with `props` contains one or more paths
+   * @param {Array} nodeList List of nodes associated with `nodeInfoList` template
+   *   metadata
    * @private
    */
-  function runBindingEffect(inst, path, props, oldProps, info, hasPaths) {
-    let value;
-    let node = inst.__templateNodes[info.index];
+  function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {
+    let node = nodeList[info.index];
+    let binding = info.binding;
+    let part = info.part;
     // Subpath notification: transform path and set to client
     // e.g.: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop
-    if (hasPaths && (path.length > info.value.length) &&
-        (info.kind == 'property') && !info.isCompound &&
-        node.__propertyEffects && node.__propertyEffects[info.name]) {
+    if (hasPaths && part.source && (path.length > part.source.length) &&
+        (binding.kind == 'property') && !binding.isCompound &&
+        node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {
       let value = props[path];
-      path = Polymer.Path.translate(info.value, info.name, path);
+      path = Polymer.Path.translate(part.source, binding.target, path);
       if (node._setPendingPropertyOrPath(path, value, false, true)) {
         inst._enqueueClient(node);
       }
     } else {
-      // Root or deeper path was set; extract bound path value
-      // e.g.: foo="{{obj.sub}}", path: 'obj', set 'foo'=obj.sub
-      //   or: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo'=obj.sub
-      if (path != info.value) {
-        value = Polymer.Path.get(inst, info.value);
-      } else {
-        if (hasPaths && Polymer.Path.isPath(path)) {
-          value = Polymer.Path.get(inst, path);
-        } else {
-          value = inst.__data[path];
-        }
-      }
+      let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);
       // Propagate value to child
-      applyBindingValue(inst, info, value);
+      applyBindingValue(inst, node, binding, part, value);
     }
   }
 
@@ -546,23 +552,24 @@
    * either as a property or attribute.
    *
    * @param {Object} inst The instance owning the binding effect
-   * @param {Object} info Effect metadata
+   * @param {Node} node Target node for binding
+   * @param {Object} binding Binding metadata
+   * @param {Object} part Binding part metadata
    * @param {*} value Value to set
    * @private
    */
-  function applyBindingValue(inst, info, value) {
-    let node = inst.__templateNodes[info.index];
-    value = computeBindingValue(node, value, info);
+  function applyBindingValue(inst, node, binding, part, value) {
+    value = computeBindingValue(node, value, binding, part);
     if (Polymer.sanitizeDOMValue) {
-      value = Polymer.sanitizeDOMValue(value, info.name, info.kind, node);
+      value = Polymer.sanitizeDOMValue(value, binding.target, binding.kind, node);
     }
-    if (info.kind == 'attribute') {
+    if (binding.kind == 'attribute') {
       // Attribute binding
-      inst._valueToNodeAttribute(node, value, info.name);
+      inst._valueToNodeAttribute(node, value, binding.target);
     } else {
       // Property binding
-      let prop = info.name;
-      if (node.__propertyEffects && node.__propertyEffects[prop]) {
+      let prop = binding.target;
+      if (node.__dataHasAccessor && node.__dataHasAccessor[prop]) {
         if (!node.__readOnly || !node.__readOnly[prop]) {
           if (node._setPendingProperty(prop, value)) {
             inst._enqueueClient(node);
@@ -580,174 +587,27 @@
    *
    * @param {Node} node Node the value will be set to
    * @param {*} value Value to set
-   * @param {Object} info Effect metadata
+   * @param {Object} binding Binding metadata
+   * @param {Object} part Binding part metadata
    * @return {*} Transformed value to set
    * @private
    */
-  function computeBindingValue(node, value, info) {
-    if (info.negate) {
-      value = !value;
-    }
-    if (info.isCompound) {
-      let storage = node.__dataCompoundStorage[info.name];
-      storage[info.compoundIndex] = value;
+  function computeBindingValue(node, value, binding, part) {
+    if (binding.isCompound) {
+      let storage = node.__dataCompoundStorage[binding.target];
+      storage[part.compoundIndex] = value;
       value = storage.join('');
     }
-    if (info.kind !== 'attribute') {
+    if (binding.kind !== 'attribute') {
       // Some browsers serialize `undefined` to `"undefined"`
-      if (info.name === 'textContent' ||
-          (node.localName == 'input' && info.name == 'value')) {
+      if (binding.target === 'textContent' ||
+          (node.localName == 'input' && binding.target == 'value')) {
         value = value == undefined ? '' : value;
       }
     }
     return value;
   }
 
-  /**
-   * Adds "binding method" property effects for the template binding
-   * ("note" for short), part metadata, and node index specified.
-   *
-   * @param {Object} model Prototype or instance
-   * @param {Object} note Binding note returned from Annotator
-   * @param {Object} part The compound part metadata
-   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
-   *   note applies to
-   * @param {Object=} dynamicFns Map indicating whether method names should
-   *   be included as a dependency to the effect.
-   * @private
-   */
-  function addMethodBindingEffect(model, note, part, index, dynamicFns) {
-    createMethodEffect(model, part.signature, TYPES.PROPAGATE,
-      runMethodBindingEffect, {
-        index: index,
-        isCompound: note.isCompound,
-        compoundIndex: part.compoundIndex,
-        kind: note.kind,
-        name: note.name,
-        negate: part.negate,
-        part: part
-      }, dynamicFns
-    );
-  }
-
-  /**
-   * Implements the "binding method" (inline computed function) effect.
-   *
-   * Runs the method with the values of the arguments specified in the `info`
-   * object and setting the return value to the node property/attribute.
-   *
-   * @param {Object} inst The instance the effect will be run on
-   * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
-   * @param {Object} info Effect metadata
-   * @private
-   */
-  function runMethodBindingEffect(inst, property, props, oldProps, info) {
-    let val = runMethodEffect(inst, property, props, oldProps, info);
-    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
@@ -762,7 +622,7 @@
    * @private
    */
   function shouldAddListener(binding) {
-    return binding.name &&
+    return binding.target &&
            binding.kind != 'attribute' &&
            binding.kind != 'text' &&
            !binding.isCompound &&
@@ -770,71 +630,80 @@
   }
 
   /**
-   * Sets up a prototypical `__notifyListeners` metadata array to be used at
-   * instance time to add event listeners for 2-way bindings.
+   * Setup compound binding storage structures, notify listeners, and dataHost
+   * references onto the bound nodeList.
    *
-   * @param {Object} model Prototype (instances not currently supported)
-   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
-   *   event should be added to
-   * @param {string} property Property of target node to listen for changes
-   * @param {string} path Host path that the change should be propagated to
-   * @param {string=} event A custom event name to listen for (e.g. via the
-   *   `{{prop::eventName}}` syntax)
-   * @param {boolean=} negate Whether the notified value should be negated before
-   *   setting to host path
+   * @param {Object} inst Instance that bas been previously bound
+   * @param {Object} templateInfo Template metadata
    * @private
    */
-  function addAnnotatedListener(model, index, property, path, event, negate) {
-    let eventName = event ||
-      (CaseMap.camelToDashCase(property) + '-changed');
-    model.__notifyListeners = model.__notifyListeners || [];
-    model.__notifyListeners.push({
-      index: index,
-      property: property,
-      path: path,
-      event: eventName,
-      negate: negate
-    });
+  function setupBindings(inst, templateInfo) {
+    // Setup compound storage, dataHost, and notify listeners
+    let {nodeList, nodeInfoList} = templateInfo;
+    if (nodeInfoList.length) {
+      for (let i=0; i < nodeInfoList.length; i++) {
+        let info = nodeInfoList[i];
+        let node = nodeList[i];
+        let bindings = info.bindings;
+        if (bindings) {
+          for (let i=0; i<bindings.length; i++) {
+            let binding = bindings[i];
+            setupCompoundStorage(node, binding);
+            addNotifyListener(node, inst, binding);
+          }
+        }
+        node.__dataHost = inst;
+      }
+    }
   }
 
   /**
-   * Adds all 2-way binding notification listeners to a host based on
-   * `__notifyListeners` metadata recorded by prior calls to`addAnnotatedListener`
+   * Initializes `__dataCompoundStorage` local storage on a bound node with
+   * initial literal data for compound bindings, and sets the joined
+   * literal parts to the bound property.
    *
-   * @param {Object} inst Host element instance
+   * When changes to compound parts occur, they are first set into the compound
+   * storage array for that property, and then the array is joined to result in
+   * the final value set to the property/attribute.
+   *
+   * @param {Node} node Bound node to initialize
+   * @param {Object} binding Binding metadata
    * @private
    */
-  function setupNotifyListeners(inst) {
-    let b$ = inst.__notifyListeners;
-    for (let i=0, l=b$.length, info; (i<l) && (info=b$[i]); i++) {
-      let node = inst.__templateNodes[info.index];
-      addNotifyListener(node, inst, info);
+  function setupCompoundStorage(node, binding) {
+    if (binding.isCompound) {
+      // Create compound storage map
+      let storage = node.__dataCompoundStorage ||
+        (node.__dataCompoundStorage = {});
+      let parts = binding.parts;
+      // Copy literals from parts into storage for this binding
+      let literals = new Array(parts.length);
+      for (let j=0; j<parts.length; j++) {
+        literals[j] = parts[j].literal;
+      }
+      let target = binding.target;
+      storage[target] = literals;
+      // Configure properties with their literal parts
+      if (binding.literal && binding.kind == 'property') {
+        node[target] = binding.literal;
+      }
     }
   }
 
   /**
-   * On the `inst` element that was previously bound, uses `inst.__templateNotes`
-   * to setup compound binding storage structures onto the bound
-   * nodes (`inst.__templateNodes`).
-   * (`inst._, and 2-way binding event listeners are also added.)
+   * Adds a 2-way binding notification event listener to the node specified
    *
-   * @param {Object} inst Instance that bas been previously bound
+   * @param {Object} node Child element to add listener to
+   * @param {Object} inst Host element instance to handle notification event
+   * @param {Object} binding Binding metadata
    * @private
    */
-  function setupBindings(inst) {
-    let notes = inst.__templateNotes;
-    if (notes.length) {
-      for (let i=0; i < notes.length; i++) {
-        let note = notes[i];
-        let node = inst.__templateNodes[i];
-        node.__dataHost = inst;
-        if (note.bindings) {
-          setupCompoundBinding(note, node);
-        }
-      }
-    }
-    if (inst.__notifyListeners) {
-      setupNotifyListeners(inst);
+  function addNotifyListener(node, inst, binding) {
+    if (binding.listenerEvent) {
+      let part = binding.parts[0];
+      node.addEventListener(binding.listenerEvent, function(e) {
+        handleNotification(e, inst, binding.target, part.source, part.negate);
+      });
     }
   }
 
@@ -847,9 +716,10 @@
    *
    * @param {Element | Object} model Prototype or instance
    * @param {Object} sig Method signature metadata
-   * @param {string} type
+   * @param {string} type Type of property effect to add
    * @param {Function} effectFn Function to run when arguments change
-   * @param {*=} methodInfo
+   * @param {*=} methodInfo Effect-specific information to be included in
+   *   method effect metadata
    * @param {Object=} dynamicFns Map indicating whether method names should
    *   be included as a dependency to the effect. Note, defaults to true
    *   if the signature is statci (sig.static is true).
@@ -887,9 +757,10 @@
    *
    * @param {Object} inst The instance the effect will be run on
    * @param {string} property Name of property
-   * @param {*} value Current value of property
-   * @param {*} old Previous value of property
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
    * @param {Object} info Effect metadata
+   * @return {*} Returns the return value from the method invocation
    * @private
    */
   function runMethodEffect(inst, property, props, oldProps, info) {
@@ -907,6 +778,33 @@
 
   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 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
@@ -921,7 +819,8 @@
     // tries to match valid javascript property names
     let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
     if (m) {
-      let sig = { methodName: m[1], static: true };
+      let methodName = m[1];
+      let sig = { methodName, static: true };
       if (m[2].trim()) {
         // replace escaped commas with comma entity, split on un-escaped commas
         let args = m[2].replace(/\\,/g, '&comma;').split(',');
@@ -1008,7 +907,7 @@
     if (!a.literal) {
       a.rootProperty = Polymer.Path.root(arg);
       // detect structured path (has dots)
-      a.structured = Polymer.Path.isDeep(arg);
+      a.structured = Polymer.Path.isPath(arg);
       if (a.structured) {
         a.wildcard = (arg.slice(-2) == '.*');
         if (a.wildcard) {
@@ -1028,6 +927,8 @@
    *
    * @param {Object} data Instance data storage object to read properties from
    * @param {Array<Object>} args Array of argument metadata
+   * @param {string} path Property/path name that triggered the method effect
+   * @param {Object} props Bag of current property changes
    * @return {Array<*>} Array of argument values
    * @private
    */
@@ -1067,43 +968,6 @@
     return values;
   }
 
-  /**
-   * Initializes `__dataCompoundStorage` local storage on a bound node with
-   * initial literal data for compound bindings, and sets the joined
-   * literal parts to the bound property.
-   *
-   * When changes to compound parts occur, they are first set into the compound
-   * 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 {Node} node Bound node to initialize
-   * @private
-   */
-  function setupCompoundBinding(note, node) {
-    let bindings = note.bindings;
-    for (let i=0; i<bindings.length; i++) {
-      let binding = bindings[i];
-      if (binding.isCompound) {
-        // Create compound storage map
-        let storage = node.__dataCompoundStorage ||
-          (node.__dataCompoundStorage = {});
-        let parts = binding.parts;
-        // Copy literals from parts into storage for this binding
-        let literals = new Array(parts.length);
-        for (let j=0; j<parts.length; j++) {
-          literals[j] = parts[j].literal;
-        }
-        let name = binding.name;
-        storage[name] = literals;
-        // Configure properties with their literal parts
-        if (binding.literal && binding.kind == 'property') {
-          node[name] = binding.literal;
-        }
-      }
-    }
-  }
-
   // data api
 
   /**
@@ -1160,24 +1024,6 @@
     return name[0].toUpperCase() + name.substring(1);
   }
 
-  /**
-   * Sets the provided properties into pending data on the instance.
-   *
-   * @param {HTMLElement} inst Instance to apply data to
-   * @param {object} props Bag of instance properties to set
-   * @private
-   */
-  function initalizeInstanceProperties(inst, props) {
-    inst.__dataOld = inst.__dataOld || {};
-    inst.__dataPending = inst.__dataPending || {};
-    let readOnly = inst.__readOnly;
-    for (let prop in props) {
-      if (!readOnly || !readOnly[prop]) {
-        inst.__data[prop] = inst.__dataPending[prop] = props[prop];
-      }
-    }
-  }
-
   /**
    * Element class mixin that provides meta-programming for Polymer's template
    * binding and data observation (collectively, "property effects") system.
@@ -1198,6 +1044,12 @@
    * but are designed to be called on element prototypes such that the work to
    * set up accessors and effect metadata are done once per element class.
    *
+   * Note that this mixin overrides several `PropertyAccessors` methods, in
+   * many cases to maintain guarantees provided by the Polymer 1.x features;
+   * notably it changes property accessors to be synchronous by default
+   * whereas the default when using `PropertyAccessors` standalone is to be
+   * async by default.
+   *
    * @polymerMixin
    * @mixes Polymer.TemplateStamp
    * @mixes Polymer.PropertyAccessors
@@ -1239,7 +1091,6 @@
        */
       _initializeProperties() {
         super._initializeProperties();
-        this.__dataInitialized = false;
         this.__dataClientsInitialized = false;
         this.__dataPendingClients = null;
         this.__dataToNotify = null;
@@ -1249,16 +1100,6 @@
         this.__dataCompoundStorage = this.__dataCompoundStorage || null;
         this.__dataHost = this.__dataHost || null;
         this.__dataTemp = {};
-        // Capture instance properties; these will be set into accessors
-        // during first flush. Don't set them here, since we want
-        // these to overwrite defaults/constructor assignments
-        for (let p in this.__propertyEffects) {
-          if (this.hasOwnProperty(p)) {
-            this.__dataInstanceProps = this.__dataInstanceProps || {};
-            this.__dataInstanceProps[p] = this[p];
-            delete this[p];
-          }
-        }
       }
 
       /**
@@ -1274,6 +1115,23 @@
         this.__dataOld = {};
       }
 
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
+       * `_setProperty`'s `shouldNotify: true`.
+       *
+       * @override
+       */
+      _initializeInstanceProperties(props) {
+        let readOnly = this.__readOnly;
+        for (let prop in props) {
+          if (!readOnly || !readOnly[prop]) {
+            this.__dataPending = this.__dataPending || {};
+            this.__dataOld = this.__dataOld || {};
+            this.__data[prop] = this.__dataPending[prop] = props[prop];
+          }
+        }
+      }
+
       // Prototype setup ----------------------------------------
 
       /**
@@ -1286,12 +1144,25 @@
        *   {
        *     fn: effectFunction, // Reference to function to call to perform effect
        *     info: { ... }       // Effect metadata passed to function
-       *     // path: '...'      // Will be set by this method based on path arg
+       *     trigger: {          // Optional triggering metadata; if not provided
+       *       name: string      // the property is treated as a wildcard
+       *       structured: boolean
+       *       wildcard: boolean
+       *     }
        *   }
        *
+       * Effects are called from `_propertiesChanged` in the following order by
+       * type:
+       *
+       * 1. COMPUTE
+       * 2. PROPAGATE
+       * 3. REFLECT
+       * 4. OBSERVE
+       * 5. NOTIFY
+       *
        * Effect functions are called with the following signature:
        *
-       *   effectFunction(inst, property, currentValue, oldValue, info)
+       *   effectFunction(inst, path, props, oldProps, info, hasPaths)
        *
        * This method may be called either on the prototype of a class
        * using the PropertyEffects mixin (for best performance), or on
@@ -1300,29 +1171,36 @@
        * its prototype, the property effect lists will be cloned and added as
        * own properties of the caller.
        *
-       * @param {string} path Property (or path) that should trigger the effect
+       * @param {string} property Property that should trigger the effect
        * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
        * @param {Object=} effect Effect metadata object
        * @protected
        */
       _addPropertyEffect(property, type, effect) {
-        let effects = ensureOwnEffectMap(this, TYPES.ANY)[property];
-        if (!effects) {
-          effects = this.__propertyEffects[property] = [];
-          this._createPropertyAccessor(property,
-            type == TYPES.READ_ONLY);
-        }
+        this._createPropertyAccessor(property, type == TYPES.READ_ONLY);
         // effects are accumulated into arrays per property based on type
-        if (effect) {
-          effects.push(effect);
-        }
-        effects = ensureOwnEffectMap(this, type)[property];
+        let effects = ensureOwnEffectMap(this, type)[property];
         if (!effects) {
           effects = this[type][property] = [];
         }
         effects.push(effect);
       }
 
+      /**
+       * Removes the given property effect.
+       *
+       * @param {string} property Property the effect was associated with
+       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @param {Object=} effect Effect metadata object to remove
+       */
+      _removePropertyEffect(property, type, effect) {
+        let effects = ensureOwnEffectMap(this, type)[property];
+        let idx = effects.indexOf(effect);
+        if (idx >= 0) {
+          effects.splice(idx, 1);
+        }
+      }
+
       /**
        * Returns whether the current prototype/instance has a property effect
        * of a certain type.
@@ -1333,7 +1211,7 @@
        * @protected
        */
       _hasPropertyEffect(property, type) {
-        let effects = this[type || TYPES.ANY];
+        let effects = this[type];
         return Boolean(effects && effects[property]);
       }
 
@@ -1404,6 +1282,8 @@
        *
        * @param {string | !Array<number|string>} path Path to set
        * @param {*} value Value to set
+       * @param {boolean=} shouldNotify Set to true if this change should
+       *  cause a property notification event dispatch
        * @param {boolean=} isPathNotification If the path being set is a path
        *   notification of an already changed value, as opposed to a request
        *   to set and notify the change.  In the latter `false` case, a dirty
@@ -1415,9 +1295,9 @@
        */
       _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
         let rootProperty = Polymer.Path.root(Array.isArray(path) ? path[0] : path);
-        let hasEffect = this.__propertyEffects && this.__propertyEffects[rootProperty];
+        let hasAccessor = this.__dataHasAccessor && this.__dataHasAccessor[rootProperty];
         let isPath = (rootProperty !== path);
-        if (hasEffect) {
+        if (hasAccessor) {
           if (isPath) {
             if (!isPathNotification) {
               // Dirty check changes being set to a path against the actual object,
@@ -1611,11 +1491,14 @@
        *
        * @param {Object} props Bag of one or more key-value pairs whose key is
        *   a property and value is the new value to set for that property.
+       * @param {boolean=} setReadOnly When true, any private values set in
+       *   `props` will be set. By default, `setProperties` will not set
+       *   `readOnly: true` root properties.
        * @public
        */
-      setProperties(props) {
+      setProperties(props, setReadOnly) {
         for (let path in props) {
-          if (!this.__readOnly || !this.__readOnly[path]) {
+          if (setReadOnly || !this.__readOnly || !this.__readOnly[path]) {
             //TODO(kschaaf): explicitly disallow paths in setProperty?
             // wildcard observers currently only pass the first changed path
             // in the `info` object, and you could do some odd things batching
@@ -1627,55 +1510,14 @@
       }
 
       /**
-       * Overrides PropertyAccessor's default async queuing of
-       * `_propertiesChanged`, to instead synchronously flush
-       * `_propertiesChanged` unless the `this._asyncEffects` property is true.
-       *
-       * If this is the first time properties are being flushed, the `ready`
-       * callback will be called.
+       * Overrides PropertyAccessor
        *
        * @override
        */
-      _flushProperties() {
-        if (!this.__dataInitialized) {
-          this.ready()
-        } else if (this.__dataPending) {
-          super._flushProperties();
-          if (!this.__dataCounter) {
-            // Clear temporary cache at end of turn
-            this.__dataTemp = {};
-          }
-        }
-      }
-
-      /**
-       * Polymer-specific lifecycle callback called the first time properties
-       * are being flushed.  Prior to `ready`, all property sets through
-       * accessors are queued and their effects are flushed after this method
-       * returns.
-       *
-       * Users may override this function to implement behavior that is
-       * dependent on the element having its properties initialized, e.g.
-       * from defaults (initialized from `constructor`, `_initializeProperties`),
-       * `attributeChangedCallback`, or binding values propagated from host
-       * "binding effects".  `super.ready()` must be called to ensure the
-       * data system becomes enabled.
-       *
-       * @public
-       */
       ready() {
-        // Update instance properties that shadowed proto accessors; these take
-        // priority over any defaults set in `properties` or constructor
-        let instanceProps = this.__dataInstanceProps;
-        if (instanceProps) {
-          initalizeInstanceProperties(this, instanceProps);
-        }
-        // Enable acceessors
-        this.__dataInitialized = true;
-        if (this.__dataPending) {
-          // Run normal flush
-          this._flushProperties();
-        } else {
+        let dataPending = this.__dataPending;
+        super.ready();
+        if (!dataPending) {
           this._readyClients();
         }
       }
@@ -1691,30 +1533,6 @@
         this.__dataClientsInitialized = true;
       }
 
-      /**
-       * Stamps the provided template and performs instance-time setup for
-       * Polymer template features, including data bindings, declarative event
-       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
-       * is returned containing the stamped DOM, ready for insertion into the
-       * DOM.
-       *
-       * Note that for host data to be bound into the stamped DOM, the template
-       * must have been previously bound to the prototype via a call to
-       * `_bindTemplate`, which performs one-time template binding work.
-       *
-       * Note that this method currently only supports being called once per
-       * instance.
-       *
-       * @param {HTMLTemplateElement} template Template to stamp
-       * @return {DocumentFragment} Cloned template content
-       * @protected
-       */
-      _stampTemplate(template) {
-        let dom = super._stampTemplate(template);
-        setupBindings(this);
-        return dom;
-      }
-
       /**
        * Implements `PropertyAccessors`'s properties changed callback.
        *
@@ -1740,7 +1558,7 @@
         let notifyProps = this.__dataToNotify;
         this.__dataToNotify = null;
         // Propagate properties to clients
-        runEffects(this, this.__propagateEffects, changedProps, oldProps, hasPaths);
+        this._propagatePropertyChanges(changedProps, oldProps, hasPaths);
         // Flush clients
         this._flushClients();
         // Reflect properties
@@ -1751,16 +1569,40 @@
         if (notifyProps) {
           runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);
         }
+        // Clear temporary cache at end of turn
+        if (this.__dataCounter == 1) {
+          this.__dataTemp = {};
+        }
         // ----------------------------
         // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);
         // ----------------------------
       }
 
+      /**
+       * Called to propagate any property changes to stamped template nodes
+       * managed by this element.
+       *
+       * @param {Object} changedProps Bag of changed properties
+       * @param {Object} oldProps Bag of previous values for changed properties
+       * @param {boolean} hasPaths True with `props` contains one or more paths
+       * @protected
+       */
+      _propagatePropertyChanges(changedProps, oldProps, hasPaths) {
+        if (this.__propagateEffects) {
+          runEffects(this, this.__propagateEffects, changedProps, oldProps, hasPaths);
+        }
+        let templateInfo = this.__templateInfo;
+        while (templateInfo) {
+          runEffects(this, templateInfo.propertyEffects, changedProps, oldProps,
+            hasPaths, templateInfo.nodeList);
+          templateInfo = templateInfo.nextTemplateInfo;
+        }
+      }
+
       /**
        * Aliases one data path as another, such that path notifications from one
        * are routed to the other.
        *
-       * @method linkPaths
        * @param {string | !Array<string|number>} to Target path to link.
        * @param {string | !Array<string|number>} from Source path to link.
        * @public
@@ -1778,7 +1620,6 @@
        * Note, the path to unlink should be the target (`to`) used when
        * linking the paths.
        *
-       * @method unlinkPaths
        * @param {string | !Array<string|number>} path Target path to unlink.
        * @public
        */
@@ -1831,7 +1672,6 @@
        * `undefined` (this method does not throw when dereferencing undefined
        * paths).
        *
-       * @method get
        * @param {(string|!Array<(string|number)>)} path Path to the value
        *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
        *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
@@ -1856,7 +1696,6 @@
        * this method does nothing (this method does not throw when
        * dereferencing undefined paths).
        *
-       * @method set
        * @param {(string|!Array<(string|number)>)} path Path to the value
        *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
        *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
@@ -1890,7 +1729,6 @@
        * This method notifies other paths to the same array that a
        * splice occurred to the array.
        *
-       * @method push
        * @param {string} path Path to array.
        * @param {...*} items Items to push onto array
        * @return {number} New length of the array.
@@ -1916,7 +1754,6 @@
        * This method notifies other paths to the same array that a
        * splice occurred to the array.
        *
-       * @method pop
        * @param {string} path Path to array.
        * @return {*} Item that was removed.
        * @public
@@ -1942,7 +1779,6 @@
        * This method notifies other paths to the same array that a
        * splice occurred to the array.
        *
-       * @method splice
        * @param {string} path Path to array.
        * @param {number} start Index from which to start removing/inserting.
        * @param {number} deleteCount Number of items to remove.
@@ -1978,7 +1814,6 @@
        * This method notifies other paths to the same array that a
        * splice occurred to the array.
        *
-       * @method shift
        * @param {string} path Path to array.
        * @return {*} Item that was removed.
        * @public
@@ -2003,7 +1838,6 @@
        * This method notifies other paths to the same array that a
        * splice occurred to the array.
        *
-       * @method unshift
        * @param {string} path Path to array.
        * @param {...*} items Items to insert info array
        * @return {number} New length of the array.
@@ -2178,35 +2012,380 @@
       // -- binding ----------------------------------------------
 
       /**
-       * Creates "binding" property effects for all binding bindings
-       * in the provided template that forward host properties into DOM stamped
-       * from the template via `_stampTemplate`.
+       * Parses the provided template to ensure binding effects are created
+       * for them, and then ensures property accessors are created for any
+       * dependent properties in the template.  Binding effects for bound
+       * templates are stored in a linked list on the instance so that
+       * templates can be efficiently stamped and unstamped.
+       *
+       * This method may be called on the prototype (for prototypical template
+       * binding, to avoid creating accessors every instance) once per prototype,
+       * and will be called with `runtimeBinding: true` by `_stampTemplate` to
+       * create and link an instance of the template metadata associated with a
+       * particular stamping.
        *
        * @param {HTMLTemplateElement} template Template containing binding
        *   bindings
-       * @param {Object=} dynamicFns Map indicating whether method names should
-       *   be included as a dependency to the effect.
+       * @param {boolean=} instanceBinding When false (default), performs
+       *   "prototypical" binding of the template and overwrites any previously
+       *   bound template for the class. When true (as passed from
+       *   `_stampTemplate`), the template info is instanced and linked into
+       *   the list of bound templates.
+       * @return {Object} Template metadata object; for `runtimeBinding`,
+       *   this is an instance of the prototypical template info
+       * @protected
+       */
+      _bindTemplate(template, instanceBinding) {
+        let templateInfo = this.constructor._parseTemplate(template);
+        let wasPreBound = this.__templateInfo == templateInfo;
+        // Optimization: since this is called twice for proto-bound templates,
+        // don't attempt to recreate accessors if this template was pre-bound
+        if (!wasPreBound) {
+          for (let prop in templateInfo.propertyEffects) {
+            this._createPropertyAccessor(prop);
+          }
+        }
+        if (instanceBinding) {
+          // For instance-time binding, create instance of template metadata
+          // and link into list of templates if necessary
+          templateInfo = Object.create(templateInfo);
+          templateInfo.wasPreBound = wasPreBound;
+          if (!wasPreBound && this.__templateInfo) {
+            templateInfo.nextTemplateInfo = this.__templateInfo;
+            this.__templateInfo.previousTemplateInfo = templateInfo;
+          }
+        }
+        return this.__templateInfo = templateInfo;
+      }
+
+      /**
+       * Adds a property effect to the given template metadata, which is run
+       * at the "propagate" stage of `_propertiesChanged` when the template
+       * has been bound to the element via `_bindTemplate`.
+       *
+       * The `effect` object should match the format in `_addPropertyEffect`.
+       *
+       * @param {Object} templateInfo Template metadata to add effect to
+       * @param {string} prop Property that should trigger the effect
+       * @param {Object=} effect Effect metadata object
        * @protected
        */
-      _bindTemplate(template, dynamicFns) {
-        // 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++)  {
-          // 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);
+      static _addTemplatePropertyEffect(templateInfo, prop, effect) {
+        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
+        hostProps[prop] = true;
+        let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};
+        let propEffects = effects[prop] = effects[prop] || [];
+        propEffects.push(effect);
+      }
+
+      /**
+       * Stamps the provided template and performs instance-time setup for
+       * Polymer template features, including data bindings, declarative event
+       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
+       * is returned containing the stamped DOM, ready for insertion into the
+       * DOM.
+       *
+       * This method may be called more than once; however note that due to
+       * `shadycss` polyfill limitations, only styles from templates prepared
+       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
+       * to the shadow root and support CSS custom properties), and note that
+       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
+       * any styles required by in runtime-stamped templates must be included
+       * in the main element template.
+       *
+       * @param {HTMLTemplateElement} template Template to stamp
+       * @return {DocumentFragment} Cloned template content
+       * @protected
+       */
+      _stampTemplate(template) {
+        let dom = super._stampTemplate(template);
+        let templateInfo = this._bindTemplate(template, true);
+        // Add template-instance-specific data to instanced templateInfo
+        templateInfo.nodeList = dom.nodeList;
+        // Capture child nodes to allow unstamping of non-prototypical templates
+        if (!templateInfo.wasPreBound) {
+          let nodes = templateInfo.childNodes = [];
+          for (let n=dom.firstChild; n; n=n.nextSibling) {
+            nodes.push(n);
+          }
+        }
+        dom.templateInfo = templateInfo;
+        // Setup compound storage, 2-way listeners, and dataHost for bindings
+        setupBindings(this, templateInfo);
+        // Flush properties into template nodes if already booted
+        if (this.__dataInitialized) {
+          runEffects(this, templateInfo.propertyEffects, this.__data, null,
+            false, templateInfo.nodeList);
+        }
+        return dom;
+      }
+
+      /**
+       * Removes and unbinds the nodes previously contained in the provided
+       * DocumentFragment returned from `_stampTemplate`.
+       *
+       * @param {DocumentFragment} dom DocumentFragment previously returned
+       *   from `_stampTemplate` associated with the nodes to be removed
+       * @protected
+       */
+      _removeBoundDom(dom) {
+        // Unlink template info
+        let templateInfo = dom.templateInfo;
+        if (templateInfo.previousTemplateInfo) {
+          templateInfo.previousTemplateInfo.nextTemplateInfo =
+            templateInfo.nextTemplateInfo;
+        }
+        if (templateInfo.nextTemplateInfo) {
+          templateInfo.nextTemplateInfo.previousTemplateInfo =
+            templateInfo.previousTemplateInfo;
+        }
+        // Remove stamped nodes
+        let nodes = templateInfo.childNodes;
+        for (let i=0; i<nodes.length; i++) {
+          let node = nodes[i];
+          node.parentNode.removeChild(node);
+        }
+      }
+
+      /**
+       * 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 node
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNode(node, templateInfo, nodeInfo) {
+        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
+        if (node.nodeType === Node.TEXT_NODE) {
+          let parts = this._parseBindings(node.textContent, templateInfo);
+          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) || ' ';
+            addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);
+            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 node
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+        let parts = this._parseBindings(value, templateInfo);
+        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.
+          if (kind === 'property') {
+            name = Polymer.CaseMap.dashToCamelCase(name);
+          }
+          addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
+          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 node
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @protected
+       */
+      static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {
+        let noted = super._parseTemplateNestedTemplate(node, templateInfo, nodeInfo);
+        // Merge host props into outer template and add bindings
+        let hostProps = nodeInfo.templateInfo.hostProps;
+        let mode = '{';
+        for (let source in hostProps) {
+          let parts = [{ mode, source, dependencies: [source] }];
+          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);
+        }
+        return noted;
+      }
+
+      /**
+       * Called to parse text in a template (either attribute values or
+       * textContent) into binding metadata.
+       *
+       * Any overrides of this method should return an array of binding part
+       * metadata  representing one or more bindings found in the provided text
+       * and any "literal" text in between.  Any non-literal parts will be passed
+       * to `_evaluateBinding` when any dependencies change.  The only required
+       * fields of each "part" in the returned array are as follows:
+       *
+       * - `dependencies` - Array containing trigger metadata for each property
+       *   that should trigger the binding to update
+       * - `literal` - String containing text if the part represents a literal;
+       *   in this case no `dependencies` are needed
+       *
+       * Additional metadata for use by `_evaluateBinding` may be provided in
+       * each part object as needed.
+       *
+       * The default implementation handles the following types of bindings
+       * (one or more may be intermixed with literal strings):
+       * - Property binding: `[[prop]]`
+       * - Path binding: `[[object.prop]]`
+       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+       * - Two-way property or path bindings (supports negation):
+       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+       * - Inline computed method (supports negation):
+       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+       *
+       * @param {string} text Text to parse from attribute or textContent
+       * @param {Object} templateInfo Current template metadata
+       * @return {Array<Object>} Array of binding part metadata
+       * @protected
+       */
+      static _parseBindings(text, templateInfo) {
+        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
+          let mode = m[1][0];
+          let negate = Boolean(m[2]);
+          let source = m[3].trim();
+          let customEvent, notifyEvent, colon;
+          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
+            notifyEvent = source.substring(colon + 2);
+            source = source.substring(0, colon);
+            customEvent = true;
+          }
+          let signature = parseMethod(source);
+          let dependencies = [];
+          if (signature) {
+            // Inline computed function
+            let {args, methodName} = signature;
+            for (let i=0; i<args.length; i++) {
+              let arg = args[i];
+              if (!arg.literal) {
+                dependencies.push(arg);
+              }
             }
-            addBindingEffect(this, binding, i, dynamicFns);
+            let dynamicFns = templateInfo.dynamicFns;
+            if (dynamicFns && dynamicFns[methodName] || signature.static) {
+              dependencies.push(methodName);
+            }
+          } else {
+            // Property or path
+            dependencies.push(source);
+          }
+          parts.push({
+            source, mode, negate, customEvent, signature, dependencies,
+            event: notifyEvent
+          });
+          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;
+        }
+      }
+
+      /**
+       * Called to evaluate a previously parsed binding part based on a set of
+       * one or more changed dependencies.
+       *
+       * @param {HTMLElement} inst Element that should be used as scope for
+       *   binding dependencies
+       * @param {Object} part Binding part metadata
+       * @param {string} path Property/path that triggered this effect
+       * @param {Object} props Bag of current property changes
+       * @param {Object} oldProps Bag of previous values for changed properties
+       * @param {boolean} hasPaths True with `props` contains one or more paths
+       * @return {*} Value the binding part evaluated to
+       * @protected
+       */
+      static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {
+        let value;
+        if (part.signature) {
+          value = runMethodEffect(inst, path, props, oldProps, part.signature);
+        } else if (path != part.source) {
+          value = Polymer.Path.get(inst, part.source);
+        } else {
+          if (hasPaths && Polymer.Path.isPath(path)) {
+            value = Polymer.Path.get(inst, path);
+          } else {
+            value = inst.__data[path];
           }
         }
+        if (part.negate) {
+          value = !value;
+        }
+        return value;
       }
 
     }
diff --git a/lib/mixins/template-stamp.html b/lib/mixins/template-stamp.html
index 70fa9921c7..170f4fe747 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.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);
     // 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.parentIndex === 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
@@ -463,11 +123,266 @@
      */
     return class TemplateStamp extends superClass {
 
-      constructor() {
-        super();
+      _initializeProperties() {
+        super._initializeProperties();
         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
+       *         parentInfo: <reference to parent nodeInfo>,
+       *         parentIndex: <integer index in parent's `childNodes` collection>
+       *         infoIndex: <integer index of this `nodeInfo` in `templateInfo.nodeInfoList`
+       *       },
+       *       ...
+       *     ],
+       *     // 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 <---------------------+
+       *      _parseTemplateContent              |
+       *        _parseTemplateNode  <------------|--+
+       *          _parseTemplateNestedTemplate --+  |
+       *          _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 = {};
+          templateInfo.nodeInfoList = [];
+          templateInfo.stripWhiteSpace =
+            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
+            template.hasAttribute('strip-whitespace');
+          this._parseTemplateContent(template, templateInfo, {parent: null});
+        }
+        return template._templateInfo;
+      }
+
+      static _parseTemplateContent(template, templateInfo, nodeInfo) {
+        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
+      }
+
+      /**
+       * 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._parseTemplateNestedTemplate(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, parentIndex=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 = { parentIndex, parentInfo: nodeInfo };
+          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
+            childInfo.infoIndex = templateInfo.nodeInfoList.push(childInfo) - 1;
+          }
+          parentIndex++;
+        }
+      }
+
+      /**
+       * 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 {HTMLTemplateElement} node Node to parse (a <template>)
+       * @param {Object} outerTemplateInfo Template metadata for current template
+       *   that includes the template `node`
+       * @param {Object} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       */
+      static _parseTemplateNestedTemplate(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 {*} value 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;
       }
 
       /**
@@ -475,27 +390,22 @@
        * 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 listeners for `on-event="handler"` attributes
+       * * Generates an "id map" for all nodes with id's under `$` on returned
+       *   document fragment
+       * * 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
        * removed after being noted in notes, and any nested <template>.content
        * is removed and stored in notes as well.
        *
-       * Note that this method may only be called once per instance (it does
-       * 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
@@ -503,32 +413,36 @@
             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;
-        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);
+        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
+        let nodes = dom.nodeList = new Array(nodeInfo.length);
+        dom.$ = {};
+        for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {
+          let node = nodes[i] = findTemplateNode(dom, info);
+          applyIdToMap(this, dom.$, 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
+       * @param {*=} context Context the method will be called on (defaults
+       *   to `node`)
+       * @return {Function} Generated handler function
+       */
       _addMethodEventListenerToNode(node, eventName, methodName, context) {
         context = context || node;
         let handler = createNodeEventHandler(context, eventName, methodName);
@@ -536,10 +450,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/array-splice.html b/lib/utils/array-splice.html
index 34e45a65de..34bd0b7b0b 100644
--- a/lib/utils/array-splice.html
+++ b/lib/utils/array-splice.html
@@ -147,6 +147,23 @@
      * Complexity: O(l * p)
      *   l: The length of the current array
      *   p: The length of the old array
+     *
+     * @param {Array} current The current "changed" array for which to
+     * calculate splices.
+     * @param {Integer} currentStart Starting index in the `current` array for
+     * which splices are calculated.
+     * @param {Integer} currentEnd Ending index in the `current` array for
+     * which splices are calculated.
+     * @param {Array} old The original "unchanged" array to compare `current`
+     * against to determine splices.
+     * @param {Integer} oldStart Starting index in the `old` array for
+     * which splices are calculated.
+     * @param {Integer} oldEnd Ending index in the `old` array for
+     * which splices are calculated.
+     * @return {Array} Returns an array of splice record objects. Each of these
+     * contains: `index` the location where the splice occurred; `removed`
+     * the array of removed items from this location; `addedCount` the number
+     * of items added at this location.
      */
     calcSplices(current, currentStart, currentEnd,
                           old, oldStart, oldEnd) {
@@ -286,6 +303,14 @@
      * non-shared portions of the arrays.
      *
      * @memberof Polymer.ArraySplice
+     * @param {Array} current The "changed" array for which splices will be
+     * calculated.
+     * @param {Array} previous The "unchanged" original array to compare
+     * `current` against to determine the splices.
+     * @return {Array} Returns an array of splice record objects. Each of these
+     * contains: `index` the location where the splice occurred; `removed`
+     * the array of removed items from this location; `addedCount` the number
+     * of items added at this location.
      */
     calculateSplices(current, previous) {
       return ArraySplice.calculateSplices(current, previous);
diff --git a/lib/utils/async.html b/lib/utils/async.html
index 1124dda81e..19293ddc1f 100644
--- a/lib/utils/async.html
+++ b/lib/utils/async.html
@@ -145,10 +145,10 @@
        * @memberof Polymer.Async.timeOut
        * @param {number} handle Handle returned from `run` of callback to cancel
        */
-      cancel(timer) {
-        return window.cancelIdleCallback ?
-          window.cancelIdleCallback(timer) :
-          window.clearTimeout(timer);
+      cancel(handle) {
+        window.cancelIdleCallback ?
+          window.cancelIdleCallback(handle) :
+          window.clearTimeout(handle);
       }
     },
 
@@ -172,7 +172,8 @@
        * Enqueues a function called at microtask timing.
        *
        * @memberof Polymer.Async.timeOut
-       * @param {Function} fn Callback to run
+       * @param {Function} callback Callback to run
+       * @return {*} Handle used for canceling task
        */
       run(callback) {
         microtaskNode.textContent = microtaskNodeContent++;
diff --git a/lib/utils/boot.html b/lib/utils/boot.html
index e6c0258fbb..bb531ff36e 100644
--- a/lib/utils/boot.html
+++ b/lib/utils/boot.html
@@ -18,6 +18,12 @@
    * @summary Polymer is a lightweight library built on top of the web
    * standards-based Web Components API's, and makes it easy to build your
    * own custom HTML elements.
+   * @param {Object} info Prototype for the custom element. It must contain
+   * an `is` property to specify the element name. Other properties populate
+   * the element prototype. The `properties`, `observers`, `hostAttributes`,
+   * and `listeners` properties are processed to create element features.
+   * @return {Object} Returns a custom element class for the given provided
+   * prototype `info` object. The name of the element if given by `info.is`.
    */
   window.Polymer = function(info) {
     return window.Polymer._polymerFn(info);
diff --git a/lib/utils/debounce.html b/lib/utils/debounce.html
index 8681b43259..dc8f66a796 100644
--- a/lib/utils/debounce.html
+++ b/lib/utils/debounce.html
@@ -29,12 +29,12 @@
      * a callback and optional arguments to be passed to the run function
      * from the async module.
      *
-     * @param {!AsyncModule} asyncModule
-     * @param {function()} callback
+     * @param {!AsyncModule} asyncModule Object with Async interface.
+     * @param {function()} callback Callback to run.
      */
-    setConfig(asyncModule, cb) {
+    setConfig(asyncModule, callback) {
       this._asyncModule = asyncModule;
-      this._callback = cb;
+      this._callback = callback;
       this._timer = this._asyncModule.run(() => {
         this._timer = null;
         this._callback()
@@ -61,7 +61,7 @@
     /**
      * Returns true if the debouncer is active.
      *
-     * @return {boolean}
+     * @return {boolean} True if active.
      */
     isActive() {
       return this._timer != null;
@@ -70,22 +70,25 @@
    * Creates a debouncer if no debouncer is passed as a parameter
    * or it cancels an active debouncer otherwise.
    *
-   * @param {Polymer.Debouncer?} debouncer
-   * @param {!AsyncModule} asyncModule
-   * @param {function()} cb
-   * @return {!Debouncer}
+   * @param {Polymer.Debouncer?} debouncer Debouncer object.
+   * @param {!AsyncModule} asyncModule Object with Async interface
+   * @param {function()} callback Callback to run.
+   * @return {!Debouncer} Returns a debouncer object.
    */
-    static debounce(debouncer, asyncModule, cb) {
+    static debounce(debouncer, asyncModule, callback) {
       if (debouncer instanceof Debouncer) {
         debouncer.cancel();
       } else {
         debouncer = new Debouncer();
       }
-      debouncer.setConfig(asyncModule, cb);
+      debouncer.setConfig(asyncModule, callback);
       return debouncer;
     }
   }
 
+  /**
+   * @memberof Polymer
+   */
   Polymer.Debouncer = Debouncer;
 })();
 </script>
diff --git a/lib/utils/flattened-nodes-observer.html b/lib/utils/flattened-nodes-observer.html
index 0a49b3ab0d..c1f75d038b 100644
--- a/lib/utils/flattened-nodes-observer.html
+++ b/lib/utils/flattened-nodes-observer.html
@@ -57,7 +57,7 @@
      * `<slot>` elements assigned to it, these are flattened as well.
      *
      * @param {Node} node The node for which to return the list of flattened nodes.
-     * @returns {Array} The list of flattened nodes for the given `node`.
+     * @return {Array} The list of flattened nodes for the given `node`.
     */
     static getFlattenedNodes(node) {
       if (isSlot(node)) {
diff --git a/lib/utils/gestures.html b/lib/utils/gestures.html
index e4599758c2..4ee65c3b87 100644
--- a/lib/utils/gestures.html
+++ b/lib/utils/gestures.html
@@ -86,7 +86,7 @@
   };
 
   /**
-   * @param {boolean=} setup
+   * @param {boolean=} setup True to add, false to remove.
    */
   function setupTeardownMouseCanceller(setup) {
     let events = IS_TOUCH_ONLY ? ['click'] : MOUSE_EVENTS;
@@ -150,6 +150,11 @@
       // the bounding box of the target of the event
       // Thanks IE 10 >:(
       let t = Gestures._findOriginalTarget(ev);
+      // make sure the target of the event is an element so we can use getBoundingClientRect,
+      // if not, just assume it is a synthetic click
+      if (t.nodeType !== Node.ELEMENT_NODE) {
+        return true;
+      }
       let bcr = t.getBoundingClientRect();
       // use page x/y to account for scrolling
       let x = ev.pageX, y = ev.pageY;
@@ -230,6 +235,8 @@
      * @memberof Polymer.Gestures
      * @param {number} x Horizontal pixel coordinate
      * @param {number} y Vertical pixel coordinate
+     * @return {HTMLElement} Returns the deepest shadowRoot inclusive element
+     * found at the screen position given.
      */
     deepTargetFind: function(x, y) {
       let node = document.elementFromPoint(x, y);
@@ -239,7 +246,12 @@
       // if there is not a shadowroot, exit the loop
       while (next && next.shadowRoot && !window.ShadyDOM) {
         // if there is a node at x/y in the shadowroot, look deeper
+        let oldNext = next;
         next = next.shadowRoot.elementFromPoint(x, y);
+        // on Safari, elementFromPoint may return the shadowRoot host
+        if (oldNext === next) {
+          break;
+        }
         if (next) {
           node = next;
         }
@@ -250,6 +262,8 @@
      * a cheaper check than ev.composedPath()[0];
      *
      * @private
+     * @param {Event} ev Event.
+     * @return {HTMLElement} Returns the event target.
      */
     _findOriginalTarget: function(ev) {
       // shadowdom
@@ -262,6 +276,7 @@
 
     /**
      * @private
+     * @param {Event} ev Event.
      */
     _handleNative: function(ev) {
       let handled;
@@ -322,6 +337,7 @@
 
     /**
      * @private
+     * @param {Event} ev Event.
      */
     _handleTouchAction: function(ev) {
       let t = ev.changedTouches[0];
@@ -363,6 +379,7 @@
      * @param {Node} node Node to add listener on
      * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
      * @param {Function} handler Event listener function to call
+     * @return {boolean} Returns true if a gesture event listener was added.
      */
     addListener: function(node, evType, handler) {
       if (this.gestures[evType]) {
@@ -379,6 +396,7 @@
      * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
      * @param {Function} handler Event listener function previously passed to
      *  `addListener`.
+     * @return {boolean} Returns true if a gesture event listener was removed.
      */
     removeListener: function(node, evType, handler) {
       if (this.gestures[evType]) {
@@ -391,6 +409,9 @@
      * automate the event listeners for the native events
      *
      * @private
+     * @param {HTMLElement} node Node on which to add the event.
+     * @param {string} evType Event type to add.
+     * @param {function} handler Event handler function.
      */
     _add: function(node, evType, handler) {
       let recognizer = this.gestures[evType];
@@ -426,6 +447,9 @@
      * automate event listener removal for native events
      *
      * @private
+     * @param {HTMLElement} node Node on which to remove the event.
+     * @param {string} evType Event type to remove.
+     * @param {function} handler Event handler function.
      */
     _remove: function(node, evType, handler) {
       let recognizer = this.gestures[evType];
@@ -464,6 +488,8 @@
 
     /**
      * @private
+     * @param {string} evName Event name.
+     * @return {Object} Returns the gesture for the given event name.
      */
     _findRecognizerByEvent: function(evName) {
       for (let i = 0, r; i < this.recognizers.length; i++) {
@@ -496,7 +522,12 @@
     },
 
     /**
+     * Dispatches an event on the `target` element of `type` with the given
+     * `detail`.
      * @private
+     * @param {HTMLElement} target The element on which to fire an event.
+     * @param {string} type The type of event to fire.
+     * @param {Object=} detail The detail object to populate on the event.
      */
     _fire: function(target, type, detail) {
       let ev = new Event(type, { bubbles: true, cancelable: true, composed: true });
@@ -515,6 +546,7 @@
      * Prevents the dispatch and default action of the given event name.
      *
      * @memberof Polymer.Gestures
+     * @param {string} evName Event name.
      */
     prevent: function(evName) {
       let recognizer = this._findRecognizerByEvent(evName);
@@ -530,7 +562,6 @@
      * This method should only be called during testing with simulated touch inputs.
      * Calling this method in production may cause duplicate taps or other Gestures.
      *
-     * @method resetMouseCanceller
      * @memberof Polymer.Gestures
      */
     resetMouseCanceller: function() {
diff --git a/lib/utils/import-href.html b/lib/utils/import-href.html
index 627eae9c9b..77933a4e43 100644
--- a/lib/utils/import-href.html
+++ b/lib/utils/import-href.html
@@ -35,7 +35,6 @@
    * element will contain the imported document contents.
    *
    * @memberof Polymer
-   * @method importHref
    * @param {string} href URL to document to load.
    * @param {Function=} onload Callback to notify when an import successfully
    *   loaded.
diff --git a/lib/utils/mixin.html b/lib/utils/mixin.html
index 51ac437c52..661de88889 100644
--- a/lib/utils/mixin.html
+++ b/lib/utils/mixin.html
@@ -23,8 +23,9 @@
    * Given a mixin producing function, memoize applications of mixin to base
    * @private
    * @template T
-   * @param {T} mixin
-   * @return {T}
+   * @param {T} mixin Mixin for which to create a caching mixin.
+   * @return {T} Returns a mixin which when applied multiple times to the
+   * same base will always return the same extended class.
    */
   function cachingMixin(mixin) {
     return function(base) {
diff --git a/lib/utils/path.html b/lib/utils/path.html
index 869358d36e..2dfe89403c 100644
--- a/lib/utils/path.html
+++ b/lib/utils/path.html
@@ -76,8 +76,9 @@
      * ```
      *
      * @memberof Polymer.Path
-     * @param {string} path Path string
-     * @return {boolean} True if `path` is an ancestor of `base`
+     * @param {string} base Path string to test against.
+     * @param {string} path Path string to test.
+     * @return {boolean} True if `path` is an ancestor of `base`.
      */
     isAncestor: function(base, path) {
       //     base.startsWith(path + '.');
@@ -96,6 +97,9 @@
      * ```
      *
      * @memberof Polymer.Path
+     * @param {string} base Path string to test against.
+     * @param {string} path Path string to test.
+     * @return {boolean} True if `path` is a descendant of `base`.
      */
     isDescendant: function(base, path) {
       //     path.startsWith(base + '.');
diff --git a/lib/utils/render-status.html b/lib/utils/render-status.html
index 9703356c21..ca7175adce 100644
--- a/lib/utils/render-status.html
+++ b/lib/utils/render-status.html
@@ -26,24 +26,33 @@
       flushQueue(beforeRenderQueue);
       // after the render
       setTimeout(function() {
-        flushQueue(afterRenderQueue);
+        runQueue(afterRenderQueue);
       });
     });
   }
 
   function flushQueue(queue) {
     while (queue.length) {
-      const q = queue.shift();
-      const context = q[0];
-      const callback = q[1];
-      const args = q[2];
-      try {
-        callback.apply(context, args);
-      } catch(e) {
-        setTimeout(() => {
-          throw e;
-        })
-      }
+      callMethod(queue.shift());
+    }
+  }
+
+  function runQueue(queue) {
+    for (let i=0, l=queue.length; i < l; i++) {
+      callMethod(queue.shift());
+    }
+  }
+
+  function callMethod(info) {
+    const context = info[0];
+    const callback = info[1];
+    const args = info[2];
+    try {
+      callback.apply(context, args);
+    } catch(e) {
+      setTimeout(() => {
+        throw e;
+      })
     }
   }
 
@@ -52,6 +61,7 @@
       flushQueue(beforeRenderQueue);
       flushQueue(afterRenderQueue);
     }
+    scheduled = false;
   }
 
   /**
diff --git a/lib/utils/style-gather.html b/lib/utils/style-gather.html
index 1fb045f3bd..e18a347fc2 100644
--- a/lib/utils/style-gather.html
+++ b/lib/utils/style-gather.html
@@ -36,7 +36,8 @@
      * Returns CSS text of styles in a space-separated list of `dom-module`s.
      *
      * @memberof Polymer.StyleGather
-     * @param {string} moduleIds
+     * @param {string} moduleIds List of dom-module id's within which to
+     * search for css.
      * @return {string} Concatenated CSS content from specified `dom-module`s
      */
     cssFromModules(moduleIds) {
diff --git a/lib/utils/templatize.html b/lib/utils/templatize.html
index c2376016d0..25786cfc6e 100644
--- a/lib/utils/templatize.html
+++ b/lib/utils/templatize.html
@@ -67,7 +67,10 @@
         }
       }
       /**
+       * Configure the given `props` by calling `_setPendingProperty`. Also
+       * sets any properties stored in `__hostProps`.
        * @private
+       * @param {Object} props Object of property name-value pairs to set.
        */
       _configureProperties(props) {
         let options = this.__templatizeOptions;
@@ -118,6 +121,11 @@
         }
       }
       /**
+       * Shows or hides the template instance top level child elements. For
+       * text nodes, `textContent` is removed while "hidden" and replaced when
+       * "shown."
+       * @param {boolean} hide Set to true to hide the children;
+       * set to false to show them.
        * @protected
        */
       _showHideChildren(hide) {
@@ -198,7 +206,7 @@
       return templateHost && templateHost._methodHost || templateHost;
     }
 
-    function createTemplatizerClass(template, options) {
+    function createTemplatizerClass(template, templateInfo, options) {
       // Anonymous class created by the templatize
       /**
        * @unrestricted
@@ -208,22 +216,22 @@
       let klass = class extends base { }
       klass.prototype.__templatizeOptions = options;
       klass.prototype._bindTemplate(template);
-      addNotifyEffects(klass, template, options);
+      addNotifyEffects(klass, template, templateInfo, options);
       return klass;
     }
 
-    function addPropagateEffects(template, options) {
+    function addPropagateEffects(template, templateInfo, options) {
       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,
@@ -254,8 +262,8 @@
       }
     }
 
-    function addNotifyEffects(klass, template, options) {
-      let hostProps = template._content._hostProps || {};
+    function addNotifyEffects(klass, template, templateInfo, options) {
+      let hostProps = templateInfo.hostProps || {};
       for (let iprop in options.instanceProps) {
         delete hostProps[iprop];
         let userNotifyInstanceProp = options.notifyInstanceProp;
@@ -296,7 +304,7 @@
      *     // Get a template from somewhere, e.g. light DOM
      *     let template = this.querySelector('template');
      *     // Prepare the template
-     *     let TemplateClass = Polymer.Tempaltize.templatize(template);
+     *     let TemplateClass = Polymer.Templatize.templatize(template);
      *     // Instance the template with an initial data model
      *     let instance = new TemplateClass({myProp: 'initial'});
      *     // Insert the instance's DOM somewhere, e.g. element's shadow DOM
@@ -358,11 +366,11 @@
        * - `instanceProps`: Dictionary of property names that will be added
        *   to the instance by the templatize owner.  These properties shadow any
        *   host properties, and changes within the template to these properties
-       *   will result in `notifyInstanceProperties` to be called.
+       *   will result in `notifyInstanceProp` being called.
        * - `mutableData`: When `true`, the generated class will skip strict
        *   dirty-checking for objects and arrays (always consider them to be
        *   "dirty").
-       * - `notifyInstanceProperties(instance, property, value)`: Called when
+       * - `notifyInstanceProp(instance, property, value)`: Called when
        *   an instance property changes.  Users may choose to call `notifyPath`
        *   on e.g. the owner to notify the change.
        * - `parentModel`: When `true`, events handled by declarative event listeners
@@ -384,40 +392,41 @@
        * @param {HTMLTemplateElement} template Template to templatize
        * @param {*} owner Owner of the template instances; any optional callbacks
        *   will be bound to this owner.
-       * @param {*} options Options dictionary (see summary for details)
+       * @param {*=} options Options dictionary (see summary for details)
        * @return {TemplateInstanceBase} Generated class bound to the template
        *   provided
        */
       templatize(template, owner, options) {
+        options = options || {};
         if (template.__templatizeOwner) {
           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 = owner.constructor._parseTemplate(template);
         // Get memoized base class for the prototypical template, which
         // includes property effects for binding template & forwarding
-        let baseClass = template._content.__templatizeInstanceClass;
+        let baseClass = templateInfo.templatizeInstanceClass;
         if (!baseClass) {
-          baseClass = template._content.__templatizeInstanceClass =
-            createTemplatizerClass(template, options);
+          baseClass = createTemplatizerClass(template, templateInfo, options);
+          templateInfo.templatizeInstanceClass = baseClass;
         }
         // Host property forwarding must be installed onto template instance
-        addPropagateEffects(template, options);
+        addPropagateEffects(template, templateInfo, options);
         // Subclass base class and add reference for this specific template
         let klass = class TemplateInstance extends baseClass {};
         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;
       },
 
       /**
        * Returns the template "model" associated with a given element, which
        * serves as the binding scope for the template instance the element is
-       * contained in. A template model is an instance of `Polymer.Base`, and
-       * should be used to manipulate data associated with this template instance.
+       * contained in. A template model is an instance of
+       * `TemplateInstanceBase`, and should be used to manipulate data
+       * associated with this template instance.
        *
        * Example:
        *
@@ -427,12 +436,13 @@
        *   }
        *
        * @memberof Polymer.Templatize
-       * @method modelForElement
+       * @param {HTMLTemplateElement} template The model will be returned for
+       *   elements stamped from this template
        * @param {HTMLElement} el Element for which to return a template model.
        * @return {TemplateInstanceBase} Template instance representing the
        *   binding scope for the element
        */
-      modelForElement(host, el) {
+      modelForElement(template, el) {
         let model;
         while (el) {
           // An element with a __templatizeInstance marks the top boundary
@@ -441,7 +451,7 @@
           if ((model = el.__templatizeInstance)) {
             // Found an element stamped by another template; keep walking up
             // from its __dataHost
-            if (model.__dataHost != host) {
+            if (model.__dataHost != template) {
               el = model.__dataHost;
             } else {
               return model;
diff --git a/package.json b/package.json
index 7eeb010799..9686cbc1fc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@polymer/polymer",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.5",
   "description": "The Polymer library makes it easy to create your own web components. Give your element some markup and properties, and then use it on a site. Polymer provides features like dynamic templates and data binding to reduce the amount of boilerplate you need to write",
   "main": "polymer.html",
   "directories": {
diff --git a/test/runner.html b/test/runner.html
index 6ac8473e86..e15a8de0a5 100644
--- a/test/runner.html
+++ b/test/runner.html
@@ -27,6 +27,7 @@
       'unit/globals.html',
       'unit/property-accessors.html',
       'unit/property-effects.html',
+      'unit/property-effects-template.html',
       'unit/path-effects.html',
       'unit/shady.html',
       'unit/shady-events.html',
@@ -36,6 +37,7 @@
       'unit/styling-cross-scope-var.html',
       'unit/styling-cross-scope-apply.html',
       'unit/styling-cross-scope-unknown-host.html',
+      'unit/styling-only-with-template.html',
       'unit/custom-style.html',
       'unit/custom-style-late.html',
       'unit/custom-style-async.html',
@@ -46,6 +48,7 @@
       'unit/case-map.html',
       'unit/configure.html',
       'unit/ready-attached-order.html',
+      'unit/ready-attached-order-class.html',
       'unit/attributes.html',
       'unit/async.html',
       'unit/behaviors.html',
@@ -68,7 +71,8 @@
       'unit/logging.html',
       'unit/mixin-utils.html',
       'unit/mixin-behaviors.html',
-      'unit/render-status.html'
+      'unit/render-status.html',
+      'unit/disable-upgrade.html'
     ];
 
     // http://eddmann.com/posts/cartesian-product-in-javascript/
diff --git a/test/smoke/disable-upgrade.html b/test/smoke/disable-upgrade.html
new file mode 100644
index 0000000000..0897b46d03
--- /dev/null
+++ b/test/smoke/disable-upgrade.html
@@ -0,0 +1,98 @@
+ <!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+<dom-module id="x-child">
+  <template>
+    <style>
+      :host {
+        display: block;
+        border: 2px solid lightgreen;
+        margin: 2px;
+        padding: 2px;
+      };
+    </style>
+    <div>I'm a child, yo!</div>
+  </template>
+  <script>
+    HTMLImports.whenReady(function() {
+      class XChild extends Polymer.Element {
+        static get is() { return 'x-child'}
+        static get properties() {
+          return {
+            prop: { value: 'hi'}
+          }
+        }
+      }
+      customElements.define(XChild.is, XChild);
+    });
+  </script>
+</dom-module>
+
+
+<dom-module id="x-test">
+  <template>
+    <style>
+      :host {
+        display: block;
+        border: 2px solid orange;
+        padding: 2px;
+      };
+    </style>
+    <div>element says: {{prop}}</div>
+    <x-child id="child" disable-upgrade$="[[disabled]]"></x-child>
+  </template>
+  <script>
+    HTMLImports.whenReady(function() {
+      class XTest extends Polymer.Element {
+        static get is() { return 'x-test'}
+        static get properties() {
+          return {
+            prop: { value: 'hi'},
+            disabled: {value: true}
+          }
+        }
+
+        ready() {
+          super.ready();
+          setTimeout(() => {
+            // this.$.child.removeAttribute('disable-upgrade');
+            this.disabled = false;
+          }, 1000)
+        }
+      }
+      customElements.define(XTest.is, XTest);
+    });
+  </script>
+</dom-module>
+
+
+<h2>Enabled</h2>
+<x-test></x-test>
+<x-test></x-test>
+<h2>Disabled</h2>
+<script>
+  function go() {
+    Array.from(document.querySelectorAll('[disable-upgrade]'))
+      .forEach((e) => e.removeAttribute('disable-upgrade'));
+  }
+</script>
+<button onclick="go()">Go</button>
+<x-test id="one" disable-upgrade></x-test>
+<x-test id="two" disable-upgrade></x-test>
+
+</body>
+</html>
diff --git a/test/smoke/ordering-test.html b/test/smoke/ordering-test.html
index c46d9a0079..5400425ed8 100644
--- a/test/smoke/ordering-test.html
+++ b/test/smoke/ordering-test.html
@@ -40,8 +40,8 @@
     }
     connectedCallback() {
       console.group(this.localName, 'connected');
-      super.connectedCallback();
       console.warn(this.localName, 'connected (user)', this.shadowRoot);
+      super.connectedCallback();
       console.groupEnd(this.localName, 'connected');
     }
     _flushProperties() {
@@ -79,8 +79,8 @@
     }
     connectedCallback() {
       console.group(this.localName, 'connected');
-      super.connectedCallback();
       console.warn(this.localName, 'connected (user)', this.shadowRoot);
+      super.connectedCallback();
       console.groupEnd(this.localName, 'connected');
     }
     _flushProperties() {
@@ -113,8 +113,8 @@
     }
     connectedCallback() {
       console.group(this.localName, 'connected');
-      super.connectedCallback();
       console.warn(this.localName, 'connected (user)', this.shadowRoot);
+      super.connectedCallback();
       console.groupEnd(this.localName, 'connected');
     }
     _flushProperties() {
diff --git a/test/unit/attributes.html b/test/unit/attributes.html
index 1df5e881be..12f957c545 100644
--- a/test/unit/attributes.html
+++ b/test/unit/attributes.html
@@ -212,6 +212,15 @@
       assert.strictEqual(element.dashCase, 'Changed');
     });
 
+    test('value that cannot deserialize from JSON warns', function() {
+      sinon.spy(console, 'warn');
+      var badAttr = '[foo, bar]';
+      element.setAttribute('array', badAttr);
+      assert.isTrue(console.warn.calledOnce);
+      assert.include(console.warn.firstCall.args[0], badAttr);
+      console.warn.restore();
+    });
+
   });
 
   suite('imperative attribute change (reflect)', function() {
diff --git a/test/unit/behaviors.html b/test/unit/behaviors.html
index 997a6ded74..24f44b5aea 100644
--- a/test/unit/behaviors.html
+++ b/test/unit/behaviors.html
@@ -224,6 +224,11 @@
     });
 
     Polymer.registerBehavior1 ={
+      beforeRegister: function() {
+        this._createPropertyObserver('beforeProp', 'beforePropChanged1');
+        this.beforeRegisterCount++;
+        this.beforeRegisterBehaviors = this.behaviors;
+      },
       registered: function() {
         this._createPropertyObserver('prop', 'propChanged1');
         this._createMethodObserver('propChanged2(prop)');
@@ -235,6 +240,9 @@
       ready: function() {
         this._ensureAttribute('attr', true);
       },
+      beforePropChanged1: function() {
+        this.beforePropChangedCalled = true;
+      },
       propChanged1: function() {
         this.propChanged1Called = true;
       },
@@ -245,6 +253,9 @@
 
     Polymer.registerBehavior2 ={
       prop2: true,
+      beforeRegister: function() {
+        this.beforeRegisterCount++;
+      },
       registered: function() {
         this.registeredCount++;
       }
@@ -252,6 +263,9 @@
 
     Polymer.registerBehavior3 ={
       prop3: true,
+      beforeRegister: function() {
+        this.beforeRegisterCount++;
+      },
       registered: function() {
         this.registeredCount++;
       }
@@ -264,11 +278,14 @@
         Polymer.registerBehavior3
       ],
       prop4: true,
-
+      beforeRegister: function() {
+        this.beforeRegisterCount++;
+      },
       registered: function() {
         this.registeredCount++;
       },
 
+      beforeRegisterCount: 0,
       registeredCount: 0,
 
       is: 'behavior-registered'
@@ -366,6 +383,23 @@
 
 });
 
+suite('behavior.beforeRegister', function() {
+  test('can install dynamic properties', function() {
+    var el = fixture('registered');
+    assert.ok(el.$.content);
+    el.beforeProp = 43;
+    assert.isTrue(el.beforePropChangedCalled);
+  });
+
+  test('called once for each behavior with access to element prototype', function() {
+    var el = fixture('registered');
+    assert.equal(el.beforeRegisterCount, 4);
+    assert.equal(el.beforeRegisterBehaviors.length, 3);
+    assert.equal(el.beforeRegisterBehaviors, el.behaviors);
+  });
+
+});
+
 
 suite('multi-behaviors element', function() {
   var el;
diff --git a/test/unit/custom-style-late-import.html b/test/unit/custom-style-late-import.html
deleted file mode 100644
index 161e8aa8c8..0000000000
--- a/test/unit/custom-style-late-import.html
+++ /dev/null
@@ -1,32 +0,0 @@
-<!--
-@license
-Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--->
-<script>
-  Polymer({
-    is: 'x-input',
-    extends : 'input'
-  });
-</script>
-<custom-style>
-<style is="custom-style">
-  input[is=x-input] {
-    border : 4px solid red;
-    @apply --cs-blue;
-  }
-</style>
-</custom-style>
-<custom-style>
-<style is="custom-style">
-  :root {
-    --cs-blue: {
-      border : 8px solid blue;
-    };
-  }
-</style>
-</custom-style>
diff --git a/test/unit/custom-style-late.html b/test/unit/custom-style-late.html
index 0456a265f8..aab52da785 100644
--- a/test/unit/custom-style-late.html
+++ b/test/unit/custom-style-late.html
@@ -14,19 +14,50 @@
   <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
   <script src="../../../web-component-tester/browser.js"></script>
   <link rel="import" href="../../polymer.html">
-  <link rel="import" href="custom-style-late-import.html">
-
 </head>
 <body>
-  <input id="input" is="x-input">
+
+  <custom-style>
+    <style is="custom-style">
+      x-input {
+        border: 4px solid red;
+        @apply --cs-blue;
+      }
+    </style>
+  </custom-style>
+
+  <template id="late">
+  <custom-style>
+    <style is="custom-style">
+      html {
+        --cs-blue: {
+          border: 8px solid blue;
+        };
+      }
+    </style>
+  </custom-style>
+  </template>
+
+  <x-input id="input"></x-input>
 
   <script>
   /* global input */
 
     suite('custom-style late property definition', function() {
 
-      test('late defined properties applied to custom-style', function() {
-        assertComputed(input, '8px');
+      test('late defined properties applied to custom-style', function(done) {
+        Polymer({
+          is: 'x-input'
+        });
+        var template = document.querySelector('template#late');
+        document.body.appendChild(document.importNode(template.content, true));
+        // wait 2 rounds of `afterNextRender` as `<custom-style>` boots asynchronously
+        Polymer.RenderStatus.afterNextRender(null, function() {
+          Polymer.RenderStatus.afterNextRender(null, function() {
+            assertComputed(input, '8px');
+            done();
+          });
+        });
       });
 
     });
diff --git a/test/unit/disable-upgrade.html b/test/unit/disable-upgrade.html
new file mode 100644
index 0000000000..c90387fe95
--- /dev/null
+++ b/test/unit/disable-upgrade.html
@@ -0,0 +1,158 @@
+<!doctype html>
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<meta charset="utf-8">
+<script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+<script src="../../../web-component-tester/browser.js"></script>
+<link rel="import" href="../../polymer.html">
+
+<dom-module id="x-lazy">
+  <template>
+    <style>
+    :host {
+      display: block;
+    }
+    </style>
+    <div id="child">Live!</div>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    Polymer({
+      is: 'x-lazy'
+    });
+  });
+  </script>
+</dom-module>
+
+<test-fixture id="simple">
+  <template>
+    <x-lazy disable-upgrade></x-lazy>
+  </template>
+</test-fixture>
+
+<dom-module id="x-complicated-child">
+  <script>
+  HTMLImports.whenReady(function() {
+    Polymer({
+      is: 'x-complicated-child',
+      properties: {
+        a: {
+          observer: 'aChanged'
+        },
+        c: {
+          observer: 'cChanged'
+        },
+        aRan: {
+          value: false
+        },
+        cRan: {
+          value: false
+        }
+      },
+      aChanged: function() {
+        this.aRan = true;
+      },
+      cChanged: function() {
+        this.cRan = true;
+      }
+    });
+  })
+  </script>
+</dom-module>
+
+<dom-module id="x-complicated-lazy">
+  <template>
+    <x-complicated-child id="child" a="{{a}}" disable-upgrade$="{{b}}" c="{{c}}"></x-complicated-child>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    Polymer({
+      is: 'x-complicated-lazy',
+      properties: {
+        a: {value: true},
+        b: {value: true},
+        c: {value: true}
+      }
+    });
+  });
+  </script>
+</dom-module>
+
+<test-fixture id="databind-lazy">
+  <template>
+    <x-complicated-lazy></x-complicated-lazy>
+  </template>
+</test-fixture>
+
+<dom-module id="x-complicated-not-lazy">
+  <template>
+    <!-- the <x-non-lazy> element here ensures there are other elements on -->
+    <!-- the host-stack to trigger "configuration", to ensure the disabled -->
+    <!-- element handles that code path correctly -->
+    <x-non-lazy></x-non-lazy>
+    <x-complicated-child id="child" a="{{a}}" disable-upgrade$="{{b}}" c="{{c}}"></x-complicated-child>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    Polymer({
+      is: 'x-non-lazy'
+    });
+    Polymer({
+      is: 'x-complicated-not-lazy',
+      properties: {
+        a: {value: true},
+        b: {value: false},
+        c: {value: true}
+      }
+    });
+  });
+  </script>
+</dom-module>
+
+<test-fixture id="databind-not-lazy">
+  <template>
+    <x-complicated-not-lazy></x-complicated-not-lazy>
+  </template>
+</test-fixture>
+
+<script>
+suite('Element disableUpgrade', function() {
+  suite('disable-upgrade', function() {
+    var el;
+    setup(function() {
+      el = fixture('simple');
+    });
+    test('does not stamp when lazy', function() {
+      assert.equal(el.hasAttribute('disable-upgrade'), true);
+      assert.notOk(el.shadowRoot);
+      assert.notOk(el.$);
+    });
+    test('stamps when disableUpgrade is removed', function() {
+      el.removeAttribute('disable-upgrade');
+      assert.ok(el.root);
+      assert.ok(el.$.child);
+    });
+  });
+  suite('disableUpgrade and Databinding', function() {
+    test('binding to disable-upgrade with true', function() {
+      var el = fixture('databind-lazy');
+      assert.equal(el.$.child.hasAttribute('disable-upgrade'), true);
+      assert.equal(el.$.child.aRan, false);
+      assert.equal(el.$.child.cRan, false);
+    });
+    test('bindings to disable-upgrade with false', function () {
+      var el = fixture('databind-not-lazy');
+      assert.notOk(el.$.child.hasAttribute('disable-upgrade'));
+      assert.equal(el.$.child.aRan, true);
+      assert.equal(el.$.child.cRan, true);
+    })
+  })
+});
+</script>
\ No newline at end of file
diff --git a/test/unit/dom-bind.html b/test/unit/dom-bind.html
index 70a6bef904..82739e5e01 100644
--- a/test/unit/dom-bind.html
+++ b/test/unit/dom-bind.html
@@ -32,7 +32,7 @@
 
   <dom-bind id="declarativeDomBind">
     <template>
-      <x-basic id="declaredXBasic1" value="{{value}}" notifyingvalue="{{nvalue}}" on-custom="handleEvent" computed="{{compute(dep)}}"></x-basic>
+      <x-basic id="declaredXBasic1" value="{{value}}" notifyingvalue="{{nvalue}}" on-custom="handleEvent" on-tap="handleTap" computed="{{compute(dep)}}"></x-basic>
       <x-basic id="declaredXBasic2" value="{{value}}" notifyingvalue="{{nvalue}}"></x-basic>
       <x-produce-a bind-to-text={{boundText}}></x-produce-a>
       <div id="boundTextDiv">{{boundText}}</div>
@@ -89,12 +89,15 @@
       });
 
       test('event listener fires', function() {
-        var count = 0;
-        domBind.handleEvent = function() {
-          count++;
-        };
+        domBind.handleEvent = sinon.spy();
         el1.fire('custom');
-        assert.equal(count, 1);
+        assert.equal(domBind.handleEvent.callCount, 1);
+      });
+
+      test('gesture event listener fires', function() {
+        domBind.handleTap = sinon.spy();
+        el1.click();
+        assert.equal(domBind.handleTap.callCount, 1);
       });
 
       test('inline function runs', function() {
@@ -130,6 +133,7 @@
         el1.setAttribute('value', '{{value}}');
         el1.setAttribute('notifyingvalue', '{{nvalue}}');
         el1.setAttribute('on-custom', 'handleEvent');
+        el1.setAttribute('on-tap', 'handleTap');
         el1.setAttribute('computed', '{{compute(dep)}}');
 
         el2 = doc.createElement('x-basic');
@@ -165,12 +169,15 @@
       });
 
       test('event listener fires', function() {
-        var count = 0;
-        domBind.handleEvent = function() {
-          count++;
-        };
+        domBind.handleEvent = sinon.spy();
         el1.fire('custom');
-        assert.equal(count, 1);
+        assert.equal(domBind.handleEvent.callCount, 1);
+      });
+
+      test('gesture event listener fires', function() {
+        domBind.handleTap = sinon.spy();
+        el1.click();
+        assert.equal(domBind.handleTap.callCount, 1);
       });
 
       test('inline function runs', function() {
diff --git a/test/unit/gestures.html b/test/unit/gestures.html
index 868961910c..289de18e61 100644
--- a/test/unit/gestures.html
+++ b/test/unit/gestures.html
@@ -506,6 +506,16 @@
         assert.equal(el[key], 'pan-y');
       })
     });
+
+    suite('Regression Testing', function() {
+      test('#4459', function() {
+        Polymer.Gestures.add(document, 'tap', null);
+        document.dispatchEvent(new MouseEvent('mousedown', { detail: 1, clientX: -100, bubbles: true, composed: true }));
+        document.dispatchEvent(new MouseEvent('mouseup', { detail: 1, clientX: 100, bubbles: true, composed: true }));
+        document.dispatchEvent(new MouseEvent('click', { detail: 1, clientX: 100, bubbles: true, composed: true }));
+        Polymer.Gestures.remove(document, 'tap', null);
+      });
+    })
   </script>
 
 </body>
diff --git a/test/unit/polymer.element.html b/test/unit/polymer.element.html
index e6273517e1..02afd0d6be 100644
--- a/test/unit/polymer.element.html
+++ b/test/unit/polymer.element.html
@@ -288,6 +288,33 @@ <h1>Sub template</h1>
   });
   </script>
 
+  <dom-module id="sub-extended-template">
+    <script>
+    HTMLImports.whenReady(function() {
+      // Setting up property bind listeners in both base and sub class
+      // is required to catch regression bug
+      class ElementWithBindListeners extends window.MyElement {
+        static get is() { return 'element-with-bind-listeners'; }
+      }
+      class SubExtendedTemplate extends ElementWithBindListeners {
+        static get is() { return 'sub-extended-template'; }
+        static get template() {
+          if (!this.hasOwnProperty('_template')) {
+            const baseClass = Object.getPrototypeOf(this.prototype).constructor;
+            this._template = baseClass.template.cloneNode(true);
+            const newElement = document.createElement('div');
+            newElement.innerHTML = '<div id="subContent" imaginary-prop$="{{prop}}""></div>';
+            this._template.content.appendChild(newElement.firstChild);
+          }
+          return this._template;
+        }
+      }
+      customElements.define(ElementWithBindListeners.is, ElementWithBindListeners);
+      customElements.define(SubExtendedTemplate.is, SubExtendedTemplate);
+    })
+    </script>
+  </dom-module>
+
   <test-fixture id="my-element-attr">
     <template>
       <my-element prop="attr"></my-element>
@@ -545,6 +572,31 @@ <h1>Sub template</h1>
     })
   });
 
+  suite('extend sub-class template', function() {
+    var el, baseEl;
+    setup(function() {
+      el = document.createElement('sub-extended-template');
+      document.body.appendChild(el);
+      baseEl = document.createElement('element-with-bind-listeners');
+      document.body.appendChild(baseEl);
+    });
+    teardown(function() {
+      document.body.removeChild(el);
+      document.body.removeChild(baseEl);
+    });
+    test('has original template', function() {
+      assert.equal(el.prop, 'base');
+      assert.equal(el.$.content.textContent, el.prop);
+    });
+    test('has new element', function() {
+      assert.ok(el.$.subContent);
+      assert.equal(el.$.subContent.getAttribute('imaginary-prop'), 'base');
+    });
+    test('base doesnt have new element', function() {
+      assert.notOk(baseEl.$.subContent);
+    });
+  });
+
   </script>
 </body>
 </html>
diff --git a/test/unit/property-accessors.html b/test/unit/property-accessors.html
index 8947a509f1..9fb9a4f61c 100644
--- a/test/unit/property-accessors.html
+++ b/test/unit/property-accessors.html
@@ -28,6 +28,9 @@
         super();
         this._propertiesChanged = sinon.spy();
       }
+      connectedCallback() {
+        this._flushProperties();
+      }
     }
     XFoo.createPropertiesForAttributes();
     window.XFoo = XFoo;
diff --git a/test/unit/property-effects-template.html b/test/unit/property-effects-template.html
new file mode 100644
index 0000000000..2d9bc64017
--- /dev/null
+++ b/test/unit/property-effects-template.html
@@ -0,0 +1,724 @@
+<!doctype html>
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../../web-component-tester/browser.js"></script>
+  <link rel="import" href="../../polymer-element.html">
+  <link rel="import" href="../../lib/mixins/gesture-event-listeners.html">
+  <link rel="import" href="../../lib/elements/dom-if.html">
+<body>
+
+<script>
+  HTMLImports.whenReady(() => {
+    class XElementChild extends Polymer.Element {
+      ready() {
+        super.ready();
+        Polymer.lifecycleOrder.log(this, 'ready');
+      }
+    }
+    customElements.define('x-element-child', XElementChild);
+  });
+</script>
+
+<dom-module id="x-element">
+  <template>
+    [[prop]] - [[path]]
+    <x-element-child id="noBinding" log></x-element>
+    <x-element-child id="hasBinding" prop="{{prop}}" path="{{path}}" log></x-element>
+    <x-element-child id="events" on-click="handleClick" on-tap="handleTap"></x-element-child>
+  </template>
+  <script>
+  HTMLImports.whenReady(() => {
+    class XElement extends Polymer.Element {
+      static get is() { return 'x-element'; }
+      static get observers() { return ['propChanged(prop)', 'pathChanged(path)']; }
+      static get properties() { return { prop: { notify: true }, path: { notify: true } }; }
+      constructor() {
+        super();
+        this.propChanged = sinon.spy();
+        this.pathChanged = sinon.spy();
+      }
+      ready() {
+        super.ready();
+        Polymer.lifecycleOrder.log(this, 'ready');
+      }
+    }
+    customElements.define('x-element', XElement);
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-runtime">
+  <template>
+    <!-- Main template content -->
+    <style>
+      x-element {
+        display: block;
+        border-bottom: 10px solid orange;
+      }
+    </style>
+    <x-element id="first"></x-element>
+    <x-element id="textBinding">[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]</x-element>
+    <x-element id="propBinding" prop="{{prop}}" log="proto"></x-element>
+    <x-element id="pathBinding" path="{{obj.path}}"></x-element>
+    <x-element id="compoundPropBinding" compound="[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]"></x-element>
+    <x-element id="events" on-click="handleClick" on-tap="handleTap"></x-element>
+    <template id="domIf" is="dom-if" if="[[prop]]">
+      <x-element id="ifElement" prop="{{prop}}" path="{{obj.path}}"></x-element>
+    </template>
+    <!-- Nested template in Shadow DOM for runtime stamping -->
+    <template id="templateFromShadowDom">
+      <x-element id="first"></x-element>
+      <x-element id="events" on-click="handleClick" on-tap="handleTap"></x-element>
+      <template id="domIf" is="dom-if" if="[[prop]]">
+        <x-element id="ifElementSD" prop="{{prop}}" path="{{obj.path}}"></x-element>
+      </template>
+      <span></span><span></span><span></span><span></span>
+      <x-element id="compoundPropBinding" compound="[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]"></x-element>
+      <x-element id="pathBinding" path="{{obj.path}}"></x-element>
+      <x-element id="propBinding" prop="{{prop}}" log="shadow"></x-element>
+      <x-element id="textBinding">[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]</x-element>
+    </template>
+  </template>
+  <!-- Template in light DOM for runtime stamping -->
+  <template id="templateFromLightDom">
+    <x-element id="first"></x-element>
+    <span></span><span></span><span></span><span></span>
+    <x-element id="compoundPropBinding" compound="[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]"></x-element>
+    <x-element id="pathBinding" path="{{obj.path}}"></x-element>
+    <x-element id="propBinding" prop="{{prop}}" log="light"></x-element>
+    <x-element id="textBinding">[[prop]] - [[obj.path]] - [[compute(prop, obj.path)]]</x-element>
+    <x-element id="events" on-click="handleClick" on-tap="handleTap"></x-element>
+    <template id="domIf" is="dom-if" if="[[prop]]">
+      <x-element id="ifElementLD" prop="{{prop}}" path="{{obj.path}}"></x-element>
+    </template>
+  </template>
+  <template id="templateWithDifferentProps">
+    <div id="bound">[[otherProp]]</div>
+  </template>
+  <script>
+  HTMLImports.whenReady(() => {
+    class XRuntime extends Polymer.GestureEventListeners(Polymer.Element) {
+      static get is() { return 'x-runtime'; }
+      static get observers() { return ['propChanged(prop)', 'pathChanged(obj.path)']; }
+      constructor() {
+        super();
+        this.propChanged = sinon.spy();
+        this.pathChanged = sinon.spy();
+        this.prop = 'prop';
+        this.obj = {path: 'obj.path'};
+      }
+      ready() {
+        super.setAttribute('log', '');
+        super.ready();
+        Polymer.lifecycleOrder.log(this, 'ready');
+      }
+      compute(a, b) {
+        return `[${a} - ${b}]`;
+      }
+      stampTemplateFromShadow() {
+        let dom = this._stampTemplate(this.$.templateFromShadowDom);
+        this.shadowRoot.appendChild(dom);
+        return dom;
+      }
+      stampTemplateFromLight() {
+        let dom = this._stampTemplate(Polymer.DomModule.import(this.localName, '#templateFromLightDom'));
+        this.shadowRoot.appendChild(dom);
+        return dom;
+      }
+      stampTemplateWithDifferentProps() {
+        let dom = this._stampTemplate(Polymer.DomModule.import(this.localName, '#templateWithDifferentProps'));
+        this.shadowRoot.appendChild(dom);
+        return dom;
+      }
+    }
+    customElements.define('x-runtime', XRuntime);
+  });
+  </script>
+</dom-module>
+
+<template id="custom-template">
+  <x-special name="el1" special="attr1" binding="[[prop]]" on-event="handler"></x-special>
+  <div name="el2" special="attr2">
+    <div name="el3" special="attr3">
+      <x-special name="el4" special="attr4"></x-special>
+    </div>
+    <div></div><div></div><div></div>
+    <div name="el5" binding="[[prop]]" on-event="handler"></div>
+    <template name="el6">
+      <div>
+        <x-special name="t-el" special="t-attr" binding="[[prop]]" on-event="handler"></x-special>
+      </div>
+    </template>
+  </div>
+  <x-special name="el7" special="attr5"><x-special name="el8" special="attr6"></x-special></x-special>
+</template>
+<script>
+HTMLImports.whenReady(() => {
+  class XParsing extends Polymer.Element {
+    static get template() { return document.getElementById('custom-template'); }
+    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+      if (name == 'special') {
+        nodeInfo.specialAttr = value;
+        node.removeAttribute('special');
+        node.setAttribute('had-special', '');
+        return true;
+      } else {
+        return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
+      }
+    }
+    static _parseTemplateNode(node, templateInfo, nodeInfo) {
+      let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
+      if (node.localName == 'x-special') {
+        noted = nodeInfo.specialNode = true;
+      }
+      return noted;
+    }
+    _bindTemplate(template) {
+      return this.templateInfoForTesting = super._bindTemplate(template);
+    }
+  }
+  customElements.define('x-parsing', XParsing);
+
+  class XEffects extends XParsing {
+    static get template() { return document.getElementById('custom-template'); }
+    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+      let noted = super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
+      if (nodeInfo.specialAttr) {
+        this._addTemplatePropertyEffect(templateInfo, 'attr', {
+          fn(inst, property, props, oldProps, info, hasPaths, nodeList) {
+            nodeList[nodeInfo.infoIndex].specialAttr = props[property];
+          }
+        });
+      }
+      return noted;
+    }
+    static _parseTemplateNode(node, templateInfo, nodeInfo) {
+      let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
+      if (nodeInfo.specialNode) {
+        this._addTemplatePropertyEffect(templateInfo, 'node', {
+          fn(inst, property, props, oldProps, info, hasPaths, nodeList) {
+            nodeList[nodeInfo.infoIndex].specialNode = props[property];
+          }
+        });
+      }
+      return noted;
+    }
+  }
+  customElements.define('x-effects', XEffects);
+});
+</script>
+
+<dom-module id="x-binding">
+  <template>
+    <x-element id="standard1" prop="[[prop]]" path="[[obj.path]]"></x-element>
+    <x-element id="custom1" prop='[{"a": "prop", "b": "prop2"}]'></x-element>
+    <div>
+      <x-element id="standard2" prop="[[prop]]" path="[[obj.path]]"></x-element>
+      <x-element id="custom2" prop='[{"a": "prop", "b": "prop2"}]'></x-element>
+    </div>
+    <template id="domIf" is="dom-if" if="[[prop2]]" restamp>
+      <x-element id="standard3" prop="[[prop]]" path="[[obj.path]]"></x-element>
+      <x-element id="custom3" prop='[{"a": "prop", "b": "prop2"}]'></x-element>
+    </template>
+  </template>
+  <script>
+  HTMLImports.whenReady(() => {
+    class XBinding extends Polymer.Element {
+      static get is() { return 'x-binding'; }
+      constructor() {
+        super();
+        this.prop = true;
+        this.obj = {path: 'obj.path'};
+        this.prop2 = true;
+      }
+      static _parseBindings(text, templateInfo) {
+        if (text.slice(0,2) == '[{' && text.slice(-2) == '}]') {
+          let bindingData = JSON.parse(text.slice(1,-1));
+          let dependencies = Object.keys(bindingData).map(n=>bindingData[n]);
+          return [{dependencies, bindingData}]
+        } else {
+          return super._parseBindings(text, templateInfo);
+        }
+      }
+      static _evaluateBinding(scope, part, path, props, oldProps, hasPaths) {
+        if (part.bindingData) {
+          return Object.keys(part.bindingData)
+            .map(n => scope[part.bindingData[n]] ? n : '')
+            .filter(c => Boolean(c))
+            .join(' ');
+        } else {
+          return super._evaluateBinding(scope, part, path, props, oldProps, hasPaths);
+        }
+      }
+    }
+    customElements.define(XBinding.is, XBinding);
+  });
+  </script>
+</dom-module>
+
+<script>
+
+suite('runtime template stamping', function() {
+
+  let el;
+
+  setup(function() {
+    Polymer.lifecycleOrder = {
+      log(el, lifecycle) {
+        if (this.shouldLog(el)) {
+          let list = this[lifecycle] = this[lifecycle] || [];
+          list.push(this.idFor(el));
+        }
+      },
+      shouldLog(el) {
+        let host = el.getRootNode().host;
+        return (!host || this.shouldLog(host)) && el.hasAttribute('log');
+      },
+      idFor(el) {
+        let host = el.getRootNode().host;
+        let id = el.getAttribute('log') || el.id;
+        return (host ? this.idFor(host) + '|' : '') + el.localName + (id ? '#' + id : '');
+      }
+    };
+    el = document.createElement('x-runtime');
+    document.body.appendChild(el);
+  });
+
+  teardown(function() {
+    document.body.removeChild(el);
+  });
+
+  function assertStampingCorrect(el, $, type) {
+    // Text binding
+    assert.equal($.textBinding.textContent, 'prop - obj.path - [prop - obj.path]');
+    // Property binding
+    assert.equal($.propBinding.prop, 'prop');
+    assert.equal($.propBinding.propChanged.callCount, 1);
+    assert.equal($.propBinding.propChanged.firstCall.args[0], 'prop');
+    // Path binding
+    assert.equal($.pathBinding.path, 'obj.path');
+    assert.equal($.pathBinding.pathChanged.callCount, 1);
+    assert.equal($.pathBinding.pathChanged.firstCall.args[0], 'obj.path');
+    // Compound property binding
+    assert.equal($.compoundPropBinding.compound, 'prop - obj.path - [prop - obj.path]');
+    // Observers
+    assert.equal(el.propChanged.callCount, 1);
+    assert.equal(el.propChanged.firstCall.args[0], 'prop');
+    assert.equal(el.pathChanged.callCount, 1);
+    assert.equal(el.pathChanged.firstCall.args[0], 'obj.path');
+    // Event handlers
+    el.handleClick = sinon.spy();
+    el.handleTap = sinon.spy();
+    $.events.click();
+    assert.equal(el.handleClick.callCount, 1);
+    assert.equal(el.handleTap.callCount, 1);
+    // Nested dom-* template
+    $.domIf.render();
+    let ifElement = el.shadowRoot.querySelector(`#ifElement${type||''}`);
+    assert.equal(ifElement.prop, 'prop');
+    assert.equal(ifElement.path, 'obj.path');
+    // Styling correct
+    assert.equal(getComputedStyle($.textBinding).borderBottomWidth, '10px');
+  }
+
+  test('prototypical stamping', () => {
+    assertStampingCorrect(el, el.$);
+    let stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 1);
+    assert.equal(stamped[0], el.$.first);
+    // Lifecycle order correct
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime'
+    ]);
+  });
+
+  test('runtime stamp template (from shadow dom)', () => {
+    let dom = el.stampTemplateFromShadow();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom.$, 'SD');
+    let stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom.$.first);
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime',
+      'x-runtime|x-element#shadow|x-element-child#noBinding',
+      'x-runtime|x-element#shadow|x-element-child#hasBinding',
+      'x-runtime|x-element#shadow'
+    ]);
+  });
+
+  test('runtime stamp and remove multiple templates (from shadow dom)', () => {
+    let stamped;
+    // Stamp template
+    let dom1 = el.stampTemplateFromShadow();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom1.$, 'SD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom1.$.first);
+    // Unstamp
+    el._removeBoundDom(dom1);
+    for (let n in dom1.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 1);
+    assert.equal(stamped[0], el.$.first);
+    // Stamp again
+    let dom2 = el.stampTemplateFromShadow();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom2.$, 'SD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom2.$.first);
+    // Stamp again
+    let dom3 = el.stampTemplateFromShadow();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom2.$, 'SD');
+    assertStampingCorrect(el, dom3.$, 'SD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 3);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom2.$.first);
+    assert.equal(stamped[2], dom3.$.first);
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime',
+      'x-runtime|x-element#shadow|x-element-child#noBinding',
+      'x-runtime|x-element#shadow|x-element-child#hasBinding',
+      'x-runtime|x-element#shadow',
+      'x-runtime|x-element#shadow|x-element-child#noBinding',
+      'x-runtime|x-element#shadow|x-element-child#hasBinding',
+      'x-runtime|x-element#shadow',
+      'x-runtime|x-element#shadow|x-element-child#noBinding',
+      'x-runtime|x-element#shadow|x-element-child#hasBinding',
+      'x-runtime|x-element#shadow'
+    ]);
+    // Unstamp
+    el._removeBoundDom(dom2);
+    el._removeBoundDom(dom3);
+    for (let n in dom2.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    for (let n in dom3.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 1);
+    assert.equal(stamped[0], el.$.first);
+  });
+
+  test('runtime stamp template (from light dom)', () => {
+    let dom = el.stampTemplateFromLight();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom.$, 'LD');
+    let stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom.$.first);
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime',
+      'x-runtime|x-element#light|x-element-child#noBinding',
+      'x-runtime|x-element#light|x-element-child#hasBinding',
+      'x-runtime|x-element#light'
+    ]);
+  });
+
+  test('runtime stamp and remove multiple templates (from light dom)', () => {
+    let stamped;
+    // Stamp template
+    let dom1 = el.stampTemplateFromLight();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom1.$, 'LD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom1.$.first);
+    // Unstamp
+    el._removeBoundDom(dom1);
+    for (let n in dom1.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    // Stamp again
+    let dom2 = el.stampTemplateFromLight();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom2.$, 'LD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 2);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom2.$.first);
+    // Stamp again
+    let dom3 = el.stampTemplateFromLight();
+    assertStampingCorrect(el, el.$);
+    assertStampingCorrect(el, dom2.$, 'LD');
+    assertStampingCorrect(el, dom3.$, 'LD');
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 3);
+    assert.equal(stamped[0], el.$.first);
+    assert.equal(stamped[1], dom2.$.first);
+    assert.equal(stamped[2], dom3.$.first);
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime',
+      'x-runtime|x-element#light|x-element-child#noBinding',
+      'x-runtime|x-element#light|x-element-child#hasBinding',
+      'x-runtime|x-element#light',
+      'x-runtime|x-element#light|x-element-child#noBinding',
+      'x-runtime|x-element#light|x-element-child#hasBinding',
+      'x-runtime|x-element#light',
+      'x-runtime|x-element#light|x-element-child#noBinding',
+      'x-runtime|x-element#light|x-element-child#hasBinding',
+      'x-runtime|x-element#light'
+    ]);
+    // Unstamp
+    el._removeBoundDom(dom2);
+    el._removeBoundDom(dom3);
+    for (let n in dom2.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    for (let n in dom3.$) {
+      assert.notOk(dom1.$[n].parentNode, null);
+    }
+    stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 1);
+    assert.equal(stamped[0], el.$.first);
+  });
+
+  function assertPropValues(el, prop, value, count) {
+    let e = el.$[prop + 'Binding'];
+    assert.equal(e[prop], value);
+    assert.equal(e[prop + 'Changed'].callCount, count);
+    assert.equal(e[prop + 'Changed'].getCall(count-1).args[0], value);
+    assert.equal(e.$.hasBinding[prop], value);
+  }
+
+  function assertAllPropValues(el, ld, sd, prop, value, count) {
+    assertPropValues(el, prop, value, count);
+    assertPropValues(ld, prop, value, count);
+    assertPropValues(sd, prop, value, count);
+  }
+
+  test('downward runtime binding', () => {
+    let sd = el.stampTemplateFromShadow();
+    let ld = el.stampTemplateFromLight();
+    assertAllPropValues(el, sd, ld, 'prop', 'prop', 1);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    el.prop = 'prop+';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+', 2);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    el.obj = {path: 'obj.path+'};
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+', 2);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path+', 2);
+    el.set('obj.path', 'obj.path++');
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+', 2);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path++', 3);
+  });
+
+  test('two-way runtime binding', () => {
+    let sd = el.stampTemplateFromShadow();
+    let ld = el.stampTemplateFromLight();
+    assertAllPropValues(el, sd, ld, 'prop', 'prop', 1);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    el.$.propBinding.prop = 'prop+';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+', 2);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    sd.$.propBinding.prop = 'prop++';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop++', 3);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    ld.$.propBinding.prop = 'prop+++';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+++', 4);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path', 1);
+    el.$.pathBinding.path = 'obj.path+';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+++', 4);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path+', 2);
+    sd.$.pathBinding.path = 'obj.path++';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+++', 4);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path++', 3);
+    ld.$.pathBinding.path = 'obj.path+++';
+    assertAllPropValues(el, sd, ld, 'prop', 'prop+++', 4);
+    assertAllPropValues(el, sd, ld, 'path', 'obj.path+++', 4);
+  });
+
+  test('accessors for non-prototypically bound properties created', () => {
+    // First element
+    let dom = el.stampTemplateWithDifferentProps();
+    el.otherProp = 'otherProp';
+    assert.equal(dom.$.bound.textContent, 'otherProp');
+    // Second element
+    let el2 = document.createElement('x-runtime');
+    document.body.appendChild(el2);
+    let dom2 = el2.stampTemplateWithDifferentProps();
+    el2.otherProp = 'otherProp';
+    assert.equal(dom2.$.bound.textContent, 'otherProp');
+    document.body.removeChild(el2);
+  });
+
+  test('prototypical stamping not affected by runtime stamping', () => {
+    assertStampingCorrect(el, el.$);
+    let stamped = el.shadowRoot.querySelectorAll('x-element#first');
+    assert.equal(stamped.length, 1);
+    assert.equal(stamped[0], el.$.first);
+    // Lifecycle order correct
+    assert.deepEqual(Polymer.lifecycleOrder.ready, [
+      'x-runtime|x-element#proto|x-element-child#noBinding',
+      'x-runtime|x-element#proto|x-element-child#hasBinding',
+      'x-runtime|x-element#proto',
+      'x-runtime'
+    ]);
+  });
+
+});
+
+suite('template parsing hooks', () => {
+
+  test('custom parsing', () => {
+    let el = document.createElement('x-parsing');
+    document.body.appendChild(el);
+    let templateInfo = el.templateInfoForTesting;
+    let nodeInfoList = templateInfo.nodeInfoList;
+    let nodeList = templateInfo.nodeList;
+    // The node order is depth-first bottom up but not a guarantee or generally
+    // important; as such, just ensure all expected nodes are there, then
+    // loop to
+    assert.sameMembers(nodeList.map(e=>e.getAttribute('name')),
+      ['el1', 'el2', 'el3', 'el4', 'el5', 'el6', 'el7', 'el8']);
+    for (let i=0; i<nodeList.length; i++) {
+      let node = nodeList[i];
+      let nodeInfo = nodeInfoList[i];
+      let templateNodeInfo;
+      switch (node.getAttribute('name')) {
+        case 'el1':
+          assert.equal(nodeInfo.specialNode, true);
+          assert.equal(nodeInfo.specialAttr, 'attr1');
+          assert.equal(nodeInfo.bindings.length, 1);
+          assert.equal(nodeInfo.events.length, 1);
+          break;
+        case 'el2':
+          assert.equal(nodeInfo.specialAttr, 'attr2');
+          break;
+        case 'el3':
+          assert.equal(nodeInfo.specialAttr, 'attr3');
+          break;
+        case 'el4':
+          assert.equal(nodeInfo.specialNode, true);
+          assert.equal(nodeInfo.specialAttr, 'attr4');
+          break;
+        case 'el5':
+          assert.equal(nodeInfo.bindings.length, 1);
+          assert.equal(nodeInfo.events.length, 1);
+          break;
+        case 'el6':
+          assert.isOk(nodeInfo.templateInfo);
+          assert.equal(nodeInfo.templateInfo.nodeInfoList.length, 1)
+          templateNodeInfo = nodeInfo.templateInfo.nodeInfoList[0];
+          assert.equal(templateNodeInfo.bindings.length, 1);
+          assert.equal(templateNodeInfo.events.length, 1);
+          assert.equal(templateNodeInfo.specialAttr, 't-attr');
+          assert.equal(templateNodeInfo.specialNode, true);
+          break;
+        case 'el7':
+          assert.equal(nodeInfo.specialNode, true);
+          assert.equal(nodeInfo.specialAttr, 'attr5');
+          break;
+        case 'el8':
+          assert.equal(nodeInfo.specialNode, true);
+          assert.equal(nodeInfo.specialAttr, 'attr6');
+          break;
+        default:
+          throw new Error('unexpected node was recorded');
+      }
+    }
+  });
+
+  test('custom template effects', () => {
+    let el = document.createElement('x-effects');
+    document.body.appendChild(el);
+
+    assert.equal(Array.from(el.shadowRoot.querySelectorAll('x-special')).length, 4);
+    Array.from(el.shadowRoot.querySelectorAll('x-special')).forEach(e => {
+      assert.notOk(e.isSpecialNode);
+    });
+    el.node = 'node!';
+    Array.from(el.shadowRoot.querySelectorAll('x-special')).forEach(e => {
+      assert.equal(e.specialNode, 'node!');
+    });
+
+    assert.equal(Array.from(el.shadowRoot.querySelectorAll('[had-special]')).length, 6);
+    Array.from(el.shadowRoot.querySelectorAll('[had-special]')).forEach(e => {
+      assert.notOk(e.hasSpecialAttr);
+    });
+    el.attr = 'attr!';
+    Array.from(el.shadowRoot.querySelectorAll('[had-special]')).forEach(e => {
+      assert.equal(e.specialAttr, 'attr!');
+    });
+    document.body.removeChild(el);
+  });
+
+  test('custom template binding', () => {
+    let el = document.createElement('x-binding');
+    document.body.appendChild(el);
+    el.$.domIf.render();
+    assert.equal(el.$.standard1.prop, true);
+    assert.equal(el.$.standard2.prop, true);
+    assert.equal(el.shadowRoot.querySelector('#standard3').prop, true);
+    assert.equal(el.$.standard1.path, 'obj.path');
+    assert.equal(el.$.standard2.path, 'obj.path');
+    assert.equal(el.shadowRoot.querySelector('#standard3').path, 'obj.path');
+    assert.equal(el.$.custom1.prop, 'a b');
+    assert.equal(el.$.custom2.prop, 'a b');
+    assert.equal(el.shadowRoot.querySelector('#custom3').prop, 'a b');
+    el.prop = false;
+    assert.equal(el.$.standard1.prop, false);
+    assert.equal(el.$.standard2.prop, false);
+    assert.equal(el.shadowRoot.querySelector('#standard3').prop, false);
+    assert.equal(el.$.standard1.path, 'obj.path');
+    assert.equal(el.$.standard2.path, 'obj.path');
+    assert.equal(el.shadowRoot.querySelector('#standard3').path, 'obj.path');
+    assert.equal(el.$.custom1.prop, 'b');
+    assert.equal(el.$.custom2.prop, 'b');
+    assert.equal(el.shadowRoot.querySelector('#custom3').prop, 'b');
+    el.prop = true;
+    assert.equal(el.$.standard1.prop, true);
+    assert.equal(el.$.standard2.prop, true);
+    assert.equal(el.shadowRoot.querySelector('#standard3').prop, true);
+    assert.equal(el.$.standard1.path, 'obj.path');
+    assert.equal(el.$.standard2.path, 'obj.path');
+    assert.equal(el.shadowRoot.querySelector('#standard3').path, 'obj.path');
+    assert.equal(el.$.custom1.prop, 'a b');
+    assert.equal(el.$.custom2.prop, 'a b');
+    assert.equal(el.shadowRoot.querySelector('#custom3').prop, 'a b');
+    document.body.removeChild(el);
+  });
+});
+
+</script>
+
+</body>
+</html>
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index e59a6e2a92..1310ef0365 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -253,6 +253,36 @@
     assert.equal(el.observerCounts.multipleDepChangeHandler, 1, 'observer not called once');
   });
 
+  test('setProperties does not set readOnly by default', function() {
+    assert.equal(el.observerCounts.valueChanged, 1);
+    assert.equal(el.observerCounts.readonlyvalueChanged, 0);
+    el.setProperties({
+      value: 'shouldChange',
+      nofx: 'shouldChange',
+      readonlyvalue: 'shouldNotChange'
+    });
+    assert.equal(el.value, 'shouldChange');
+    assert.equal(el.nofx, 'shouldChange');
+    assert.equal(el.readonlyvalue, undefined);
+    assert.equal(el.observerCounts.valueChanged, 2);
+    assert.equal(el.observerCounts.readonlyvalueChanged, 0);
+  });
+
+  test('setProperties sets readOnly using `setPrivate` arg', function() {
+    assert.equal(el.observerCounts.valueChanged, 1);
+    assert.equal(el.observerCounts.readonlyvalueChanged, 0);
+    el.setProperties({
+      value: 'shouldChange',
+      nofx: 'shouldChange',
+      readonlyvalue: 'shouldChange'
+    }, true);
+    assert.equal(el.value, 'shouldChange');
+    assert.equal(el.nofx, 'shouldChange');
+    assert.equal(el.readonlyvalue, 'shouldChange');
+    assert.equal(el.observerCounts.valueChanged, 2);
+    assert.equal(el.observerCounts.readonlyvalueChanged, 1);
+  });
+
   test('annotated computed property', function() {
     el.value = 20;
     el.add = 40;
@@ -1400,6 +1430,74 @@
 
 });
 
+suite('runtime effects', function() {
+
+  var el, el2;
+
+  setup(function() {
+    el = document.createElement('x-basic');
+    document.body.appendChild(el);
+  });
+
+  teardown(function() {
+    document.body.removeChild(el);
+    document.body.removeChild(el2);
+  });
+
+  test('add/remove runtime property effect', function() {
+    assert.equal(el.observerCounts.valueChanged, 1);
+    let info = {};
+    let fn = sinon.spy();
+    let effect = { info, fn };
+    el._addPropertyEffect('value', el.PROPERTY_EFFECT_TYPES.OBSERVE, effect);
+    el.value = 'value++';
+    assert.equal(el.observerCounts.valueChanged, 2);
+    assert.equal(fn.callCount, 1);
+    assert.equal(fn.firstCall.args[0], el);
+    assert.equal(fn.firstCall.args[1], 'value');
+    assert.equal(fn.firstCall.args[2].value, 'value++');
+    assert.equal(fn.firstCall.args[4], info);
+    el._removePropertyEffect('value', el.PROPERTY_EFFECT_TYPES.OBSERVE, effect);
+    el.value = 'value+++';
+    assert.equal(fn.callCount, 1);
+    // Ensure prototype wasn't affected
+    el2 = document.createElement('x-basic');
+    document.body.appendChild(el2);
+    assert.equal(fn.callCount, 1);
+  });
+
+  test('add/remove runtime path effect', function() {
+    assert.equal(el.observerCounts.valueChanged, 1);
+    let info = {};
+    let fn = sinon.spy();
+    let trigger = {name: 'value.path', structured: true};
+    let effect = { info, fn, trigger };
+    el._addPropertyEffect('value', el.PROPERTY_EFFECT_TYPES.OBSERVE, effect);
+    el.value = {path: 'value.path'};
+    assert.equal(el.observerCounts.valueChanged, 2);
+    assert.equal(fn.callCount, 1);
+    assert.equal(fn.getCall(0).args[0], el);
+    assert.equal(fn.getCall(0).args[1], 'value');
+    assert.equal(fn.getCall(0).args[2].value, el.value);
+    assert.equal(fn.getCall(0).args[4], info);
+    el.set('value.path', 'value.path++');
+    assert.equal(el.observerCounts.valueChanged, 2);
+    assert.equal(fn.callCount, 2);
+    assert.equal(fn.getCall(1).args[0], el);
+    assert.equal(fn.getCall(1).args[1], 'value.path');
+    assert.equal(fn.getCall(1).args[2]['value.path'], 'value.path++');
+    assert.equal(fn.getCall(1).args[4], info);
+    el._removePropertyEffect('value', el.PROPERTY_EFFECT_TYPES.OBSERVE, effect);
+    el.set('value.path', 'value.path+++');
+    assert.equal(fn.callCount, 2);
+    // Ensure prototype wasn't affected
+    el2 = document.createElement('x-basic');
+    document.body.appendChild(el2);
+    assert.equal(fn.callCount, 2);
+  });
+
+});
+
 </script>
 
 </body>
diff --git a/test/unit/ready-attached-order-class.html b/test/unit/ready-attached-order-class.html
new file mode 100644
index 0000000000..b675de8e9d
--- /dev/null
+++ b/test/unit/ready-attached-order-class.html
@@ -0,0 +1,277 @@
+<!doctype html>
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../../web-component-tester/browser.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+<script>
+  window.clearTestLists = function() {
+    window.actualAttachedList = [];
+    window.actualReadyList = [];
+    window.actualReadyBeforeAtachedList = [];
+  }
+
+  window.clearTestLists();
+
+  window.readyMixin = function(base) {
+    return class readyMixin extends base {
+      static get properties() {
+        return {
+          prop: {
+            value: true,
+            observer: '_propChanged'
+          }
+        }
+      }
+
+      _propChanged() {
+        this.observerShadowRoot = Boolean(this.shadowRoot);
+      }
+      ready() {
+        super.ready();
+        this._readied = true;
+        this.readyList = window.actualReadyList.slice();
+        this.readyShadowRoot = Boolean(this.shadowRoot);
+        window.actualReadyList.push(this);
+      }
+
+      connectedCallback() {
+        this._eventList = [];
+        this.addEventListener('e', (e) => {
+          this._eventList.push(e.composedPath()[0]);
+        });
+        super.connectedCallback();
+        this.dispatchEvent(new Event('e', {composed: true, bubbles: true}))
+        this.attachedShadowRoot = Boolean(this.shadowRoot);
+        this.attachedTime$Keys = Object.keys(this.$);
+        this.attachedList = window.actualAttachedList.slice();
+        window.actualAttachedList.push(this);
+        if (!this._readied) {
+          window.actualReadyBeforeAtachedList.push(this);
+        }
+      }
+    }
+  };
+</script>
+
+<dom-module id="x-zot">
+  <template>
+    x-zot<slot></slot>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    class El extends window.readyMixin(Polymer.Element) {
+      static get is() { return 'x-zot' }
+    }
+    customElements.define(El.is, El);
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-bar">
+  <template>
+    <x-zot id="zot"></x-zot>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    class El extends window.readyMixin(Polymer.Element) {
+      static get is() { return 'x-bar' }
+    }
+    customElements.define(El.is, El);
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-foo">
+  <template>
+    <x-bar id="bar1"></x-bar>
+    <x-bar id="bar2"></x-bar>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    class El extends window.readyMixin(Polymer.Element) {
+      static get is() { return 'x-foo' }
+    }
+    customElements.define(El.is, El);
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-ready">
+  <template>
+    <x-zot id="a">
+      <x-zot id="b"></x-zot>
+      <x-zot id="c">
+        <x-zot id="d"></x-zot>
+      </x-zot>
+    </x-zot>
+    <x-foo id="foo"></x-foo>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    class El extends window.readyMixin(Polymer.Element) {
+      static get is() { return 'x-ready' }
+      static get properties() {
+        return {
+          foo: {
+            observer: '_fooChanged'
+          }
+        }
+      }
+      _fooChanged() {}
+    }
+    customElements.define(El.is, El);
+
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-templatized">
+  <template>
+    <template is="dom-if" if>
+      <x-ready foo="[[foo]]"></x-ready>
+    </template>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    class El extends Polymer.Element {
+      static get is() { return 'x-templatized' }
+      static get properties() {
+        return {
+          foo: {
+            value: 'foo'
+          }
+        }
+      }
+    }
+    customElements.define(El.is, El);
+  });
+  </script>
+</dom-module>
+
+<script>
+
+  suite('ready and attached ordering', function() {
+
+    let el;
+
+    setup(function() {
+      window.clearTestLists();
+      el = document.createElement('x-ready');
+      document.body.appendChild(el);
+    });
+
+    teardown(function() {
+      document.body.removeChild(el);
+    });
+
+    test('element dom ready before element', function() {
+      assert.includeMembers(el.readyList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+      var foo = el.$.foo;
+      assert.includeMembers(foo.readyList, [foo.$.bar1, foo.$.bar1.$.zot, foo.$.bar2, foo.$.bar2.$.zot]);
+      var b1 = foo.$.bar1, b2 = foo.$.bar2;
+      assert.includeMembers(b1.readyList, [b1.$.zot]);
+      assert.includeMembers(b2.readyList, [b2.$.zot]);
+    });
+
+    test('can listen to events fired by element dom in connected', function() {
+      assert.includeMembers(el._eventList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+      var foo = el.$.foo;
+      assert.includeMembers(foo._eventList, [foo.$.bar1, foo.$.bar2]);
+      var b1 = foo.$.bar1, b2 = foo.$.bar2;
+      assert.includeMembers(b1._eventList, [b1.$.zot]);
+      assert.includeMembers(b2._eventList, [b2.$.zot]);
+    });
+
+    test('shadowRoot available in ready, connected, observer', function() {
+      [el, el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo,
+        el.$.foo.$.bar1, el.$.foo.$.bar1.$.zot,
+        el.$.foo.$.bar2, el.$.foo.$.bar2.$.zot].forEach((e) => {
+        assert.isTrue(e.observerShadowRoot);
+        assert.isTrue(e.readyShadowRoot);
+        assert.isTrue(e.attachedShadowRoot);
+      });
+    });
+
+    test('element attached called after ready', function() {
+      assert.equal(window.actualReadyBeforeAtachedList.length, 0);
+    });
+
+    test('element has $ references at attached time', function() {
+      assert.sameMembers(el.attachedTime$Keys, ['a', 'b', 'c', 'd', 'foo']);
+      assert.sameMembers(el.$.foo.attachedTime$Keys, ['bar1', 'bar2']);
+    })
+
+  });
+
+  suite('templatized: ready and attached ordering', function() {
+
+    let container, el;
+
+    setup(function() {
+      window.clearTestLists();
+      container = document.createElement('x-templatized');
+      document.body.appendChild(container);
+      Polymer.flush();
+      el = container.shadowRoot.querySelector('x-ready');
+    });
+
+    teardown(function() {
+      document.body.removeChild(container);
+    });
+
+    test('element dom ready before element', function() {
+      assert.includeMembers(el.readyList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+      var foo = el.$.foo;
+      assert.includeMembers(foo.readyList, [foo.$.bar1, foo.$.bar1.$.zot, foo.$.bar2, foo.$.bar2.$.zot]);
+      var b1 = foo.$.bar1, b2 = foo.$.bar2;
+      assert.includeMembers(b1.readyList, [b1.$.zot]);
+      assert.includeMembers(b2.readyList, [b2.$.zot]);
+    });
+
+    test('can listen to events fired by element dom in connected', function() {
+      assert.includeMembers(el._eventList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+      var foo = el.$.foo;
+      assert.includeMembers(foo._eventList, [foo.$.bar1, foo.$.bar2]);
+      var b1 = foo.$.bar1, b2 = foo.$.bar2;
+      assert.includeMembers(b1._eventList, [b1.$.zot]);
+      assert.includeMembers(b2._eventList, [b2.$.zot]);
+    });
+
+    test('shadowRoot available in ready, connected, observer', function() {
+      [el, el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo,
+        el.$.foo.$.bar1, el.$.foo.$.bar1.$.zot,
+        el.$.foo.$.bar2, el.$.foo.$.bar2.$.zot].forEach((e) => {
+        assert.isTrue(e.observerShadowRoot);
+        assert.isTrue(e.readyShadowRoot);
+        assert.isTrue(e.attachedShadowRoot);
+      });
+    });
+
+    test('element attached called after ready', function() {
+      assert.equal(window.actualReadyBeforeAtachedList.length, 0);
+    });
+
+    test('element has $ references at attached time', function() {
+      assert.sameMembers(el.attachedTime$Keys, ['a', 'b', 'c', 'd', 'foo']);
+      assert.sameMembers(el.$.foo.attachedTime$Keys, ['bar1', 'bar2']);
+    })
+
+  });
+
+</script>
+</body>
+</html>
diff --git a/test/unit/ready-attached-order.html b/test/unit/ready-attached-order.html
index ab473f132f..5ac821ed07 100644
--- a/test/unit/ready-attached-order.html
+++ b/test/unit/ready-attached-order.html
@@ -112,7 +112,33 @@
   HTMLImports.whenReady(function() {
     Polymer({
       is: 'x-ready',
-      behaviors: [window.readyBehavior]
+      properties: {
+        foo: {
+          observer: '_fooChanged'
+        }
+      },
+      behaviors: [window.readyBehavior],
+      _fooChanged: function() {}
+    });
+  });
+  </script>
+</dom-module>
+
+<dom-module id="x-templatized">
+  <template>
+    <template is="dom-if" if>
+      <x-ready foo="[[foo]]"></x-ready>
+    </template>
+  </template>
+  <script>
+  HTMLImports.whenReady(function() {
+    Polymer({
+      is: 'x-templatized',
+      properties: {
+        foo: {
+          value: 'foo'
+        }
+      }
     });
   });
   </script>
@@ -143,13 +169,59 @@
       assert.includeMembers(b2.readyList, [b2.$.zot]);
     });
 
-    test('element dom connected before element', function() {
-      assert.includeMembers(el.attachedList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+    // test('element dom connected before element', function() {
+    //   assert.includeMembers(el.attachedList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
+    //   var foo = el.$.foo;
+    //   assert.includeMembers(foo.attachedList, [foo.$.bar1, foo.$.bar2]);
+    //   var b1 = foo.$.bar1, b2 = foo.$.bar2;
+    //   assert.includeMembers(b1.attachedList, [b1.$.zot]);
+    //   assert.includeMembers(b2.attachedList, [b2.$.zot]);
+    // });
+
+    test('shadowRoot available in ready, connected, observer', function() {
+      [el, el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo,
+        el.$.foo.$.bar1, el.$.foo.$.bar1.$.zot,
+        el.$.foo.$.bar2, el.$.foo.$.bar2.$.zot].forEach((e) => {
+        assert.isTrue(e.observerShadowRoot);
+        assert.isTrue(e.readyShadowRoot);
+        assert.isTrue(e.attachedShadowRoot);
+      });
+    });
+
+    test('element attached called after ready', function() {
+      assert.equal(window.actualReadyBeforeAtachedList.length, 0);
+    });
+
+    test('element has $ references at attached time', function() {
+      assert.sameMembers(el.attachedTime$Keys, ['a', 'b', 'c', 'd', 'foo']);
+      assert.sameMembers(el.$.foo.attachedTime$Keys, ['bar1', 'bar2']);
+    })
+
+  });
+
+  suite('templatized: ready and attached ordering', function() {
+
+    let container, el;
+
+    setup(function() {
+      window.clearTestLists();
+      container = document.createElement('x-templatized');
+      document.body.appendChild(container);
+      Polymer.flush();
+      el = container.shadowRoot.querySelector('x-ready');
+    });
+
+    teardown(function() {
+      document.body.removeChild(container);
+    });
+
+    test('element dom ready before element', function() {
+      assert.includeMembers(el.readyList, [el.$.a, el.$.b, el.$.c, el.$.d, el.$.foo]);
       var foo = el.$.foo;
-      assert.includeMembers(foo.attachedList, [foo.$.bar1, foo.$.bar2]);
+      assert.includeMembers(foo.readyList, [foo.$.bar1, foo.$.bar1.$.zot, foo.$.bar2, foo.$.bar2.$.zot]);
       var b1 = foo.$.bar1, b2 = foo.$.bar2;
-      assert.includeMembers(b1.attachedList, [b1.$.zot]);
-      assert.includeMembers(b2.attachedList, [b2.$.zot]);
+      assert.includeMembers(b1.readyList, [b1.$.zot]);
+      assert.includeMembers(b2.readyList, [b2.$.zot]);
     });
 
     test('shadowRoot available in ready, connected, observer', function() {
diff --git a/test/unit/render-status.html b/test/unit/render-status.html
index 0f1e4509b4..6312c10732 100644
--- a/test/unit/render-status.html
+++ b/test/unit/render-status.html
@@ -21,18 +21,47 @@
     class XFoo extends Polymer.LegacyElementMixin(HTMLElement) {
       ready() {
         super.ready();
+        sinon.spy(this, 'beforeNextRender');
+        sinon.spy(this, 'stillBeforeNextRender');
         Polymer.RenderStatus.beforeNextRender(this, this.beforeNextRender,
           ['before']);
+      }
+
+      beforeNextRender() {
+        Polymer.RenderStatus.beforeNextRender(this, this.stillBeforeNextRender,
+          ['still-before']);
+      }
+      stillBeforeNextRender() {
+        if (this.beforeDone) {
+          this.beforeDone();
+        }
+      }
+    }
+    customElements.define('x-foo', XFoo);
+
+    class XBar extends Polymer.LegacyElementMixin(HTMLElement) {
+      ready() {
+        super.ready();
+        sinon.spy(this, 'afterNextRender');
+        sinon.spy(this, 'afterAfterNextRender');
         Polymer.RenderStatus.afterNextRender(this, (a) => {
           this.afterNextRender(a);
         }, ['after']);
       }
 
-      beforeNextRender() {}
-      afterNextRender() {}
+      afterNextRender() {
+        Polymer.RenderStatus.afterNextRender(this, (a) => {
+          this.afterAfterNextRender(a);
+        }, ['after-after']);
+      }
+      afterAfterNextRender() {
+        if (this.afterDone) {
+          this.afterDone();
+        }
+      }
 
     }
-    customElements.define('x-foo', XFoo);
+    customElements.define('x-bar', XBar);
   });
 </script>
 
@@ -42,51 +71,46 @@
 
   test('beforeNextRender', function(done) {
     let el = document.createElement('x-foo');
-    let beforeCalled;
-    el.beforeNextRender = function(a) {
-      assert.equal(a, 'before', 'before render argument incorrect');
-      beforeCalled = true;
-    }
     document.body.appendChild(el);
-    requestAnimationFrame(() => {
-      setTimeout(() => {
-        assert.isTrue(beforeCalled);
-        done();
-      });
-    });
+    el.beforeDone = function() {
+      assert.ok(el.beforeNextRender.withArgs('before').calledOnce);
+      assert.ok(el.stillBeforeNextRender.withArgs('still-before').calledOnce);
+      // break out of this raf so next test is not tainted.
+      requestAnimationFrame(() => { done() });
+    };
   });
 
   test('afterNextRender', function(done) {
-    let el = document.createElement('x-foo');
-    let afterCalled;
-    let raf;
+    let el = document.createElement('x-bar');
+    let raf1 = sinon.spy();
+    let raf2 = sinon.spy();
     requestAnimationFrame(() => {
-      assert.notOk(afterCalled);
-      raf = true;
-    })
-    el.afterNextRender = function(a) {
-      assert.equal(a, 'after', 'after render argument incorrect');
-      afterCalled = true;
-      assert.ok(raf);
-      done();
+      raf1();
+      requestAnimationFrame(() => {
+        raf2();
+      });
+    });
+    el.afterDone = function() {
+      assert.ok(el.afterNextRender.withArgs('after').calledOnce);
+      assert.ok(el.afterNextRender.calledAfter(raf1));
+      assert.ok(el.afterAfterNextRender.withArgs('after-after').calledOnce);
+      assert.ok(el.afterAfterNextRender.calledAfter(raf2));
+      // break out of this raf so next test is not tainted.
+      requestAnimationFrame(() => { done() });
     }
     document.body.appendChild(el);
   });
 
   test('flush', function() {
-    let el = document.createElement('x-foo');
-    let beforeCalled;
-    el.beforeNextRender = function() {
-      beforeCalled = true;
-    }
-    let afterCalled;
-    el.afterNextRender = function() {
-      afterCalled = true;
-    }
-    document.body.appendChild(el);
+    let el1 = document.createElement('x-foo');
+    let el2 = document.createElement('x-bar');
+    document.body.appendChild(el1);
+    document.body.appendChild(el2);
     Polymer.RenderStatus.flush();
-    assert.isTrue(beforeCalled);
-    assert.isTrue(afterCalled);
+    assert.ok(el1.beforeNextRender.withArgs('before').calledOnce);
+    assert.ok(el1.stillBeforeNextRender.withArgs('still-before').calledOnce);
+    assert.ok(el2.afterNextRender.withArgs('after').calledOnce);
+    assert.ok(el2.afterAfterNextRender.withArgs('after-after').calledOnce);
   });
 
 });
diff --git a/test/unit/shady-dynamic.html b/test/unit/shady-dynamic.html
index 84837131b9..c935b92afa 100644
--- a/test/unit/shady-dynamic.html
+++ b/test/unit/shady-dynamic.html
@@ -131,7 +131,7 @@
 
 
 <dom-module id="x-select3">
-  <template><slot name="s3"></slot></template>
+  <template><slot id="x-select3-slot" name="s3"></slot></template>
   <script>
   HTMLImports.whenReady(function() {
     Polymer({is: 'x-select3'});
@@ -140,7 +140,7 @@
 </dom-module>
 
 <dom-module id="x-select2">
-  <template><x-select3 id="select"><slot name="s2"></slot></x-select3></template>
+  <template><x-select3 id="select"><slot id="x-select2-slot" name="s2"></slot></x-select3></template>
   <script>
   HTMLImports.whenReady(function() {
     Polymer({is: 'x-select2'});
@@ -149,7 +149,7 @@
 </dom-module>
 
 <dom-module id="x-select1">
-  <template><x-select2 id="select"><slot name="s1"></slot></x-select2></template>
+  <template><x-select2 id="select"><slot id="x-select1-slot" name="s1"></slot></x-select2></template>
   <script>
   HTMLImports.whenReady(function() {
     Polymer({is: 'x-select1'});
diff --git a/test/unit/shady.html b/test/unit/shady.html
index 72f4e4cd13..6fd4f8d0d9 100644
--- a/test/unit/shady.html
+++ b/test/unit/shady.html
@@ -29,7 +29,7 @@
   });
 });
 
-/**
+/*
  * Test the `<slot>` element distribution algorithm by verifying the
  * resulting composed tree structure.
  */
diff --git a/test/unit/styling-cross-scope-apply.html b/test/unit/styling-cross-scope-apply.html
index a91bc5b5c2..f0ffa27445 100644
--- a/test/unit/styling-cross-scope-apply.html
+++ b/test/unit/styling-cross-scope-apply.html
@@ -446,6 +446,50 @@
   </script>
 </dom-module>
 
+<dom-module id="order-child">
+  <template>
+    <style>
+      div {
+        @apply --order-mixin;
+      }
+    </style>
+    <div id="target"></div>
+  </template>
+</dom-module>
+
+<dom-module id="order-parent">
+  <template>
+    <style>
+      order-child {
+        --order-mixin: {
+          border: 10px solid black;
+        };
+      }
+    </style>
+    <order-child id="child"></order-child>
+  </template>
+</dom-module>
+
+<dom-module id="order-gp">
+  <template>
+    <style>
+      order-child {
+        --order-mixin: {
+        };
+      }
+    </style>
+    <order-child id="child"></order-child>
+    <order-parent id="parent"></order-parent>
+  </template>
+</dom-module>
+
+<script>
+  HTMLImports.whenReady(function() {
+    Polymer({is: 'order-child'});
+    Polymer({is: 'order-parent'});
+    Polymer({is: 'order-gp'});
+  })
+</script>
 <script>
 suite('scoped-styling-apply', function() {
   function assertComputed(element, value, property) {
@@ -614,6 +658,16 @@
     assertComputed(div, '2px');
     assertComputed(div, '0px', 'height');
   });
+
+  test('mixin redefinition applies to complicated hierarchies', function() {
+    var e = document.createElement('order-gp');
+    document.body.appendChild(e);
+    Polymer.flush();
+    var childDiv = e.$.child.$.target;
+    var parentDiv = e.$.parent.$.child.$.target;
+    assertComputed(childDiv, '0px');
+    assertComputed(parentDiv, '10px');
+  })
 });
 
 </script>
diff --git a/test/unit/styling-cross-scope-var.html b/test/unit/styling-cross-scope-var.html
index c45d7fa9e4..4747494fe6 100644
--- a/test/unit/styling-cross-scope-var.html
+++ b/test/unit/styling-cross-scope-var.html
@@ -752,6 +752,9 @@
   suite('scoped-styling-var', function() {
 
   function assertComputed(element, value, pseudo, name) {
+    // force a style-recalc for Safari missing updated CSS Custom Properties
+    // https://bugs.webkit.org/show_bug.cgi?id=170708
+    element.offsetWidth;
     name = name || 'border-top-width';
     var computed = element.getComputedStyleValue && !pseudo ?
       element.getComputedStyleValue(name) :
@@ -787,6 +790,11 @@
   });
 
   test('instances of scoped @keyframes', function(done) {
+    if (navigator.userAgent.match(/Safari\/603/) && ShadyCSS.nativeCss && ShadyCSS.nativeShadow) {
+      // `:nth-of-type` is broken in shadow roots on Safari 10.1
+      // https://bugs.webkit.org/show_bug.cgi?id=166748
+      this.skip();
+    }
     var xKeyframes = styled.$.keyframes2;
     var onAnimationEnd = function() {
       assertStylePropertyValue(xKeyframes, 'left', '5px');
diff --git a/test/unit/styling-only-with-template.html b/test/unit/styling-only-with-template.html
new file mode 100644
index 0000000000..5134867a36
--- /dev/null
+++ b/test/unit/styling-only-with-template.html
@@ -0,0 +1,79 @@
+<!doctype html>
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../../web-component-tester/browser.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+
+<body>
+  <custom-style>
+    <style is="custom-style">
+      html {
+        --mixin: {
+          border: 2px solid rgb(255, 0, 0);
+        };
+      }
+    </style>
+  </custom-style>
+
+  <custom-style>
+    <style is="custom-style">
+      #target {
+        @apply --mixin;
+      }
+    </style>
+  </custom-style>
+
+  <div id="target"></div>
+  <dom-if><template></template></dom-if>
+  <dom-repeat><template></template></dom-repeat>
+
+  <script>
+    addEventListener('WebComponentsReady', () => {
+      class XFoo extends Polymer.Element {
+        connectedCallback() {
+          this.spy = sinon.spy(window.ShadyCSS, 'styleElement');
+          super.connectedCallback();
+          this.spy.restore();
+        }
+      }
+      customElements.define('x-foo', XFoo);
+    })
+  </script>
+
+  <script>
+      suite('styling-only-template', function () {
+
+        function assertComputed(element, value, pseudo) {
+          var computed = getComputedStyle(element, pseudo);
+          assert.equal(computed['border-top-width'], value, 'computed style incorrect');
+        }
+
+        test('elements without templates do not call ShadyCSS', () => {
+          let el = document.createElement('x-foo');
+          document.body.appendChild(el);
+          assert.ok(el.spy);
+          assert.isTrue(el.spy.notCalled);
+        });
+
+        test('dom-repeat and dom-if do not break custom-style', () => {
+          // force custom-style flushing
+          let target = document.querySelector('#target');
+          window.ShadyCSS.styleDocument();
+          assertComputed(target, '2px');
+        });
+      });
+  </script>
+</body>
\ No newline at end of file
diff --git a/test/unit/styling-scoped.html b/test/unit/styling-scoped.html
index 2bb5c88728..feb262e40e 100644
--- a/test/unit/styling-scoped.html
+++ b/test/unit/styling-scoped.html
@@ -759,13 +759,7 @@
       Polymer.flush();
       assert.notInclude(d.getAttribute('style-scoped') || '', styled.is, 'scoping attribute not removed when added to other root');
       assert.notInclude(d.className, styled.is, 'scoping class not removed when added to other root');
-      Polymer.dom(styled.root).appendChild(d);
-      Polymer.flush();
-      assertComputed(d, '4px');
-      Polymer.dom(styled.root).removeChild(d);
-      Polymer.flush();
-      assert.notInclude(d.getAttribute('style-scoped') || '', styled.is, 'scoping attribute not removed when removed from root');
-      assert.notInclude(d.className, styled.is, 'scoping class not removed when removed from root');
+      assertComputed(d, '0px');
       Polymer.dom(styled.root).appendChild(d);
       Polymer.flush();
       assertComputed(d, '4px');
diff --git a/test/unit/templatize.html b/test/unit/templatize.html
index efd694e184..5cbb44d0a6 100644
--- a/test/unit/templatize.html
+++ b/test/unit/templatize.html
@@ -123,7 +123,7 @@
     });
 
     test('ensure literals are not forwarded to templates', function() {
-      assert.notOk(host.__propertyEffects[33]);
+      assert.notOk(host._hasAccessor(33));
       assert.notOk(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(host), 33));
     });
 
@@ -286,7 +286,7 @@
     });
 
     test('ensure literals are not forwarded to templates', function() {
-      assert.notOk(host.__propertyEffects[33]);
+      assert.notOk(host._hasAccessor(33));
       assert.notOk(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(host), 33));
     });
 
diff --git a/util/gen-changelog.sh b/util/gen-changelog.sh
index ba6fcb0cb2..84018969be 100755
--- a/util/gen-changelog.sh
+++ b/util/gen-changelog.sh
@@ -17,7 +17,7 @@ fi
 cat > CHANGELOG.md <<EOD
 # Change Log
 
-##[${end}](https://github.com/Polymer/polymer/tree/${end}) (${enddate})
+## [${end}](https://github.com/Polymer/polymer/tree/${end}) (${enddate})
 `git log --no-merges "${startrev}".."${endrev}^1" --pretty="${PRETTY}"`
 
 ${old}