diff --git a/CHANGELOG.md b/CHANGELOG.md
index ccb7547bba12..640f797b1f9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,67 @@
+<a name="2.0.0-beta.0"></a>
+# 2.0.0-beta.0 somnambulant-inauguration (2015-12-15)
+
+**Enjoy!**
+
+
+<a name="2.0.0-alpha.55"></a>
+# 2.0.0-alpha.55 (2015-12-15)
+
+
+### Bug Fixes
+
+* **router:** export ROUTER_LINK_DSL_PROVIDER and hide MockPopStateEvent ([fc75220](https://github.com/angular/angular/commit/fc75220))
+
+### Features
+
+* **core:** enable dev mode by default ([3dca9d5](https://github.com/angular/angular/commit/3dca9d5))
+
+
+### BREAKING CHANGES
+
+* Before
+Previously Angular would run in dev prod mode by default, and you could enable the dev mode by calling enableDevMode.
+After
+Now, Angular runs in the dev mode by default, and you can enable the prod mode by calling enableProdMode.
+
+
+
+<a name="2.0.0-alpha.54"></a>
+# 2.0.0-alpha.54 (2015-12-15)
+
+
+### Bug Fixes
+
+* **bundles:** don't include RxJS in System.register bundles ([77b7cae](https://github.com/angular/angular/commit/77b7cae))
+* **bundles:** remove ngUpgrade from the angular2.js bundle ([283962f](https://github.com/angular/angular/commit/283962f)), closes [#5739](https://github.com/angular/angular/issues/5739) [#5854](https://github.com/angular/angular/issues/5854)
+* **bundles:** remove polyfills from angular2.js bundle ([2983558](https://github.com/angular/angular/commit/2983558)), closes [#5881](https://github.com/angular/angular/issues/5881)
+* **bundles:** rename the testing.js bundle to testing.dev.js ([d55655f](https://github.com/angular/angular/commit/d55655f)), closes [#5899](https://github.com/angular/angular/issues/5899) [#5776](https://github.com/angular/angular/issues/5776)
+* **bundles:** rename UMD bundles ([61b9468](https://github.com/angular/angular/commit/61b9468)), closes [#5898](https://github.com/angular/angular/issues/5898)
+
+
+### BREAKING CHANGES
+
+* System.register testing bundle was renamed:
+`testing.js` -> `testing.dev.js`
+
+* UMD bundles were renamed:
+  * `angular2.umd.js` -> `angular2-all.umd.js`
+  * `angular2-testing.umd.js` -> `angular2-all-testing.umd.js`
+
+* RxJS used to be bundled with Angular 2 code and this is not the case
+any more. RxJS needs to be loaded explicitly.
+
+* Previously `angular2.js`, `angular2.min.js` and `angular2.dev.js` bundles
+would have zone.js and reflect-metadata pre-appended. New bundles don't
+contain zone.js nor reflect-metadata - those external dependencies can
+be easily loaded into a browser using `angular2-polyfills.js`
+
+* `ngUpgrade` related symbols are no longer part of the `angular2.js`
+bundle. `ngUpgrade` has a dedicated `upgrade.js` bundle now.
+
+
+
+
 <a name="2.0.0-alpha.53"></a>
 # 2.0.0-alpha.53 (2015-12-13)
 
@@ -90,7 +154,7 @@ Use imports from `angular2/compiler` instead.
       <my-cmp (myEvent)="action()">
       <my-cmp [(myProp)]="prop">
       <input #myInput>`,
-      <template ngFor="#myItem" [ngForOf]=items #myIndex="index">
+      <template ngFor "#myItem" [ngForOf]=items #myIndex="index">
   ```
 
   The full migration instruction can be found at [angular2/docs/migration/kebab-case.md](https://github.com/angular/angular/blob/master/modules/angular2/docs/migration/kebab-case.md).
@@ -259,9 +323,9 @@ import * as core from 'angular2/core';
 
 * Operators and Observables from RxJS (e.g. .map(), .toArray(), .toPromise(), etc ) now need to be explicitly imported (once per operator in your app)
   ```
-  import {Observable} from 'angular2/angular2'
-  import 'rxjs/operators/map';
-  import 'rxjs/observable/interval'
+  import {Observable} from 'rxjs/Observable';
+  import 'rxjs/add/operators/map';
+  import 'rxjs/add/observable/interval';
 
   Observable.interval(1000).subscribe(...);
 
diff --git a/COMMITTER.md b/COMMITTER.md
index 851237eb6ebf..ef408a6c6a47 100644
--- a/COMMITTER.md
+++ b/COMMITTER.md
@@ -11,8 +11,11 @@ Someone with committer access will do the rest.
 We have automated the process for merging pull requests into master. Our goal is to minimize the disruption for
 Angular committers and also prevent breakages on master.
 
-When a PR is ready to merge, a project member in the CoreTeamMember list (see below) can add the special label,
-`PR: merge`.
+When a PR has `pr_state: LGTM` and is ready to merge, you should add the `pr_action: merge` label.
+Currently (late 2015), we need to ensure that each PR will cleanly merge into the Google-internal version control,
+so the caretaker reviews the changes manually.
+
+After this review, the caretaker adds `zomg_admin: do_merge` which is restricted to admins only. 
 A robot running as [mary-poppins](https://github.com/mary-poppins)
 is notified that the label was added by an authorized person,
 and will create a new branch in the angular project, using the convention `presubmit-{username}-pr-{number}`.
@@ -26,6 +29,6 @@ Finally, after merge `mary-poppins` removes the presubmit branch.
 
 ## Administration
 
-The list of users who can trigger a merge by adding the label is stored in our appengine app datastore.
+The list of users who can trigger a merge by adding the `zomg_admin: do_merge` label is stored in our appengine app datastore.
 Edit the contents of the [CoreTeamMember Table](
 https://console.developers.google.com/project/angular2-automation/datastore/query?queryType=KindQuery&namespace=&kind=CoreTeamMember)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e22ad4831f33..b8da1f04776b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -48,14 +48,18 @@ features, by not reporting duplicate issues.  Providing the following informatio
 chances of your issue being dealt with quickly:
 
 * **Overview of the Issue** - if an error is being thrown a non-minified stack trace helps
-* **Motivation for or Use Case** - explain why this is a bug for you
+* **Angular Version** - what version of Angular is affected (e.g. 2.0.0-alpha.53)
+* **Motivation for or Use Case** - explain what are you trying to do and why the current behavior is a bug for you
 * **Browsers and Operating System** - is this a problem with all browsers?
 * **Reproduce the Error** - provide a live example (using [Plunker][plunker],
-  [JSFiddle][jsfiddle] or [Runnable][runnable]) or a unambiguous set of steps.
+  [JSFiddle][jsfiddle] or [Runnable][runnable]) or a unambiguous set of steps
 * **Related Issues** - has a similar issue been reported before?
 * **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be
   causing the problem (line of code or commit)
 
+You can file new issues by providing the above information [here](https://github.com/angular/angular/issues/new).
+
+
 ### <a name="submit-pr"></a> Submitting a Pull Request (PR)
 Before you submit your Pull Request (PR) consider the following guidelines:
 
diff --git a/README.md b/README.md
index a4d10c98ab80..1ec98bd96abf 100644
--- a/README.md
+++ b/README.md
@@ -12,20 +12,12 @@ Angular
 Angular is a development platform for building mobile and desktop web applications. This is the
 repository for [Angular 2][ng2], both the JavaScript (JS) and [Dart][dart] versions.
 
-Angular 2 is currently in **Developer Preview**. We recommend using Angular 1.X for production
-applications:
-
-* [AngularJS][ngJS]: [angular/angular.js](http://github.com/angular/angular.js).
-* [AngularDart][ngDart]: [angular/angular.dart](http://github.com/angular/angular.dart).
+Angular 2 is currently in **Beta**. 
 
 ## Quickstart
 
 [Get started in 5 minutes][quickstart].
 
-## Setup & Install Angular 2
-
-Follow the instructions given on the [Angular download page][download].
-
 
 ## Want to help?
 
@@ -36,8 +28,7 @@ guidelines for [contributing][contributing] and then check out one of our issues
 [contributing]: http://github.com/angular/angular/blob/master/CONTRIBUTING.md
 [dart]: http://www.dartlang.org
 [dartium]: http://www.dartlang.org/tools/dartium
-[download]: http://angular.io/download/
-[quickstart]: https://angular.io/docs/js/latest/quickstart.html
+[quickstart]: https://angular.io/docs/ts/latest/quickstart.html
 [ng2]: http://angular.io
 [ngDart]: http://angulardart.org
 [ngJS]: http://angularjs.org
diff --git a/TOOLS_DART.md b/TOOLS_DART.md
index 6eb34fe9a025..c61b97c25d87 100644
--- a/TOOLS_DART.md
+++ b/TOOLS_DART.md
@@ -21,7 +21,7 @@ By default the debugging tools are disabled.
 Enable the debugging tools as follows:
 
 ```dart
-import 'package:angular2/tools.dart';
+import 'package:angular2/platform/browser.dart';
 
 main() async {
   var appRef = await bootstrap(Application);
diff --git a/clone.git b/clone.git
new file mode 100644
index 000000000000..ab1b40bb2521
--- /dev/null
+++ b/clone.git
@@ -0,0 +1,10 @@
+$ git clone --bare https://github.com/angular/angular.git
+# Make a bare clone of the repository
+
+$ cd old-repository.git
+$ git push --mirror https://github.com/usernamealreadyis/commands.git
+# Mirror-push to the new repository
+
+$ cd ..
+$ rm -rf old-repository.git
+# Remove our temporary local repository
diff --git a/gulpfile.js b/gulpfile.js
index 69a5cc057cc0..fc8f207995f2 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -150,14 +150,14 @@ var ANGULAR2_BUNDLE_CONFIG = [
   'angular2/platform/common_dom'
 ];
 
-var NG2_BUNDLE_CONTENT = ANGULAR2_BUNDLE_CONFIG.join(' + ');
-var HTTP_BUNDLE_CONTENT = 'angular2/http - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
-var ROUTER_BUNDLE_CONTENT =
-    'angular2/router + angular2/router/router_link_dsl - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
+var NG2_BUNDLE_CONTENT = ANGULAR2_BUNDLE_CONFIG.join(' + ') + ' - rxjs/*';
+var HTTP_BUNDLE_CONTENT = 'angular2/http - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
+var ROUTER_BUNDLE_CONTENT = 'angular2/router + angular2/router/router_link_dsl - rxjs/* - ' +
+                            ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var TESTING_BUNDLE_CONTENT =
-    'angular2/testing + angular2/http/testing + angular2/router/testing - ' +
+    'angular2/testing + angular2/http/testing + angular2/router/testing - rxjs/* - ' +
     ANGULAR2_BUNDLE_CONFIG.join(' - ');
-var UPGRADE_BUNDLE_CONTENT = 'angular2/upgrade - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
+var UPGRADE_BUNDLE_CONTENT = 'angular2/upgrade - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 
 var BENCHPRESS_BUNDLE_CONFIG = {
   entries: ['./dist/js/cjs/benchpress/index.js'],
@@ -638,7 +638,7 @@ gulp.task('test.unit.dart', function(done) {
 // This test will fail if the size of our hello_world app goes beyond one of
 // these values when compressed at the specified level.
 // Measure in bytes.
-var _DART_PAYLOAD_SIZE_LIMITS = {'uncompressed': 375 * 1024, 'gzip level=6': 105 * 1024};
+var _DART_PAYLOAD_SIZE_LIMITS = {'uncompressed': 320 * 1024, 'gzip level=6': 90 * 1024};
 gulp.task('test.payload.dart/ci', function(done) {
   runSequence('build/packages.dart', '!pubget.payload.dart', '!pubbuild.payload.dart',
               '!checkAndReport.payload.dart', done);
@@ -1109,10 +1109,14 @@ gulp.task('!bundle.testing', ['build.js.dev'], function() {
   var devBundleConfig = merge(true, bundleConfig);
   devBundleConfig.paths = merge(true, devBundleConfig.paths, {"*": "dist/js/dev/es5/*.js"});
 
-  return bundler.bundle(devBundleConfig, TESTING_BUNDLE_CONTENT, './dist/js/bundle/testing.js',
+  return bundler.bundle(devBundleConfig, TESTING_BUNDLE_CONTENT, './dist/js/bundle/testing.dev.js',
                         {sourceMaps: true});
 });
 
+gulp.task('!bundles.js.docs', function() {
+  gulp.src('modules/angular2/docs/bundles/*').pipe(gulp.dest('dist/js/bundle'));
+});
+
 gulp.task('!bundles.js.umd', ['build.js.dev'], function() {
   var q = require('q');
   var webpack = q.denodeify(require('webpack'));
@@ -1139,15 +1143,45 @@ gulp.task('!bundles.js.umd', ['build.js.dev'], function() {
       resolve: resolveOptions(devOrProd),
       module: {preLoaders: [{test: /\.js$/, loader: 'source-map-loader'}]},
       devtool: devOrProd === 'dev' ? 'inline-source-map' : undefined,
-      output: outputOptions(outFileName, devOrProd)
+      output: outputOptions(outFileName, devOrProd),
+      externals: {
+        'rxjs/Observable': 'umd Rx',
+        'rxjs/Subject': 'umd Rx',
+        'rxjs/subject/ReplaySubject': {
+          commonjs: 'rxjs/subject/ReplaySubject',
+          commonjs2: 'rxjs/subject/ReplaySubject',
+          amd: 'rxjs/subject/ReplaySubject',
+          root: ['Rx']
+        },
+        'rxjs/operator/take': {
+          commonjs: 'rxjs/operator/take',
+          commonjs2: 'rxjs/operator/take',
+          amd: 'rxjs/operator/take',
+          root: ['Rx', 'Observable', 'prototype']
+        },
+        'rxjs/observable/fromPromise': {
+          commonjs: 'rxjs/observable/fromPromise',
+          commonjs2: 'rxjs/observable/fromPromise',
+          amd: 'rxjs/observable/fromPromise',
+          root: ['Rx', 'Observable']
+        },
+        'rxjs/operator/toPromise': {
+          commonjs: 'rxjs/operator/toPromise',
+          commonjs2: 'rxjs/operator/toPromise',
+          amd: 'rxjs/operator/toPromise',
+          root: ['Rx', 'Observable', 'prototype']
+        }
+      }
     };
   }
 
   return q.all([
-    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2.umd.js'], 'angular2', 'dev')),
-    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2.umd.js'], 'angular2', 'prod')),
-    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2-testing.umd.js'],
-                        'angular2-testing', 'dev'))
+    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2-all.umd.js'], 'angular2-all',
+                        'dev')),
+    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2-all.umd.js'], 'angular2-all',
+                        'prod')),
+    webpack(webPackConf([__dirname + '/tools/build/webpack/angular2-all-testing.umd.js'],
+                        'angular2-all-testing', 'dev'))
   ]);
 });
 
@@ -1156,7 +1190,7 @@ gulp.task('bundles.js.umd.min', ['!bundles.js.umd', '!bundle.ng.polyfills'], fun
   var uglify = require('gulp-uglify');
 
   // minify production bundles
-  return gulp.src(['dist/js/bundle/angular2-polyfills.js', 'dist/js/bundle/angular2.umd.js'])
+  return gulp.src(['dist/js/bundle/angular2-polyfills.js', 'dist/js/bundle/angular2-all.umd.js'])
       .pipe(uglify())
       .pipe(rename({extname: '.min.js'}))
       .pipe(gulp.dest('dist/js/bundle'));
@@ -1195,25 +1229,12 @@ var JS_DEV_DEPS = [
   'node_modules/reflect-metadata/Reflect.js'
 ];
 
-// Splice in RX license if rx is in the bundle.
-function insertRXLicense(source) {
-  var n = source.indexOf('System.register("rxjs/Subject"');
-  if (n >= 0) {
-    // TODO: point this to Rx once Rx includes license in dist
-    // https://github.com/angular/angular/issues/5558
-    var rxLicense = licenseWrap('LICENSE');
-    return source.slice(0, n) + rxLicense + source.slice(n);
-  } else {
-    return source;
-  }
-}
 
 function addDevDependencies(outputFile) {
   var bundler = require('./tools/build/bundle');
   var insert = require('gulp-insert');
 
   return bundler.modify(JS_DEV_DEPS.concat(['dist/build/' + outputFile]), outputFile)
-      .pipe(insert.transform(insertRXLicense))
       .pipe(gulp.dest('dist/js/bundle'));
 }
 
@@ -1252,7 +1273,8 @@ gulp.task('bundles.js',
             '!bundle.web_worker.js.dev.deps',
             'bundles.js.umd.min',
             '!bundle.testing',
-            '!bundle.ng.polyfills'
+            '!bundle.ng.polyfills',
+            '!bundles.js.docs'
           ],
           function(done) { runSequence('!bundle.copy', '!bundles.js.checksize', done); });
 
diff --git a/modules/angular1_router/lib/facades.es5 b/modules/angular1_router/lib/facades.es5
index b82d19805625..f419cdef5ff5 100644
--- a/modules/angular1_router/lib/facades.es5
+++ b/modules/angular1_router/lib/facades.es5
@@ -195,6 +195,10 @@ var ListWrapper = {
     return array[0];
   },
 
+  last: function(array) {
+    return (array && array.length) > 0 ? array[array.length - 1] : null;
+  },
+
   map: function (l, fn) {
     return l.map(fn);
   },
diff --git a/modules/angular2/core.dart b/modules/angular2/core.dart
index 187285742e17..2e43211bd5fa 100644
--- a/modules/angular2/core.dart
+++ b/modules/angular2/core.dart
@@ -2,7 +2,7 @@ library angular2.core;
 
 export './src/core/metadata.dart';
 export './src/core/util.dart';
-export './src/core/dev_mode.dart';
+export 'package:angular2/src/facade/lang.dart' show enableProdMode;
 export './src/core/di.dart' hide ForwardRefFn, resolveForwardRef, forwardRef;
 export './src/facade/facade.dart';
 export './src/core/application_ref.dart' show platform, createNgZone, PlatformRef, ApplicationRef;
diff --git a/modules/angular2/core.ts b/modules/angular2/core.ts
index 25d31ebb2e91..08f3d19d5416 100644
--- a/modules/angular2/core.ts
+++ b/modules/angular2/core.ts
@@ -5,9 +5,10 @@
  */
 export * from './src/core/metadata';
 export * from './src/core/util';
-export * from './src/core/dev_mode';
+export * from './src/core/prod_mode';
 export * from './src/core/di';
 export * from './src/facade/facade';
+export {enableProdMode} from 'angular2/src/facade/lang';
 export {platform, createNgZone, PlatformRef, ApplicationRef} from './src/core/application_ref';
 export {
   APP_ID,
diff --git a/modules/angular2/docs/bundles/overview.md b/modules/angular2/docs/bundles/overview.md
new file mode 100644
index 000000000000..25dd4b9d465c
--- /dev/null
+++ b/modules/angular2/docs/bundles/overview.md
@@ -0,0 +1,92 @@
+# TL;DR;
+
+* If you write ES5 use _one_ of the `UMD` bundles.
+* If you experiment with Angular2 using online prototyping tools like [plnkr](http://plnkr.co/) or similar use `System.register` bundles with SystemJS loader.
+* If you use build tools like Browserify or WebPack - bundle Angular2 as part of your build.
+* For all the above cases you must use `angular2-polyfills.js` in a `script` tag to easily include polyfills and external dependencies.
+
+# Modules, barrels and bundles
+
+Angular2 source code is authored using the ES2015 standardized module format where one module corresponds to exactly one file. Multiple modules (files) can be logically grouped into so-called "barrels".
+ A bundle is a file the contains all the code for one or more barrels.
+  
+Most bundles come in several flavors:
+* regular and minified (got `.min` in their name);
+* regular and "development" (have `.dev` in their name) - "development" bundles contain in-line source maps and don't have minified flavor (minification removes in-lined source maps). 
+  
+# Bundles, their content and usage scenarios
+  
+Angular 2 distributes several types of bundles targeted at specific usages:
+  * users writing ES5 code without any transpilation steps
+  * users experimenting with Angular 2 and TypeScript/ES2015 using online tools like plunker, jsbin or similar
+  
+Since each identified scenario has slightly different requirements and constraints there are specific bundles for each use-case.
+
+## ES5 and ngUpgrade users
+
+ES5 users and AngularJS 1.x users interested in the `ngUpgrade` path can take advantage of the bundles in the [UMD format](https://github.com/umdjs/umd).
+ Those are coarse-grained bundles that combine many barrels in one final file.  
+
+filename    | list of barrels   | dev/prod | minified? 
+------------|-------------------|----------|-------------|--------------|-------------
+`angular2-all.umd.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade`| prod | no
+`angular2-all.umd.min.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade` | prod | yes
+`angular2-all.umd.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade` | dev | no
+`angular2-all-testing.umd.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade`, `angular2/testing`, `angular2/http/testing`, `angular2/router/testing` | dev | no
+
+**Warning**: bundles in the `UMD` format are _not_ "additive". A single application should use only one bundle from the above list.
+
+## SystemJS loader users
+
+[SystemJS loader](https://github.com/systemjs/systemjs) with on-the-fly (in a browser) transpilations support is very useful for quick experiments using tools like plunker, jsbin or similar.
+For this scenario Angular 2 is distributed with bundles in the [System.register format](https://github.com/ModuleLoader/es6-module-loader/wiki/System.register-Explained):
+
+filename    | list of barrels   | dev/prod | minified? 
+------------|-------------------|----------|-------------|--------------|-------------
+`angular2.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/instrumentation`| prod | no
+`angular2.min.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/instrumentation`| prod | yes
+`angular2.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/instrumentation`| dev | no
+`http.js` | `angular2/http` | prod | no
+`http.min.js` | `angular2/http` | prod | yes
+`http.dev.js` | `angular2/http` | dev | no
+`router.js` | `angular2/router` | prod | no
+`router.min.js` | `angular2/router` | prod | yes
+`router.dev.js` | `angular2/router` | dev | no
+`upgrade.js` | `angular2/upgrade` | prod | no
+`upgrade.min.js` | `angular2/upgrade` | prod | yes
+`upgrade.dev.js` | `angular2/upgrade` | dev | no
+`testing.dev.js` | `angular2/testing`, `angular2/http/testing`, `angular2/router/testing` | dev | no
+
+**Note**: bundles in the `System.register` format are "additive" - it is quite common to include several bundles in one application.
+For example people using Angular 2 with `http` and `router` would include: `angular2.js`, `http.js` and `router.js`.
+
+## Browserify / JSPM / Rollup / WebPack users
+
+Angular 2 doesn't provide any bundles for use with packaging tools Browserify or WebPack. Those tools are sophisticated enough to build optimal bundles for production use from individual Angular 2 files distributed in the npm package.
+An example of an Angular 2 project built with WebPack can be found in the [angular2-seed](https://github.com/angular/angular2-seed) repository.      
+
+
+# Polyfills and external dependencies
+
+## Required Polyfills
+
+Polyfills are required for Angular 2 to function properly (the exact list depends on the browser used) and external dependencies ([zone.js](https://github.com/angular/zone.js)).
+To ease setup of Angular 2 applications there is one file - `angular2-polyfills.js` - that combines:
+* a pollyfill mandatory for all browsers: [reflect-metadata](https://www.npmjs.com/package/reflect-metadata)
+* [zone.js](https://github.com/angular/zone.js)     
+
+**Note**: `angular2-polyfills.js` contains code that should be loaded into the browser as the very first code of the web application even before the module loader. The preferred solution is to load the mentioned file in a `script` tag as early as possible. 
+
+
+## RxJS
+
+[RxJS](https://github.com/ReactiveX/RxJS) is a required dependency of Angular 2.
+
+You should include RxJS in your project by declaring a dependency on the [`rxjs` npm package](https://www.npmjs.com/package/rxjs).
+
+Depending on if you are using Angular bundles or not you can either use RxJS bundles from `node_modules/rxjs/bundles/` or configure your bundler to pull in the individual files from the npm package.
+
+
+## ES6 shims (optional)
+
+Users of pre-ES6 browsers might need to add an ES6 shim (e.g. [es6-shim](https://github.com/paulmillr/es6-shim))
\ No newline at end of file
diff --git a/modules/angular2/docs/cheatsheet/bootstrapping.md b/modules/angular2/docs/cheatsheet/bootstrapping.md
index 5859e9b5f81f..99fba2b5c0b1 100644
--- a/modules/angular2/docs/cheatsheet/bootstrapping.md
+++ b/modules/angular2/docs/cheatsheet/bootstrapping.md
@@ -2,12 +2,17 @@
 Bootstrapping
 @cheatsheetIndex 0
 @description
-{@target js ts}`import {bootstrap} from 'angular2/platform/browser';`{@endtarget}
+{@target ts}`import {bootstrap} from 'angular2/angular2';`{@endtarget}
+{@target js}Available from the `ng.platform.browser` namespace.{@endtarget}
 {@target dart}`import 'package:angular2/bootstrap.dart';`{@endtarget}
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `bootstrap​(MyAppComponent, [MyService, provide(...)]);`|`provide`
+syntax(js):
+`document.addEventListener('DOMContentLoaded', function () {
+  ng.platform.browser.bootstrap(MyAppComponent,
+    [MyService, ng.core.provide(...)]);
+});`|`provide`
 description:
-Bootstraps an application with MyAppComponent as the root component, and
-configures the app's dependency injection providers.
+Bootstraps an application with MyAppComponent as the root component and configures the DI providers. {@target js}Must be wrapped in the event listener to fire when the page loads.{@endtarget}
diff --git a/modules/angular2/docs/cheatsheet/built-in-directives.md b/modules/angular2/docs/cheatsheet/built-in-directives.md
index 126578e55c80..9e5ebee575f8 100644
--- a/modules/angular2/docs/cheatsheet/built-in-directives.md
+++ b/modules/angular2/docs/cheatsheet/built-in-directives.md
@@ -2,7 +2,8 @@
 Built-in directives
 @cheatsheetIndex 2
 @description
-{@target js ts}`import {NgIf, ...} from 'angular2/common';`{@endtarget}
+{@target ts}`import {NgIf, ...} from 'angular2/common';`{@endtarget}
+{@target js}Available from the `ng.common` namespace{@endtarget}
 {@target dart}`import 'package:angular2/common.dart';`{@endtarget}
 
 @cheatsheetItem
diff --git a/modules/angular2/docs/cheatsheet/class-decorators.md b/modules/angular2/docs/cheatsheet/class-decorators.md
index af449c8b80e8..e1862e764e73 100644
--- a/modules/angular2/docs/cheatsheet/class-decorators.md
+++ b/modules/angular2/docs/cheatsheet/class-decorators.md
@@ -2,13 +2,16 @@
 Class decorators
 @cheatsheetIndex 4
 @description
-{@target js ts}`import {Directive, ...} from 'angular2/core';`{@endtarget}
+{@target ts}`import {Directive, ...} from 'angular2/core';`{@endtarget}
+{@target js}Available from the `ng.core` namespace{@endtarget}
 {@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `@Component({...})
 class MyComponent() {}`|`@Component({...})`
+syntax(js):
+`var MyComponent = ng.core.Component({...}).Class({...})`|`ng.core.Component({...})`
 syntax(dart):
 `@Component(...)
 class MyComponent() {}`|`@Component(...)`
@@ -16,9 +19,11 @@ description:
 Declares that a class is a component and provides metadata about the component.
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `@Pipe({...})
 class MyPipe() {}`|`@Pipe({...})`
+syntax(js):
+`var MyPipe = ng.core.Pipe({...}).Class({...})`|`ng.core.Pipe({...})`
 syntax(dart):
 `@Pipe(...)
 class MyPipe() {}`|`@Pipe(...)`
@@ -26,12 +31,18 @@ description:
 Declares that a class is a pipe and provides metadata about the pipe.
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `@Injectable()
 class MyService() {}`|`@Injectable()`
+syntax(js):
+`var OtherService = ng.core.Class({constructor: function() { }});
+var MyService = ng.core.Class({constructor: [OtherService, function(otherService) { }]});`|`var MyService = ng.core.Class({constructor: [OtherService, function(otherService) { }]});`
 syntax(dart):
 `@Injectable()
 class MyService() {}`|`@Injectable()`
 description:
-Declares that a class has dependencies that should be injected into the constructor when the dependency
-injector is creating an instance of this class.
+{@target ts dart}Declares that a class has dependencies that should be injected into the constructor when the dependency injector is creating an instance of this class.
+{@endtarget}
+{@target js}
+Declares a service to inject into a class by providing an array with the services with the final item being the function which will receive the injected services.
+{@endtarget}
diff --git a/modules/angular2/docs/cheatsheet/component-configuration.md b/modules/angular2/docs/cheatsheet/component-configuration.md
index 81765661090f..64d48c0f4e04 100644
--- a/modules/angular2/docs/cheatsheet/component-configuration.md
+++ b/modules/angular2/docs/cheatsheet/component-configuration.md
@@ -2,12 +2,16 @@
 Component configuration
 @cheatsheetIndex 6
 @description
-`@Component` extends `@Directive`,
-so the `@Directive` configuration applies to components as well
+{@target js}`ng.core.Component` extends `ng.core.Directive`,
+so the `ng.core.Directive` configuration applies to components as well{@endtarget}
+{@target ts dart}`@Component` extends `@Directive`,
+so the `@Directive` configuration applies to components as well{@endtarget}
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `viewProviders: [MyService, provide(...)]`|`viewProviders:`
+syntax(js):
+`viewProviders: [MyService, ng.core.provide(...)]`|`viewProviders:`
 description:
 Array of dependency injection providers scoped to this component's view.
 
diff --git a/modules/angular2/docs/cheatsheet/dependency-injection.md b/modules/angular2/docs/cheatsheet/dependency-injection.md
index ed6426d94f85..83c1c0d291e2 100644
--- a/modules/angular2/docs/cheatsheet/dependency-injection.md
+++ b/modules/angular2/docs/cheatsheet/dependency-injection.md
@@ -2,26 +2,32 @@
 Dependency injection configuration
 @cheatsheetIndex 9
 @description
-{@target js ts}`import {provide} from 'angular2/core';`{@endtarget}
+{@target ts}`import {provide} from 'angular2/core';`{@endtarget}
+{@target js}Available from the `ng.core` namespace{@endtarget}
 {@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `provide(MyService, {useClass: MyMockService})`|`provide`|`useClass`
+syntax(js):
+`ng.core.provide(MyService, {useClass: MyMockService})`|`provide`|`useClass`
 description:
 Sets or overrides the provider for MyService to the MyMockService class.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `provide(MyService, {useFactory: myFactory})`|`provide`|`useFactory`
+syntax(js):
+`ng.core.provide(MyService, {useFactory: myFactory})`|`provide`|`useFactory`
 description:
 Sets or overrides the provider for MyService to the myFactory factory function.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
+`provide(MyValue, {useValue: 41})`|`provide`|`useValue`
+syntax(js):
 `provide(MyValue, {useValue: 41})`|`provide`|`useValue`
 description:
 Sets or overrides the provider for MyValue to the value 41.
-
diff --git a/modules/angular2/docs/cheatsheet/directive-and-component-decorators.md b/modules/angular2/docs/cheatsheet/directive-and-component-decorators.md
index 4de517b3d3ae..dcfe62e7555c 100644
--- a/modules/angular2/docs/cheatsheet/directive-and-component-decorators.md
+++ b/modules/angular2/docs/cheatsheet/directive-and-component-decorators.md
@@ -2,62 +2,79 @@
 Class field decorators for directives and components
 @cheatsheetIndex 7
 @description
-{@target js ts}`import {Input, ...} from 'angular2/core';`{@endtarget}
+{@target ts}`import {Input, ...} from 'angular2/core';`{@endtarget}
+{@target js}Available from the `ng.core` namespace{@endtarget}
 {@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@Input() myProperty;`|`@Input()`
+syntax(js):
+`ng.core.Input(myProperty, myComponent);`|`ng.core.Input(`|`);`
 description:
 Declares an input property that we can update via property binding (e.g.
 `<my-cmp [my-property]="someExpression">`).
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@Output() myEvent = new EventEmitter();`|`@Output()`
+syntax(js):
+`myEvent = new ng.core.EventEmitter(); ng.core.Output(myEvent, myComponent);`|`ng.core.Output(`|`);`
 description:
 Declares an output property that fires events to which we can subscribe with an event binding (e.g. `<my-cmp (my-event)="doSomething()">`).
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@HostBinding('[class.valid]') isValid;`|`@HostBinding('[class.valid]')`
+syntax(js):
+`ng.core.HostBinding('[class.valid]', 'isValid', myComponent);`|`ng.core.HostBinding('[class.valid]', 'isValid'`|`);`
 description:
 Binds a host element property (e.g. CSS class valid) to directive/component property (e.g. isValid).
 
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@HostListener('click', ['$event']) onClick(e) {...}`|`@HostListener('click', ['$event'])`
+syntax(js):
+`ng.core.HostListener('click', ['$event'], onClick(e) {...}, myComponent);`|`ng.core.HostListener('click', ['$event'], onClick(e)`|`);`
 description:
 Subscribes to a host element event (e.g. click) with a directive/component method (e.g. onClick), optionally passing an argument ($event).
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@ContentChild(myPredicate) myChildComponent;`|`@ContentChild(myPredicate)`
+syntax(js):
+`ng.core.ContentChild(myPredicate, 'myChildComponent', myComponent);`|`ng.core.ContentChild(myPredicate,`|`);`
 description:
 Binds the first result of the component content query (myPredicate) to the myChildComponent property of the class.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@ContentChildren(myPredicate) myChildComponents;`|`@ContentChildren(myPredicate)`
+syntax(js):
+`ng.core.ContentChildren(myPredicate, 'myChildComponents', myComponent);`|`ng.core.ContentChildren(myPredicate,`|`);`
 description:
 Binds the results of the component content query (myPredicate) to the myChildComponents property of the class.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@ViewChild(myPredicate) myChildComponent;`|`@ViewChild(myPredicate)`
+syntax(js):
+`ng.core.ViewChild(myPredicate, 'myChildComponent', myComponent);`|`ng.core.ViewChild(myPredicate,`|`);`
 description:
 Binds the first result of the component view query (myPredicate) to the myChildComponent property of the class. Not available for directives.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `@ViewChildren(myPredicate) myChildComponents;`|`@ViewChildren(myPredicate)`
+syntax(js):
+`ng.core.ViewChildren(myPredicate, 'myChildComponents', myComponent);`|`ng.core.ViewChildren(myPredicate,`|`);`
 description:
 Binds the results of the component view query (myPredicate) to the myChildComponents property of the class. Not available for directives.
diff --git a/modules/angular2/docs/cheatsheet/directive-configuration.md b/modules/angular2/docs/cheatsheet/directive-configuration.md
index 27f90eb0d5e9..afe11a671cf6 100644
--- a/modules/angular2/docs/cheatsheet/directive-configuration.md
+++ b/modules/angular2/docs/cheatsheet/directive-configuration.md
@@ -2,7 +2,8 @@
 Directive configuration
 @cheatsheetIndex 5
 @description
-{@target js ts}`@Directive({ property1: value1, ... })`{@endtarget}
+{@target ts}`@Directive({ property1: value1, ... })`{@endtarget}
+{@target js}`ng.core.Directive({ property1: value1, ... }).Class({...})`{@endtarget}
 {@target dart}`@Directive(property1: value1, ...)`{@endtarget}
 
 @cheatsheetItem
@@ -15,7 +16,9 @@ Specifies a CSS selector that identifies this directive within a template. Suppo
 Does not support parent-child relationship selectors.
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `providers: [MyService, provide(...)]`|`providers:`
+syntax(js):
+`providers: [MyService, ng.core.provide(...)]`|`providers:`
 description:
 Array of dependency injection providers for this directive and its children.
diff --git a/modules/angular2/docs/cheatsheet/forms.md b/modules/angular2/docs/cheatsheet/forms.md
index 30cc0c1c5258..250cd333d9fb 100644
--- a/modules/angular2/docs/cheatsheet/forms.md
+++ b/modules/angular2/docs/cheatsheet/forms.md
@@ -2,7 +2,8 @@
 Forms
 @cheatsheetIndex 3
 @description
-{@target js ts}`import {FORM_DIRECTIVES} from 'angular2/common';`{@endtarget}
+{@target ts}`import {FORM_DIRECTIVES} from 'angular2/common';`{@endtarget}
+{@target js}Available from `ng.common.FORM_DIRECTIVES`{@endtarget}
 {@target dart}`import 'package:angular2/common.dart';`{@endtarget}
 
 @cheatsheetItem
diff --git a/modules/angular2/docs/cheatsheet/lifecycle hooks.md b/modules/angular2/docs/cheatsheet/lifecycle hooks.md
index 1ace79efe6d6..23e31fcf3ef6 100644
--- a/modules/angular2/docs/cheatsheet/lifecycle hooks.md	
+++ b/modules/angular2/docs/cheatsheet/lifecycle hooks.md	
@@ -2,11 +2,14 @@
 Directive and component change detection and lifecycle hooks
 @cheatsheetIndex 8
 @description
-(implemented as class methods)
+{@target ts dart}(implemented as class methods){@endtarget}
+{@target js}(implemented as component properties){@endtarget}
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `constructor(myService: MyService, ...) { ... }`|`constructor(myService: MyService, ...)`
+syntax(js):
+`constructor: function(MyService, ...) { ... }`|`constructor: function(MyService, ...)`
 syntax(dart):
 `MyAppComponent(MyService myService, ...) { ... }`|`MyAppComponent(MyService myService, ...)`
 description:
@@ -14,56 +17,72 @@ The class constructor is called before any other lifecycle hook. Use it to injec
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngOnChanges(changeRecord) { ... }`|`ngOnChanges(changeRecord)`
+syntax(js):
+`ngOnChanges: function(changeRecord) { ... }`|`ngOnChanges: function(changeRecord)`
 description:
 Called after every change to input properties and before processing content or child views.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngOnInit() { ... }`|`ngOnInit()`
+syntax(js):
+`ngOnInit: function() { ... }`|`ngOnInit: function()`
 description:
 Called after the constructor, initializing input properties, and the first call to ngOnChanges.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngDoCheck() { ... }`|`ngDoCheck()`
+syntax(js):
+`ngDoCheck: function() { ... }`|`ngDoCheck: function()`
 description:
 Called every time that the input properties of a component or a directive are checked. Use it to extend change detection by performing a custom check.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngAfterContentInit() { ... }`|`ngAfterContentInit()`
+syntax(js):
+`ngAfterContentInit: function() { ... }`|`ngAfterContentInit: function()`
 description:
 Called after ngOnInit when the component's or directive's content has been initialized.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngAfterContentChecked() { ... }`|`ngAfterContentChecked()`
+syntax(js):
+`ngAfterContentChecked: function() { ... }`|`ngAfterContentChecked: function()`
 description:
 Called after every check of the component's or directive's content.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngAfterViewInit() { ... }`|`ngAfterViewInit()`
+syntax(js):
+`ngAfterViewInit: function() { ... }`|`ngAfterViewInit: function()`
 description:
 Called after ngAfterContentInit when the component's view has been initialized. Applies to components only.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngAfterViewChecked() { ... }`|`ngAfterViewChecked()`
+syntax(js):
+`ngAfterViewChecked: function() { ... }`|`ngAfterViewChecked: function()`
 description:
 Called after every check of the component's view. Applies to components only.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `ngOnDestroy() { ... }`|`ngOnDestroy()`
+syntax(js):
+`ngOnDestroy: function() { ... }`|`ngOnDestroy: function()`
 description:
 Called once, before the instance is destroyed.
diff --git a/modules/angular2/docs/cheatsheet/routing.md b/modules/angular2/docs/cheatsheet/routing.md
index 7787e5243c7d..4a265897eee5 100644
--- a/modules/angular2/docs/cheatsheet/routing.md
+++ b/modules/angular2/docs/cheatsheet/routing.md
@@ -2,18 +2,27 @@
 Routing and navigation
 @cheatsheetIndex 10
 @description
-{@target js ts}`import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, ...} from 'angular2/router';`{@endtarget}
+{@target ts}`import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, ...} from 'angular2/router';`{@endtarget}
+{@target js}Available from the `ng.router` namespace{@endtarget}
 {@target dart}`import 'package:angular2/router.dart';`{@endtarget}
 
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `@RouteConfig([
   { path: '/:myParam', component: MyComponent, as: 'MyCmp' },
   { path: '/staticPath', component: ..., as: ...},
   { path: '/*wildCardParam', component: ..., as: ...}
 ])
 class MyComponent() {}`|`@RouteConfig`
+syntax(js):
+`var MyComponent = ng.router.RouteConfig([
+  { path: '/:myParam', component: MyComponent, as: 'MyCmp' },
+  { path: '/staticPath', component: ..., as: ...},
+  { path: '/*wildCardParam', component: ..., as: ...}
+]).Class({
+  constructor: function() {}
+});`|`ng.router.RouteConfig`
 syntax(dart):
 `@RouteConfig(const [
   const Route(path: '/:myParam', component: MyComponent, name: 'MyCmp' ),
@@ -37,8 +46,10 @@ Creates a link to a different view based on a route instruction consisting of a
 
 
 @cheatsheetItem
-syntax(js ts):
+syntax(ts):
 `@CanActivate(() => { ... })class MyComponent() {}`|`@CanActivate`
+syntax(js):
+`var MyComponent = ng.router.CanActivate(function() { ... }).Component({...}).Class({constructor: ...});`|`ng.router.CanActivate(function() { ... })`
 syntax(dart):
 `@CanActivate(() => ...)class MyComponent() {}`|`@CanActivate`
 description:
@@ -46,35 +57,45 @@ A component decorator defining a function that the router should call first to d
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `routerOnActivate(nextInstruction, prevInstruction) { ... }`|`routerOnActivate`
+syntax(js):
+`routerOnActivate: function(nextInstruction, prevInstruction) { ... }`|`routerOnActivate`
 description:
 After navigating to a component, the router calls the component's routerOnActivate method (if defined).
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `routerCanReuse(nextInstruction, prevInstruction) { ... }`|`routerCanReuse`
+syntax(js):
+`routerCanReuse: function(nextInstruction, prevInstruction) { ... }`|`routerCanReuse`
 description:
 The router calls a component's routerCanReuse method (if defined) to determine whether to reuse the instance or destroy it and create a new instance. Should return a boolean or a {@target js ts}promise{@endtarget}{@target dart}future{@endtarget}.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `routerOnReuse(nextInstruction, prevInstruction) { ... }`|`routerOnReuse`
+syntax(js):
+`routerOnReuse: function(nextInstruction, prevInstruction) { ... }`|`routerOnReuse`
 description:
 The router calls the component's routerOnReuse method (if defined) when it re-uses a component instance.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `routerCanDeactivate(nextInstruction, prevInstruction) { ... }`|`routerCanDeactivate`
+syntax(js):
+`routerCanDeactivate: function(nextInstruction, prevInstruction) { ... }`|`routerCanDeactivate`
 description:
 The router calls the routerCanDeactivate methods (if defined) of every component that would be removed after a navigation. The navigation proceeds if and only if all such methods return true or a {@target js ts}promise that is resolved{@endtarget}{@target dart}future that completes successfully{@endtarget}.
 
 
 @cheatsheetItem
-syntax:
+syntax(ts dart):
 `routerOnDeactivate(nextInstruction, prevInstruction) { ... }`|`routerOnDeactivate`
+syntax(js):
+`routerOnDeactivate: function(nextInstruction, prevInstruction) { ... }`|`routerOnDeactivate`
 description:
 Called before the directive is removed as the result of a route change. May return a {@target js ts}promise{@endtarget}{@target dart}future{@endtarget} that pauses removing the directive until the {@target js ts}promise resolves{@endtarget}{@target dart}future completes{@endtarget}.
diff --git a/modules/angular2/docs/cheatsheet/template-syntax.md b/modules/angular2/docs/cheatsheet/template-syntax.md
index 6a8c3f8f7a91..6868f65bacd0 100644
--- a/modules/angular2/docs/cheatsheet/template-syntax.md
+++ b/modules/angular2/docs/cheatsheet/template-syntax.md
@@ -62,10 +62,10 @@ Creates a local variable `movieplayer` that provides access to the `video` eleme
 
 @cheatsheetItem
 syntax:
-`<p *my-unless="myExpression">...</p>`|`*my-unless`
+`<p *myUnless="myExpression">...</p>`|`*myUnless`
 description:
 The `*` symbol means that the current element will be turned into an embedded template. Equivalent to:
-`<template [myless]="myExpression"><p>...</p></template>`
+`<template [myUnless]="myExpression"><p>...</p></template>`
 
 @cheatsheetItem
 syntax:
diff --git a/modules/angular2/examples/common/forms/ts/validators/validators.ts b/modules/angular2/examples/common/forms/ts/validators/validators.ts
new file mode 100644
index 000000000000..6744c8b5ed92
--- /dev/null
+++ b/modules/angular2/examples/common/forms/ts/validators/validators.ts
@@ -0,0 +1,30 @@
+import {Component} from 'angular2/core';
+import {MinLengthValidator, MaxLengthValidator} from 'angular2/common';
+
+// #docregion min
+@Component({
+  selector: 'min-cmp',
+  directives: [MinLengthValidator],
+  template: `
+<form>
+  <p>Year: <input ngControl="year" minlength="2"></p>
+</form>
+`
+})
+class MinLengthTestComponent {
+}
+// #enddocregion
+
+// #docregion max
+@Component({
+  selector: 'max-cmp',
+  directives: [MaxLengthValidator],
+  template: `
+<form>
+  <p>Year: <input ngControl="year" maxlength="4"></p>
+</form>
+`
+})
+class MaxLengthTestComponent {
+}
+// #enddocregion
diff --git a/modules/angular2/examples/compiler/ts/url_resolver/url_resolver.ts b/modules/angular2/examples/compiler/ts/url_resolver/url_resolver.ts
new file mode 100644
index 000000000000..3910a38a1a82
--- /dev/null
+++ b/modules/angular2/examples/compiler/ts/url_resolver/url_resolver.ts
@@ -0,0 +1,19 @@
+import {provide} from 'angular2/core';
+import {bootstrap} from 'angular2/bootstrap';
+import {UrlResolver} from 'angular2/compiler';
+
+var MyApp;
+
+// #docregion url_resolver
+class MyUrlResolver extends UrlResolver {
+  resolve(baseUrl: string, url: string): string {
+    // Serve CSS files from a special CDN.
+    if (url.substr(-4) === '.css') {
+      return super.resolve('http://cdn.myapp.com/css/', url);
+    }
+    return super.resolve(baseUrl, url);
+  }
+}
+
+bootstrap(MyApp, [provide(UrlResolver, {useClass: MyUrlResolver})]);
+// #enddocregion
diff --git a/modules/angular2/examples/core/debug/ts/debug_element/debug_element.ts b/modules/angular2/examples/core/debug/ts/debug_element/debug_element.ts
new file mode 100644
index 000000000000..ebda75d05c34
--- /dev/null
+++ b/modules/angular2/examples/core/debug/ts/debug_element/debug_element.ts
@@ -0,0 +1,16 @@
+import {DebugElement, Scope} from 'angular2/core';
+
+var debugElement: DebugElement;
+var predicate;
+
+// #docregion scope_all
+debugElement.query(predicate, Scope.all);
+// #enddocregion
+
+// #docregion scope_light
+debugElement.query(predicate, Scope.light);
+// #enddocregion
+
+// #docregion scope_view
+debugElement.query(predicate, Scope.view);
+// #enddocregion
diff --git a/modules/angular2/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts b/modules/angular2/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts
index 78c99366f9a1..2d891111a1d1 100644
--- a/modules/angular2/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts
+++ b/modules/angular2/examples/core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts
@@ -5,7 +5,7 @@ import {bootstrap} from 'angular2/bootstrap';
 @Component({
   selector: 'lowerupper-example',
   template: `<div>
-    <label>Name: </label><input #name (keyup)="change(name.value)" type="text"></input>
+    <label>Name: </label><input #name (keyup)="change(name.value)" type="text">
     <p>In lowercase: <pre>'{{value | lowercase}}'</pre></p>
     <p>In uppercase: <pre>'{{value | uppercase}}'</pre></p>
   </div>`
diff --git a/modules/angular2/examples/core/ts/dev_mode/my_component.ts b/modules/angular2/examples/core/ts/prod_mode/my_component.ts
similarity index 100%
rename from modules/angular2/examples/core/ts/dev_mode/my_component.ts
rename to modules/angular2/examples/core/ts/prod_mode/my_component.ts
diff --git a/modules/angular2/examples/core/ts/dev_mode/dev_mode_example.ts b/modules/angular2/examples/core/ts/prod_mode/prod_mode_example.ts
similarity index 58%
rename from modules/angular2/examples/core/ts/dev_mode/dev_mode_example.ts
rename to modules/angular2/examples/core/ts/prod_mode/prod_mode_example.ts
index 0e973b98fd04..76c3e15f4afa 100644
--- a/modules/angular2/examples/core/ts/dev_mode/dev_mode_example.ts
+++ b/modules/angular2/examples/core/ts/prod_mode/prod_mode_example.ts
@@ -1,8 +1,8 @@
-// #docregion enableDevMode
-import {enableDevMode} from 'angular2/core';
+// #docregion enableProdMode
+import {enableProdMode} from 'angular2/core';
 import {bootstrap} from 'angular2/bootstrap';
 import {MyComponent} from 'my_component';
 
-enableDevMode();
+enableProdMode();
 bootstrap(MyComponent);
 // #enddocregion
diff --git a/modules/angular2/examples/platform/dom/debug/ts/by/by.ts b/modules/angular2/examples/platform/dom/debug/ts/by/by.ts
new file mode 100644
index 000000000000..58c888328cc4
--- /dev/null
+++ b/modules/angular2/examples/platform/dom/debug/ts/by/by.ts
@@ -0,0 +1,17 @@
+import {By} from 'angular2/platform/browser';
+import {DebugElement, Scope} from 'angular2/core';
+
+var debugElement: DebugElement;
+class MyDirective {}
+
+// #docregion by_all
+debugElement.query(By.all(), Scope.all);
+// #enddocregion
+
+// #docregion by_css
+debugElement.query(By.css('[attribute]'), Scope.all);
+// #enddocregion
+
+// #docregion by_directive
+debugElement.query(By.directive(MyDirective), Scope.all);
+// #enddocregion
diff --git a/modules/angular2/examples/platform/dom/debug/ts/debug_element_view_listener/providers.ts b/modules/angular2/examples/platform/dom/debug/ts/debug_element_view_listener/providers.ts
new file mode 100644
index 000000000000..b9dec70aaeac
--- /dev/null
+++ b/modules/angular2/examples/platform/dom/debug/ts/debug_element_view_listener/providers.ts
@@ -0,0 +1,10 @@
+import {Component} from 'angular2/core';
+import {bootstrap, ELEMENT_PROBE_PROVIDERS} from 'angular2/platform/browser';
+
+@Component({selector: 'my-component'})
+class MyAppComponent {
+}
+
+// #docregion providers
+bootstrap(MyAppComponent, [ELEMENT_PROBE_PROVIDERS]);
+// #enddocregion
\ No newline at end of file
diff --git a/modules/angular2/examples/testing/ts/fake_async.ts b/modules/angular2/examples/testing/ts/fake_async.ts
new file mode 100644
index 000000000000..55bb766b91af
--- /dev/null
+++ b/modules/angular2/examples/testing/ts/fake_async.ts
@@ -0,0 +1,29 @@
+import {describe, it, fakeAsync, expect, tick, clearPendingTimers} from 'angular2/testing';
+
+// #docregion basic
+describe('this test', () => {
+  it('looks async but is synchronous', <any>fakeAsync((): void => {
+       var flag = false;
+       setTimeout(() => { flag = true; }, 100);
+       expect(flag).toBe(false);
+       tick(50);
+       expect(flag).toBe(false);
+       tick(50);
+       expect(flag).toBe(true);
+     }));
+});
+// #enddocregion
+
+// #docregion pending
+describe('this test', () => {
+  it('aborts a timer', <any>fakeAsync((): void => {
+       // This timer is scheduled but doesn't need to complete for the
+       // test to pass (maybe it's a timeout for some operation).
+       // Leaving it will cause the test to fail...
+       setTimeout(() => {}, 100);
+
+       // Unless we clean it up first.
+       clearPendingTimers();
+     }));
+});
+// #enddocregion
\ No newline at end of file
diff --git a/modules/angular2/examples/testing/ts/matchers.ts b/modules/angular2/examples/testing/ts/matchers.ts
new file mode 100644
index 000000000000..f0bf7d2818dc
--- /dev/null
+++ b/modules/angular2/examples/testing/ts/matchers.ts
@@ -0,0 +1,40 @@
+import {expect} from 'angular2/testing';
+
+var value: any;
+var element: any;
+var exception: any;
+
+abstract class OtherClass {}
+class SomeClass {}
+
+// #docregion toBePromise
+expect(value).toBePromise();
+// #enddocregion
+
+// #docregion toBeAnInstanceOf
+expect(value).toBeAnInstanceOf(SomeClass);
+// #enddocregion
+
+// #docregion toHaveText
+expect(element).toHaveText('Hello world!');
+// #enddocregion
+
+// #docregion toHaveCssClass
+expect(element).toHaveCssClass('current');
+// #enddocregion
+
+// #docregion toHaveCssStyle
+expect(element).toHaveCssStyle({width: '100px', height: 'auto'});
+// #enddocregion
+
+// #docregion toContainError
+expect(exception).toContainError('Failed to load');
+// #enddocregion
+
+// #docregion toThrowErrorWith
+expect(() => { throw 'Failed to load'; }).toThrowErrorWith('Failed to load');
+// #enddocregion
+
+// #docregion toImplement
+expect(SomeClass).toImplement(OtherClass);
+// #enddocregion
diff --git a/modules/angular2/http.ts b/modules/angular2/http.ts
index 69c918d4ee63..5341e23191a0 100644
--- a/modules/angular2/http.ts
+++ b/modules/angular2/http.ts
@@ -166,6 +166,8 @@ export const HTTP_PROVIDERS: any[] = [
 ];
 
 /**
+ * See {@link HTTP_PROVIDERS} instead.
+ *
  * @deprecated
  */
 export const HTTP_BINDINGS = HTTP_PROVIDERS;
@@ -291,6 +293,8 @@ export const JSONP_PROVIDERS: any[] = [
 ];
 
 /**
+ * See {@link JSONP_PROVIDERS} instead.
+ *
  * @deprecated
  */
 export const JSON_BINDINGS = JSONP_PROVIDERS;
diff --git a/modules/angular2/manual_typings/globals-es6.d.ts b/modules/angular2/manual_typings/globals-es6.d.ts
index 43d437ad648a..b1292515c2e0 100644
--- a/modules/angular2/manual_typings/globals-es6.d.ts
+++ b/modules/angular2/manual_typings/globals-es6.d.ts
@@ -30,7 +30,6 @@ interface BrowserNodeGlobal {
   zone: Zone;
   getAngularTestability: Function;
   getAllAngularTestabilities: Function;
-  angularDevMode: boolean;
   setTimeout: Function;
   clearTimeout: Function;
   setInterval: Function;
diff --git a/modules/angular2/router.ts b/modules/angular2/router.ts
index 8d5409952dd4..4cea18950a6a 100644
--- a/modules/angular2/router.ts
+++ b/modules/angular2/router.ts
@@ -98,6 +98,8 @@ export const ROUTER_PROVIDERS: any[] = CONST_EXPR([
 ]);
 
 /**
+ * Use {@link ROUTER_PROVIDERS} instead.
+ *
  * @deprecated
  */
 export const ROUTER_BINDINGS = ROUTER_PROVIDERS;
diff --git a/modules/angular2/router/router_link_dsl.ts b/modules/angular2/router/router_link_dsl.ts
index 84bdfb6c9f3e..5f108b826f68 100644
--- a/modules/angular2/router/router_link_dsl.ts
+++ b/modules/angular2/router/router_link_dsl.ts
@@ -31,5 +31,5 @@ export {RouterLinkTransform} from 'angular2/src/router/router_link_transform';
  * <a [routerLink]="User[Modal]"> <!-- Same as <a [routerLink]="['User', ['Modal']]"> -->
  * ```
  */
-const ROUTER_LINK_DSL_PROVIDER =
-    CONST_EXPR(new Provider(TEMPLATE_TRANSFORMS, {useClass: RouterLinkTransform, multi: true}));
\ No newline at end of file
+export const ROUTER_LINK_DSL_PROVIDER =
+    CONST_EXPR(new Provider(TEMPLATE_TRANSFORMS, {useClass: RouterLinkTransform, multi: true}));
diff --git a/modules/angular2/src/common/directives/observable_list_diff.ts b/modules/angular2/src/common/directives/observable_list_diff.ts
index 08d07c500770..ee99cf404765 100644
--- a/modules/angular2/src/common/directives/observable_list_diff.ts
+++ b/modules/angular2/src/common/directives/observable_list_diff.ts
@@ -2,4 +2,9 @@
 
 // I need to be here to make TypeScript think this is a module.
 import {} from 'angular2/src/facade/lang';
+
+/**
+ * This module exists in Dart, but not in Typescript. This exported symbol
+ * is only here to help Typescript think this is a module.
+ */
 export var workaround_empty_observable_list_diff: any;
diff --git a/modules/angular2/src/common/forms/directives/control_value_accessor.ts b/modules/angular2/src/common/forms/directives/control_value_accessor.ts
index 33a907ba62a8..90820f7d7071 100644
--- a/modules/angular2/src/common/forms/directives/control_value_accessor.ts
+++ b/modules/angular2/src/common/forms/directives/control_value_accessor.ts
@@ -26,4 +26,9 @@ export interface ControlValueAccessor {
   registerOnTouched(fn: any): void;
 }
 
+/**
+ * Used to provide a {@link ControlValueAccessor} for form controls.
+ *
+ * See {@link DefaultValueAccessor} for how to implement one.
+ */
 export const NG_VALUE_ACCESSOR: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValueAccessor"));
\ No newline at end of file
diff --git a/modules/angular2/src/common/forms/directives/ng_control_status.ts b/modules/angular2/src/common/forms/directives/ng_control_status.ts
index 39f07e6ea475..38b7ccdabb4c 100644
--- a/modules/angular2/src/common/forms/directives/ng_control_status.ts
+++ b/modules/angular2/src/common/forms/directives/ng_control_status.ts
@@ -2,6 +2,10 @@ import {Directive, Self} from 'angular2/core';
 import {NgControl} from './ng_control';
 import {isBlank, isPresent} from 'angular2/src/facade/lang';
 
+/**
+ * Directive automatically applied to Angular forms that sets CSS classes
+ * based on control status (valid/invalid/dirty/etc).
+ */
 @Directive({
   selector: '[ngControl],[ngModel],[ngFormControl]',
   host: {
diff --git a/modules/angular2/src/common/forms/directives/validators.ts b/modules/angular2/src/common/forms/directives/validators.ts
index 53ca2ae56aaf..dcb3189bccdc 100644
--- a/modules/angular2/src/common/forms/directives/validators.ts
+++ b/modules/angular2/src/common/forms/directives/validators.ts
@@ -45,8 +45,20 @@ const REQUIRED_VALIDATOR =
 export class RequiredValidator {
 }
 
+/**
+ * Provivder which adds {@link MinLengthValidator} to {@link NG_VALIDATORS}.
+ *
+ * ## Example:
+ *
+ * {@example common/forms/ts/validators/validators.ts region='min'}
+ */
 const MIN_LENGTH_VALIDATOR = CONST_EXPR(
     new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MinLengthValidator), multi: true}));
+
+/**
+ * A directive which installs the {@link MinLengthValidator} for any `ngControl`,
+ * `ngFormControl`, or control with `ngModel` that also has a `minlength` attribute.
+ */
 @Directive({
   selector: '[minlength][ngControl],[minlength][ngFormControl],[minlength][ngModel]',
   providers: [MIN_LENGTH_VALIDATOR]
@@ -61,8 +73,20 @@ export class MinLengthValidator implements Validator {
   validate(c: Control): {[key: string]: any} { return this._validator(c); }
 }
 
+/**
+ * Provider which adds {@link MaxLengthValidator} to {@link NG_VALIDATORS}.
+ *
+ * ## Example:
+ *
+ * {@example common/forms/ts/validators/validators.ts region='max'}
+ */
 const MAX_LENGTH_VALIDATOR = CONST_EXPR(
     new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MaxLengthValidator), multi: true}));
+
+/**
+ * A directive which installs the {@link MaxLengthValidator} for any `ngControl, `ngFormControl`,
+ * or control with `ngModel` that also has a `maxlength` attribute.
+ */
 @Directive({
   selector: '[maxlength][ngControl],[maxlength][ngFormControl],[maxlength][ngModel]',
   providers: [MAX_LENGTH_VALIDATOR]
diff --git a/modules/angular2/src/common/forms/form_builder.ts b/modules/angular2/src/common/forms/form_builder.ts
index 11f415b33501..b6ef3fdc7c9a 100644
--- a/modules/angular2/src/common/forms/form_builder.ts
+++ b/modules/angular2/src/common/forms/form_builder.ts
@@ -119,6 +119,8 @@ export class FormBuilder {
 export const FORM_PROVIDERS: Type[] = CONST_EXPR([FormBuilder]);
 
 /**
+ * See {@link FORM_PROVIDERS} instead.
+ *
  * @deprecated
  */
 export const FORM_BINDINGS = FORM_PROVIDERS;
diff --git a/modules/angular2/src/common/forms/model.ts b/modules/angular2/src/common/forms/model.ts
index ffcba4f208a6..59b735bed778 100644
--- a/modules/angular2/src/common/forms/model.ts
+++ b/modules/angular2/src/common/forms/model.ts
@@ -14,7 +14,7 @@ export const VALID = "VALID";
 export const INVALID = "INVALID";
 
 /**
- * Indicates that a Control is pending, i.e. that async validation is occuring and
+ * Indicates that a Control is pending, i.e. that async validation is occurring and
  * errors are not yet available for the input value.
  */
 export const PENDING = "PENDING";
diff --git a/modules/angular2/src/common/forms/validators.ts b/modules/angular2/src/common/forms/validators.ts
index ee8bc60dad3c..f9cdc1c64762 100644
--- a/modules/angular2/src/common/forms/validators.ts
+++ b/modules/angular2/src/common/forms/validators.ts
@@ -14,7 +14,6 @@ import * as modelModule from './model';
  * ### Example
  *
  * {@example core/forms/ts/ng_validators/ng_validators.ts region='ng_validators'}
- * ```
  */
 export const NG_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValidators"));
 
@@ -32,8 +31,7 @@ export const NG_ASYNC_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgAs
  * Provides a set of validators used by form controls.
  *
  * A validator is a function that processes a {@link Control} or collection of
- * controls and returns a {@link StringMap} of errors. A null map means that
- * validation has passed.
+ * controls and returns a map of errors. A null map means that validation has passed.
  *
  * ### Example
  *
diff --git a/modules/angular2/src/common/pipes.ts b/modules/angular2/src/common/pipes.ts
index 93950e9a9d08..7c7a25c1ef26 100644
--- a/modules/angular2/src/common/pipes.ts
+++ b/modules/angular2/src/common/pipes.ts
@@ -20,6 +20,13 @@ export {LowerCasePipe} from './pipes/lowercase_pipe';
 export {NumberPipe, DecimalPipe, PercentPipe, CurrencyPipe} from './pipes/number_pipe';
 export {UpperCasePipe} from './pipes/uppercase_pipe';
 
+/**
+ * A collection of Angular core pipes that are likely to be used in each and every
+ * application.
+ *
+ * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`
+ * property of the `@Component` or `@View` decorators.
+ */
 export const COMMON_PIPES = CONST_EXPR([
   AsyncPipe,
   UpperCasePipe,
diff --git a/modules/angular2/src/common/pipes/common_pipes.ts b/modules/angular2/src/common/pipes/common_pipes.ts
index 7773c9332f00..ac6dc36c099a 100644
--- a/modules/angular2/src/common/pipes/common_pipes.ts
+++ b/modules/angular2/src/common/pipes/common_pipes.ts
@@ -12,6 +12,13 @@ import {DatePipe} from './date_pipe';
 import {DecimalPipe, PercentPipe, CurrencyPipe} from './number_pipe';
 import {CONST_EXPR} from 'angular2/src/facade/lang';
 
+/**
+ * A collection of Angular core pipes that are likely to be used in each and every
+ * application.
+ *
+ * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`
+ * property of the `@Component` or `@View` decorators.
+ */
 export const COMMON_PIPES = CONST_EXPR([
   AsyncPipe,
   UpperCasePipe,
diff --git a/modules/angular2/src/compiler/compiler.ts b/modules/angular2/src/compiler/compiler.ts
index 76a112f8798e..c35bc9104c7d 100644
--- a/modules/angular2/src/compiler/compiler.ts
+++ b/modules/angular2/src/compiler/compiler.ts
@@ -31,6 +31,10 @@ function _createChangeDetectorGenConfig() {
   return new ChangeDetectorGenConfig(assertionsEnabled(), false, true);
 }
 
+/**
+ * A set of providers that provide `RuntimeCompiler` and its dependencies to use for
+ * template compilation.
+ */
 export const COMPILER_PROVIDERS: Array<Type | Provider | any[]> = CONST_EXPR([
   Lexer,
   Parser,
diff --git a/modules/angular2/src/compiler/directive_metadata.ts b/modules/angular2/src/compiler/directive_metadata.ts
index 5033a183cbeb..f82f6b031a37 100644
--- a/modules/angular2/src/compiler/directive_metadata.ts
+++ b/modules/angular2/src/compiler/directive_metadata.ts
@@ -21,6 +21,9 @@ import {LifecycleHooks, LIFECYCLE_HOOKS_VALUES} from 'angular2/src/core/linker/i
 // group 2: "event" from "(event)"
 var HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))$/g;
 
+/**
+ * Metadata regarding compilation of a type.
+ */
 export class CompileTypeMetadata {
   runtime: Type;
   name: string;
@@ -49,6 +52,9 @@ export class CompileTypeMetadata {
   }
 }
 
+/**
+ * Metadata regarding compilation of a template.
+ */
 export class CompileTemplateMetadata {
   encapsulation: ViewEncapsulation;
   template: string;
@@ -98,6 +104,9 @@ export class CompileTemplateMetadata {
   }
 }
 
+/**
+ * Metadata regarding compilation of a directive.
+ */
 export class CompileDirectiveMetadata {
   static create({type, isComponent, dynamicLoadable, selector, exportAs, changeDetection, inputs,
                  outputs, host, lifecycleHooks, template}: {
@@ -250,6 +259,9 @@ export class CompileDirectiveMetadata {
   }
 }
 
+/**
+ * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
+ */
 export function createHostComponentMeta(componentType: CompileTypeMetadata,
                                         componentSelector: string): CompileDirectiveMetadata {
   var template = CssSelector.parse(componentSelector)[0].getMatchingElementTemplate();
diff --git a/modules/angular2/src/compiler/runtime_metadata.ts b/modules/angular2/src/compiler/runtime_metadata.ts
index 2f7951a55388..1fceb0e859d0 100644
--- a/modules/angular2/src/compiler/runtime_metadata.ts
+++ b/modules/angular2/src/compiler/runtime_metadata.ts
@@ -32,12 +32,13 @@ export class RuntimeMetadataResolver {
     var meta = this._cache.get(directiveType);
     if (isBlank(meta)) {
       var dirMeta = this._directiveResolver.resolve(directiveType);
-      var moduleUrl = calcModuleUrl(directiveType, dirMeta);
+      var moduleUrl = null;
       var templateMeta = null;
       var changeDetectionStrategy = null;
 
       if (dirMeta instanceof md.ComponentMetadata) {
         var cmpMeta = <md.ComponentMetadata>dirMeta;
+        moduleUrl = calcModuleUrl(directiveType, cmpMeta);
         var viewMeta = this._viewResolver.resolve(directiveType);
         templateMeta = new cpl.CompileTemplateMetadata({
           encapsulation: viewMeta.encapsulation,
@@ -107,8 +108,8 @@ function isValidDirective(value: Type): boolean {
   return isPresent(value) && (value instanceof Type);
 }
 
-function calcModuleUrl(type: Type, dirMeta: md.DirectiveMetadata): string {
-  var moduleId = dirMeta.moduleId;
+function calcModuleUrl(type: Type, cmpMetadata: md.ComponentMetadata): string {
+  var moduleId = cmpMetadata.moduleId;
   if (isPresent(moduleId)) {
     var scheme = getUrlScheme(moduleId);
     return isPresent(scheme) && scheme.length > 0 ? moduleId :
diff --git a/modules/angular2/src/compiler/shadow_css.ts b/modules/angular2/src/compiler/shadow_css.ts
index f85c4f169cd7..8c8c48ed82fb 100644
--- a/modules/angular2/src/compiler/shadow_css.ts
+++ b/modules/angular2/src/compiler/shadow_css.ts
@@ -52,7 +52,7 @@ import {
     }
 
   * encapsultion: Styles defined within ShadowDOM, apply only to
-  dom inside the ShadowDOM. Polymer uses one of two techniques to imlement
+  dom inside the ShadowDOM. Polymer uses one of two techniques to implement
   this feature.
 
   By default, rules are prefixed with the host element tag name
diff --git a/modules/angular2/src/compiler/source_module.ts b/modules/angular2/src/compiler/source_module.ts
index 4a5c8be44dff..49dc23a9bf6e 100644
--- a/modules/angular2/src/compiler/source_module.ts
+++ b/modules/angular2/src/compiler/source_module.ts
@@ -6,6 +6,9 @@ export function moduleRef(moduleUrl): string {
   return `#MODULE[${moduleUrl}]`;
 }
 
+/**
+ * Represents generated source code with module references. Internal to the Angular compiler.
+ */
 export class SourceModule {
   constructor(public moduleUrl: string, public sourceWithModuleRefs: string) {}
 
@@ -39,6 +42,9 @@ export class SourceExpressions {
   constructor(public declarations: string[], public expressions: string[]) {}
 }
 
+/**
+ * Represents generated source code with imports. Internal to the Angular compiler.
+ */
 export class SourceWithImports {
   constructor(public source: string, public imports: string[][]) {}
 }
diff --git a/modules/angular2/src/compiler/template_ast.ts b/modules/angular2/src/compiler/template_ast.ts
index 8c31180f969b..1b79d32be5a2 100644
--- a/modules/angular2/src/compiler/template_ast.ts
+++ b/modules/angular2/src/compiler/template_ast.ts
@@ -3,17 +3,33 @@ import {isPresent} from 'angular2/src/facade/lang';
 import {CompileDirectiveMetadata} from './directive_metadata';
 import {ParseSourceSpan} from './parse_util';
 
+/**
+ * An Abstract Syntax Tree node representing part of a parsed Angular template.
+ */
 export interface TemplateAst {
+  /**
+   * The source span from which this node was parsed.
+   */
   sourceSpan: ParseSourceSpan;
+
+  /**
+   * Visit this node and possibly transform it.
+   */
   visit(visitor: TemplateAstVisitor, context: any): any;
 }
 
+/**
+ * A segment of text within the template.
+ */
 export class TextAst implements TemplateAst {
   constructor(public value: string, public ngContentIndex: number,
               public sourceSpan: ParseSourceSpan) {}
   visit(visitor: TemplateAstVisitor, context: any): any { return visitor.visitText(this, context); }
 }
 
+/**
+ * A bound expression within the text of a template.
+ */
 export class BoundTextAst implements TemplateAst {
   constructor(public value: AST, public ngContentIndex: number,
               public sourceSpan: ParseSourceSpan) {}
@@ -22,11 +38,17 @@ export class BoundTextAst implements TemplateAst {
   }
 }
 
+/**
+ * A plain attribute on an element.
+ */
 export class AttrAst implements TemplateAst {
   constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
   visit(visitor: TemplateAstVisitor, context: any): any { return visitor.visitAttr(this, context); }
 }
 
+/**
+ * A binding for an element property (e.g. `[property]="expression"`).
+ */
 export class BoundElementPropertyAst implements TemplateAst {
   constructor(public name: string, public type: PropertyBindingType, public value: AST,
               public unit: string, public sourceSpan: ParseSourceSpan) {}
@@ -35,6 +57,9 @@ export class BoundElementPropertyAst implements TemplateAst {
   }
 }
 
+/**
+ * A binding for an element event (e.g. `(event)="handler()"`).
+ */
 export class BoundEventAst implements TemplateAst {
   constructor(public name: string, public target: string, public handler: AST,
               public sourceSpan: ParseSourceSpan) {}
@@ -50,6 +75,9 @@ export class BoundEventAst implements TemplateAst {
   }
 }
 
+/**
+ * A variable declaration on an element (e.g. `#var="expression"`).
+ */
 export class VariableAst implements TemplateAst {
   constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
   visit(visitor: TemplateAstVisitor, context: any): any {
@@ -57,6 +85,9 @@ export class VariableAst implements TemplateAst {
   }
 }
 
+/**
+ * An element declaration in a template.
+ */
 export class ElementAst implements TemplateAst {
   constructor(public name: string, public attrs: AttrAst[],
               public inputs: BoundElementPropertyAst[], public outputs: BoundEventAst[],
@@ -67,11 +98,17 @@ export class ElementAst implements TemplateAst {
     return visitor.visitElement(this, context);
   }
 
+  /**
+   * Whether the element has any active bindings (inputs, outputs, vars, or directives).
+   */
   isBound(): boolean {
     return (this.inputs.length > 0 || this.outputs.length > 0 || this.exportAsVars.length > 0 ||
             this.directives.length > 0);
   }
 
+  /**
+   * Get the component associated with this element, if any.
+   */
   getComponent(): CompileDirectiveMetadata {
     return this.directives.length > 0 && this.directives[0].directive.isComponent ?
                this.directives[0].directive :
@@ -79,6 +116,9 @@ export class ElementAst implements TemplateAst {
   }
 }
 
+/**
+ * A `<template>` element included in an Angular template.
+ */
 export class EmbeddedTemplateAst implements TemplateAst {
   constructor(public attrs: AttrAst[], public outputs: BoundEventAst[], public vars: VariableAst[],
               public directives: DirectiveAst[], public children: TemplateAst[],
@@ -88,6 +128,9 @@ export class EmbeddedTemplateAst implements TemplateAst {
   }
 }
 
+/**
+ * A directive property with a bound value (e.g. `*ngIf="condition").
+ */
 export class BoundDirectivePropertyAst implements TemplateAst {
   constructor(public directiveName: string, public templateName: string, public value: AST,
               public sourceSpan: ParseSourceSpan) {}
@@ -96,6 +139,9 @@ export class BoundDirectivePropertyAst implements TemplateAst {
   }
 }
 
+/**
+ * A directive declared on an element.
+ */
 export class DirectiveAst implements TemplateAst {
   constructor(public directive: CompileDirectiveMetadata,
               public inputs: BoundDirectivePropertyAst[],
@@ -106,6 +152,9 @@ export class DirectiveAst implements TemplateAst {
   }
 }
 
+/**
+ * Position where content is to be projected (instance of `<ng-content>` in a template).
+ */
 export class NgContentAst implements TemplateAst {
   constructor(public index: number, public ngContentIndex: number,
               public sourceSpan: ParseSourceSpan) {}
@@ -114,13 +163,35 @@ export class NgContentAst implements TemplateAst {
   }
 }
 
+/**
+ * Enumeration of types of property bindings.
+ */
 export enum PropertyBindingType {
+
+  /**
+   * A normal binding to a property (e.g. `[property]="expression"`).
+   */
   Property,
+
+  /**
+   * A binding to an element attribute (e.g. `[attr.name]="expression"`).
+   */
   Attribute,
+
+  /**
+   * A binding to a CSS class (e.g. `[class.name]="condition"`).
+   */
   Class,
+
+  /**
+   * A binding to a style rule (e.g. `[style.rule]="expression"`).
+   */
   Style
 }
 
+/**
+ * A visitor for {@link TemplateAst} trees that will process each node.
+ */
 export interface TemplateAstVisitor {
   visitNgContent(ast: NgContentAst, context: any): any;
   visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any;
@@ -135,7 +206,9 @@ export interface TemplateAstVisitor {
   visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any;
 }
 
-
+/**
+ * Visit every node in a list of {@link TemplateAst}s with the given {@link TemplateAstVisitor}.
+ */
 export function templateVisitAll(visitor: TemplateAstVisitor, asts: TemplateAst[],
                                  context: any = null): any[] {
   var result = [];
diff --git a/modules/angular2/src/compiler/template_compiler.ts b/modules/angular2/src/compiler/template_compiler.ts
index 0da118660249..06b630000049 100644
--- a/modules/angular2/src/compiler/template_compiler.ts
+++ b/modules/angular2/src/compiler/template_compiler.ts
@@ -32,6 +32,11 @@ import {
   MODULE_SUFFIX
 } from './util';
 
+/**
+ * An internal module of the Angular compiler that begins with component types,
+ * extracts templates, and eventually produces a compiled version of the component
+ * ready for linking into an application.
+ */
 @Injectable()
 export class TemplateCompiler {
   private _hostCacheKeys = new Map<Type, any>();
diff --git a/modules/angular2/src/compiler/template_parser.ts b/modules/angular2/src/compiler/template_parser.ts
index 32a69f58b132..c93307378b59 100644
--- a/modules/angular2/src/compiler/template_parser.ts
+++ b/modules/angular2/src/compiler/template_parser.ts
@@ -51,8 +51,8 @@ import {splitAtColon} from './util';
 // Group 3 = "on-"
 // Group 4 = "bindon-"
 // Group 5 = the identifier after "bind-", "var-/#", or "on-"
-// Group 6 = idenitifer inside [()]
-// Group 7 = idenitifer inside []
+// Group 6 = identifer inside [()]
+// Group 7 = identifer inside []
 // Group 8 = identifier inside ()
 var BIND_NAME_REGEXP =
     /^(?:(?:(?:(bind-)|(var-|#)|(on-)|(bindon-))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/g;
@@ -69,6 +69,13 @@ const STYLE_PREFIX = 'style';
 
 var TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];
 
+/**
+ * Provides an array of {@link TemplateAstVisitor}s which will be used to transform
+ * parsed templates before compilation is invoked, allowing custom expression syntax
+ * and other advanced transformations.
+ *
+ * This is currently an internal-only feature and not meant for general use.
+ */
 export const TEMPLATE_TRANSFORMS = CONST_EXPR(new OpaqueToken('TemplateTransforms'));
 
 export class TemplateParseError extends ParseError {
@@ -203,13 +210,13 @@ class TemplateParseVisitor implements HtmlAstVisitor {
     var attrs = [];
 
     element.attrs.forEach(attr => {
-      matchableAttrs.push([attr.name, attr.value]);
       var hasBinding = this._parseAttr(attr, matchableAttrs, elementOrDirectiveProps, events, vars);
       var hasTemplateBinding = this._parseInlineTemplateBinding(
           attr, templateMatchableAttrs, templateElementOrDirectiveProps, templateVars);
       if (!hasBinding && !hasTemplateBinding) {
         // don't include the bindings as attributes as well in the AST
         attrs.push(this.visitAttr(attr, null));
+        matchableAttrs.push([attr.name, attr.value]);
       }
       if (hasTemplateBinding) {
         hasInlineTemplates = true;
diff --git a/modules/angular2/src/compiler/url_resolver.ts b/modules/angular2/src/compiler/url_resolver.ts
index 7c914f53482b..9174f8ddfb9e 100644
--- a/modules/angular2/src/compiler/url_resolver.ts
+++ b/modules/angular2/src/compiler/url_resolver.ts
@@ -11,18 +11,28 @@ import {ListWrapper} from 'angular2/src/facade/collection';
 import {PACKAGE_ROOT_URL} from 'angular2/src/core/application_tokens';
 import {Provider} from 'angular2/src/core/di';
 
+/**
+ * Create a {@link UrlResolver} with no package prefix.
+ */
 export function createWithoutPackagePrefix(): UrlResolver {
   return new UrlResolver();
 }
 
+/**
+ * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
+ */
 export var DEFAULT_PACKAGE_URL_PROVIDER = new Provider(PACKAGE_ROOT_URL, {useValue: "/"});
 
 /**
  * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
  *
- * This interface can be overridden by the application developer to create custom behavior.
+ * This class can be overridden by the application developer to create custom behavior.
  *
  * See {@link Compiler}
+ *
+ * ## Example
+ *
+ * {@example compiler/ts/url_resolver/url_resolver.ts region='url_resolver'}
  */
 @Injectable()
 export class UrlResolver {
@@ -58,6 +68,9 @@ export class UrlResolver {
   }
 }
 
+/**
+ * Extract the scheme of a URL.
+ */
 export function getUrlScheme(url: string): string {
   var match = _split(url);
   return (match && match[_ComponentIndex.Scheme]) || "";
diff --git a/modules/angular2/src/compiler/util.ts b/modules/angular2/src/compiler/util.ts
index 2c2879f97696..ca0c6e8005ae 100644
--- a/modules/angular2/src/compiler/util.ts
+++ b/modules/angular2/src/compiler/util.ts
@@ -73,7 +73,7 @@ export function codeGenToString(expr: string): string {
   if (IS_DART) {
     return `'\${${expr}}'`;
   } else {
-    // JS automatically convets to string...
+    // JS automatically converts to string...
     return expr;
   }
 }
diff --git a/modules/angular2/src/compiler/xhr.ts b/modules/angular2/src/compiler/xhr.ts
index 43253a729500..6eb5d6a6048c 100644
--- a/modules/angular2/src/compiler/xhr.ts
+++ b/modules/angular2/src/compiler/xhr.ts
@@ -1,6 +1,10 @@
 import {Promise} from 'angular2/src/facade/async';
 
 // TODO: vsavkin rename it into TemplateLoader
+/**
+ * An interface for retrieving documents by URL that the compiler uses
+ * to load templates.
+ */
 export class XHR {
   get(url: string): Promise<string> { return null; }
 }
diff --git a/modules/angular2/src/compiler/xhr_mock.ts b/modules/angular2/src/compiler/xhr_mock.ts
index 7c92d8111041..44f715fb0dba 100644
--- a/modules/angular2/src/compiler/xhr_mock.ts
+++ b/modules/angular2/src/compiler/xhr_mock.ts
@@ -4,6 +4,10 @@ import {isBlank, isPresent, normalizeBlank} from 'angular2/src/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
 import {PromiseCompleter, PromiseWrapper, Promise} from 'angular2/src/facade/async';
 
+/**
+ * A mock implementation of {@link XHR} that allows outgoing requests to be mocked
+ * and responded to within a single test, without going to the network.
+ */
 export class MockXHR extends XHR {
   private _expectations: _Expectation[] = [];
   private _definitions = new Map<string, string>();
@@ -15,13 +19,30 @@ export class MockXHR extends XHR {
     return request.getPromise();
   }
 
+  /**
+   * Add an expectation for the given URL. Incoming requests will be checked against
+   * the next expectation (in FIFO order). The `verifyNoOutstandingExpectations` method
+   * can be used to check if any expectations have not yet been met.
+   *
+   * The response given will be returned if the expectation matches.
+   */
   expect(url: string, response: string) {
     var expectation = new _Expectation(url, response);
     this._expectations.push(expectation);
   }
 
+  /**
+   * Add a definition for the given URL to return the given response. Unlike expectations,
+   * definitions have no order and will satisfy any matching request at any time. Also
+   * unlike expectations, unused definitions do not cause `verifyNoOutstandingExpectations`
+   * to return an error.
+   */
   when(url: string, response: string) { this._definitions.set(url, response); }
 
+  /**
+   * Process pending requests and verify there are no outstanding expectations. Also fails
+   * if no requests are pending.
+   */
   flush() {
     if (this._requests.length === 0) {
       throw new BaseException('No pending requests to flush');
@@ -34,6 +55,9 @@ export class MockXHR extends XHR {
     this.verifyNoOutstandingExpectations();
   }
 
+  /**
+   * Throw an exception if any expectations have not been satisfied.
+   */
   verifyNoOutstandingExpectations() {
     if (this._expectations.length === 0) return;
 
diff --git a/modules/angular2/src/core/application_ref.ts b/modules/angular2/src/core/application_ref.ts
index bb01360f8afb..426c56853f86 100644
--- a/modules/angular2/src/core/application_ref.ts
+++ b/modules/angular2/src/core/application_ref.ts
@@ -34,9 +34,10 @@ import {
   unimplemented
 } from 'angular2/src/facade/exceptions';
 import {internalView} from 'angular2/src/core/linker/view_ref';
+import {Console} from 'angular2/src/core/console';
 import {wtfLeave, wtfCreateScope, WtfScopeFn} from './profile/profile';
 import {ChangeDetectorRef} from 'angular2/src/core/change_detection/change_detector_ref';
-import {lockDevMode} from 'angular2/src/facade/lang';
+import {lockMode} from 'angular2/src/facade/lang';
 
 /**
  * Construct providers specific to an individual root component.
@@ -98,7 +99,7 @@ var _platformProviders: any[];
  * provides, Angular will throw an exception.
  */
 export function platform(providers?: Array<Type | Provider | any[]>): PlatformRef {
-  lockDevMode();
+  lockMode();
   if (isPresent(_platform)) {
     if (ListWrapper.equals(_platformProviders, providers)) {
       return _platform;
@@ -425,7 +426,15 @@ export class ApplicationRef_ extends ApplicationRef {
         completer.reject(e, e.stack);
       }
     });
-    return completer.promise;
+    return completer.promise.then(_ => {
+      let c = this._injector.get(Console);
+      let modeDescription =
+          assertionsEnabled() ?
+              "in the development mode. Call enableProdMode() to enable the production mode." :
+              "in the production mode. Call enableDevMode() to enable the development mode.";
+      c.log(`Angular 2 is running ${modeDescription}`);
+      return _;
+    });
   }
 
   /** @internal */
diff --git a/modules/angular2/src/core/change_detection/change_detection_util.ts b/modules/angular2/src/core/change_detection/change_detection_util.ts
index 8d65100077f7..fd99a44fa851 100644
--- a/modules/angular2/src/core/change_detection/change_detection_util.ts
+++ b/modules/angular2/src/core/change_detection/change_detection_util.ts
@@ -54,10 +54,15 @@ var _wrappedValues = [
 
 var _wrappedIndex = 0;
 
-
+/**
+ * Represents a basic change from a previous to a new value.
+ */
 export class SimpleChange {
   constructor(public previousValue: any, public currentValue: any) {}
 
+  /**
+   * Check whether the new value is the first value assigned.
+   */
   isFirstChange(): boolean { return this.previousValue === ChangeDetectionUtil.uninitialized; }
 }
 
diff --git a/modules/angular2/src/core/change_detection/change_detector_ref.ts b/modules/angular2/src/core/change_detection/change_detector_ref.ts
index cee17767c567..e128dcaac2bc 100644
--- a/modules/angular2/src/core/change_detection/change_detector_ref.ts
+++ b/modules/angular2/src/core/change_detection/change_detector_ref.ts
@@ -122,7 +122,7 @@ export abstract class ChangeDetectorRef {
    * check
    * every five seconds.
    *
-   * See {@link detach} for more information.
+   * See {@link ChangeDetectorRef#detach} for more information.
    */
   abstract detectChanges(): void;
 
diff --git a/modules/angular2/src/core/change_detection/constants.ts b/modules/angular2/src/core/change_detection/constants.ts
index de23c926675f..e28f89e55904 100644
--- a/modules/angular2/src/core/change_detection/constants.ts
+++ b/modules/angular2/src/core/change_detection/constants.ts
@@ -1,5 +1,8 @@
 import {StringWrapper, normalizeBool, isBlank} from 'angular2/src/facade/lang';
 
+/**
+ * Describes the current state of the change detector.
+ */
 export enum ChangeDetectorState {
   /**
    * `NeverChecked` means that the change detector has not been checked yet, and
@@ -21,6 +24,10 @@ export enum ChangeDetectorState {
   Errored
 }
 
+/**
+ * Describes within the change detector which strategy will be used the next time change
+ * detection is triggered.
+ */
 export enum ChangeDetectionStrategy {
   /**
    * `CheckedOnce` means that after calling detectChanges the mode of the change detector
@@ -62,6 +69,9 @@ export enum ChangeDetectionStrategy {
   OnPushObserve
 }
 
+/**
+ * List of possible {@link ChangeDetectionStrategy} values.
+ */
 export var CHANGE_DETECTION_STRATEGY_VALUES = [
   ChangeDetectionStrategy.CheckOnce,
   ChangeDetectionStrategy.Checked,
@@ -72,6 +82,9 @@ export var CHANGE_DETECTION_STRATEGY_VALUES = [
   ChangeDetectionStrategy.OnPushObserve
 ];
 
+/**
+ * List of possible {@link ChangeDetectorState} values.
+ */
 export var CHANGE_DETECTOR_STATE_VALUES = [
   ChangeDetectorState.NeverChecked,
   ChangeDetectorState.CheckedBefore,
diff --git a/modules/angular2/src/core/change_detection/differs/iterable_differs.ts b/modules/angular2/src/core/change_detection/differs/iterable_differs.ts
index c6a69084d914..076ac40e582d 100644
--- a/modules/angular2/src/core/change_detection/differs/iterable_differs.ts
+++ b/modules/angular2/src/core/change_detection/differs/iterable_differs.ts
@@ -4,6 +4,10 @@ import {ListWrapper} from 'angular2/src/facade/collection';
 import {ChangeDetectorRef} from '../change_detector_ref';
 import {Provider, SkipSelfMetadata, OptionalMetadata, Injectable} from 'angular2/src/core/di';
 
+/**
+ * A strategy for tracking changes over time to an iterable. Used for {@link NgFor} to
+ * respond to changes in an iterable by effecting equivalent changes in the DOM.
+ */
 export interface IterableDiffer {
   diff(object: Object): any;
   onDestroy();
diff --git a/modules/angular2/src/core/change_detection/differs/keyvalue_differs.ts b/modules/angular2/src/core/change_detection/differs/keyvalue_differs.ts
index 3c7d24854153..83430ca4eb72 100644
--- a/modules/angular2/src/core/change_detection/differs/keyvalue_differs.ts
+++ b/modules/angular2/src/core/change_detection/differs/keyvalue_differs.ts
@@ -4,6 +4,9 @@ import {ListWrapper} from 'angular2/src/facade/collection';
 import {ChangeDetectorRef} from '../change_detector_ref';
 import {Provider, SkipSelfMetadata, OptionalMetadata, Injectable} from 'angular2/src/core/di';
 
+/**
+ * A differ that tracks changes made to an object over time.
+ */
 export interface KeyValueDiffer {
   diff(object: Object);
   onDestroy();
diff --git a/modules/angular2/src/core/console.ts b/modules/angular2/src/core/console.ts
new file mode 100644
index 000000000000..dcd96fcce007
--- /dev/null
+++ b/modules/angular2/src/core/console.ts
@@ -0,0 +1,7 @@
+import {Injectable} from 'angular2/src/core/di';
+import {print} from 'angular2/src/facade/lang';
+
+@Injectable()
+export class Console {
+  log(message: string): void { print(message); }
+}
\ No newline at end of file
diff --git a/modules/angular2/src/core/debug/debug_element.ts b/modules/angular2/src/core/debug/debug_element.ts
index 2ee97ad2c5c5..c26acb8188e2 100644
--- a/modules/angular2/src/core/debug/debug_element.ts
+++ b/modules/angular2/src/core/debug/debug_element.ts
@@ -11,16 +11,28 @@ import {ElementRef, ElementRef_} from 'angular2/src/core/linker/element_ref';
  * element and provides access to the corresponding ElementInjector and
  * underlying DOM Element, as well as a way to query for children.
  *
- * A DebugElement can be obtained from a {@link ComponentFixture} or
- * {@link RootTestComponent}.
+ * A DebugElement can be obtained from a {@link ComponentFixture} or from an
+ * {@link ElementRef} via {@link inspectElement}.
  */
 export abstract class DebugElement {
+  /**
+   * Return the instance of the component associated with this element, if any.
+   */
   get componentInstance(): any { return unimplemented(); };
 
+  /**
+   * Return the native HTML element for this DebugElement.
+   */
   get nativeElement(): any { return unimplemented(); };
 
+  /**
+   * Return an Angular {@link ElementRef} for this element.
+   */
   get elementRef(): ElementRef { return unimplemented(); };
 
+  /**
+   * Get the directive active for this element with the given index, if any.
+   */
   abstract getDirectiveInstance(directiveIndex: number): any;
 
   /**
@@ -38,12 +50,26 @@ export abstract class DebugElement {
    */
   get componentViewChildren(): DebugElement[] { return unimplemented(); };
 
+  /**
+   * Simulate an event from this element as if the user had caused
+   * this event to fire from the page.
+   */
   abstract triggerEventHandler(eventName: string, eventObj: Event): void;
 
+  /**
+   * Check whether the element has a directive with the given type.
+   */
   abstract hasDirective(type: Type): boolean;
 
+  /**
+   * Inject the given type from the element injector.
+   */
   abstract inject(type: Type): any;
 
+
+  /**
+   * Read a local variable from the element (e.g. one defined with `#variable`).
+   */
   abstract getLocal(name: string): any;
 
   /**
@@ -169,11 +195,25 @@ export function inspectElement(elementRef: ElementRef): DebugElement {
                            (<ElementRef_>elementRef).boundElementIndex);
 }
 
+/**
+ * Maps an array of {@link DebugElement}s to an array of native DOM elements.
+ */
 export function asNativeElements(arr: DebugElement[]): any[] {
   return arr.map((debugEl) => debugEl.nativeElement);
 }
 
+/**
+ * Set of scope functions used with {@link DebugElement}'s query functionality.
+ */
 export class Scope {
+  /**
+   * Scope queries to both the light dom and view of an element and its
+   * children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_all'}
+   */
   static all(debugElement: DebugElement): DebugElement[] {
     var scope = [];
     scope.push(debugElement);
@@ -184,6 +224,14 @@ export class Scope {
 
     return scope;
   }
+
+  /**
+   * Scope queries to the light dom of an element and its children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_light'}
+   */
   static light(debugElement: DebugElement): DebugElement[] {
     var scope = [];
     debugElement.children.forEach(child => {
@@ -193,6 +241,13 @@ export class Scope {
     return scope;
   }
 
+  /**
+   * Scope queries to the view of an element of its children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_view'}
+   */
   static view(debugElement: DebugElement): DebugElement[] {
     var scope = [];
 
diff --git a/modules/angular2/src/core/dev_mode.ts b/modules/angular2/src/core/dev_mode.ts
deleted file mode 100644
index 925ced89b6a7..000000000000
--- a/modules/angular2/src/core/dev_mode.ts
+++ /dev/null
@@ -1 +0,0 @@
-export {enableDevMode} from 'angular2/src/facade/lang';
\ No newline at end of file
diff --git a/modules/angular2/src/core/di/decorators.ts b/modules/angular2/src/core/di/decorators.ts
index 63604542bfa7..01126266b9d4 100644
--- a/modules/angular2/src/core/di/decorators.ts
+++ b/modules/angular2/src/core/di/decorators.ts
@@ -6,7 +6,7 @@ import {
   HostMetadata,
   SkipSelfMetadata
 } from './metadata';
-import {makeDecorator, makeParamDecorator, TypeDecorator} from '../util/decorators';
+import {makeDecorator, makeParamDecorator} from '../util/decorators';
 
 /**
  * Factory for creating {@link InjectMetadata}.
diff --git a/modules/angular2/src/core/di/exceptions.ts b/modules/angular2/src/core/di/exceptions.ts
index 6e18ccf36b57..084b1a32ddef 100644
--- a/modules/angular2/src/core/di/exceptions.ts
+++ b/modules/angular2/src/core/di/exceptions.ts
@@ -222,8 +222,10 @@ export class NoAnnotationError extends BaseException {
         signature.push(parameter.map(stringify).join(' '));
       }
     }
-    return "Cannot resolve all parameters for " + stringify(typeOrFunc) + "(" +
-           signature.join(', ') + "). " + 'Make sure they all have valid type or annotations.';
+    return "Cannot resolve all parameters for '" + stringify(typeOrFunc) + "'(" +
+           signature.join(', ') + "). " +
+           "Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
+           stringify(typeOrFunc) + "' is decorated with Injectable.";
   }
 }
 
diff --git a/modules/angular2/src/core/di/provider.ts b/modules/angular2/src/core/di/provider.ts
index c60ee1428a46..267381244d98 100644
--- a/modules/angular2/src/core/di/provider.ts
+++ b/modules/angular2/src/core/di/provider.ts
@@ -30,6 +30,10 @@ import {
 } from './exceptions';
 import {resolveForwardRef} from './forward_ref';
 
+/**
+ * `Dependency` is used by the framework to extend DI.
+ * This is internal to Angular and should not be used directly.
+ */
 export class Dependency {
   constructor(public key: Key, public optional: boolean, public lowerBoundVisibility: any,
               public upperBoundVisibility: any, public properties: any[]) {}
@@ -157,7 +161,7 @@ export class Provider {
    * expect(injector.get(String)).toEqual('Value: 3');
    * ```
    *
-   * Used in conjuction with dependencies.
+   * Used in conjunction with dependencies.
    */
   useFactory: Function;
 
@@ -207,7 +211,7 @@ export class Provider {
    * Creates multiple providers matching the same token (a multi-provider).
    *
    * Multi-providers are used for creating pluggable service, where the system comes
-   * with some default providers, and the user can register additonal providers.
+   * with some default providers, and the user can register additional providers.
    * The combination of the default providers and the additional providers will be
    * used to drive the behavior of the system.
    *
@@ -236,6 +240,8 @@ export class Provider {
 }
 
 /**
+ * See {@link Provider} instead.
+ *
  * @deprecated
  */
 @CONST()
@@ -311,6 +317,8 @@ export interface ResolvedProvider {
 }
 
 /**
+ * See {@link ResolvedProvider} instead.
+ *
  * @deprecated
  */
 export interface ResolvedBinding extends ResolvedProvider {}
@@ -339,7 +347,6 @@ export class ResolvedFactory {
 }
 
 /**
- * @deprecated
  * Creates a {@link Provider}.
  *
  * To construct a {@link Provider}, bind a `token` to either a class, a value, a factory function,
@@ -348,6 +355,8 @@ export class ResolvedFactory {
  * See {@link ProviderBuilder} for more details.
  *
  * The `token` is most commonly a class or {@link angular2/di/OpaqueToken}.
+ *
+ * @deprecated
  */
 export function bind(token): ProviderBuilder {
   return new ProviderBuilder(token);
diff --git a/modules/angular2/src/core/linker/component_url_mapper.ts b/modules/angular2/src/core/linker/component_url_mapper.ts
deleted file mode 100644
index 97200294eea5..000000000000
--- a/modules/angular2/src/core/linker/component_url_mapper.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import {Injectable} from 'angular2/src/core/di';
-import {Type, isPresent} from 'angular2/src/facade/lang';
-import {Map, MapWrapper} from 'angular2/src/facade/collection';
-import {reflector} from 'angular2/src/core/reflection/reflection';
-
-/**
- * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
- *
- * This interface can be overridden by the application developer to create custom behavior.
- *
- * See {@link Compiler}
- */
-@Injectable()
-export class ComponentUrlMapper {
-  /**
-   * Returns the base URL to the component source file.
-   * The returned URL could be:
-   * - an absolute URL,
-   * - a path relative to the application
-   */
-  getUrl(component: Type): string {
-    return reflector.isReflectionEnabled() ? reflector.importUri(component) : './';
-  }
-}
-
-export class RuntimeComponentUrlMapper extends ComponentUrlMapper {
-  /** @internal */
-  _componentUrls = new Map<Type, string>();
-
-  constructor() { super(); }
-
-  setComponentUrl(component: Type, url: string) { this._componentUrls.set(component, url); }
-
-  getUrl(component: Type): string {
-    var url = this._componentUrls.get(component);
-    if (isPresent(url)) return url;
-    return super.getUrl(component);
-  }
-}
diff --git a/modules/angular2/src/core/linker/directive_resolver.ts b/modules/angular2/src/core/linker/directive_resolver.ts
index 380cbc9f2204..1d19c4e9fe69 100644
--- a/modules/angular2/src/core/linker/directive_resolver.ts
+++ b/modules/angular2/src/core/linker/directive_resolver.ts
@@ -132,7 +132,6 @@ export class DirectiveResolver {
         outputs: mergedOutputs,
         host: mergedHost,
         exportAs: dm.exportAs,
-        moduleId: dm.moduleId,
         queries: mergedQueries,
         providers: dm.providers
       });
diff --git a/modules/angular2/src/core/linker/view_ref.ts b/modules/angular2/src/core/linker/view_ref.ts
index adc410162f2a..7cf3af02ad5c 100644
--- a/modules/angular2/src/core/linker/view_ref.ts
+++ b/modules/angular2/src/core/linker/view_ref.ts
@@ -40,7 +40,7 @@ export interface HostViewRef {
  *
  * Properties of elements in a View can change, but the structure (number and order) of elements in
  * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
- * removing nested Views via a {@link ViewContainer}. Each View can contain many View Containers.
+ * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.
  * <!-- /TODO -->
  *
  * ### Example
diff --git a/modules/angular2/src/core/linker/view_resolver.ts b/modules/angular2/src/core/linker/view_resolver.ts
index 49285b8510fc..35d90d5d3e89 100644
--- a/modules/angular2/src/core/linker/view_resolver.ts
+++ b/modules/angular2/src/core/linker/view_resolver.ts
@@ -9,6 +9,9 @@ import {Map} from 'angular2/src/facade/collection';
 import {reflector} from 'angular2/src/core/reflection/reflection';
 
 
+/**
+ * Resolves types to {@link ViewMetadata}.
+ */
 @Injectable()
 export class ViewResolver {
   /** @internal */
diff --git a/modules/angular2/src/core/metadata.dart b/modules/angular2/src/core/metadata.dart
index e47ed69c342a..ec9f12cfacf2 100644
--- a/modules/angular2/src/core/metadata.dart
+++ b/modules/angular2/src/core/metadata.dart
@@ -27,7 +27,6 @@ class Directive extends DirectiveMetadata {
       List bindings,
       List providers,
       String exportAs,
-      String moduleId,
       Map<String, dynamic> queries})
       : super(
             selector: selector,
@@ -39,7 +38,6 @@ class Directive extends DirectiveMetadata {
             bindings: bindings,
             providers: providers,
             exportAs: exportAs,
-            moduleId: moduleId,
             queries: queries);
 }
 
diff --git a/modules/angular2/src/core/metadata.ts b/modules/angular2/src/core/metadata.ts
index a6f758837ca3..fc41837254d0 100644
--- a/modules/angular2/src/core/metadata.ts
+++ b/modules/angular2/src/core/metadata.ts
@@ -146,7 +146,6 @@ export interface DirectiveFactory {
     bindings?: any[],
     providers?: any[],
     exportAs?: string,
-    moduleId?: string,
     queries?: {[key: string]: any}
   }): DirectiveDecorator;
   new (obj: {
@@ -159,7 +158,6 @@ export interface DirectiveFactory {
     bindings?: any[],
     providers?: any[],
     exportAs?: string,
-    moduleId?: string,
     queries?: {[key: string]: any}
   }): DirectiveMetadata;
 }
@@ -398,21 +396,33 @@ export interface QueryFactory {
   new (selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
 }
 
+/**
+ * Factory for {@link ContentChildren}.
+ */
 export interface ContentChildrenFactory {
   (selector: Type | string, {descendants}?: {descendants?: boolean}): any;
   new (selector: Type | string, {descendants}?: {descendants?: boolean}): ContentChildrenMetadata;
 }
 
+/**
+ * Factory for {@link ContentChild}.
+ */
 export interface ContentChildFactory {
   (selector: Type | string): any;
   new (selector: Type | string): ContentChildFactory;
 }
 
+/**
+ * Factory for {@link ViewChildren}.
+ */
 export interface ViewChildrenFactory {
   (selector: Type | string): any;
   new (selector: Type | string): ViewChildrenMetadata;
 }
 
+/**
+ * Factory for {@link ViewChild}.
+ */
 export interface ViewChildFactory {
   (selector: Type | string): any;
   new (selector: Type | string): ViewChildFactory;
diff --git a/modules/angular2/src/core/metadata/directives.ts b/modules/angular2/src/core/metadata/directives.ts
index 4c0c3ec611ca..b936e95509e0 100644
--- a/modules/angular2/src/core/metadata/directives.ts
+++ b/modules/angular2/src/core/metadata/directives.ts
@@ -696,26 +696,6 @@ export class DirectiveMetadata extends InjectableMetadata {
    */
   exportAs: string;
 
-  /**
-   * The module id of the module that contains the directive.
-   * Needed to be able to resolve relative urls for templates and styles.
-   * In Dart, this can be determined automatically and does not need to be set.
-   * In CommonJS, this can always be set to `module.id`.
-   *
-   * ## Simple Example
-   *
-   * ```
-   * @Directive({
-   *   selector: 'someDir',
-   *   moduleId: module.id
-   * })
-   * class SomeDir {
-   * }
-   *
-   * ```
-   */
-  moduleId: string;
-
   // TODO: add an example after ContentChildren and ViewChildren are in master
   /**
    * Configures the queries that will be injected into the directive.
@@ -752,7 +732,7 @@ export class DirectiveMetadata extends InjectableMetadata {
   queries: {[key: string]: any};
 
   constructor({selector, inputs, outputs, properties, events, host, bindings, providers, exportAs,
-               moduleId, queries}: {
+               queries}: {
     selector?: string,
     inputs?: string[],
     outputs?: string[],
@@ -762,7 +742,6 @@ export class DirectiveMetadata extends InjectableMetadata {
     providers?: any[],
     /** @deprecated */ bindings?: any[],
     exportAs?: string,
-    moduleId?: string,
     queries?: {[key: string]: any}
   } = {}) {
     super();
@@ -773,7 +752,6 @@ export class DirectiveMetadata extends InjectableMetadata {
     this._events = events;
     this.host = host;
     this.exportAs = exportAs;
-    this.moduleId = moduleId;
     this.queries = queries;
     this._providers = providers;
     this._bindings = bindings;
@@ -865,6 +843,26 @@ export class ComponentMetadata extends DirectiveMetadata {
   private _viewProviders: any[];
   private _viewBindings: any[];
 
+  /**
+   * The module id of the module that contains the component.
+   * Needed to be able to resolve relative urls for templates and styles.
+   * In Dart, this can be determined automatically and does not need to be set.
+   * In CommonJS, this can always be set to `module.id`.
+   *
+   * ## Simple Example
+   *
+   * ```
+   * @Directive({
+   *   selector: 'someDir',
+   *   moduleId: module.id
+   * })
+   * class SomeDir {
+   * }
+   *
+   * ```
+   */
+  moduleId: string;
+
   templateUrl: string;
 
   template: string;
@@ -913,7 +911,6 @@ export class ComponentMetadata extends DirectiveMetadata {
       events: events,
       host: host,
       exportAs: exportAs,
-      moduleId: moduleId,
       bindings: bindings,
       providers: providers,
       queries: queries
@@ -929,6 +926,7 @@ export class ComponentMetadata extends DirectiveMetadata {
     this.directives = directives;
     this.pipes = pipes;
     this.encapsulation = encapsulation;
+    this.moduleId = moduleId;
   }
 }
 
diff --git a/modules/angular2/src/core/platform_common_providers.ts b/modules/angular2/src/core/platform_common_providers.ts
index 14a84c160374..491b30e5b3cd 100644
--- a/modules/angular2/src/core/platform_common_providers.ts
+++ b/modules/angular2/src/core/platform_common_providers.ts
@@ -1,5 +1,6 @@
 import {Type, isBlank, isPresent, assertionsEnabled, CONST_EXPR} from 'angular2/src/facade/lang';
 import {provide, Provider, Injector, OpaqueToken} from 'angular2/src/core/di';
+import {Console} from 'angular2/src/core/console';
 import {Reflector, reflector} from './reflection/reflection';
 import {TestabilityRegistry} from 'angular2/src/core/testability/testability';
 
@@ -10,5 +11,5 @@ function _reflector(): Reflector {
 /**
  * A default set of providers which should be included in any Angular platform.
  */
-export const PLATFORM_COMMON_PROVIDERS: Array<Type | Provider | any[]> =
-    CONST_EXPR([new Provider(Reflector, {useFactory: _reflector, deps: []}), TestabilityRegistry]);
+export const PLATFORM_COMMON_PROVIDERS: Array<Type | Provider | any[]> = CONST_EXPR(
+    [new Provider(Reflector, {useFactory: _reflector, deps: []}), TestabilityRegistry, Console]);
diff --git a/modules/angular2/src/core/prod_mode.ts b/modules/angular2/src/core/prod_mode.ts
new file mode 100644
index 000000000000..e44014dae62e
--- /dev/null
+++ b/modules/angular2/src/core/prod_mode.ts
@@ -0,0 +1 @@
+export {enableProdMode} from 'angular2/src/facade/lang';
\ No newline at end of file
diff --git a/modules/angular2/src/core/profile/wtf_impl.ts b/modules/angular2/src/core/profile/wtf_impl.ts
index 133e1a59a583..1a5e5e107489 100644
--- a/modules/angular2/src/core/profile/wtf_impl.ts
+++ b/modules/angular2/src/core/profile/wtf_impl.ts
@@ -1,5 +1,8 @@
 import {global} from 'angular2/src/facade/lang';
 
+/**
+ * A scope function for the Web Tracing Framework (WTF).
+ */
 export interface WtfScopeFn { (arg0?: any, arg1?: any): any; }
 
 interface WTF {
diff --git a/modules/angular2/src/core/reflection/reflection.ts b/modules/angular2/src/core/reflection/reflection.ts
index a22b118771f7..2d4fc89f74d4 100644
--- a/modules/angular2/src/core/reflection/reflection.ts
+++ b/modules/angular2/src/core/reflection/reflection.ts
@@ -4,4 +4,8 @@ import {Reflector} from './reflector';
 export {Reflector, ReflectionInfo} from './reflector';
 import {ReflectionCapabilities} from './reflection_capabilities';
 
+/**
+ * The {@link Reflector} used internally in Angular to access metadata
+ * about symbols.
+ */
 export var reflector = new Reflector(new ReflectionCapabilities());
diff --git a/modules/angular2/src/core/reflection/reflector.ts b/modules/angular2/src/core/reflection/reflector.ts
index e19e65e94408..5b58109d78ac 100644
--- a/modules/angular2/src/core/reflection/reflector.ts
+++ b/modules/angular2/src/core/reflection/reflector.ts
@@ -13,11 +13,18 @@ import {PlatformReflectionCapabilities} from './platform_reflection_capabilities
 export {SetterFn, GetterFn, MethodFn} from './types';
 export {PlatformReflectionCapabilities} from './platform_reflection_capabilities';
 
+/**
+ * Reflective information about a symbol, including annotations, interfaces, and other metadata.
+ */
 export class ReflectionInfo {
   constructor(public annotations?: any[], public parameters?: any[][], public factory?: Function,
               public interfaces?: any[], public propMetadata?: {[key: string]: any[]}) {}
 }
 
+/**
+ * Provides access to reflection data about symbols. Used internally by Angular
+ * to power dependency injection and compilation.
+ */
 export class Reflector {
   /** @internal */
   _injectableInfo = new Map<any, ReflectionInfo>();
diff --git a/modules/angular2/src/core/render/api.ts b/modules/angular2/src/core/render/api.ts
index fc2461659b41..c5bcc1c02b19 100644
--- a/modules/angular2/src/core/render/api.ts
+++ b/modules/angular2/src/core/render/api.ts
@@ -21,9 +21,9 @@ export class RenderProtoViewRef {}
  * Represents a list of sibling Nodes that can be moved by the {@link Renderer} independently of
  * other Render Fragments.
  *
- * Any {@link RenderView} has one Render Fragment.
+ * Any {@link RenderViewRef} has one Render Fragment.
  *
- * Additionally any View with an Embedded View that contains a {@link NgContent View Projection}
+ * Additionally any View with an Embedded View that contains a {@link NgContentAst View Projection}
  * results in additional Render Fragment.
  */
 /*
@@ -71,19 +71,31 @@ export class RenderFragmentRef {}
 // TODO(i): refactor into an interface
 export class RenderViewRef {}
 
+/**
+ * Abstract base class for commands to the Angular renderer, using the visitor pattern.
+ */
 export abstract class RenderTemplateCmd {
   abstract visit(visitor: RenderCommandVisitor, context: any): any;
 }
 
+/**
+ * Command to begin rendering.
+ */
 export abstract class RenderBeginCmd extends RenderTemplateCmd {
   get ngContentIndex(): number { return unimplemented(); };
   get isBound(): boolean { return unimplemented(); };
 }
 
+/**
+ * Command to render text.
+ */
 export abstract class RenderTextCmd extends RenderBeginCmd {
   get value(): string { return unimplemented(); };
 }
 
+/**
+ * Command to render projected content.
+ */
 export abstract class RenderNgContentCmd extends RenderTemplateCmd {
   // The index of this NgContent element
   get index(): number { return unimplemented(); };
@@ -92,21 +104,33 @@ export abstract class RenderNgContentCmd extends RenderTemplateCmd {
   get ngContentIndex(): number { return unimplemented(); };
 }
 
+/**
+ * Command to begin rendering an element.
+ */
 export abstract class RenderBeginElementCmd extends RenderBeginCmd {
   get name(): string { return unimplemented(); };
   get attrNameAndValues(): string[] { return unimplemented(); };
   get eventTargetAndNames(): string[] { return unimplemented(); };
 }
 
+/**
+ * Command to begin rendering a component.
+ */
 export abstract class RenderBeginComponentCmd extends RenderBeginElementCmd {
   get templateId(): string { return unimplemented(); };
 }
 
+/**
+ * Command to render a component's template.
+ */
 export abstract class RenderEmbeddedTemplateCmd extends RenderBeginElementCmd {
   get isMerged(): boolean { return unimplemented(); };
   get children(): RenderTemplateCmd[] { return unimplemented(); };
 }
 
+/**
+ * Visitor for a {@link RenderTemplateCmd}.
+ */
 export interface RenderCommandVisitor {
   visitText(cmd: RenderTextCmd, context: any): any;
   visitNgContent(cmd: RenderNgContentCmd, context: any): any;
@@ -161,6 +185,9 @@ export interface RenderElementRef {
   boundElementIndex: number;
 }
 
+/**
+ * Template for rendering a component, including commands and styles.
+ */
 export class RenderComponentTemplate {
   constructor(public id: string, public shortId: string, public encapsulation: ViewEncapsulation,
               public commands: RenderTemplateCmd[], public styles: string[]) {}
@@ -176,7 +203,7 @@ export class RenderComponentTemplate {
  *
  * If you are implementing a custom renderer, you must implement this interface.
  *
- * The default Renderer implementation is {@link DomRenderer}. Also see {@link WebWorkerRenderer}.
+ * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.
  */
 export abstract class Renderer {
   /**
diff --git a/modules/angular2/src/core/testability/testability.ts b/modules/angular2/src/core/testability/testability.ts
index 741cffb8e401..ebd9dcd8293b 100644
--- a/modules/angular2/src/core/testability/testability.ts
+++ b/modules/angular2/src/core/testability/testability.ts
@@ -88,6 +88,9 @@ export class Testability {
   }
 }
 
+/**
+ * A global registry of {@link Testability} instances for specific elements.
+ */
 @Injectable()
 export class TestabilityRegistry {
   /** @internal */
@@ -108,6 +111,10 @@ export class TestabilityRegistry {
   }
 }
 
+/**
+ * Adapter interface for retrieving the `Testability` service associated for a
+ * particular context.
+ */
 export interface GetTestability {
   addToWindow(registry: TestabilityRegistry): void;
   findTestabilityInTree(registry: TestabilityRegistry, elem: any,
@@ -123,6 +130,9 @@ class _NoopGetTestability implements GetTestability {
   }
 }
 
+/**
+ * Set the {@link GetTestability} implementation used by the Angular testing framework.
+ */
 export function setTestabilityGetter(getter: GetTestability): void {
   _testabilityGetter = getter;
 }
diff --git a/modules/angular2/src/core/zone/ng_zone.ts b/modules/angular2/src/core/zone/ng_zone.ts
index 0df53e44a540..368c818350e9 100644
--- a/modules/angular2/src/core/zone/ng_zone.ts
+++ b/modules/angular2/src/core/zone/ng_zone.ts
@@ -8,8 +8,14 @@ export interface NgZoneZone extends Zone {
   _innerZone: boolean;
 }
 
+/**
+ * Interface for a function with zero arguments.
+ */
 export interface ZeroArgFunction { (): void; }
 
+/**
+ * Function type for an error handler, which takes an error and a stack trace.
+ */
 export interface ErrorHandlingFn { (error: any, stackTrace: any): void; }
 
 /**
@@ -270,7 +276,7 @@ export class NgZone {
   get hasPendingTimers(): boolean { return this._pendingTimeouts.length > 0; }
 
   /**
-   * Whether there are any outstanding asychnronous tasks of any kind that are
+   * Whether there are any outstanding asynchronous tasks of any kind that are
    * scheduled to run within Angular zone.
    *
    * Useful as a signal of UI stability. For example, when a test reaches a
diff --git a/modules/angular2/src/facade/collection.ts b/modules/angular2/src/facade/collection.ts
index a35e9391a948..aabbe66f0e5c 100644
--- a/modules/angular2/src/facade/collection.ts
+++ b/modules/angular2/src/facade/collection.ts
@@ -166,6 +166,10 @@ export class StringMapWrapper {
   }
 }
 
+/**
+ * A boolean-valued function over a value, possibly including context information
+ * regarding that value's position in an array.
+ */
 export interface Predicate<T> { (value: T, index?: number, array?: T[]): boolean; }
 
 export class ListWrapper {
diff --git a/modules/angular2/src/facade/exceptions.ts b/modules/angular2/src/facade/exceptions.ts
index cd8ee4cb520a..a5cb61404609 100644
--- a/modules/angular2/src/facade/exceptions.ts
+++ b/modules/angular2/src/facade/exceptions.ts
@@ -12,6 +12,9 @@ export class BaseException extends Error {
   toString(): string { return this.message; }
 }
 
+/**
+ * Wraps an exception and provides additional context or information.
+ */
 export class WrappedException extends Error {
   private _wrapperStack: any;
 
diff --git a/modules/angular2/src/facade/lang.dart b/modules/angular2/src/facade/lang.dart
index 26ed8ec7dea4..c8067485f69f 100644
--- a/modules/angular2/src/facade/lang.dart
+++ b/modules/angular2/src/facade/lang.dart
@@ -11,6 +11,7 @@ class Math {
   static final _random = new math.Random();
   static int floor(num n) => n.floor();
   static double random() => _random.nextDouble();
+  static num min(num a, num b) => math.min(a, b);
 }
 
 class CONST {
@@ -30,7 +31,15 @@ bool isPromise(obj) => obj is Future;
 bool isNumber(obj) => obj is num;
 bool isDate(obj) => obj is DateTime;
 
-String stringify(obj) => obj.toString();
+String stringify(obj) {
+  final exp = new RegExp(r"from Function '(\w+)'");
+  final str = obj.toString();
+  if (exp.firstMatch(str) != null) {
+    return exp.firstMatch(str).group(1);
+  } else {
+    return str;
+  }
+}
 
 int serializeEnum(val) {
   return val.index;
@@ -249,27 +258,34 @@ bool isJsObject(o) {
   return false;
 }
 
-bool _forceDevMode = false;
-bool _devModeLocked = false;
-
-void lockDevMode() {
-  _devModeLocked = true;
-}
-
-void enableDevMode() {
-  if (_forceDevMode) {
-    return;
-  }
-  if (_devModeLocked) {
-    throw new Exception("Cannot enable dev mode after platform setup.");
-  }
-  _forceDevMode = true;
-}
-
+// Functions below are noop in Dart. Imperatively controlling dev mode kills
+// tree shaking. We should only rely on `assertionsEnabled`.
+@Deprecated('Do not use this function. It is for JS only. There is no alternative.')
+void lockMode() {}
+@Deprecated('Do not use this function. It is for JS only. There is no alternative.')
+void enableDevMode() {}
+@Deprecated('Do not use this function. It is for JS only. There is no alternative.')
+void enableProdMode() {}
+
+/// Use this function to guard debugging code. When Dart is compiled in
+/// production mode, the code guarded using this function will be tree
+/// shaken away, reducing code size.
+///
+/// WARNING: DO NOT CHANGE THIS METHOD! This method is designed to have no
+/// more AST nodes than the maximum allowed by dart2js to inline it. In
+/// addition, the use of `assert` allows the compiler to statically compute
+/// the value returned by this function and tree shake conditions guarded by
+/// it.
+///
+/// Example:
+///
+/// if (assertionsEnabled()) {
+///   ...code here is tree shaken away in prod mode...
+/// }
 bool assertionsEnabled() {
   var k = false;
   assert((k = true));
-  return _forceDevMode || k;
+  return k;
 }
 
 // Can't be all uppercase as our transpiler would think it is a special directive...
diff --git a/modules/angular2/src/facade/lang.ts b/modules/angular2/src/facade/lang.ts
index bd4be8060dd8..3d741d1dc131 100644
--- a/modules/angular2/src/facade/lang.ts
+++ b/modules/angular2/src/facade/lang.ts
@@ -29,6 +29,10 @@ export var Type = Function;
  * the `MyCustomComponent` constructor function.
  */
 export interface Type extends Function {}
+
+/**
+ * Runtime representation of a type that is constructable (non-abstract).
+ */
 export interface ConcreteType extends Type { new (...args): any; }
 
 export function getTypeNameForDebugging(type: Type): string {
@@ -39,30 +43,27 @@ export function getTypeNameForDebugging(type: Type): string {
 export var Math = _global.Math;
 export var Date = _global.Date;
 
-var _devMode: boolean = !!_global.angularDevMode;
-var _devModeLocked: boolean = false;
+var _devMode: boolean = true;
+var _modeLocked: boolean = false;
 
-export function lockDevMode() {
-  _devModeLocked = true;
+export function lockMode() {
+  _modeLocked = true;
 }
 
 /**
- * Enable Angular's development mode, which turns on assertions and other
+ * Disable Angular's development mode, which turns off assertions and other
  * checks within the framework.
  *
- * One important assertion this enables verifies that a change detection pass
+ * One important assertion this disables verifies that a change detection pass
  * does not result in additional changes to any bindings (also known as
  * unidirectional data flow).
- *
- * {@example core/ts/dev_mode/dev_mode_example.ts region='enableDevMode'}
  */
-export function enableDevMode() {
-  // TODO(alxhub): Refactor out of facade/lang as per issue #5157.
-  if (_devModeLocked) {
+export function enableProdMode() {
+  if (_modeLocked) {
     // Cannot use BaseException as that ends up importing from facade/lang.
-    throw 'Cannot enable dev mode after platform setup.';
+    throw 'Cannot enable prod mode after platform setup.';
   }
-  _devMode = true;
+  _devMode = false;
 }
 
 export function assertionsEnabled(): boolean {
diff --git a/modules/angular2/src/http/backends/browser_xhr.ts b/modules/angular2/src/http/backends/browser_xhr.ts
index 0665ae7b4658..42051915e31d 100644
--- a/modules/angular2/src/http/backends/browser_xhr.ts
+++ b/modules/angular2/src/http/backends/browser_xhr.ts
@@ -1,6 +1,10 @@
 import {Injectable} from 'angular2/core';
 
-// Make sure not to evaluate this in a non-browser environment!
+/**
+ * A backend for http that uses the `XMLHttpRequest` browser API.
+ *
+ * Take care not to evaluate this in non-browser contexts.
+ */
 @Injectable()
 export class BrowserXhr {
   constructor() {}
diff --git a/modules/angular2/src/http/backends/jsonp_backend.ts b/modules/angular2/src/http/backends/jsonp_backend.ts
index f0bada51b335..40d4beb8dbfc 100644
--- a/modules/angular2/src/http/backends/jsonp_backend.ts
+++ b/modules/angular2/src/http/backends/jsonp_backend.ts
@@ -12,10 +12,29 @@ import {Observable} from 'rxjs/Observable';
 const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
 const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';
 
+/**
+ * Abstract base class for an in-flight JSONP request.
+ */
 export abstract class JSONPConnection implements Connection {
+  /**
+   * The {@link ReadyState} of this request.
+   */
   readyState: ReadyState;
+
+  /**
+   * The outgoing HTTP request.
+   */
   request: Request;
+
+  /**
+   * An observable that completes with the response, when the request is finished.
+   */
   response: Observable<Response>;
+
+  /**
+   * Callback called when the JSONP request completes, to notify the application
+   * of the new data.
+   */
   abstract finished(data?: any): void;
 }
 
@@ -111,6 +130,9 @@ export class JSONPConnection_ extends JSONPConnection {
   }
 }
 
+/**
+ * A {@link ConnectionBackend} that uses the JSONP strategy of making requests.
+ */
 export abstract class JSONPBackend extends ConnectionBackend {}
 
 @Injectable()
diff --git a/modules/angular2/src/http/http.ts b/modules/angular2/src/http/http.ts
index bdb2a40e356c..798b40a33339 100644
--- a/modules/angular2/src/http/http.ts
+++ b/modules/angular2/src/http/http.ts
@@ -35,7 +35,7 @@ function mergeOptions(defaultOpts, providedOpts, method, url): RequestOptions {
  * Performs http requests using `XMLHttpRequest` as the default backend.
  *
  * `Http` is available as an injectable class, with methods to perform http requests. Calling
- * `request` returns an {@link Observable} which will emit a single {@link Response} when a
+ * `request` returns an `Observable` which will emit a single {@link Response} when a
  * response is received.
  *
  * ### Example
diff --git a/modules/angular2/src/mock/directive_resolver_mock.ts b/modules/angular2/src/mock/directive_resolver_mock.ts
index 9b1e0993feb8..267c664a10e8 100644
--- a/modules/angular2/src/mock/directive_resolver_mock.ts
+++ b/modules/angular2/src/mock/directive_resolver_mock.ts
@@ -4,6 +4,10 @@ import {Type, isPresent, stringify, isBlank, print} from 'angular2/src/facade/la
 import {DirectiveMetadata, ComponentMetadata} from '../core/metadata';
 import {DirectiveResolver} from 'angular2/src/core/linker/directive_resolver';
 
+/**
+ * An implementation of {@link DirectiveResolver} that allows overriding
+ * various properties of directives.
+ */
 @Injectable()
 export class MockDirectiveResolver extends DirectiveResolver {
   private _providerOverrides = new Map<Type, any[]>();
@@ -47,7 +51,6 @@ export class MockDirectiveResolver extends DirectiveResolver {
       host: dm.host,
       providers: providers,
       exportAs: dm.exportAs,
-      moduleId: dm.moduleId,
       queries: dm.queries
     });
   }
diff --git a/modules/angular2/src/mock/location_mock.ts b/modules/angular2/src/mock/location_mock.ts
index 551dc8cca7b5..0c70727e46f5 100644
--- a/modules/angular2/src/mock/location_mock.ts
+++ b/modules/angular2/src/mock/location_mock.ts
@@ -3,6 +3,9 @@ import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {ListWrapper} from 'angular2/src/facade/collection';
 import {Location} from 'angular2/src/router/location';
 
+/**
+ * A spy for {@link Location} that allows tests to fire simulated location events.
+ */
 @Injectable()
 export class SpyLocation implements Location {
   urlChanges: string[] = [];
diff --git a/modules/angular2/src/mock/mock_application_ref.ts b/modules/angular2/src/mock/mock_application_ref.ts
index 568e5fac2978..77062f0f685d 100644
--- a/modules/angular2/src/mock/mock_application_ref.ts
+++ b/modules/angular2/src/mock/mock_application_ref.ts
@@ -6,6 +6,9 @@ import {Provider, Injector} from 'angular2/src/core/di';
 import {NgZone} from 'angular2/src/core/zone/ng_zone';
 import {Promise} from 'angular2/src/facade/async';
 
+/**
+ * A no-op implementation of {@link ApplicationRef}, useful for testing.
+ */
 @Injectable()
 export class MockApplicationRef extends ApplicationRef {
   registerBootstrapListener(listener: (ref: ComponentRef) => void): void {}
diff --git a/modules/angular2/src/mock/mock_location_strategy.ts b/modules/angular2/src/mock/mock_location_strategy.ts
index 0bd8f7a74615..de7dcb746d2d 100644
--- a/modules/angular2/src/mock/mock_location_strategy.ts
+++ b/modules/angular2/src/mock/mock_location_strategy.ts
@@ -3,6 +3,10 @@ import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {LocationStrategy} from 'angular2/src/router/location_strategy';
 
 
+/**
+ * A mock implementation of {@link LocationStrategy} that allows tests to fire simulated
+ * location events.
+ */
 @Injectable()
 export class MockLocationStrategy extends LocationStrategy {
   internalBaseHref: string = '/';
@@ -15,7 +19,7 @@ export class MockLocationStrategy extends LocationStrategy {
 
   simulatePopState(url: string): void {
     this.internalPath = url;
-    ObservableWrapper.callEmit(this._subject, new MockPopStateEvent(this.path()));
+    ObservableWrapper.callEmit(this._subject, new _MockPopStateEvent(this.path()));
   }
 
   path(): string { return this.internalPath; }
@@ -62,7 +66,7 @@ export class MockLocationStrategy extends LocationStrategy {
   forward(): void { throw 'not implemented'; }
 }
 
-class MockPopStateEvent {
+class _MockPopStateEvent {
   pop: boolean = true;
   type: string = 'popstate';
   constructor(public newUrl: string) {}
diff --git a/modules/angular2/src/mock/ng_zone_mock.ts b/modules/angular2/src/mock/ng_zone_mock.ts
index 20f20dfdbe1a..443db975f6db 100644
--- a/modules/angular2/src/mock/ng_zone_mock.ts
+++ b/modules/angular2/src/mock/ng_zone_mock.ts
@@ -2,6 +2,9 @@ import {Injectable} from 'angular2/src/core/di';
 import {NgZone} from 'angular2/src/core/zone/ng_zone';
 import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 
+/**
+ * A mock implementation of {@link NgZone}.
+ */
 @Injectable()
 export class MockNgZone extends NgZone {
   /** @internal */
diff --git a/modules/angular2/src/platform/browser/browser_adapter.dart b/modules/angular2/src/platform/browser/browser_adapter.dart
index d867f11d4a67..34ace25a2185 100644
--- a/modules/angular2/src/platform/browser/browser_adapter.dart
+++ b/modules/angular2/src/platform/browser/browser_adapter.dart
@@ -221,7 +221,7 @@ class BrowserDomAdapter extends GenericBrowserDomAdapter {
       _supportsTemplateElement ? el.content : el;
   Node firstChild(el) => el.firstChild;
   Node nextSibling(Node el) => el.nextNode;
-  Element parentElement(Node el) => el.parent;
+  Element parentElement(Node el) => el.parentNode;
   List<Node> childNodes(Node el) => el.childNodes;
   List childNodesAsList(Node el) => childNodes(el).toList();
   void clearNodes(Node el) {
diff --git a/modules/angular2/src/platform/browser/browser_adapter.ts b/modules/angular2/src/platform/browser/browser_adapter.ts
index 986c90e2ec9f..d01b7239233e 100644
--- a/modules/angular2/src/platform/browser/browser_adapter.ts
+++ b/modules/angular2/src/platform/browser/browser_adapter.ts
@@ -53,6 +53,9 @@ var _chromeNumKeyPadMap = {
   '\x90': 'NumLock'
 };
 
+/**
+ * A `DomAdapter` powered by full browser DOM APIs.
+ */
 /* tslint:disable:requireParameterType */
 export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   parse(templateHtml: string) { throw new Error("parse not implemented"); }
diff --git a/modules/angular2/src/platform/browser_common.ts b/modules/angular2/src/platform/browser_common.ts
index 300829bffc02..d99a2d756ae0 100644
--- a/modules/angular2/src/platform/browser_common.ts
+++ b/modules/angular2/src/platform/browser_common.ts
@@ -42,6 +42,11 @@ export {
 export {BrowserDomAdapter} from './browser/browser_adapter';
 export {enableDebugTools, disableDebugTools} from 'angular2/src/platform/browser/tools/tools';
 
+/**
+ * A set of providers to initialize the Angular platform in a web browser.
+ *
+ * Used automatically by `bootstrap`, or can be passed to {@link platform}.
+ */
 export const BROWSER_PROVIDERS: Array<any /*Type | Provider | any[]*/> = CONST_EXPR([
   PLATFORM_COMMON_PROVIDERS,
   new Provider(PLATFORM_INITIALIZER, {useValue: initDomAdapter, multi: true}),
@@ -57,6 +62,11 @@ function _document(): any {
   return DOM.defaultDoc();
 }
 
+/**
+ * A set of providers to initialize an Angular application in a web browser.
+ *
+ * Used automatically by `bootstrap`, or can be passed to {@link PlatformRef.application}.
+ */
 export const BROWSER_APP_COMMON_PROVIDERS: Array<any /*Type | Provider | any[]*/> = CONST_EXPR([
   APPLICATION_COMMON_PROVIDERS,
   FORM_PROVIDERS,
diff --git a/modules/angular2/src/platform/dom/debug/by.ts b/modules/angular2/src/platform/dom/debug/by.ts
index 9daa684f423c..b3933f50a8b4 100644
--- a/modules/angular2/src/platform/dom/debug/by.ts
+++ b/modules/angular2/src/platform/dom/debug/by.ts
@@ -3,9 +3,26 @@ import {Predicate} from 'angular2/src/facade/collection';
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
 import {DebugElement} from 'angular2/core';
 
+/**
+ * Predicates for use with {@link DebugElement}'s query functions.
+ */
 export class By {
-  static all(): Function { return (debugElement) => true; }
+  /**
+   * Match all elements.
+   *
+   * ## Example
+   *
+   * {@example platform/dom/debug/ts/by/by.ts region='by_all'}
+   */
+  static all(): Predicate<DebugElement> { return (debugElement) => true; }
 
+  /**
+   * Match elements by the given CSS selector.
+   *
+   * ## Example
+   *
+   * {@example platform/dom/debug/ts/by/by.ts region='by_css'}
+   */
   static css(selector: string): Predicate<DebugElement> {
     return (debugElement) => {
       return isPresent(debugElement.nativeElement) ?
@@ -13,6 +30,14 @@ export class By {
                  false;
     };
   }
+
+  /**
+   * Match elements that have the given directive present.
+   *
+   * ## Example
+   *
+   * {@example platform/dom/debug/ts/by/by.ts region='by_directive'}
+   */
   static directive(type: Type): Predicate<DebugElement> {
     return (debugElement) => { return debugElement.hasDirective(type); };
   }
diff --git a/modules/angular2/src/platform/dom/debug/debug_element_view_listener.ts b/modules/angular2/src/platform/dom/debug/debug_element_view_listener.ts
index 9a023e6ef502..561e817a5d3c 100644
--- a/modules/angular2/src/platform/dom/debug/debug_element_view_listener.ts
+++ b/modules/angular2/src/platform/dom/debug/debug_element_view_listener.ts
@@ -72,9 +72,21 @@ export class DebugElementViewListener implements AppViewListener {
   }
 }
 
+/**
+ * Providers which support debugging Angular applications (e.g. via `ng.probe`).
+ *
+ * ## Example
+ *
+ * {@example platform/dom/debug/ts/debug_element_view_listener/providers.ts region='providers'}
+ */
 export const ELEMENT_PROBE_PROVIDERS: any[] = CONST_EXPR([
   DebugElementViewListener,
   CONST_EXPR(new Provider(AppViewListener, {useExisting: DebugElementViewListener})),
 ]);
 
+/**
+ * Use {@link ELEMENT_PROBE_PROVIDERS}.
+ *
+ * @deprecated
+ */
 export const ELEMENT_PROBE_BINDINGS = ELEMENT_PROBE_PROVIDERS;
diff --git a/modules/angular2/src/router/component_recognizer.ts b/modules/angular2/src/router/component_recognizer.ts
index 56730566fdfb..616680673cfa 100644
--- a/modules/angular2/src/router/component_recognizer.ts
+++ b/modules/angular2/src/router/component_recognizer.ts
@@ -7,7 +7,8 @@ import {
   AbstractRecognizer,
   RouteRecognizer,
   RedirectRecognizer,
-  RouteMatch
+  RouteMatch,
+  PathMatch
 } from './route_recognizer';
 import {Route, AsyncRoute, AuxRoute, Redirect, RouteDefinition} from './route_config_impl';
 import {AsyncRouteHandler} from './async_route_handler';
@@ -117,6 +118,11 @@ export class ComponentRecognizer {
       }
     });
 
+    // handle cases where we are routing just to an aux route
+    if (solutions.length == 0 && isPresent(urlParse) && urlParse.auxiliary.length > 0) {
+      return [PromiseWrapper.resolve(new PathMatch(null, null, urlParse.auxiliary))];
+    }
+
     return solutions;
   }
 
diff --git a/modules/angular2/src/router/instruction.ts b/modules/angular2/src/router/instruction.ts
index be3e3d46f189..815745bd920d 100644
--- a/modules/angular2/src/router/instruction.ts
+++ b/modules/angular2/src/router/instruction.ts
@@ -111,12 +111,12 @@ export abstract class Instruction {
   public child: Instruction;
   public auxInstruction: {[key: string]: Instruction} = {};
 
-  get urlPath(): string { return this.component.urlPath; }
+  get urlPath(): string { return isPresent(this.component) ? this.component.urlPath : ''; }
 
-  get urlParams(): string[] { return this.component.urlParams; }
+  get urlParams(): string[] { return isPresent(this.component) ? this.component.urlParams : []; }
 
-  get specificity(): number {
-    var total = 0;
+  get specificity(): string {
+    var total = '';
     if (isPresent(this.component)) {
       total += this.component.specificity;
     }
@@ -181,7 +181,7 @@ export abstract class Instruction {
 
   /** @internal */
   _stringifyMatrixParams(): string {
-    return this.urlParams.length > 0 ? (';' + this.component.urlParams.join(';')) : '';
+    return this.urlParams.length > 0 ? (';' + this.urlParams.join(';')) : '';
   }
 
   /** @internal */
@@ -305,7 +305,7 @@ export class ComponentInstruction {
   public routeData: RouteData;
 
   constructor(public urlPath: string, public urlParams: string[], data: RouteData,
-              public componentType, public terminal: boolean, public specificity: number,
+              public componentType, public terminal: boolean, public specificity: string,
               public params: {[key: string]: any} = null) {
     this.routeData = isPresent(data) ? data : BLANK_ROUTE_DATA;
   }
diff --git a/modules/angular2/src/router/path_recognizer.ts b/modules/angular2/src/router/path_recognizer.ts
index 1e03e1271d84..263ae9446d4a 100644
--- a/modules/angular2/src/router/path_recognizer.ts
+++ b/modules/angular2/src/router/path_recognizer.ts
@@ -96,21 +96,22 @@ function parsePathString(route: string): {[key: string]: any} {
 
   var segments = splitBySlash(route);
   var results = [];
-  var specificity = 0;
+
+  var specificity = '';
+
+  // a single slash (or "empty segment" is as specific as a static segment
+  if (segments.length == 0) {
+    specificity += '2';
+  }
 
   // The "specificity" of a path is used to determine which route is used when multiple routes match
-  // a URL.
-  // Static segments (like "/foo") are the most specific, followed by dynamic segments (like
-  // "/:id"). Star segments
-  // add no specificity. Segments at the start of the path are more specific than proceeding ones.
+  // a URL. Static segments (like "/foo") are the most specific, followed by dynamic segments (like
+  // "/:id"). Star segments add no specificity. Segments at the start of the path are more specific
+  // than proceeding ones.
+  //
   // The code below uses place values to combine the different types of segments into a single
-  // integer that we can
-  // sort later. Each static segment is worth hundreds of points of specificity (10000, 9900, ...,
-  // 200), and each
-  // dynamic segment is worth single points of specificity (100, 99, ... 2).
-  if (segments.length > 98) {
-    throw new BaseException(`'${route}' has more than the maximum supported number of segments.`);
-  }
+  // string that we can sort later. Each static segment is marked as a specificity of "2," each
+  // dynamic segment is worth "1" specificity, and stars are worth "0" specificity.
 
   var limit = segments.length - 1;
   for (var i = 0; i <= limit; i++) {
@@ -118,9 +119,10 @@ function parsePathString(route: string): {[key: string]: any} {
 
     if (isPresent(match = RegExpWrapper.firstMatch(paramMatcher, segment))) {
       results.push(new DynamicSegment(match[1]));
-      specificity += (100 - i);
+      specificity += '1';
     } else if (isPresent(match = RegExpWrapper.firstMatch(wildcardMatcher, segment))) {
       results.push(new StarSegment(match[1]));
+      specificity += '0';
     } else if (segment == '...') {
       if (i < limit) {
         throw new BaseException(`Unexpected "..." before the end of the path for "${route}".`);
@@ -128,13 +130,11 @@ function parsePathString(route: string): {[key: string]: any} {
       results.push(new ContinuationSegment());
     } else {
       results.push(new StaticSegment(segment));
-      specificity += 100 * (100 - i);
+      specificity += '2';
     }
   }
-  var result = StringMapWrapper.create();
-  StringMapWrapper.set(result, 'segments', results);
-  StringMapWrapper.set(result, 'specificity', specificity);
-  return result;
+
+  return {'segments': results, 'specificity': specificity};
 }
 
 // this function is used to determine whether a route config path like `/foo/:id` collides with
@@ -177,7 +177,7 @@ function assertPath(path: string) {
  */
 export class PathRecognizer {
   private _segments: Segment[];
-  specificity: number;
+  specificity: string;
   terminal: boolean = true;
   hash: string;
 
diff --git a/modules/angular2/src/router/route_config_decorator.ts b/modules/angular2/src/router/route_config_decorator.ts
index bfac76e4b881..bb0e1535fbff 100644
--- a/modules/angular2/src/router/route_config_decorator.ts
+++ b/modules/angular2/src/router/route_config_decorator.ts
@@ -2,5 +2,12 @@ import {RouteConfig as RouteConfigAnnotation, RouteDefinition} from './route_con
 import {makeDecorator} from 'angular2/src/core/util/decorators';
 
 export {Route, Redirect, AuxRoute, AsyncRoute, RouteDefinition} from './route_config_impl';
+
+// Copied from RouteConfig in route_config_impl.
+/**
+ * The `RouteConfig` decorator defines routes for a given component.
+ *
+ * It takes an array of {@link RouteDefinition}s.
+ */
 export var RouteConfig: (configs: RouteDefinition[]) => ClassDecorator =
     makeDecorator(RouteConfigAnnotation);
diff --git a/modules/angular2/src/router/route_definition.ts b/modules/angular2/src/router/route_definition.ts
index 7d38690ee1da..c34c27815801 100644
--- a/modules/angular2/src/router/route_definition.ts
+++ b/modules/angular2/src/router/route_definition.ts
@@ -23,6 +23,12 @@ export interface RouteDefinition {
   useAsDefault?: boolean;
 }
 
+/**
+ * Represents either a component type (`type` is `component`) or a loader function
+ * (`type` is `loader`).
+ *
+ * See also {@link RouteDefinition}.
+ */
 export interface ComponentDefinition {
   type: string;
   loader?: Function;
diff --git a/modules/angular2/src/router/route_recognizer.ts b/modules/angular2/src/router/route_recognizer.ts
index fb0b8973e90f..7f44fffa8612 100644
--- a/modules/angular2/src/router/route_recognizer.ts
+++ b/modules/angular2/src/router/route_recognizer.ts
@@ -59,7 +59,7 @@ export class RedirectRecognizer implements AbstractRecognizer {
 
 // represents something like '/foo/:bar'
 export class RouteRecognizer implements AbstractRecognizer {
-  specificity: number;
+  specificity: string;
   terminal: boolean = true;
   hash: string;
 
diff --git a/modules/angular2/src/router/route_registry.ts b/modules/angular2/src/router/route_registry.ts
index fd10fab80b4f..dbf757f4a779 100644
--- a/modules/angular2/src/router/route_registry.ts
+++ b/modules/angular2/src/router/route_registry.ts
@@ -8,6 +8,8 @@ import {
   isString,
   isStringMap,
   Type,
+  StringWrapper,
+  Math,
   getTypeNameForDebugging,
   CONST_EXPR
 } from 'angular2/src/facade/lang';
@@ -144,20 +146,18 @@ export class RouteRegistry {
    */
   recognize(url: string, ancestorInstructions: Instruction[]): Promise<Instruction> {
     var parsedUrl = parser.parse(url);
-    return this._recognize(parsedUrl, ancestorInstructions);
+    return this._recognize(parsedUrl, []);
   }
 
 
   /**
    * Recognizes all parent-child routes, but creates unresolved auxiliary routes
    */
-
   private _recognize(parsedUrl: Url, ancestorInstructions: Instruction[],
                      _aux = false): Promise<Instruction> {
-    var parentComponent =
-        ancestorInstructions.length > 0 ?
-            ancestorInstructions[ancestorInstructions.length - 1].component.componentType :
-            this._rootComponent;
+    var parentInstruction = ListWrapper.last(ancestorInstructions);
+    var parentComponent = isPresent(parentInstruction) ? parentInstruction.component.componentType :
+                                                         this._rootComponent;
 
     var componentRecognizer = this._rules.get(parentComponent);
     if (isBlank(componentRecognizer)) {
@@ -174,14 +174,13 @@ export class RouteRegistry {
 
           if (candidate instanceof PathMatch) {
             var auxParentInstructions =
-                ancestorInstructions.length > 0 ?
-                    [ancestorInstructions[ancestorInstructions.length - 1]] :
-                    [];
+                ancestorInstructions.length > 0 ? [ListWrapper.last(ancestorInstructions)] : [];
             var auxInstructions =
                 this._auxRoutesToUnresolved(candidate.remainingAux, auxParentInstructions);
+
             var instruction = new ResolvedInstruction(candidate.instruction, null, auxInstructions);
 
-            if (candidate.instruction.terminal) {
+            if (isBlank(candidate.instruction) || candidate.instruction.terminal) {
               return instruction;
             }
 
@@ -203,7 +202,8 @@ export class RouteRegistry {
           }
 
           if (candidate instanceof RedirectMatch) {
-            var instruction = this.generate(candidate.redirectTo, ancestorInstructions);
+            var instruction =
+                this.generate(candidate.redirectTo, ancestorInstructions.concat([null]));
             return new RedirectInstruction(instruction.component, instruction.child,
                                            instruction.auxInstruction);
           }
@@ -237,69 +237,88 @@ export class RouteRegistry {
    * route boundary.
    */
   generate(linkParams: any[], ancestorInstructions: Instruction[], _aux = false): Instruction {
-    let normalizedLinkParams = splitAndFlattenLinkParams(linkParams);
-
-    var first = ListWrapper.first(normalizedLinkParams);
-    var rest = ListWrapper.slice(normalizedLinkParams, 1);
+    var params = splitAndFlattenLinkParams(linkParams);
+    var prevInstruction;
 
     // The first segment should be either '.' (generate from parent) or '' (generate from root).
     // When we normalize above, we strip all the slashes, './' becomes '.' and '/' becomes ''.
-    if (first == '') {
+    if (ListWrapper.first(params) == '') {
+      params.shift();
+      prevInstruction = ListWrapper.first(ancestorInstructions);
       ancestorInstructions = [];
-    } else if (first == '..') {
-      // we already captured the first instance of "..", so we need to pop off an ancestor
-      ancestorInstructions.pop();
-      while (ListWrapper.first(rest) == '..') {
-        rest = ListWrapper.slice(rest, 1);
-        ancestorInstructions.pop();
-        if (ancestorInstructions.length <= 0) {
-          throw new BaseException(
-              `Link "${ListWrapper.toJSON(linkParams)}" has too many "../" segments.`);
+    } else {
+      prevInstruction = ancestorInstructions.length > 0 ? ancestorInstructions.pop() : null;
+
+      if (ListWrapper.first(params) == '.') {
+        params.shift();
+      } else if (ListWrapper.first(params) == '..') {
+        while (ListWrapper.first(params) == '..') {
+          if (ancestorInstructions.length <= 0) {
+            throw new BaseException(
+                `Link "${ListWrapper.toJSON(linkParams)}" has too many "../" segments.`);
+          }
+          prevInstruction = ancestorInstructions.pop();
+          params = ListWrapper.slice(params, 1);
+        }
+
+        // we're on to implicit child/sibling route
+      } else {
+        // we must only peak at the link param, and not consume it
+        let routeName = ListWrapper.first(params);
+        let parentComponentType = this._rootComponent;
+        let grandparentComponentType = null;
+
+        if (ancestorInstructions.length > 1) {
+          let parentComponentInstruction = ancestorInstructions[ancestorInstructions.length - 1];
+          let grandComponentInstruction = ancestorInstructions[ancestorInstructions.length - 2];
+
+          parentComponentType = parentComponentInstruction.component.componentType;
+          grandparentComponentType = grandComponentInstruction.component.componentType;
+        } else if (ancestorInstructions.length == 1) {
+          parentComponentType = ancestorInstructions[0].component.componentType;
+          grandparentComponentType = this._rootComponent;
         }
-      }
-    } else if (first != '.') {
-      let parentComponent = this._rootComponent;
-      let grandparentComponent = null;
-      if (ancestorInstructions.length > 1) {
-        parentComponent =
-            ancestorInstructions[ancestorInstructions.length - 1].component.componentType;
-        grandparentComponent =
-            ancestorInstructions[ancestorInstructions.length - 2].component.componentType;
-      } else if (ancestorInstructions.length == 1) {
-        parentComponent = ancestorInstructions[0].component.componentType;
-        grandparentComponent = this._rootComponent;
-      }
 
-      // For a link with no leading `./`, `/`, or `../`, we look for a sibling and child.
-      // If both exist, we throw. Otherwise, we prefer whichever exists.
-      var childRouteExists = this.hasRoute(first, parentComponent);
-      var parentRouteExists =
-          isPresent(grandparentComponent) && this.hasRoute(first, grandparentComponent);
+        // For a link with no leading `./`, `/`, or `../`, we look for a sibling and child.
+        // If both exist, we throw. Otherwise, we prefer whichever exists.
+        var childRouteExists = this.hasRoute(routeName, parentComponentType);
+        var parentRouteExists = isPresent(grandparentComponentType) &&
+                                this.hasRoute(routeName, grandparentComponentType);
 
-      if (parentRouteExists && childRouteExists) {
-        let msg =
-            `Link "${ListWrapper.toJSON(linkParams)}" is ambiguous, use "./" or "../" to disambiguate.`;
-        throw new BaseException(msg);
-      }
-      if (parentRouteExists) {
-        ancestorInstructions.pop();
+        if (parentRouteExists && childRouteExists) {
+          let msg =
+              `Link "${ListWrapper.toJSON(linkParams)}" is ambiguous, use "./" or "../" to disambiguate.`;
+          throw new BaseException(msg);
+        }
+
+        if (parentRouteExists) {
+          prevInstruction = ancestorInstructions.pop();
+        }
       }
-      rest = linkParams;
     }
 
-    if (rest[rest.length - 1] == '') {
-      rest.pop();
+    if (params[params.length - 1] == '') {
+      params.pop();
+    }
+
+    if (params.length > 0 && params[0] == '') {
+      params.shift();
     }
 
-    if (rest.length < 1) {
+    if (params.length < 1) {
       let msg = `Link "${ListWrapper.toJSON(linkParams)}" must include a route name.`;
       throw new BaseException(msg);
     }
 
-    var generatedInstruction = this._generate(rest, ancestorInstructions, _aux);
+    var generatedInstruction =
+        this._generate(params, ancestorInstructions, prevInstruction, _aux, linkParams);
 
+    // we don't clone the first (root) element
     for (var i = ancestorInstructions.length - 1; i >= 0; i--) {
       let ancestorInstruction = ancestorInstructions[i];
+      if (isBlank(ancestorInstruction)) {
+        break;
+      }
       generatedInstruction = ancestorInstruction.replaceChild(generatedInstruction);
     }
 
@@ -308,95 +327,113 @@ export class RouteRegistry {
 
 
   /*
-   * Internal helper that does not make any assertions about the beginning of the link DSL
+   * Internal helper that does not make any assertions about the beginning of the link DSL.
+   * `ancestorInstructions` are parents that will be cloned.
+   * `prevInstruction` is the existing instruction that would be replaced, but which might have
+   * aux routes that need to be cloned.
    */
   private _generate(linkParams: any[], ancestorInstructions: Instruction[],
-                    _aux = false): Instruction {
-    let parentComponent =
-        ancestorInstructions.length > 0 ?
-            ancestorInstructions[ancestorInstructions.length - 1].component.componentType :
-            this._rootComponent;
-
-
-    if (linkParams.length == 0) {
-      return this.generateDefault(parentComponent);
-    }
-    let linkIndex = 0;
-    let routeName = linkParams[linkIndex];
+                    prevInstruction: Instruction, _aux = false, _originalLink: any[]): Instruction {
+    let parentComponentType = this._rootComponent;
+    let componentInstruction = null;
+    let auxInstructions: {[key: string]: Instruction} = {};
 
-    if (!isString(routeName)) {
-      throw new BaseException(`Unexpected segment "${routeName}" in link DSL. Expected a string.`);
-    } else if (routeName == '' || routeName == '.' || routeName == '..') {
-      throw new BaseException(`"${routeName}/" is only allowed at the beginning of a link DSL.`);
+    let parentInstruction: Instruction = ListWrapper.last(ancestorInstructions);
+    if (isPresent(parentInstruction) && isPresent(parentInstruction.component)) {
+      parentComponentType = parentInstruction.component.componentType;
     }
 
-    let params = {};
-    if (linkIndex + 1 < linkParams.length) {
-      let nextSegment = linkParams[linkIndex + 1];
-      if (isStringMap(nextSegment) && !isArray(nextSegment)) {
-        params = nextSegment;
-        linkIndex += 1;
+    if (linkParams.length == 0) {
+      let defaultInstruction = this.generateDefault(parentComponentType);
+      if (isBlank(defaultInstruction)) {
+        throw new BaseException(
+            `Link "${ListWrapper.toJSON(_originalLink)}" does not resolve to a terminal instruction.`);
       }
+      return defaultInstruction;
     }
 
-    let auxInstructions: {[key: string]: Instruction} = {};
-    var nextSegment;
-    while (linkIndex + 1 < linkParams.length && isArray(nextSegment = linkParams[linkIndex + 1])) {
-      let auxParentInstruction = ancestorInstructions.length > 0 ?
-                                     [ancestorInstructions[ancestorInstructions.length - 1]] :
-                                     [];
-      let auxInstruction = this._generate(nextSegment, auxParentInstruction, true);
-
-      // TODO: this will not work for aux routes with parameters or multiple segments
-      auxInstructions[auxInstruction.component.urlPath] = auxInstruction;
-      linkIndex += 1;
+    // for non-aux routes, we want to reuse the predecessor's existing primary and aux routes
+    // and only override routes for which the given link DSL provides
+    if (isPresent(prevInstruction) && !_aux) {
+      auxInstructions = StringMapWrapper.merge(prevInstruction.auxInstruction, auxInstructions);
+      componentInstruction = prevInstruction.component;
     }
 
-    var componentRecognizer = this._rules.get(parentComponent);
+    var componentRecognizer = this._rules.get(parentComponentType);
     if (isBlank(componentRecognizer)) {
       throw new BaseException(
-          `Component "${getTypeNameForDebugging(parentComponent)}" has no route config.`);
+          `Component "${getTypeNameForDebugging(parentComponentType)}" has no route config.`);
     }
 
-    var routeRecognizer =
-        (_aux ? componentRecognizer.auxNames : componentRecognizer.names).get(routeName);
+    let linkParamIndex = 0;
+    let routeParams = {};
 
-    if (!isPresent(routeRecognizer)) {
-      throw new BaseException(
-          `Component "${getTypeNameForDebugging(parentComponent)}" has no route named "${routeName}".`);
-    }
+    // first, recognize the primary route if one is provided
+    if (linkParamIndex < linkParams.length && isString(linkParams[linkParamIndex])) {
+      let routeName = linkParams[linkParamIndex];
+      if (routeName == '' || routeName == '.' || routeName == '..') {
+        throw new BaseException(`"${routeName}/" is only allowed at the beginning of a link DSL.`);
+      }
+      linkParamIndex += 1;
+      if (linkParamIndex < linkParams.length) {
+        let linkParam = linkParams[linkParamIndex];
+        if (isStringMap(linkParam) && !isArray(linkParam)) {
+          routeParams = linkParam;
+          linkParamIndex += 1;
+        }
+      }
+      var routeRecognizer =
+          (_aux ? componentRecognizer.auxNames : componentRecognizer.names).get(routeName);
 
-    if (!isPresent(routeRecognizer.handler.componentType)) {
-      var compInstruction = routeRecognizer.generateComponentPathValues(params);
-      return new UnresolvedInstruction(() => {
-        return routeRecognizer.handler.resolveComponentType().then(
-            (_) => { return this._generate(linkParams, ancestorInstructions, _aux); });
-      }, compInstruction['urlPath'], compInstruction['urlParams']);
-    }
+      if (isBlank(routeRecognizer)) {
+        throw new BaseException(
+            `Component "${getTypeNameForDebugging(parentComponentType)}" has no route named "${routeName}".`);
+      }
 
-    var componentInstruction = _aux ? componentRecognizer.generateAuxiliary(routeName, params) :
-                                      componentRecognizer.generate(routeName, params);
+      // Create an "unresolved instruction" for async routes
+      // we'll figure out the rest of the route when we resolve the instruction and
+      // perform a navigation
+      if (isBlank(routeRecognizer.handler.componentType)) {
+        var compInstruction = routeRecognizer.generateComponentPathValues(routeParams);
+        return new UnresolvedInstruction(() => {
+          return routeRecognizer.handler.resolveComponentType().then((_) => {
+            return this._generate(linkParams, ancestorInstructions, prevInstruction, _aux,
+                                  _originalLink);
+          });
+        }, compInstruction['urlPath'], compInstruction['urlParams']);
+      }
 
+      componentInstruction = _aux ? componentRecognizer.generateAuxiliary(routeName, routeParams) :
+                                    componentRecognizer.generate(routeName, routeParams);
+    }
 
+    // Next, recognize auxiliary instructions.
+    // If we have an ancestor instruction, we preserve whatever aux routes are active from it.
+    while (linkParamIndex < linkParams.length && isArray(linkParams[linkParamIndex])) {
+      let auxParentInstruction = [parentInstruction];
+      let auxInstruction = this._generate(linkParams[linkParamIndex], auxParentInstruction, null,
+                                          true, _originalLink);
 
-    var remaining = linkParams.slice(linkIndex + 1);
+      // TODO: this will not work for aux routes with parameters or multiple segments
+      auxInstructions[auxInstruction.component.urlPath] = auxInstruction;
+      linkParamIndex += 1;
+    }
 
     var instruction = new ResolvedInstruction(componentInstruction, null, auxInstructions);
 
-    // the component is sync
-    if (isPresent(componentInstruction.componentType)) {
+    // If the component is sync, we can generate resolved child route instructions
+    // If not, we'll resolve the instructions at navigation time
+    if (isPresent(componentInstruction) && isPresent(componentInstruction.componentType)) {
       let childInstruction: Instruction = null;
-      if (linkIndex + 1 < linkParams.length) {
-        let childAncestorComponents = ancestorInstructions.concat([instruction]);
-        childInstruction = this._generate(remaining, childAncestorComponents);
-      } else if (!componentInstruction.terminal) {
-        // ... look for defaults
-        childInstruction = this.generateDefault(componentInstruction.componentType);
-
-        if (isBlank(childInstruction)) {
-          throw new BaseException(
-              `Link "${ListWrapper.toJSON(linkParams)}" does not resolve to a terminal instruction.`);
+      if (componentInstruction.terminal) {
+        if (linkParamIndex >= linkParams.length) {
+          // TODO: throw that there are extra link params beyond the terminal component
         }
+      } else {
+        let childAncestorComponents = ancestorInstructions.concat([instruction]);
+        let remainingLinkParams = linkParams.slice(linkParamIndex);
+        childInstruction = this._generate(remainingLinkParams, childAncestorComponents, null, false,
+                                          _originalLink);
       }
       instruction.child = childInstruction;
     }
@@ -422,7 +459,6 @@ export class RouteRegistry {
       return null;
     }
 
-
     var defaultChild = null;
     if (isPresent(componentRecognizer.defaultRoute.handler.componentType)) {
       var componentInstruction = componentRecognizer.defaultRoute.generate({});
@@ -458,7 +494,39 @@ function splitAndFlattenLinkParams(linkParams: any[]): any[] {
  * Given a list of instructions, returns the most specific instruction
  */
 function mostSpecific(instructions: Instruction[]): Instruction {
-  return ListWrapper.maximum(instructions, (instruction: Instruction) => instruction.specificity);
+  instructions = instructions.filter((instruction) => isPresent(instruction));
+  if (instructions.length == 0) {
+    return null;
+  }
+  if (instructions.length == 1) {
+    return instructions[0];
+  }
+  var first = instructions[0];
+  var rest = instructions.slice(1);
+  return rest.reduce((instruction: Instruction, contender: Instruction) => {
+    if (compareSpecificityStrings(contender.specificity, instruction.specificity) == -1) {
+      return contender;
+    }
+    return instruction;
+  }, first);
+}
+
+/*
+ * Expects strings to be in the form of "[0-2]+"
+ * Returns -1 if string A should be sorted above string B, 1 if it should be sorted after,
+ * or 0 if they are the same.
+ */
+function compareSpecificityStrings(a: string, b: string): number {
+  var l = Math.min(a.length, b.length);
+  for (var i = 0; i < l; i += 1) {
+    var ai = StringWrapper.charCodeAt(a, i);
+    var bi = StringWrapper.charCodeAt(b, i);
+    var difference = bi - ai;
+    if (difference != 0) {
+      return difference;
+    }
+  }
+  return a.length - b.length;
 }
 
 function assertTerminalComponent(component, path) {
diff --git a/modules/angular2/src/router/router.ts b/modules/angular2/src/router/router.ts
index 032f3932c5e3..e90982e35345 100644
--- a/modules/angular2/src/router/router.ts
+++ b/modules/angular2/src/router/router.ts
@@ -95,8 +95,6 @@ export class Router {
       throw new BaseException(`registerAuxOutlet expects to be called with an outlet with a name.`);
     }
 
-    // TODO...
-    // what is the host of an aux route???
     var router = this.auxRouter(this.hostComponent);
 
     this._auxRouters.set(outletName, router);
@@ -224,10 +222,12 @@ export class Router {
   /** @internal */
   _settleInstruction(instruction: Instruction): Promise<any> {
     return instruction.resolveComponent().then((_) => {
-      instruction.component.reuse = false;
-
       var unsettledInstructions: Array<Promise<any>> = [];
 
+      if (isPresent(instruction.component)) {
+        instruction.component.reuse = false;
+      }
+
       if (isPresent(instruction.child)) {
         unsettledInstructions.push(this._settleInstruction(instruction.child));
       }
@@ -256,6 +256,9 @@ export class Router {
     if (isBlank(this._outlet)) {
       return _resolveToFalse;
     }
+    if (isBlank(instruction.component)) {
+      return _resolveToTrue;
+    }
     return this._outlet.routerCanReuse(instruction.component)
         .then((result) => {
           instruction.component.reuse = result;
@@ -280,7 +283,7 @@ export class Router {
     if (isPresent(instruction)) {
       childInstruction = instruction.child;
       componentInstruction = instruction.component;
-      reuse = instruction.component.reuse;
+      reuse = isBlank(instruction.component) || instruction.component.reuse;
     }
     if (reuse) {
       next = _resolveToTrue;
@@ -304,8 +307,9 @@ export class Router {
    */
   commit(instruction: Instruction, _skipLocationChange: boolean = false): Promise<any> {
     this._currentInstruction = instruction;
+
     var next: Promise<any> = _resolveToTrue;
-    if (isPresent(this._outlet)) {
+    if (isPresent(this._outlet) && isPresent(instruction.component)) {
       var componentInstruction = instruction.component;
       if (componentInstruction.reuse) {
         next = this._outlet.reuse(componentInstruction);
@@ -381,15 +385,12 @@ export class Router {
   }
 
   private _getAncestorInstructions(): Instruction[] {
-    var ancestorComponents = [];
+    var ancestorInstructions = [this._currentInstruction];
     var ancestorRouter: Router = this;
-    while (isPresent(ancestorRouter.parent) &&
-           isPresent(ancestorRouter.parent._currentInstruction)) {
-      ancestorRouter = ancestorRouter.parent;
-      ancestorComponents.unshift(ancestorRouter._currentInstruction);
+    while (isPresent(ancestorRouter = ancestorRouter.parent)) {
+      ancestorInstructions.unshift(ancestorRouter._currentInstruction);
     }
-
-    return ancestorComponents;
+    return ancestorInstructions;
   }
 
 
@@ -505,6 +506,9 @@ class ChildRouter extends Router {
 function canActivateOne(nextInstruction: Instruction,
                         prevInstruction: Instruction): Promise<boolean> {
   var next = _resolveToTrue;
+  if (isBlank(nextInstruction.component)) {
+    return next;
+  }
   if (isPresent(nextInstruction.child)) {
     next = canActivateOne(nextInstruction.child,
                           isPresent(prevInstruction) ? prevInstruction.child : null);
diff --git a/modules/angular2/src/router/router_link.ts b/modules/angular2/src/router/router_link.ts
index f228c4f7aefb..bc51960bdee8 100644
--- a/modules/angular2/src/router/router_link.ts
+++ b/modules/angular2/src/router/router_link.ts
@@ -53,16 +53,24 @@ export class RouterLink {
   // the instruction passed to the router to navigate
   private _navigationInstruction: Instruction;
 
-  constructor(private _router: Router, private _location: Location) {}
+  constructor(private _router: Router, private _location: Location) {
+    // we need to update the link whenever a route changes to account for aux routes
+    this._router.subscribe((_) => this._updateLink());
+  }
+
+  // because auxiliary links take existing primary and auxiliary routes into account,
+  // we need to update the link whenever params or other routes change.
+  private _updateLink(): void {
+    this._navigationInstruction = this._router.generate(this._routeParams);
+    var navigationHref = this._navigationInstruction.toLinkUrl();
+    this.visibleHref = this._location.prepareExternalUrl(navigationHref);
+  }
 
   get isRouteActive(): boolean { return this._router.isRouteActive(this._navigationInstruction); }
 
   set routeParams(changes: any[]) {
     this._routeParams = changes;
-    this._navigationInstruction = this._router.generate(this._routeParams);
-
-    var navigationHref = this._navigationInstruction.toLinkUrl();
-    this.visibleHref = this._location.prepareExternalUrl(navigationHref);
+    this._updateLink();
   }
 
   onClick(): boolean {
diff --git a/modules/angular2/src/testing/fake_async.ts b/modules/angular2/src/testing/fake_async.ts
index 832ed5f1d47a..49cc35dc549a 100644
--- a/modules/angular2/src/testing/fake_async.ts
+++ b/modules/angular2/src/testing/fake_async.ts
@@ -19,6 +19,10 @@ interface FakeAsyncZone extends NgZoneZone {
  *
  * If there are any pending timers at the end of the function, an exception will be thrown.
  *
+ * ## Example
+ *
+ * {@example testing/ts/fake_async.ts region='basic'}
+ *
  * @param fn
  * @returns {Function} The function wrapped to be executed in the fakeAsync zone
  */
@@ -63,8 +67,17 @@ export function fakeAsync(fn: Function): Function {
   }
 }
 
-// TODO we should fix tick to dequeue the failed timer instead of relying on clearPendingTimers
+/**
+ * Clear the queue of pending timers and microtasks.
+ *
+ * Useful for cleaning up after an asynchronous test passes.
+ *
+ * ## Example
+ *
+ * {@example testing/ts/fake_async.ts region='pending'}
+ */
 export function clearPendingTimers(): void {
+  // TODO we should fix tick to dequeue the failed timer instead of relying on clearPendingTimers
   ListWrapper.clear(_microtasks);
   ListWrapper.clear(_pendingPeriodicTimers);
   ListWrapper.clear(_pendingTimers);
@@ -77,6 +90,10 @@ export function clearPendingTimers(): void {
  * The microtasks queue is drained at the very start of this function and after any timer callback
  * has been executed.
  *
+ * ## Example
+ *
+ * {@example testing/ts/fake_async.ts region='basic'}
+ *
  * @param {number} millis Number of millisecond, defaults to 0
  */
 export function tick(millis: number = 0): void {
diff --git a/modules/angular2/src/testing/matchers.ts b/modules/angular2/src/testing/matchers.ts
index 163b68e92ccf..79e21f7236de 100644
--- a/modules/angular2/src/testing/matchers.ts
+++ b/modules/angular2/src/testing/matchers.ts
@@ -2,21 +2,97 @@ import {DOM} from 'angular2/src/platform/dom/dom_adapter';
 import {global, isString} from 'angular2/src/facade/lang';
 import {StringMapWrapper} from 'angular2/src/facade/collection';
 
-
+/**
+ * Jasmine matchers that check Angular specific conditions.
+ */
 export interface NgMatchers extends jasmine.Matchers {
+  /**
+   * Expect the value to be a `Promise`.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toBePromise'}
+   */
   toBePromise(): boolean;
+
+  /**
+   * Expect the value to be an instance of a class.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toBeAnInstanceOf'}
+   */
   toBeAnInstanceOf(expected: any): boolean;
+
+  /**
+   * Expect the element to have exactly the given text.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toHaveText'}
+   */
   toHaveText(expected: any): boolean;
+
+  /**
+   * Expect the element to have the given CSS class.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toHaveCssClass'}
+   */
   toHaveCssClass(expected: any): boolean;
+
+  /**
+   * Expect the element to have the given CSS styles.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toHaveCssStyle'}
+   */
   toHaveCssStyle(expected: any): boolean;
+
+  /**
+   * Expect a class to implement the interface of the given class.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toImplement'}
+   */
   toImplement(expected: any): boolean;
+
+  /**
+   * Expect an exception to contain the given error text.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toContainError'}
+   */
   toContainError(expected: any): boolean;
+
+  /**
+   * Expect a function to throw an error with the given error text when executed.
+   *
+   * ## Example
+   *
+   * {@example testing/ts/matchers.ts region='toThrowErrorWith'}
+   */
   toThrowErrorWith(expectedMessage: any): boolean;
+
+  /**
+   * Invert the matchers.
+   */
   not: NgMatchers;
 }
 
 var _global: jasmine.GlobalPolluter = <any>(typeof window === 'undefined' ? global : window);
 
+/**
+ * Jasmine matching function with Angular matchers mixed in.
+ *
+ * ## Example
+ *
+ * {@example testing/ts/matchers.ts region='toHaveText'}
+ */
 export var expect: (actual: any) => NgMatchers = <any>_global.expect;
 
 
diff --git a/modules/angular2/src/testing/test_injector.ts b/modules/angular2/src/testing/test_injector.ts
index 377c2c9bd673..05fddf45f872 100644
--- a/modules/angular2/src/testing/test_injector.ts
+++ b/modules/angular2/src/testing/test_injector.ts
@@ -23,7 +23,7 @@ import {
   defaultKeyValueDiffers,
   ChangeDetectorGenConfig
 } from 'angular2/src/core/change_detection/change_detection';
-import {ExceptionHandler} from 'angular2/src/facade/exceptions';
+import {BaseException, ExceptionHandler} from 'angular2/src/facade/exceptions';
 import {PipeResolver} from 'angular2/src/core/linker/pipe_resolver';
 import {XHR} from 'angular2/src/compiler/xhr';
 
@@ -131,20 +131,69 @@ function _runtimeCompilerBindings() {
   ];
 }
 
+export class TestInjector {
+  private _instantiated: boolean = false;
+
+  private _injector: Injector = null;
+
+  private _providers: Array<Type | Provider | any[]> = [];
+
+  reset() {
+    this._injector = null;
+    this._providers = [];
+    this._instantiated = false;
+  }
+
+  addProviders(providers: Array<Type | Provider | any[]>) {
+    if (this._instantiated) {
+      throw new BaseException('Cannot add providers after test injector is instantiated');
+    }
+    this._providers = ListWrapper.concat(this._providers, providers);
+  }
+
+  createInjector() {
+    var rootInjector = Injector.resolveAndCreate(_getRootProviders());
+    this._injector = rootInjector.resolveAndCreateChild(ListWrapper.concat(
+        ListWrapper.concat(_getAppBindings(), _runtimeCompilerBindings()), this._providers));
+    this._instantiated = true;
+    return this._injector;
+  }
+
+  execute(fn: FunctionWithParamTokens): any {
+    if (!this._instantiated) {
+      this.createInjector();
+    }
+    return fn.execute(this._injector);
+  }
+}
+
+var _testInjector: TestInjector = null;
+
+export function getTestInjector() {
+  if (_testInjector == null) {
+    _testInjector = new TestInjector();
+  }
+  return _testInjector;
+}
+
+/**
+ * @deprecated Use TestInjector#createInjector() instead.
+ */
 export function createTestInjector(providers: Array<Type | Provider | any[]>): Injector {
   var rootInjector = Injector.resolveAndCreate(_getRootProviders());
   return rootInjector.resolveAndCreateChild(ListWrapper.concat(_getAppBindings(), providers));
 }
 
+/**
+ * @deprecated Use TestInjector#createInjector() instead.
+ */
 export function createTestInjectorWithRuntimeCompiler(
     providers: Array<Type | Provider | any[]>): Injector {
   return createTestInjector(ListWrapper.concat(_runtimeCompilerBindings(), providers));
 }
 
 /**
- * Allows injecting dependencies in `beforeEach()` and `it()`. When using with the
- * `angular2/testing` library, the test function will be run within a zone and will
- * automatically complete when all asynchronous tests have finished.
+ * Allows injecting dependencies in `beforeEach()` and `it()`.
  *
  * Example:
  *
@@ -155,14 +204,14 @@ export function createTestInjectorWithRuntimeCompiler(
  * }));
  *
  * it('...', inject([AClass], (object) => {
- *   object.doSomething().then(() => {
- *     expect(...);
- *   });
+ *   object.doSomething();
+ *   expect(...);
  * })
  * ```
  *
  * Notes:
- * - inject is currently a function because of some Traceur limitation the syntax should eventually
+ * - inject is currently a function because of some Traceur limitation the syntax should
+ * eventually
  *   becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`
  *
  * @param {Array} tokens
@@ -174,7 +223,22 @@ export function inject(tokens: any[], fn: Function): FunctionWithParamTokens {
 }
 
 /**
- * @deprecated Use inject instead, which now supports both synchronous and asynchronous tests.
+ * Allows injecting dependencies in `beforeEach()` and `it()`. The test must return
+ * a promise which will resolve when all asynchronous activity is complete.
+ *
+ * Example:
+ *
+ * ```
+ * it('...', injectAsync([AClass], (object) => {
+ *   return object.doSomething().then(() => {
+ *     expect(...);
+ *   });
+ * })
+ * ```
+ *
+ * @param {Array} tokens
+ * @param {Function} fn
+ * @return {FunctionWithParamTokens}
  */
 export function injectAsync(tokens: any[], fn: Function): FunctionWithParamTokens {
   return new FunctionWithParamTokens(tokens, fn, true);
diff --git a/modules/angular2/src/testing/testing.ts b/modules/angular2/src/testing/testing.ts
index 6112c1624499..73176eea213b 100644
--- a/modules/angular2/src/testing/testing.ts
+++ b/modules/angular2/src/testing/testing.ts
@@ -7,10 +7,11 @@ import {ListWrapper} from 'angular2/src/facade/collection';
 import {bind} from 'angular2/core';
 
 import {
-  createTestInjectorWithRuntimeCompiler,
   FunctionWithParamTokens,
   inject,
-  injectAsync
+  injectAsync,
+  TestInjector,
+  getTestInjector
 } from './test_injector';
 
 export {inject, injectAsync} from './test_injector';
@@ -71,8 +72,20 @@ export var fdescribe: Function = _global.fdescribe;
  */
 export var xdescribe: Function = _global.xdescribe;
 
+/**
+ * Signature for a synchronous test function (no arguments).
+ */
 export type SyncTestFn = () => void;
+
+/**
+ * Signature for an asynchronous test function which takes a
+ * `done` callback.
+ */
 export type AsyncTestFn = (done: () => void) => void;
+
+/**
+ * Signature for any simple testing function.
+ */
 export type AnyTestFn = SyncTestFn | AsyncTestFn;
 
 var jsmBeforeEach = _global.beforeEach;
@@ -80,14 +93,10 @@ var jsmIt = _global.it;
 var jsmIIt = _global.fit;
 var jsmXIt = _global.xit;
 
-var testProviders;
-var injector;
+var testInjector: TestInjector = getTestInjector();
 
 // Reset the test providers before each test.
-jsmBeforeEach(() => {
-  testProviders = [];
-  injector = null;
-});
+jsmBeforeEach(() => { testInjector.reset(); });
 
 /**
  * Allows overriding default providers of the test injector,
@@ -103,8 +112,9 @@ export function beforeEachProviders(fn): void {
   jsmBeforeEach(() => {
     var providers = fn();
     if (!providers) return;
-    testProviders = [...testProviders, ...providers];
-    if (injector !== null) {
+    try {
+      testInjector.addProviders(providers);
+    } catch (e) {
       throw new Error('beforeEachProviders was called after the injector had ' +
                       'been used in a beforeEach or it block. This invalidates the ' +
                       'test injector');
@@ -176,13 +186,26 @@ function _it(jsmFn: Function, name: string, testFn: FunctionWithParamTokens | An
 
   if (testFn instanceof FunctionWithParamTokens) {
     jsmFn(name, (done) => {
-      if (!injector) {
-        injector = createTestInjectorWithRuntimeCompiler(testProviders);
-      }
+      var finishCallback = () => {
+        // Wait one more event loop to make sure we catch unreturned promises and
+        // promise rejections.
+        setTimeout(done, 0);
+      };
+      var returnedTestValue =
+          runInTestZone(() => testInjector.execute(testFn), finishCallback, done.fail);
 
-      var returnedTestValue = runInTestZone(() => testFn.execute(injector), done, done.fail);
-      if (_isPromiseLike(returnedTestValue)) {
-        (<Promise<any>>returnedTestValue).then(null, (err) => { done.fail(err); });
+      if (testFn.isAsync) {
+        if (_isPromiseLike(returnedTestValue)) {
+          (<Promise<any>>returnedTestValue).then(null, (err) => { done.fail(err); });
+        } else {
+          done.fail('Error: injectAsync was expected to return a promise, but the ' +
+                    ' returned value was: ' + returnedTestValue);
+        }
+      } else {
+        if (!(returnedTestValue === undefined)) {
+          done.fail('Error: inject returned a value. Did you mean to use injectAsync? Returned ' +
+                    'value was: ' + returnedTestValue);
+        }
       }
     }, timeOut);
   } else {
@@ -208,13 +231,28 @@ export function beforeEach(fn: FunctionWithParamTokens | AnyTestFn): void {
   if (fn instanceof FunctionWithParamTokens) {
     // The test case uses inject(). ie `beforeEach(inject([ClassA], (a) => { ...
     // }));`
-
     jsmBeforeEach((done) => {
-      if (!injector) {
-        injector = createTestInjectorWithRuntimeCompiler(testProviders);
-      }
+      var finishCallback = () => {
+        // Wait one more event loop to make sure we catch unreturned promises and
+        // promise rejections.
+        setTimeout(done, 0);
+      };
 
-      runInTestZone(() => fn.execute(injector), done, done.fail);
+      var returnedTestValue =
+          runInTestZone(() => testInjector.execute(fn), finishCallback, done.fail);
+      if (fn.isAsync) {
+        if (_isPromiseLike(returnedTestValue)) {
+          (<Promise<any>>returnedTestValue).then(null, (err) => { done.fail(err); });
+        } else {
+          done.fail('Error: injectAsync was expected to return a promise, but the ' +
+                    ' returned value was: ' + returnedTestValue);
+        }
+      } else {
+        if (!(returnedTestValue === undefined)) {
+          done.fail('Error: inject returned a value. Did you mean to use injectAsync? Returned ' +
+                    'value was: ' + returnedTestValue);
+        }
+      }
     });
   } else {
     // The test case doesn't use inject(). ie `beforeEach((done) => { ... }));`
@@ -238,7 +276,7 @@ export function beforeEach(fn: FunctionWithParamTokens | AnyTestFn): void {
  *
  * ## Example:
  *
- * {@example testing/ts/testing.ts region='it'}
+ * {@example testing/ts/testing.ts region='describeIt'}
  */
 export function it(name: string, fn: FunctionWithParamTokens | AnyTestFn,
                    timeOut: number = null): void {
diff --git a/modules/angular2/src/testing/testing_internal.dart b/modules/angular2/src/testing/testing_internal.dart
index 0bc0f6d5a29f..821300b74242 100644
--- a/modules/angular2/src/testing/testing_internal.dart
+++ b/modules/angular2/src/testing/testing_internal.dart
@@ -21,20 +21,23 @@ import 'package:angular2/src/core/reflection/reflection.dart';
 import 'package:angular2/src/core/reflection/reflection_capabilities.dart';
 
 import 'package:angular2/src/core/di/provider.dart' show bind;
-import 'package:angular2/src/core/di/injector.dart' show Injector;
 import 'package:angular2/src/facade/collection.dart' show StringMapWrapper;
 
 import 'test_injector.dart';
 export 'test_injector.dart' show inject;
 
-List _testBindings = [];
-Injector _injector;
+TestInjector _testInjector = getTestInjector();
 bool _isCurrentTestAsync;
+Future _currentTestFuture;
 bool _inIt = false;
 
 class AsyncTestCompleter {
   final _completer = new Completer();
 
+  AsyncTestCompleter() {
+    _currentTestFuture = this.future;
+  }
+
   void done() {
     _completer.complete();
   }
@@ -50,10 +53,11 @@ void testSetup() {
   // - Priority 1: create the test injector to be used in beforeEach() and it()
 
   gns.beforeEach(() {
-    _testBindings.clear();
+    _testInjector.reset();
+    _currentTestFuture = null;
   }, priority: 3);
 
-  var completerBinding = bind(AsyncTestCompleter).toFactory(() {
+  var completerProvider = bind(AsyncTestCompleter).toFactory(() {
     // Mark the test as async when an AsyncTestCompleter is injected in an it(),
     if (!_inIt) throw 'AsyncTestCompleter can only be injected in an "it()"';
     _isCurrentTestAsync = true;
@@ -62,15 +66,14 @@ void testSetup() {
 
   gns.beforeEach(() {
     _isCurrentTestAsync = false;
-    _testBindings.add(completerBinding);
-    _injector = createTestInjectorWithRuntimeCompiler(_testBindings);
+    _testInjector.addProviders([completerProvider]);
   }, priority: 1);
 }
 
 /**
- * Allows overriding default bindings defined in test_injector.js.
+ * Allows overriding default providers defined in test_injector.js.
  *
- * The given function must return a list of DI bindings.
+ * The given function must return a list of DI providers.
  *
  * Example:
  *
@@ -81,8 +84,8 @@ void testSetup() {
  */
 void beforeEachProviders(Function fn) {
   gns.beforeEach(() {
-    var bindings = fn();
-    if (bindings != null) _testBindings.addAll(bindings);
+    var providers = fn();
+    if (providers != null) _testInjector.addProviders(providers);
   }, priority: 2);
 }
 
@@ -95,7 +98,7 @@ void beforeEach(fn) {
   if (fn is! FunctionWithParamTokens) fn =
       new FunctionWithParamTokens([], fn, false);
   gns.beforeEach(() {
-    fn.execute(_injector);
+    _testInjector.execute(fn);
   });
 }
 
@@ -104,9 +107,9 @@ void _it(gnsFn, name, fn) {
       new FunctionWithParamTokens([], fn, false);
   gnsFn(name, () {
     _inIt = true;
-    fn.execute(_injector);
+    _testInjector.execute(fn);
     _inIt = false;
-    if (_isCurrentTestAsync) return _injector.get(AsyncTestCompleter).future;
+    if (_isCurrentTestAsync) return _currentTestFuture;
   });
 }
 
diff --git a/modules/angular2/src/testing/testing_internal.ts b/modules/angular2/src/testing/testing_internal.ts
index 54c01333c1f9..72ca9ebb10db 100644
--- a/modules/angular2/src/testing/testing_internal.ts
+++ b/modules/angular2/src/testing/testing_internal.ts
@@ -5,11 +5,7 @@ import {NgZoneZone} from 'angular2/src/core/zone/ng_zone';
 
 import {provide} from 'angular2/core';
 
-import {
-  createTestInjectorWithRuntimeCompiler,
-  FunctionWithParamTokens,
-  inject
-} from './test_injector';
+import {TestInjector, getTestInjector, FunctionWithParamTokens, inject} from './test_injector';
 import {browserDetection} from './utils';
 
 export {inject} from './test_injector';
@@ -26,6 +22,9 @@ export type SyncTestFn = () => void;
 type AsyncTestFn = (done: () => void) => void;
 type AnyTestFn = SyncTestFn | AsyncTestFn;
 
+/**
+ * Injectable completer that allows signaling completion of an asynchronous test. Used internally.
+ */
 export class AsyncTestCompleter {
   constructor(private _done: Function) {}
 
@@ -45,7 +44,7 @@ var inIt = false;
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 500;
 var globalTimeOut = browserDetection.isSlow ? 3000 : jasmine.DEFAULT_TIMEOUT_INTERVAL;
 
-var testProviders;
+var testInjector = getTestInjector();
 
 /**
  * Mechanism to run `beforeEach()` functions of Angular tests.
@@ -59,16 +58,17 @@ class BeforeEachRunner {
 
   beforeEach(fn: FunctionWithParamTokens | SyncTestFn): void { this._fns.push(fn); }
 
-  run(injector): void {
-    if (this._parent) this._parent.run(injector);
+  run(): void {
+    if (this._parent) this._parent.run();
     this._fns.forEach((fn) => {
-      return isFunction(fn) ? (<SyncTestFn>fn)() : (<FunctionWithParamTokens>fn).execute(injector);
+      return isFunction(fn) ? (<SyncTestFn>fn)() :
+                              (testInjector.execute(<FunctionWithParamTokens>fn));
     });
   }
 }
 
 // Reset the test providers before each test
-jsmBeforeEach(() => { testProviders = []; });
+jsmBeforeEach(() => { testInjector.reset(); });
 
 function _describe(jsmFn, ...args) {
   var parentRunner = runnerStack.length === 0 ? null : runnerStack[runnerStack.length - 1];
@@ -117,7 +117,7 @@ export function beforeEachProviders(fn): void {
   jsmBeforeEach(() => {
     var providers = fn();
     if (!providers) return;
-    testProviders = [...testProviders, ...providers];
+    testInjector.addProviders(providers);
   });
 }
 
@@ -147,18 +147,17 @@ function _it(jsmFn: Function, name: string, testFn: FunctionWithParamTokens | An
           }
         });
 
-        var injector = createTestInjectorWithRuntimeCompiler([...testProviders, completerProvider]);
-        runner.run(injector);
+        testInjector.addProviders([completerProvider]);
+        runner.run();
 
         inIt = true;
-        testFn.execute(injector);
+        testInjector.execute(testFn);
         inIt = false;
       }, timeOut);
     } else {
       jsmFn(name, () => {
-        var injector = createTestInjectorWithRuntimeCompiler(testProviders);
-        runner.run(injector);
-        testFn.execute(injector);
+        runner.run();
+        testInjector.execute(testFn);
       }, timeOut);
     }
 
@@ -167,14 +166,12 @@ function _it(jsmFn: Function, name: string, testFn: FunctionWithParamTokens | An
 
     if ((<any>testFn).length === 0) {
       jsmFn(name, () => {
-        var injector = createTestInjectorWithRuntimeCompiler(testProviders);
-        runner.run(injector);
+        runner.run();
         (<SyncTestFn>testFn)();
       }, timeOut);
     } else {
       jsmFn(name, (done) => {
-        var injector = createTestInjectorWithRuntimeCompiler(testProviders);
-        runner.run(injector);
+        runner.run();
         (<AsyncTestFn>testFn)(done);
       }, timeOut);
     }
diff --git a/modules/angular2/test/compiler/eval_module.ts b/modules/angular2/test/compiler/eval_module.ts
index 0e5f89063124..497bccbe6439 100644
--- a/modules/angular2/test/compiler/eval_module.ts
+++ b/modules/angular2/test/compiler/eval_module.ts
@@ -26,7 +26,7 @@ export function evalModule(moduleSource: string, imports: string[][], args: any[
     // using SystemJS, the loader might get confused by the presence of require,
     // and attempt to load "+ modName +.js" !?!
     // A simple string concat manages to prevent that, but that is one compiler
-    // optimaztion away from breaking again. Proceed with caution!
+    // optimization away from breaking again. Proceed with caution!
     moduleSourceWithImports.push(`var ${modAlias} = require` + `('${modId}');`);
   });
   moduleSourceWithImports.push(moduleSource);
diff --git a/modules/angular2/test/compiler/runtime_metadata_spec.ts b/modules/angular2/test/compiler/runtime_metadata_spec.ts
index 46fd18e4097c..50ca069ca241 100644
--- a/modules/angular2/test/compiler/runtime_metadata_spec.ts
+++ b/modules/angular2/test/compiler/runtime_metadata_spec.ts
@@ -70,10 +70,10 @@ export function main() {
 
       it('should use the moduleUrl from the reflector if none is given',
          inject([RuntimeMetadataResolver], (resolver: RuntimeMetadataResolver) => {
-           var value: string = resolver.getMetadata(DirectiveWithoutModuleId).type.moduleUrl;
+           var value: string = resolver.getMetadata(ComponentWithoutModuleId).type.moduleUrl;
            var expectedEndValue =
                IS_DART ? 'base/dist/dart/angular2/test/compiler/runtime_metadata_spec.dart' : './';
-           expect((<any>value).endsWith(expectedEndValue)).toBe(true);
+           expect(value.endsWith(expectedEndValue)).toBe(true);
          }));
     });
 
@@ -82,7 +82,7 @@ export function main() {
       it('should return the directive metadatas',
          inject([RuntimeMetadataResolver], (resolver: RuntimeMetadataResolver) => {
            expect(resolver.getViewDirectivesMetadata(ComponentWithEverything))
-               .toEqual([resolver.getMetadata(DirectiveWithoutModuleId)]);
+               .toEqual([resolver.getMetadata(SomeDirective)]);
          }));
 
       describe("platform directives", () => {
@@ -91,10 +91,7 @@ export function main() {
         it('should include platform directives when available',
            inject([RuntimeMetadataResolver], (resolver: RuntimeMetadataResolver) => {
              expect(resolver.getViewDirectivesMetadata(ComponentWithEverything))
-                 .toEqual([
-                   resolver.getMetadata(ADirective),
-                   resolver.getMetadata(DirectiveWithoutModuleId)
-                 ]);
+                 .toEqual([resolver.getMetadata(ADirective), resolver.getMetadata(SomeDirective)]);
            }));
       });
     });
@@ -102,14 +99,16 @@ export function main() {
   });
 }
 
-
-
 @Directive({selector: 'a-directive'})
 class ADirective {
 }
 
 @Directive({selector: 'someSelector'})
-class DirectiveWithoutModuleId {
+class SomeDirective {
+}
+
+@Component({selector: 'someComponent', template: ''})
+class ComponentWithoutModuleId {
 }
 
 @Component({
@@ -131,7 +130,7 @@ class DirectiveWithoutModuleId {
   encapsulation: ViewEncapsulation.Emulated,
   styles: ['someStyle'],
   styleUrls: ['someStyleUrl'],
-  directives: [DirectiveWithoutModuleId]
+  directives: [SomeDirective]
 })
 class ComponentWithEverything implements OnChanges,
     OnInit, DoCheck, OnDestroy, AfterContentInit, AfterContentChecked, AfterViewInit,
diff --git a/modules/angular2/test/compiler/shadow_css_spec.ts b/modules/angular2/test/compiler/shadow_css_spec.ts
index 810f81088e87..14d1fd1080ff 100644
--- a/modules/angular2/test/compiler/shadow_css_spec.ts
+++ b/modules/angular2/test/compiler/shadow_css_spec.ts
@@ -203,7 +203,7 @@ export function main() {
             .toEqual([new CssRule('a', 'b {c}'), new CssRule('d', 'e')]);
       });
 
-      it('should capture mutiple rules where some have no body', () => {
+      it('should capture multiple rules where some have no body', () => {
         expect(captureRules('@import a ; b {c}'))
             .toEqual([new CssRule('@import a', ''), new CssRule('b', 'c')]);
       });
diff --git a/modules/angular2/test/compiler/template_compiler_spec.ts b/modules/angular2/test/compiler/template_compiler_spec.ts
index b09c0bc9ff96..cb5c0234ebf4 100644
--- a/modules/angular2/test/compiler/template_compiler_spec.ts
+++ b/modules/angular2/test/compiler/template_compiler_spec.ts
@@ -321,7 +321,7 @@ class CompWithEmbeddedTemplate {
 }
 
 
-@Directive({selector: 'plain', moduleId: THIS_MODULE_ID})
+@Directive({selector: 'plain'})
 @View({template: ''})
 class NonComponent {
 }
diff --git a/modules/angular2/test/compiler/template_normalizer_spec.ts b/modules/angular2/test/compiler/template_normalizer_spec.ts
index 8e07341e0f45..bb861beed1f8 100644
--- a/modules/angular2/test/compiler/template_normalizer_spec.ts
+++ b/modules/angular2/test/compiler/template_normalizer_spec.ts
@@ -296,7 +296,7 @@ export function main() {
            expect(template.styleUrls).toEqual(['http://some/module/test.css']);
          }));
 
-      it('should normalize ViewEncapsulation.Emulated to ViewEncapsulation.None if there are no stlyes nor stylesheets',
+      it('should normalize ViewEncapsulation.Emulated to ViewEncapsulation.None if there are no styles nor stylesheets',
          inject([TemplateNormalizer], (normalizer: TemplateNormalizer) => {
            var template = normalizer.normalizeLoadedTemplate(
                dirType, new CompileTemplateMetadata(
diff --git a/modules/angular2/test/compiler/xhr_mock_spec.ts b/modules/angular2/test/compiler/xhr_mock_spec.ts
index e502e9edfa66..44a797f78c8f 100644
--- a/modules/angular2/test/compiler/xhr_mock_spec.ts
+++ b/modules/angular2/test/compiler/xhr_mock_spec.ts
@@ -101,7 +101,7 @@ export function main() {
     it('should throw when flush is called without any pending requests',
        () => { expect(() => { xhr.flush(); }).toThrowError('No pending requests to flush'); });
 
-    it('should throw on unstatisfied expectations', () => {
+    it('should throw on unsatisfied expectations', () => {
       xhr.expect('/foo', 'bar');
       xhr.when('/bar', 'foo');
       xhr.get('/bar');
diff --git a/modules/angular2/test/core/application_ref_spec.ts b/modules/angular2/test/core/application_ref_spec.ts
index ae9a13a7101a..0f54b9c80f05 100644
--- a/modules/angular2/test/core/application_ref_spec.ts
+++ b/modules/angular2/test/core/application_ref_spec.ts
@@ -33,7 +33,7 @@ export function main() {
 
   describe("PlatformRef", () => {
     describe("asyncApplication", () => {
-      it("should merge syncronous and asyncronous providers",
+      it("should merge synchronous and asynchronous providers",
          inject([AsyncTestCompleter, Injector], (async, injector) => {
            let ref = new PlatformRef_(injector, null);
            let ASYNC_PROVIDERS = [new Provider(Foo, {useValue: new Foo()})];
diff --git a/modules/angular2/test/core/change_detection/change_detector_spec.ts b/modules/angular2/test/core/change_detection/change_detector_spec.ts
index 5128cfd2bfb5..80a9cb3cb621 100644
--- a/modules/angular2/test/core/change_detection/change_detector_spec.ts
+++ b/modules/angular2/test/core/change_detection/change_detector_spec.ts
@@ -1332,7 +1332,7 @@ export function main() {
           expect(d.a).toEqual(2);
         });
 
-        // TODO: enable after chaning dart infrastructure for generating tests
+        // TODO: enable after chaining dart infrastructure for generating tests
         // it('should throw when trying to assign to a local', () => {
         //   expect(() => {
         //     _createChangeDetector('(event)="$event=1"', d, null)
diff --git a/modules/angular2/test/core/di/injector_spec.ts b/modules/angular2/test/core/di/injector_spec.ts
index eed196dfe90b..41bc80970883 100644
--- a/modules/angular2/test/core/di/injector_spec.ts
+++ b/modules/angular2/test/core/di/injector_spec.ts
@@ -88,6 +88,8 @@ class NoAnnotations {
   constructor(secretDependency) {}
 }
 
+function factoryFn(a) {}
+
 export function main() {
   var dynamicProviders = [
     provide('provider0', {useValue: 1}),
@@ -142,10 +144,20 @@ export function main() {
         expect(car.engine).toBeAnInstanceOf(TurboEngine);
       });
 
-      it('should throw when no type and not @Inject', () => {
+      it('should throw when no type and not @Inject (class case)', () => {
         expect(() => createInjector([NoAnnotations]))
-            .toThrowError('Cannot resolve all parameters for NoAnnotations(?). ' +
-                          'Make sure they all have valid type or annotations.');
+            .toThrowError(
+                "Cannot resolve all parameters for 'NoAnnotations'(?). " +
+                'Make sure that all the parameters are decorated with Inject or have valid type annotations ' +
+                "and that 'NoAnnotations' is decorated with Injectable.");
+      });
+
+      it('should throw when no type and not @Inject (factory case)', () => {
+        expect(() => createInjector([provide("someToken", {useFactory: factoryFn})]))
+            .toThrowError(
+                "Cannot resolve all parameters for 'factoryFn'(?). " +
+                'Make sure that all the parameters are decorated with Inject or have valid type annotations ' +
+                "and that 'factoryFn' is decorated with Injectable.");
       });
 
       it('should cache instances', () => {
diff --git a/modules/angular2/test/core/reflection/reflector_spec.ts b/modules/angular2/test/core/reflection/reflector_spec.ts
index de865d6ba927..40e97c565a2d 100644
--- a/modules/angular2/test/core/reflection/reflector_spec.ts
+++ b/modules/angular2/test/core/reflection/reflector_spec.ts
@@ -160,7 +160,7 @@ export function main() {
         expect(reflector.parameters(TestObj)).toEqual([[1], [2]]);
       });
 
-      it("should return an empty list when no paramters field in the stored type info", () => {
+      it("should return an empty list when no parameters field in the stored type info", () => {
         reflector.registerType(TestObj, new ReflectionInfo());
         expect(reflector.parameters(TestObj)).toEqual([]);
       });
diff --git a/modules/angular2/test/core/util/decorators_spec.ts b/modules/angular2/test/core/util/decorators_spec.ts
index c1e32ff138a3..0b585751a000 100644
--- a/modules/angular2/test/core/util/decorators_spec.ts
+++ b/modules/angular2/test/core/util/decorators_spec.ts
@@ -108,13 +108,13 @@ export function main() {
         });
 
 
-        it('should ensure that last possition is function', () => {
+        it('should ensure that last position is function', () => {
           expect(() => {Class({constructor: []})})
               .toThrowError(
                   "Last position of Class method array must be Function in key constructor was 'undefined'");
         });
 
-        it('should ensure that annotation count matches paramaters count', () => {
+        it('should ensure that annotation count matches parameters count', () => {
           expect(() => {Class({constructor: [String, function MyType() {}]})})
               .toThrowError(
                   "Number of annotations (1) does not match number of arguments (0) in the function: MyType");
diff --git a/modules/angular2/test/facade/lang_spec.ts b/modules/angular2/test/facade/lang_spec.ts
index ceef4e2a6d2e..25a283adc9b9 100644
--- a/modules/angular2/test/facade/lang_spec.ts
+++ b/modules/angular2/test/facade/lang_spec.ts
@@ -80,7 +80,7 @@ export function main() {
            expect(StringWrapper.stripLeft(input, "#")).toEqual(expectedOutput);
          });
 
-      it('should not alter the provided input if the first charater does not match the provided input',
+      it('should not alter the provided input if the first character does not match the provided input',
          () => {
            var input = "+angular2 is amazing";
            expect(StringWrapper.stripLeft(input, "*")).toEqual(input);
@@ -100,7 +100,7 @@ export function main() {
         expect(StringWrapper.stripRight(input, "!")).toEqual(expectedOutput);
       });
 
-      it('should not alter the provided input if the first charater does not match the provided input',
+      it('should not alter the provided input if the first character does not match the provided input',
          () => {
            var input = "angular2 is amazing+";
 
diff --git a/modules/angular2/test/mock/view_resolver_mock_spec.ts b/modules/angular2/test/mock/view_resolver_mock_spec.ts
index 9325ee600809..f9f09cf8691d 100644
--- a/modules/angular2/test/mock/view_resolver_mock_spec.ts
+++ b/modules/angular2/test/mock/view_resolver_mock_spec.ts
@@ -55,7 +55,7 @@ export function main() {
         expect(view.directives).toEqual([SomeDirective]);
       });
 
-      it('should allow overriding an overriden @View', () => {
+      it('should allow overriding an overridden @View', () => {
         viewResolver.setView(SomeComponent, new ViewMetadata({template: 'overridden template'}));
         viewResolver.setInlineTemplate(SomeComponent, 'overridden template x 2');
         var view = viewResolver.resolve(SomeComponent);
@@ -79,7 +79,7 @@ export function main() {
         expect(view.directives[0]).toBe(SomeOtherDirective);
       });
 
-      it('should allow overriding a directive from an overriden @View', () => {
+      it('should allow overriding a directive from an overridden @View', () => {
         viewResolver.setView(SomeComponent, new ViewMetadata({directives: [SomeOtherDirective]}));
         viewResolver.overrideViewDirective(SomeComponent, SomeOtherDirective, SomeComponent);
         var view = viewResolver.resolve(SomeComponent);
diff --git a/modules/angular2/test/platform/browser/bootstrap_spec.ts b/modules/angular2/test/platform/browser/bootstrap_spec.ts
index 1b6b1ce52990..8b4fa3445571 100644
--- a/modules/angular2/test/platform/browser/bootstrap_spec.ts
+++ b/modules/angular2/test/platform/browser/bootstrap_spec.ts
@@ -15,6 +15,7 @@ import {
 import {IS_DART, isPresent, stringify} from 'angular2/src/facade/lang';
 import {bootstrap} from 'angular2/platform/browser';
 import {ApplicationRef} from 'angular2/src/core/application_ref';
+import {Console} from 'angular2/src/core/console';
 import {Component, Directive, View, OnDestroy, platform} from 'angular2/core';
 import {BROWSER_PROVIDERS, BROWSER_APP_PROVIDERS} from 'angular2/platform/browser';
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
@@ -88,6 +89,10 @@ class _ArrayLogger {
 }
 
 
+class DummyConsole implements Console {
+  log(message) {}
+}
+
 export function main() {
   var fakeDoc, el, el2, testProviders, lightDom;
 
@@ -101,7 +106,8 @@ export function main() {
       DOM.appendChild(fakeDoc.body, el2);
       DOM.appendChild(el, lightDom);
       DOM.setText(lightDom, 'loading');
-      testProviders = [provide(DOCUMENT, {useValue: fakeDoc})];
+      testProviders =
+          [provide(DOCUMENT, {useValue: fakeDoc}), provide(Console, {useClass: DummyConsole})];
     });
 
     afterEach(disposePlatform);
diff --git a/modules/angular2/test/public_api_spec.ts b/modules/angular2/test/public_api_spec.ts
index 5d7c2d915b69..094393653823 100644
--- a/modules/angular2/test/public_api_spec.ts
+++ b/modules/angular2/test/public_api_spec.ts
@@ -923,7 +923,6 @@ var NG_CORE = [
   'Directive.events',
   'Directive.exportAs',
   'Directive.host',
-  'Directive.moduleId',
   'Directive.inputs',
   'Directive.properties',
   'Directive.queries',
@@ -935,7 +934,6 @@ var NG_CORE = [
   'DirectiveMetadata.events',
   'DirectiveMetadata.exportAs',
   'DirectiveMetadata.host',
-  'DirectiveMetadata.moduleId',
   'DirectiveMetadata.inputs',
   'DirectiveMetadata.properties',
   'DirectiveMetadata.queries',
@@ -1012,7 +1010,7 @@ var NG_CORE = [
   'EventEmitter.emit():js',
   'OutputMetadata',
   'OutputMetadata.bindingPropertyName',
-  'enableDevMode():js',
+  'enableProdMode():js',
   'ExpressionChangedAfterItHasBeenCheckedException',
   'ExpressionChangedAfterItHasBeenCheckedException.message',
   'ExpressionChangedAfterItHasBeenCheckedException.stackTrace',
diff --git a/modules/angular2/test/router/integration/async_route_spec.ts b/modules/angular2/test/router/integration/async_route_spec.ts
index 40b182bfec75..2706f52235e4 100644
--- a/modules/angular2/test/router/integration/async_route_spec.ts
+++ b/modules/angular2/test/router/integration/async_route_spec.ts
@@ -12,7 +12,7 @@ import {registerSpecs} from './impl/async_route_spec_impl';
 export function main() {
   registerSpecs();
 
-  ddescribeRouter('async routes', () => {
+  describeRouter('async routes', () => {
     describeWithout('children', () => {
       describeWith('route data', itShouldRoute);
       describeWithAndWithout('params', itShouldRoute);
diff --git a/modules/angular2/test/router/integration/auxiliary_route_spec.ts b/modules/angular2/test/router/integration/auxiliary_route_spec.ts
index 968acbe7d23e..3bc7dd496a76 100644
--- a/modules/angular2/test/router/integration/auxiliary_route_spec.ts
+++ b/modules/angular2/test/router/integration/auxiliary_route_spec.ts
@@ -1,145 +1,19 @@
 import {
-  ComponentFixture,
-  AsyncTestCompleter,
-  TestComponentBuilder,
-  beforeEach,
-  ddescribe,
-  xdescribe,
-  describe,
-  el,
-  expect,
-  iit,
-  inject,
-  beforeEachProviders,
-  it,
-  xit
-} from 'angular2/testing_internal';
+  describeRouter,
+  ddescribeRouter,
+  describeWith,
+  describeWithout,
+  describeWithAndWithout,
+  itShouldRoute
+} from './util';
 
-import {provide, Component, Injector, Inject} from 'angular2/core';
-
-import {Router, ROUTER_DIRECTIVES, RouteParams, RouteData, Location} from 'angular2/router';
-import {RouteConfig, Route, AuxRoute, Redirect} from 'angular2/src/router/route_config_decorator';
-
-import {TEST_ROUTER_PROVIDERS, RootCmp, compile, clickOnElement, getHref} from './util';
-
-function getLinkElement(rtc: ComponentFixture) {
-  return rtc.debugElement.componentViewChildren[0].nativeElement;
-}
-
-var cmpInstanceCount;
-var childCmpInstanceCount;
+import {registerSpecs} from './impl/aux_route_spec_impl';
 
 export function main() {
-  describe('auxiliary routes', () => {
-
-    var tcb: TestComponentBuilder;
-    var fixture: ComponentFixture;
-    var rtr;
-
-    beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
-
-    beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
-      tcb = tcBuilder;
-      rtr = router;
-      childCmpInstanceCount = 0;
-      cmpInstanceCount = 0;
-    }));
-
-    it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async) => {
-         compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
-             .then((rtc) => {fixture = rtc})
-             .then((_) => rtr.config([
-               new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
-               new AuxRoute({path: '/modal', component: ModalCmp, name: 'Aux'})
-             ]))
-             .then((_) => rtr.navigateByUrl('/hello(modal)'))
-             .then((_) => {
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('main {hello} | aux {modal}');
-               async.done();
-             });
-       }));
-
-    it('should navigate via the link DSL', inject([AsyncTestCompleter], (async) => {
-         compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
-             .then((rtc) => {fixture = rtc})
-             .then((_) => rtr.config([
-               new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
-               new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
-             ]))
-             .then((_) => rtr.navigate(['/Hello', ['Modal']]))
-             .then((_) => {
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('main {hello} | aux {modal}');
-               async.done();
-             });
-       }));
+  registerSpecs();
 
-    it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
-         compile(
-             tcb,
-             `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
-             .then((rtc) => {fixture = rtc})
-             .then((_) => rtr.config([
-               new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
-               new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
-             ]))
-             .then((_) => {
-               fixture.detectChanges();
-               expect(getHref(getLinkElement(fixture))).toEqual('/hello(modal)');
-               async.done();
-             });
-       }));
-
-    it('should navigate from a link click',
-       inject([AsyncTestCompleter, Location], (async, location) => {
-         compile(
-             tcb,
-             `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
-             .then((rtc) => {fixture = rtc})
-             .then((_) => rtr.config([
-               new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
-               new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
-             ]))
-             .then((_) => {
-               fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement)
-                   .toHaveText('open modal | main {} | aux {}');
-
-               rtr.subscribe((_) => {
-                 fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement)
-                     .toHaveText('open modal | main {hello} | aux {modal}');
-                 expect(location.urlChanges).toEqual(['/hello(modal)']);
-                 async.done();
-               });
-
-               clickOnElement(getLinkElement(fixture));
-             });
-       }));
+  describeRouter('aux routes', () => {
+    itShouldRoute();
+    describeWith('a primary route', itShouldRoute);
   });
 }
-
-
-@Component({selector: 'hello-cmp', template: `{{greeting}}`})
-class HelloCmp {
-  greeting: string;
-  constructor() { this.greeting = 'hello'; }
-}
-
-@Component({selector: 'modal-cmp', template: `modal`})
-class ModalCmp {
-}
-
-@Component({
-  selector: 'aux-cmp',
-  template: 'main {<router-outlet></router-outlet>} | ' +
-                'aux {<router-outlet name="modal"></router-outlet>}',
-  directives: [ROUTER_DIRECTIVES],
-})
-@RouteConfig([
-  new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
-  new AuxRoute({path: '/modal', component: ModalCmp, name: 'Aux'})
-])
-class AuxCmp {
-}
diff --git a/modules/angular2/test/router/integration/bootstrap_spec.ts b/modules/angular2/test/router/integration/bootstrap_spec.ts
index 362a82368a50..45d75349f24f 100644
--- a/modules/angular2/test/router/integration/bootstrap_spec.ts
+++ b/modules/angular2/test/router/integration/bootstrap_spec.ts
@@ -17,6 +17,7 @@ import {
 import {bootstrap} from 'angular2/platform/browser';
 import {Component, Directive, View} from 'angular2/src/core/metadata';
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+import {Console} from 'angular2/src/core/console';
 import {provide, ViewChild, AfterViewInit} from 'angular2/core';
 import {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
 import {RouteConfig, Route, Redirect, AuxRoute} from 'angular2/src/router/route_config_decorator';
@@ -36,6 +37,10 @@ import {MockLocationStrategy} from 'angular2/src/mock/mock_location_strategy';
 import {ApplicationRef} from 'angular2/src/core/application_ref';
 import {MockApplicationRef} from 'angular2/src/mock/mock_application_ref';
 
+class DummyConsole implements Console {
+  log(message) {}
+}
+
 export function main() {
   describe('router bootstrap', () => {
     beforeEachProviders(() => [
@@ -56,7 +61,8 @@ export function main() {
                      ROUTER_PROVIDERS,
                      provide(ROUTER_PRIMARY_COMPONENT, {useValue: AppCmp}),
                      provide(LocationStrategy, {useClass: MockLocationStrategy}),
-                     provide(DOCUMENT, {useValue: fakeDoc})
+                     provide(DOCUMENT, {useValue: fakeDoc}),
+                     provide(Console, {useClass: DummyConsole})
                    ])
              .then((applicationRef) => {
                var router = applicationRef.hostComponent.router;
diff --git a/modules/angular2/test/router/integration/impl/aux_route_spec_impl.ts b/modules/angular2/test/router/integration/impl/aux_route_spec_impl.ts
new file mode 100644
index 000000000000..eebe20cd0c37
--- /dev/null
+++ b/modules/angular2/test/router/integration/impl/aux_route_spec_impl.ts
@@ -0,0 +1,247 @@
+import {
+  ComponentFixture,
+  AsyncTestCompleter,
+  TestComponentBuilder,
+  beforeEach,
+  ddescribe,
+  xdescribe,
+  describe,
+  el,
+  expect,
+  iit,
+  inject,
+  beforeEachProviders,
+  it,
+  xit
+} from 'angular2/testing_internal';
+
+import {provide, Component, Injector, Inject} from 'angular2/core';
+
+import {Router, ROUTER_DIRECTIVES, RouteParams, RouteData, Location} from 'angular2/router';
+import {RouteConfig, Route, AuxRoute, Redirect} from 'angular2/src/router/route_config_decorator';
+
+import {specs, compile, TEST_ROUTER_PROVIDERS, clickOnElement, getHref} from '../util';
+import {BaseException} from 'angular2/src/facade/exceptions';
+
+function getLinkElement(rtc: ComponentFixture, linkIndex: number = 0) {
+  return rtc.debugElement.componentViewChildren[linkIndex].nativeElement;
+}
+
+function auxRoutes() {
+  var tcb: TestComponentBuilder;
+  var fixture: ComponentFixture;
+  var rtr;
+
+  beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
+
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+    tcb = tcBuilder;
+    rtr = router;
+  }));
+
+  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async) => {
+       compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Aux'})
+           ]))
+           .then((_) => rtr.navigateByUrl('/(modal)'))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement).toHaveText('main {} | aux {modal}');
+             async.done();
+           });
+     }));
+
+  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async) => {
+       compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => rtr.navigate(['/', ['Modal']]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement).toHaveText('main {} | aux {modal}');
+             async.done();
+           });
+     }));
+
+  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+       compile(
+           tcb,
+           `<a [routerLink]="['/', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(getHref(getLinkElement(fixture))).toEqual('/(modal)');
+             async.done();
+           });
+     }));
+
+  it('should navigate from a link click',
+     inject([AsyncTestCompleter, Location], (async, location) => {
+       compile(
+           tcb,
+           `<a [routerLink]="['/', ['Modal']]">open modal</a> | <a [routerLink]="['/Hello']">hello</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement)
+                 .toHaveText('open modal | hello | main {} | aux {}');
+
+             var navCount = 0;
+
+             rtr.subscribe((_) => {
+               navCount += 1;
+               fixture.detectChanges();
+               if (navCount == 1) {
+                 expect(fixture.debugElement.nativeElement)
+                     .toHaveText('open modal | hello | main {} | aux {modal}');
+                 expect(location.urlChanges).toEqual(['/(modal)']);
+                 expect(getHref(getLinkElement(fixture, 0))).toEqual('/(modal)');
+                 expect(getHref(getLinkElement(fixture, 1))).toEqual('/hello(modal)');
+
+                 // click on primary route link
+                 clickOnElement(getLinkElement(fixture, 1));
+               } else if (navCount == 2) {
+                 expect(fixture.debugElement.nativeElement)
+                     .toHaveText('open modal | hello | main {hello} | aux {modal}');
+                 expect(location.urlChanges).toEqual(['/(modal)', '/hello(modal)']);
+                 expect(getHref(getLinkElement(fixture, 0))).toEqual('/hello(modal)');
+                 expect(getHref(getLinkElement(fixture, 1))).toEqual('/hello(modal)');
+                 async.done();
+               } else {
+                 throw new BaseException(`Unexpected route change #${navCount}`);
+               }
+             });
+
+             clickOnElement(getLinkElement(fixture));
+           });
+     }));
+}
+
+
+function auxRoutesWithAPrimaryRoute() {
+  var tcb: TestComponentBuilder;
+  var fixture: ComponentFixture;
+  var rtr;
+
+  beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
+
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+    tcb = tcBuilder;
+    rtr = router;
+  }));
+
+  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async) => {
+       compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Aux'})
+           ]))
+           .then((_) => rtr.navigateByUrl('/hello(modal)'))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement).toHaveText('main {hello} | aux {modal}');
+             async.done();
+           });
+     }));
+
+  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async) => {
+       compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => rtr.navigate(['/Hello', ['Modal']]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement).toHaveText('main {hello} | aux {modal}');
+             async.done();
+           });
+     }));
+
+  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+       compile(
+           tcb,
+           `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(getHref(getLinkElement(fixture))).toEqual('/hello(modal)');
+             async.done();
+           });
+     }));
+
+  it('should navigate from a link click',
+     inject([AsyncTestCompleter, Location], (async, location) => {
+       compile(
+           tcb,
+           `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
+           .then((rtc) => {fixture = rtc})
+           .then((_) => rtr.config([
+             new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+             new AuxRoute({path: '/modal', component: ModalCmp, name: 'Modal'})
+           ]))
+           .then((_) => {
+             fixture.detectChanges();
+             expect(fixture.debugElement.nativeElement).toHaveText('open modal | main {} | aux {}');
+
+             rtr.subscribe((_) => {
+               fixture.detectChanges();
+               expect(fixture.debugElement.nativeElement)
+                   .toHaveText('open modal | main {hello} | aux {modal}');
+               expect(location.urlChanges).toEqual(['/hello(modal)']);
+               async.done();
+             });
+
+             clickOnElement(getLinkElement(fixture));
+           });
+     }));
+}
+
+export function registerSpecs() {
+  specs['auxRoutes'] = auxRoutes;
+  specs['auxRoutesWithAPrimaryRoute'] = auxRoutesWithAPrimaryRoute;
+}
+
+
+@Component({selector: 'hello-cmp', template: `{{greeting}}`})
+class HelloCmp {
+  greeting: string;
+  constructor() { this.greeting = 'hello'; }
+}
+
+@Component({selector: 'modal-cmp', template: `modal`})
+class ModalCmp {
+}
+
+@Component({
+  selector: 'aux-cmp',
+  template: 'main {<router-outlet></router-outlet>} | ' +
+                'aux {<router-outlet name="modal"></router-outlet>}',
+  directives: [ROUTER_DIRECTIVES],
+})
+@RouteConfig([
+  new Route({path: '/hello', component: HelloCmp, name: 'Hello'}),
+  new AuxRoute({path: '/modal', component: ModalCmp, name: 'Aux'})
+])
+class AuxCmp {
+}
diff --git a/modules/angular2/test/router/integration/router_link_spec.ts b/modules/angular2/test/router/integration/router_link_spec.ts
index bf6d3b494e91..86fad53f5b84 100644
--- a/modules/angular2/test/router/integration/router_link_spec.ts
+++ b/modules/angular2/test/router/integration/router_link_spec.ts
@@ -325,7 +325,7 @@ export function main() {
          }));
 
 
-      describe("router link dsl", () => {
+      describe('router link dsl', () => {
         it('should generate link hrefs with params', inject([AsyncTestCompleter], (async) => {
              compile('<a href="hello" [routerLink]="route:./User(name: name)">{{name}}</a>')
                  .then((_) => router.config(
diff --git a/modules/angular2/test/router/integration/util.ts b/modules/angular2/test/router/integration/util.ts
index 5610d99b7870..7789ebeb1a88 100644
--- a/modules/angular2/test/router/integration/util.ts
+++ b/modules/angular2/test/router/integration/util.ts
@@ -77,7 +77,11 @@ export var specs = {};
 export function describeRouter(description: string, fn: Function, exclusive = false): void {
   var specName = descriptionToSpecName(description);
   specNameBuilder.push(specName);
-  describe(description, fn);
+  if (exclusive) {
+    ddescribe(description, fn);
+  } else {
+    describe(description, fn);
+  }
   specNameBuilder.pop();
 }
 
diff --git a/modules/angular2/test/router/route_config_spec.ts b/modules/angular2/test/router/route_config_spec.ts
index c3040ef7fd71..cfc97429b22f 100644
--- a/modules/angular2/test/router/route_config_spec.ts
+++ b/modules/angular2/test/router/route_config_spec.ts
@@ -14,6 +14,7 @@ import {
 import {bootstrap} from 'angular2/platform/browser';
 import {Component, Directive, View} from 'angular2/src/core/metadata';
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+import {Console} from 'angular2/src/core/console';
 import {provide} from 'angular2/core';
 import {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
 import {Type, IS_DART} from 'angular2/src/facade/lang';
@@ -38,6 +39,10 @@ class _ArrayLogger {
   logGroupEnd(){};
 }
 
+class DummyConsole implements Console {
+  log(message) {}
+}
+
 export function main() {
   describe('RouteConfig with POJO arguments', () => {
     var fakeDoc, el, testBindings;
@@ -51,7 +56,8 @@ export function main() {
         ROUTER_PROVIDERS,
         provide(LocationStrategy, {useClass: MockLocationStrategy}),
         provide(DOCUMENT, {useValue: fakeDoc}),
-        provide(ExceptionHandler, {useValue: exceptionHandler})
+        provide(ExceptionHandler, {useValue: exceptionHandler}),
+        provide(Console, {useClass: DummyConsole})
       ];
     });
 
diff --git a/modules/angular2/test/router/route_registry_spec.ts b/modules/angular2/test/router/route_registry_spec.ts
index 423a88d26424..972c78cdfb65 100644
--- a/modules/angular2/test/router/route_registry_spec.ts
+++ b/modules/angular2/test/router/route_registry_spec.ts
@@ -47,9 +47,9 @@ export function main() {
       var instr = registry.generate(['FirstCmp', 'SecondCmp'], []);
       expect(stringifyInstruction(instr)).toEqual('first/second');
 
-      expect(stringifyInstruction(registry.generate(['SecondCmp'], [instr])))
+      expect(stringifyInstruction(registry.generate(['SecondCmp'], [instr, instr.child])))
           .toEqual('first/second');
-      expect(stringifyInstruction(registry.generate(['./SecondCmp'], [instr])))
+      expect(stringifyInstruction(registry.generate(['./SecondCmp'], [instr, instr.child])))
           .toEqual('first/second');
     });
 
@@ -181,6 +181,21 @@ export function main() {
              });
        }));
 
+    it('should prefer routes with high specificity over routes with children with lower specificity',
+       inject([AsyncTestCompleter], (async) => {
+         registry.config(RootHostCmp, new Route({path: '/first', component: DummyCmpA}));
+
+         // terminates to DummyCmpB
+         registry.config(RootHostCmp,
+                         new Route({path: '/:second/...', component: SingleSlashChildCmp}));
+
+         registry.recognize('/first', [])
+             .then((instruction) => {
+               expect(instruction.component.componentType).toBe(DummyCmpA);
+               async.done();
+             });
+       }));
+
     it('should match the full URL using child components', inject([AsyncTestCompleter], (async) => {
          registry.config(RootHostCmp, new Route({path: '/first/...', component: DummyParentCmp}));
 
@@ -322,6 +337,10 @@ class DummyCmpB {}
 class DefaultRouteCmp {
 }
 
+@RouteConfig([new Route({path: '/', component: DummyCmpB, name: 'ThirdCmp'})])
+class SingleSlashChildCmp {
+}
+
 
 @RouteConfig([
   new Route(
diff --git a/modules/angular2/test/router/router_link_spec.ts b/modules/angular2/test/router/router_link_spec.ts
index 228750341de4..cf20732deb36 100644
--- a/modules/angular2/test/router/router_link_spec.ts
+++ b/modules/angular2/test/router/router_link_spec.ts
@@ -33,8 +33,8 @@ import {
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
 import {ResolvedInstruction} from 'angular2/src/router/instruction';
 
-let dummyInstruction =
-    new ResolvedInstruction(new ComponentInstruction('detail', [], null, null, true, 0), null, {});
+let dummyInstruction = new ResolvedInstruction(
+    new ComponentInstruction('detail', [], null, null, true, '0'), null, {});
 
 export function main() {
   describe('routerLink directive', function() {
diff --git a/modules/angular2/test/testing/testing_public_spec.ts b/modules/angular2/test/testing/testing_public_spec.ts
index 535760adc756..f37c918dcdc7 100644
--- a/modules/angular2/test/testing/testing_public_spec.ts
+++ b/modules/angular2/test/testing/testing_public_spec.ts
@@ -9,6 +9,7 @@ import {
   tick,
   beforeEach,
   inject,
+  injectAsync,
   beforeEachProviders,
   TestComponentBuilder
 } from 'angular2/testing';
@@ -153,8 +154,9 @@ export function main() {
       it('should use set up providers',
          inject([FancyService], (service) => { expect(service.value).toEqual('real value'); }));
 
-      it('should wait until returned promises', inject([FancyService], (service) => {
-           service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
+      it('should wait until returned promises', injectAsync([FancyService], (service) => {
+           return service.getAsyncValue().then(
+               (value) => { expect(value).toEqual('async value'); });
          }));
 
       describe('using beforeEach', () => {
@@ -167,8 +169,8 @@ export function main() {
       });
 
       describe('using async beforeEach', () => {
-        beforeEach(inject([FancyService], (service) => {
-          service.getAsyncValue().then((value) => { service.value = value; });
+        beforeEach(injectAsync([FancyService], (service) => {
+          return service.getAsyncValue().then((value) => { service.value = value; });
         }));
 
         it('should use asynchronously modified value',
@@ -196,18 +198,70 @@ export function main() {
     var restoreJasmineIt = () => { jasmine.getEnv().it = originalJasmineIt; };
 
     var patchJasmineBeforeEach = () => {
+      var deferred = PromiseWrapper.completer();
       originalJasmineBeforeEach = jasmine.getEnv().beforeEach;
       jasmine.getEnv().beforeEach = (fn: any) => {
-        var done = () => {};
-        (<any>done).fail = (err) => { throw new Error(err) };
+        var done = () => { deferred.resolve() };
+        (<any>done).fail = (err) => { deferred.reject(err) };
         fn(done);
         return null;
-      }
+      };
+      return deferred.promise;
     };
 
     var restoreJasmineBeforeEach =
         () => { jasmine.getEnv().beforeEach = originalJasmineBeforeEach; }
 
+    it('injectAsync should fail when return was forgotten in it', (done) => {
+      var itPromise = patchJasmineIt();
+      it('forgets to return a proimse', injectAsync([], () => { return true; }));
+
+      itPromise.then(() => { done.fail('Expected function to throw, but it did not'); }, (err) => {
+        expect(err).toEqual(
+            'Error: injectAsync was expected to return a promise, but the  returned value was: true');
+        done();
+      });
+      restoreJasmineIt();
+    });
+
+    it('inject should fail if a value was returned', (done) => {
+      var itPromise = patchJasmineIt();
+      it('returns a value', inject([], () => { return true; }));
+
+      itPromise.then(() => { done.fail('Expected function to throw, but it did not'); }, (err) => {
+        expect(err).toEqual(
+            'Error: inject returned a value. Did you mean to use injectAsync? Returned value was: true');
+        done();
+      });
+      restoreJasmineIt();
+    });
+
+    it('injectAsync should fail when return was forgotten in beforeEach', (done) => {
+      var beforeEachPromise = patchJasmineBeforeEach();
+      beforeEach(injectAsync([], () => { return true; }));
+
+      beforeEachPromise.then(
+          () => { done.fail('Expected function to throw, but it did not'); }, (err) => {
+            expect(err).toEqual(
+                'Error: injectAsync was expected to return a promise, but the  returned value was: true');
+            done();
+          });
+      restoreJasmineBeforeEach();
+    });
+
+    it('inject should fail if a value was returned in beforeEach', (done) => {
+      var beforeEachPromise = patchJasmineBeforeEach();
+      beforeEach(inject([], () => { return true; }));
+
+      beforeEachPromise.then(
+          () => { done.fail('Expected function to throw, but it did not'); }, (err) => {
+            expect(err).toEqual(
+                'Error: inject returned a value. Did you mean to use injectAsync? Returned value was: true');
+            done();
+          });
+      restoreJasmineBeforeEach();
+    });
+
     it('should fail when an error occurs inside inject', (done) => {
       var itPromise = patchJasmineIt();
       it('throws an error', inject([], () => { throw new Error('foo'); }));
@@ -235,7 +289,7 @@ export function main() {
     it('should fail when a returned promise is rejected', (done) => {
       var itPromise = patchJasmineIt();
 
-      it('should fail with an error from a promise', inject([], () => {
+      it('should fail with an error from a promise', injectAsync([], () => {
            var deferred = PromiseWrapper.completer();
            var p = deferred.promise.then(() => { expect(1).toEqual(2); });
 
@@ -259,8 +313,8 @@ export function main() {
       describe('nested beforeEachProviders', () => {
 
         it('should fail when the injector has already been used', () => {
+          patchJasmineBeforeEach();
           expect(() => {
-            patchJasmineBeforeEach();
             beforeEachProviders(() => [bind(FancyService).toValue(new FancyService())]);
           })
               .toThrowError('beforeEachProviders was called after the injector had been used ' +
@@ -273,9 +327,9 @@ export function main() {
 
   describe('test component builder', function() {
     it('should instantiate a component with valid DOM',
-       inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.createAsync(ChildComp).then((componentFixture) => {
+         return tcb.createAsync(ChildComp).then((componentFixture) => {
            componentFixture.detectChanges();
 
            expect(componentFixture.debugElement.nativeElement).toHaveText('Original Child');
@@ -283,9 +337,9 @@ export function main() {
        }));
 
     it('should allow changing members of the component',
-       inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.createAsync(MyIfComp).then((componentFixture) => {
+         return tcb.createAsync(MyIfComp).then((componentFixture) => {
            componentFixture.detectChanges();
            expect(componentFixture.debugElement.nativeElement).toHaveText('MyIf()');
 
@@ -295,9 +349,10 @@ export function main() {
          });
        }));
 
-    it('should override a template', inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+    it('should override a template',
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideTemplate(MockChildComp, '<span>Mock</span>')
+         return tcb.overrideTemplate(MockChildComp, '<span>Mock</span>')
              .createAsync(MockChildComp)
              .then((componentFixture) => {
                componentFixture.detectChanges();
@@ -306,10 +361,12 @@ export function main() {
              });
        }));
 
-    it('should override a view', inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+    it('should override a view',
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideView(ChildComp,
-                          new ViewMetadata({template: '<span>Modified {{childBinding}}</span>'}))
+         return tcb.overrideView(
+                       ChildComp,
+                       new ViewMetadata({template: '<span>Modified {{childBinding}}</span>'}))
              .createAsync(ChildComp)
              .then((componentFixture) => {
                componentFixture.detectChanges();
@@ -319,9 +376,9 @@ export function main() {
        }));
 
     it('should override component dependencies',
-       inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideDirective(ParentComp, ChildComp, MockChildComp)
+         return tcb.overrideDirective(ParentComp, ChildComp, MockChildComp)
              .createAsync(ParentComp)
              .then((componentFixture) => {
                componentFixture.detectChanges();
@@ -332,9 +389,9 @@ export function main() {
 
 
     it("should override child component's dependencies",
-       inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideDirective(ParentComp, ChildComp, ChildWithChildComp)
+         return tcb.overrideDirective(ParentComp, ChildComp, ChildWithChildComp)
              .overrideDirective(ChildWithChildComp, ChildChildComp, MockChildChildComp)
              .createAsync(ParentComp)
              .then((componentFixture) => {
@@ -345,9 +402,11 @@ export function main() {
              });
        }));
 
-    it('should override a provider', inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+    it('should override a provider',
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideProviders(TestProvidersComp, [bind(FancyService).toClass(MockFancyService)])
+         return tcb.overrideProviders(TestProvidersComp,
+                                      [bind(FancyService).toClass(MockFancyService)])
              .createAsync(TestProvidersComp)
              .then((componentFixture) => {
                componentFixture.detectChanges();
@@ -358,10 +417,10 @@ export function main() {
 
 
     it('should override a viewProvider',
-       inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+       injectAsync([TestComponentBuilder], (tcb: TestComponentBuilder) => {
 
-         tcb.overrideViewProviders(TestViewProvidersComp,
-                                   [bind(FancyService).toClass(MockFancyService)])
+         return tcb.overrideViewProviders(TestViewProvidersComp,
+                                          [bind(FancyService).toClass(MockFancyService)])
              .createAsync(TestViewProvidersComp)
              .then((componentFixture) => {
                componentFixture.detectChanges();
diff --git a/modules/angular2/test/upgrade/upgrade_spec.ts b/modules/angular2/test/upgrade/upgrade_spec.ts
index c22dc9f67621..dd335f34562f 100644
--- a/modules/angular2/test/upgrade/upgrade_spec.ts
+++ b/modules/angular2/test/upgrade/upgrade_spec.ts
@@ -239,7 +239,7 @@ export function main() {
                      scope.dataB = 'SAVKIN';
                      scope.event('WORKS');
 
-                     // Should not update becaus [model-a] is uni directional
+                     // Should not update because [model-a] is uni directional
                      scope.dataA = 'VICTOR';
                    }
                  })
diff --git a/modules/angular2/test/web_workers/debug_tools/multi_client_server_message_bus.server.spec.dart b/modules/angular2/test/web_workers/debug_tools/multi_client_server_message_bus.server.spec.dart
index 43494c9e6a52..857b948b0b3d 100644
--- a/modules/angular2/test/web_workers/debug_tools/multi_client_server_message_bus.server.spec.dart
+++ b/modules/angular2/test/web_workers/debug_tools/multi_client_server_message_bus.server.spec.dart
@@ -11,7 +11,6 @@ import "package:angular2/testing_internal.dart"
         iit,
         expect,
         beforeEach,
-        createTestInjector,
         beforeEachProviders,
         SpyObject,
         proxy;
diff --git a/modules/angular2/test/web_workers/debug_tools/single_client_server_message_bus.server.spec.dart b/modules/angular2/test/web_workers/debug_tools/single_client_server_message_bus.server.spec.dart
index 0cf86f781b0c..50ca5f15ae0b 100644
--- a/modules/angular2/test/web_workers/debug_tools/single_client_server_message_bus.server.spec.dart
+++ b/modules/angular2/test/web_workers/debug_tools/single_client_server_message_bus.server.spec.dart
@@ -10,7 +10,6 @@ import "package:angular2/testing_internal.dart"
         it,
         expect,
         beforeEach,
-        createTestInjector,
         beforeEachProviders,
         SpyObject,
         proxy;
diff --git a/modules/angular2/test/web_workers/debug_tools/web_socket_message_bus_spec.dart b/modules/angular2/test/web_workers/debug_tools/web_socket_message_bus_spec.dart
index 6823eb008ad0..9b87a3e28155 100644
--- a/modules/angular2/test/web_workers/debug_tools/web_socket_message_bus_spec.dart
+++ b/modules/angular2/test/web_workers/debug_tools/web_socket_message_bus_spec.dart
@@ -8,7 +8,6 @@ import "package:angular2/testing_internal.dart"
         it,
         expect,
         beforeEach,
-        createTestInjector,
         beforeEachProviders,
         SpyObject,
         proxy;
diff --git a/modules/angular2/test/web_workers/shared/message_bus_spec.ts b/modules/angular2/test/web_workers/shared/message_bus_spec.ts
index e4fcc2ade053..1e3073c94ed5 100644
--- a/modules/angular2/test/web_workers/shared/message_bus_spec.ts
+++ b/modules/angular2/test/web_workers/shared/message_bus_spec.ts
@@ -5,7 +5,6 @@ import {
   it,
   expect,
   beforeEach,
-  createTestInjectorWithRuntimeCompiler,
   beforeEachProviders,
   SpyObject,
   proxy
diff --git a/modules/angular2/test/web_workers/shared/service_message_broker_spec.ts b/modules/angular2/test/web_workers/shared/service_message_broker_spec.ts
index 9b0b148221e0..d30be8bc593a 100644
--- a/modules/angular2/test/web_workers/shared/service_message_broker_spec.ts
+++ b/modules/angular2/test/web_workers/shared/service_message_broker_spec.ts
@@ -5,7 +5,6 @@ import {
   it,
   expect,
   beforeEach,
-  createTestInjectorWithRuntimeCompiler,
   beforeEachProviders,
   SpyObject,
   proxy
diff --git a/modules/angular2/test/web_workers/worker/event_dispatcher_spec.ts b/modules/angular2/test/web_workers/worker/event_dispatcher_spec.ts
index 5efa1ea81108..a97d1b00967d 100644
--- a/modules/angular2/test/web_workers/worker/event_dispatcher_spec.ts
+++ b/modules/angular2/test/web_workers/worker/event_dispatcher_spec.ts
@@ -5,7 +5,6 @@ import {
   it,
   expect,
   beforeEach,
-  createTestInjectorWithRuntimeCompiler,
   beforeEachProviders,
   SpyObject,
   proxy
diff --git a/modules/angular2/test/web_workers/worker/renderer_integration_spec.ts b/modules/angular2/test/web_workers/worker/renderer_integration_spec.ts
index dbeca905823a..8f56648945ed 100644
--- a/modules/angular2/test/web_workers/worker/renderer_integration_spec.ts
+++ b/modules/angular2/test/web_workers/worker/renderer_integration_spec.ts
@@ -7,8 +7,8 @@ import {
   iit,
   expect,
   beforeEach,
-  createTestInjectorWithRuntimeCompiler,
   beforeEachProviders,
+  TestInjector,
   TestComponentBuilder
 } from "angular2/testing_internal";
 import {DOM} from 'angular2/src/platform/dom/dom_adapter';
@@ -102,12 +102,14 @@ export function main() {
     beforeEachProviders(() => {
       var uiRenderProtoViewStore = new RenderProtoViewRefStore(false);
       uiRenderViewStore = new RenderViewWithFragmentsStore(false);
-      uiInjector = createTestInjectorWithRuntimeCompiler([
+      var testInjector = new TestInjector();
+      testInjector.addProviders([
         provide(RenderProtoViewRefStore, {useValue: uiRenderProtoViewStore}),
         provide(RenderViewWithFragmentsStore, {useValue: uiRenderViewStore}),
         provide(DomRenderer, {useClass: DomRenderer_}),
         provide(Renderer, {useExisting: DomRenderer})
       ]);
+      uiInjector = testInjector.createInjector();
       var uiSerializer = uiInjector.get(Serializer);
       var domRenderer = uiInjector.get(DomRenderer);
       var workerRenderProtoViewStore = new RenderProtoViewRefStore(true);
diff --git a/modules/angular2/test/web_workers/worker/xhr_impl_spec.ts b/modules/angular2/test/web_workers/worker/xhr_impl_spec.ts
index 83fe0f9828e7..dfb68279afcf 100644
--- a/modules/angular2/test/web_workers/worker/xhr_impl_spec.ts
+++ b/modules/angular2/test/web_workers/worker/xhr_impl_spec.ts
@@ -5,7 +5,6 @@ import {
   it,
   expect,
   beforeEach,
-  createTestInjectorWithRuntimeCompiler,
   beforeEachProviders
 } from 'angular2/testing_internal';
 import {SpyMessageBroker} from './spies';
diff --git a/modules/angular2_material/src/components/button/button.ts b/modules/angular2_material/src/components/button/button.ts
index ac5f61f91f29..cf5f242bcd95 100644
--- a/modules/angular2_material/src/components/button/button.ts
+++ b/modules/angular2_material/src/components/button/button.ts
@@ -22,7 +22,7 @@ import {isPresent} from 'angular2/src/facade/lang';
   encapsulation: ViewEncapsulation.None,
 })
 export class MdButton {
-  /** Whether a mousedown has occured on this element in the last 100ms. */
+  /** Whether a mousedown has occurred on this element in the last 100ms. */
   isMouseDown: boolean = false;
 
   /** Whether the button has focus from the keyboard (not the mouse). Used for class binding. */
diff --git a/modules/angular2_material/src/components/grid_list/grid_list.ts b/modules/angular2_material/src/components/grid_list/grid_list.ts
index 2323c338838e..de916d4f907a 100644
--- a/modules/angular2_material/src/components/grid_list/grid_list.ts
+++ b/modules/angular2_material/src/components/grid_list/grid_list.ts
@@ -19,7 +19,7 @@ import {Math} from 'angular2/src/facade/math';
 // TODO(jelbourn): Re-layout on window resize / media change (debounced).
 // TODO(jelbourn): gridTileHeader and gridTileFooter.
 
-/** Row hieght mode options. Use a static class b/c TypeScript enums are strictly number-based. */
+/** Row height mode options. Use a static class b/c TypeScript enums are strictly number-based. */
 class RowHeightMode {
   static FIT = 'fit';
   static FIXED = 'fixed';
@@ -128,7 +128,7 @@ export class MdGridList implements AfterContentChecked {
   getBaseTileSize(sizePercent: number, gutterFraction: number): string {
     // Take the base size percent (as would be if evenly dividing the size between cells),
     // and then subtracting the size of one gutter. However, since there are no gutters on the
-    // edges, each tile only uses a fration (gutterShare = numGutters / numCells) of the gutter
+    // edges, each tile only uses a fraction (gutterShare = numGutters / numCells) of the gutter
     // size. (Imagine having one gutter per tile, and then breaking up the extra gutter on the
     // edge evenly among the cells).
     return `(${sizePercent}% - ( ${this.gutterSize} * ${gutterFraction} ))`;
diff --git a/modules/angular2_material/src/components/radio/radio_dispatcher.ts b/modules/angular2_material/src/components/radio/radio_dispatcher.ts
index 458680e0aac8..28974839e71c 100644
--- a/modules/angular2_material/src/components/radio/radio_dispatcher.ts
+++ b/modules/angular2_material/src/components/radio/radio_dispatcher.ts
@@ -13,7 +13,7 @@ export class MdRadioDispatcher {
     this.listeners_ = [];
   }
 
-  /** Notify other nadio buttons that selection for the given name has been set. */
+  /** Notify other radio buttons that selection for the given name has been set. */
   notify(name: string) {
     this.listeners_.forEach(listener => listener(name));
   }
diff --git a/modules/benchmarks/src/naive_infinite_scroll/index.html b/modules/benchmarks/src/naive_infinite_scroll/index.html
index c1523b1722c4..496ab0aa3c5c 100644
--- a/modules/benchmarks/src/naive_infinite_scroll/index.html
+++ b/modules/benchmarks/src/naive_infinite_scroll/index.html
@@ -5,9 +5,9 @@
 </head>
 <body>
   <form>
-    App size: <input type="text" name="appSize" value="1"></input><br>
-    Iteration count: <input type="text" name="iterationCount" value="1"></input><br>
-    Scroll increment: <input type="text" name="scrollIncrement" value="1"></input><br>
+    App size: <input type="text" name="appSize" value="1"><br>
+    Iteration count: <input type="text" name="iterationCount" value="1"><br>
+    Scroll increment: <input type="text" name="scrollIncrement" value="1"><br>
   </form>
   <div>
     <button id="run-btn">Run</button>
diff --git a/modules/benchmarks_external/src/naive_infinite_scroll/index.html b/modules/benchmarks_external/src/naive_infinite_scroll/index.html
index 701cdaecd5a8..a64776bc6e7f 100644
--- a/modules/benchmarks_external/src/naive_infinite_scroll/index.html
+++ b/modules/benchmarks_external/src/naive_infinite_scroll/index.html
@@ -5,9 +5,9 @@
 </head>
 <body>
   <form>
-    App size: <input type="text" name="appSize" value="1"></input><br>
-    Iteration count: <input type="text" name="iterationCount" value="1"></input><br>
-    Scroll increment: <input type="text" name="scrollIncrement" value="1"></input><br>
+    App size: <input type="text" name="appSize" value="1"><br>
+    Iteration count: <input type="text" name="iterationCount" value="1"><br>
+    Scroll increment: <input type="text" name="scrollIncrement" value="1"><br>
   </form>
   <div>
     <button id="run-btn">Run</button>
diff --git a/modules/benchpress/src/metric/perflog_metric.ts b/modules/benchpress/src/metric/perflog_metric.ts
index 1da20be993e7..2b3b7ed1715f 100644
--- a/modules/benchpress/src/metric/perflog_metric.ts
+++ b/modules/benchpress/src/metric/perflog_metric.ts
@@ -111,7 +111,7 @@ export class PerflogMetric extends Metric {
 
   _endPlainMeasureAndMeasureForceGc(restartMeasure: boolean) {
     return this._endMeasure(true).then((measureValues) => {
-      // disable frame capture for measurments during forced gc
+      // disable frame capture for measurements during forced gc
       var originalFrameCaptureValue = this._captureFrames;
       this._captureFrames = false;
       return this._driverExtension.gc()
diff --git a/modules/benchpress/src/webdriver/chrome_driver_extension.ts b/modules/benchpress/src/webdriver/chrome_driver_extension.ts
index d28bd8e7f9e0..9086a82fca33 100644
--- a/modules/benchpress/src/webdriver/chrome_driver_extension.ts
+++ b/modules/benchpress/src/webdriver/chrome_driver_extension.ts
@@ -103,7 +103,7 @@ export class ChromeDriverExtension extends WebDriverExtension {
         //   2nd choice: BenchmarkInstrumentation::DisplayRenderingStats - available on systems with
         //               new surfaces framework (not broadly enabled yet)
         //   3rd choice: BenchmarkInstrumentation::ImplThreadRenderingStats - fallback event that is
-        //               allways available if something is rendered
+        //               always available if something is rendered
         var frameCount = event['args']['data']['frame_count'];
         if (frameCount > 1) {
           throw new BaseException('multi-frame render stats not supported');
diff --git a/modules_dart/angular2_testing/lib/angular2_testing.dart b/modules_dart/angular2_testing/lib/angular2_testing.dart
index 60d1302dd358..da737b3863b3 100644
--- a/modules_dart/angular2_testing/lib/angular2_testing.dart
+++ b/modules_dart/angular2_testing/lib/angular2_testing.dart
@@ -1,11 +1,8 @@
 library angular2_testing.angular2_testing;
 
 import 'package:test/test.dart';
-import 'package:test/src/backend/invoker.dart';
-import 'package:test/src/backend/live_test.dart';
 
 import 'package:angular2/angular2.dart';
-import 'package:angular2/src/core/di/injector.dart' show Injector;
 import 'package:angular2/src/core/di/metadata.dart' show InjectMetadata;
 import 'package:angular2/src/core/di/exceptions.dart' show NoAnnotationError;
 import 'package:angular2/platform/browser_static.dart' show BrowserDomAdapter;
@@ -31,6 +28,13 @@ void initAngularTests() {
   reflector.reflectionCapabilities = new ReflectionCapabilities();
 }
 
+void _addTestInjectorTearDown() {
+  // Multiple resets are harmless.
+  tearDown(() {
+    _testInjector.reset();
+  });
+}
+
 /// Allows overriding default bindings defined in test_injector.dart.
 ///
 /// The given function must return a list of DI providers.
@@ -45,13 +49,17 @@ void initAngularTests() {
 /// ```
 void setUpProviders(Iterable<Provider> providerFactory()) {
   setUp(() {
-    if (_currentInjector != null) {
+    try {
+      _testInjector.addProviders(providerFactory());
+    } catch(e) {
       throw 'setUpProviders was called after the injector had '
           'been used in a setUp or test block. This invalidates the '
           'test injector';
     }
-    _currentTestProviders.addAll(providerFactory());
+
   });
+
+  _addTestInjectorTearDown();
 }
 
 dynamic _runInjectableFunction(Function fn) {
@@ -72,11 +80,8 @@ dynamic _runInjectableFunction(Function fn) {
     tokens.add(token);
   }
 
-  if (_currentInjector == null) {
-    _currentInjector = createTestInjectorWithRuntimeCompiler(_currentTestProviders);
-  }
   var injectFn = new FunctionWithParamTokens(tokens, fn, false);
-  return injectFn.execute(_currentInjector);
+  return _testInjector.execute(injectFn);
 }
 
 /// Use the test injector to get bindings and run a function.
@@ -92,6 +97,8 @@ void ngSetUp(Function fn) {
   setUp(() async {
     await _runInjectableFunction(fn);
   });
+
+  _addTestInjectorTearDown();
 }
 
 /// Add a test which can use the test injector.
@@ -108,25 +115,8 @@ void ngTest(String description, Function fn,
   test(description, () async {
     await _runInjectableFunction(fn);
   }, testOn: testOn, timeout: timeout, skip: skip, onPlatform: onPlatform);
-}
-
-final _providersExpando =
-    new Expando<List<Provider>>('Providers for the current test');
-final _injectorExpando =
-    new Expando<Injector>('Angular Injector for the current test');
-
-List get _currentTestProviders {
-  if (_providersExpando[_currentTest] == null) {
-    return _providersExpando[_currentTest] = [];
-  }
-  return _providersExpando[_currentTest];
-}
 
-Injector get _currentInjector => _injectorExpando[_currentTest];
-void set _currentInjector(Injector newInjector) {
-  _injectorExpando[_currentTest] = newInjector;
+  _addTestInjectorTearDown();
 }
 
-// TODO: warning, the Invoker.current.liveTest is not a settled API and is
-// subject to change in future versions of package:test.
-LiveTest get _currentTest => Invoker.current.liveTest;
+final TestInjector _testInjector = getTestInjector();
diff --git a/modules_dart/payload/hello_world/www.utc b/modules_dart/payload/hello_world/www.utc
new file mode 100644
index 000000000000..9d428848cced
--- /dev/null
+++ b/modules_dart/payload/hello_world/www.utc
@@ -0,0 +1,14 @@
+getCapitol(country){
+
+        //Can this be done differently?
+        if(this.pendingRequest){
+            this.pendingRequest.unsubscribe();
+            console.log('cancelled observable');
+        }
+
+        this.activeCountry = country;
+
+        this.pendingRequest = this.http.get('./country-info/' + country + '.json')
+                              .map((res: Response) => res.json())
+                              .subscribe(res => this.capitol = res.capitol);
+    }
diff --git a/npm-shrinkwrap.clean.json b/npm-shrinkwrap.clean.json
index a6825b8f0825..f026eea42b2a 100644
--- a/npm-shrinkwrap.clean.json
+++ b/npm-shrinkwrap.clean.json
@@ -13212,7 +13212,7 @@
       }
     },
     "rxjs": {
-      "version": "5.0.0-alpha.14"
+      "version": "5.0.0-beta.0"
     },
     "selenium-webdriver": {
       "version": "2.48.2",
@@ -14765,5 +14765,5 @@
     }
   },
   "name": "angular-srcs",
-  "version": "2.0.0-alpha.52"
+  "version": "2.0.0-alpha.53"
 }
diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json
index aa2c97401668..9594c52d5250 100644
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
@@ -1,6 +1,6 @@
 {
   "name": "angular-srcs",
-  "version": "2.0.0-alpha.52",
+  "version": "2.0.0-alpha.53",
   "dependencies": {
     "angular": {
       "version": "1.4.7",
@@ -20253,9 +20253,9 @@
       }
     },
     "rxjs": {
-      "version": "5.0.0-alpha.14",
-      "from": "https://registry.npmjs.org/rxjs/-/rxjs-5.0.0-alpha.14.tgz",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-5.0.0-alpha.14.tgz"
+      "version": "5.0.0-beta.0",
+      "from": "rxjs@5.0.0-beta.0",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-5.0.0-beta.0.tgz"
     },
     "selenium-webdriver": {
       "version": "2.48.2",
@@ -20725,7 +20725,7 @@
     },
     "ts2dart": {
       "version": "0.7.18",
-      "from": "ts2dart@0.7.18",
+      "from": "https://registry.npmjs.org/ts2dart/-/ts2dart-0.7.18.tgz",
       "resolved": "https://registry.npmjs.org/ts2dart/-/ts2dart-0.7.18.tgz",
       "dependencies": {
         "source-map": {
@@ -22645,7 +22645,7 @@
     },
     "zone.js": {
       "version": "0.5.10",
-      "from": "zone.js@0.5.10",
+      "from": "https://registry.npmjs.org/zone.js/-/zone.js-0.5.10.tgz",
       "resolved": "https://registry.npmjs.org/zone.js/-/zone.js-0.5.10.tgz"
     }
   }
diff --git a/package.json b/package.json
index 49a473b30675..4ac7d861bd18 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "angular-srcs",
-  "version": "2.0.0-alpha.53",
+  "version": "2.0.0-beta.0",
   "branchPattern": "2.0.*",
   "description": "Angular 2 - a web framework for modern web apps",
   "homepage": "https://github.com/angular/angular",
@@ -34,7 +34,7 @@
     "es6-promise": "^3.0.2",
     "es6-shim": "^0.33.3",
     "reflect-metadata": "0.1.2",
-    "rxjs": "5.0.0-alpha.14",
+    "rxjs": "5.0.0-beta.0",
     "zone.js": "0.5.10"
   },
   "devDependencies": {
diff --git a/test-main.js b/test-main.js
index d0d01a6131f1..0fa487d93f61 100644
--- a/test-main.js
+++ b/test-main.js
@@ -18,8 +18,6 @@ System.config({
   }
 });
 
-window.angularDevMode = true;
-
 // Import all the specs, execute their `main()` method and kick off Karma (Jasmine).
 System.import('angular2/src/platform/browser/browser_adapter').then(function(browser_adapter) {
   browser_adapter.BrowserDomAdapter.makeCurrent();
diff --git a/tools/broccoli/broccoli-typescript.ts b/tools/broccoli/broccoli-typescript.ts
index 9a4ab4b14f7a..ff572053060e 100644
--- a/tools/broccoli/broccoli-typescript.ts
+++ b/tools/broccoli/broccoli-typescript.ts
@@ -212,7 +212,10 @@ class DiffingTSCompiler implements DiffingBroccoliPlugin {
 
     if (fs.existsSync(absoluteJsFilePath)) {
       fs.unlinkSync(absoluteJsFilePath);
-      fs.unlinkSync(absoluteMapFilePath);
+      if (fs.existsSync(absoluteMapFilePath)) {
+        // source map could be inline or not generated
+        fs.unlinkSync(absoluteMapFilePath);
+      }
       fs.unlinkSync(absoluteDtsFilePath);
     }
   }
diff --git a/tools/broccoli/html-replace/SCRIPTS.html b/tools/broccoli/html-replace/SCRIPTS.html
index c7e14d2ff4b3..6f7bea55fb97 100644
--- a/tools/broccoli/html-replace/SCRIPTS.html
+++ b/tools/broccoli/html-replace/SCRIPTS.html
@@ -20,8 +20,8 @@
 <script src="/bundle/angular2.dev.js"></script>
 <script src="/bundle/http.js"></script>
 <script src="/bundle/router.dev.js"></script>
+<script src="/rxjs/bundles/Rx.js"></script>
 <script>
-  window.angularDevMode = true;
   var filename = '@@PATH/@@FILENAME';
   System.import(filename).then(function(m) { m.main(); }, console.error.bind(console));
 </script>
diff --git a/tools/broccoli/html-replace/SCRIPTS_benchmarks.html b/tools/broccoli/html-replace/SCRIPTS_benchmarks.html
index 743b9570d1aa..3996862f5cd2 100644
--- a/tools/broccoli/html-replace/SCRIPTS_benchmarks.html
+++ b/tools/broccoli/html-replace/SCRIPTS_benchmarks.html
@@ -19,6 +19,7 @@
 </script>
 <script src="/bundle/angular2-polyfills.js"></script>
 <script src="/bundle/angular2.dev.js"></script>
+<script src="/rxjs/bundles/Rx.js"></script>
 <script>
   var filename = '@@PATH/@@FILENAME';
   System.import(filename).then(function(m) { m.main(); }, console.error.bind(console));
diff --git a/tools/broccoli/js-replace/SCRIPTS.js b/tools/broccoli/js-replace/SCRIPTS.js
index feb581a9e7e7..7ef18d10ad03 100644
--- a/tools/broccoli/js-replace/SCRIPTS.js
+++ b/tools/broccoli/js-replace/SCRIPTS.js
@@ -1,3 +1,2 @@
-self.angularDevMode = true;
 importScripts("es6-shim.js", "zone-microtask.js", "long-stack-trace-zone.js", "system.src.js",
               "Reflect.js");
diff --git a/tools/build/webpack/angular2-testing.umd.js b/tools/build/webpack/angular2-all-testing.umd.js
similarity index 91%
rename from tools/build/webpack/angular2-testing.umd.js
rename to tools/build/webpack/angular2-all-testing.umd.js
index d1a2388c7031..fad83ecb246e 100644
--- a/tools/build/webpack/angular2-testing.umd.js
+++ b/tools/build/webpack/angular2-all-testing.umd.js
@@ -12,7 +12,7 @@ exports.router = require('angular2/router');
 exports.router_link_dsl = require('angular2/router/router_link_dsl.js');
 exports.instrumentation = require('angular2/instrumentation');
 exports.upgrade = require('angular2/upgrade');
-// this is the only difference as compared to the angular2.umd.js bundle
+// this is the only difference as compared to the angular2-all.umd.js bundle
 exports.testing = require('angular2/testing');
 exports.http.testing = require('angular2/http/testing');
 exports.router.testing = require('angular2/router/testing');
diff --git a/tools/build/webpack/angular2.umd.js b/tools/build/webpack/angular2-all.umd.js
similarity index 100%
rename from tools/build/webpack/angular2.umd.js
rename to tools/build/webpack/angular2-all.umd.js
diff --git a/tools/cjs-jasmine/index.js b/tools/cjs-jasmine/index.js
index 10fc759c0c94..0e97d7fa614e 100644
--- a/tools/cjs-jasmine/index.js
+++ b/tools/cjs-jasmine/index.js
@@ -6,8 +6,6 @@ var path = require('path');
 require('es6-shim/es6-shim.js');
 require('reflect-metadata/Reflect');
 
-global.angularDevMode = true;
-
 var jrunner = new JasmineRunner();
 
 // Tun on full stack traces in errors to help debugging
diff --git a/tools/code.angularjs.org/add-license-to-rx.js b/tools/code.angularjs.org/add-license-to-rx.js
new file mode 100644
index 000000000000..559671385d81
--- /dev/null
+++ b/tools/code.angularjs.org/add-license-to-rx.js
@@ -0,0 +1,38 @@
+#! /usr/bin/env node
+
+/**
+ * TODO: remove this file when license is included in RxJS bundles.
+ * https://github.com/ReactiveX/RxJS/issues/1067
+ *
+ * This script runs after bundles have already been copied to the build-path,
+ * to prepend the license to each bundle.
+ **/
+var fs = require('fs');
+var args = require('minimist')(process.argv);
+
+var license = fs.readFileSync(args['license-path']);
+// Make the license block into a JS comment
+license = `/**
+${license}
+**/
+`;
+
+var bundles = fs.readdirSync(args['build-path'])
+  // Match files that begin with Rx and end with js
+  .filter(bundle => /^Rx\.?.*\.js$/.test(bundle))
+  // Load file contents
+  .map(bundle => {
+    return {
+      path: bundle,
+      contents: fs.readFileSync(`${args['build-path']}/${bundle}`).toString()
+    };
+  })
+  // Concatenate license to bundle
+  .map(bundle => {
+    return {
+      path: bundle.path,
+      contents: `${license}${bundle.contents}`
+    };
+  })
+  // Write file to disk
+  .forEach(bundle => fs.writeFileSync(`${args['build-path']}/${bundle.path}`, bundle.contents));
diff --git a/tools/code.angularjs.org/publish.sh b/tools/code.angularjs.org/publish.sh
index 7402133657af..5fe04e4e7044 100755
--- a/tools/code.angularjs.org/publish.sh
+++ b/tools/code.angularjs.org/publish.sh
@@ -22,12 +22,24 @@ function init {
   else
     IS_SNAPSHOT_BUILD=
   fi
+  RX_BUNDLE_DIR=$(resolveDir ../../node_modules/rxjs/bundles)
+  RX_LICENSE=$(resolveDir ../../node_modules/rxjs)/LICENSE.txt
 }
 
 function prepare {
 
-  echo "-- Cloning code.angularjs.org"
-  git clone git@github.com:angular/code.angularjs.org.git $REPO_DIR --depth=1
+
+
+  if [ -d "$REPO_DIR" ]; then
+    cd $REPO_DIR
+    git fetch --update-shallow origin
+    git checkout master
+    git merge --ff-only origin/master
+    cd -
+  else
+    echo "-- Cloning code.angularjs.org into $REPO_DIR"
+    git clone git@github.com:angular/code.angularjs.org.git $REPO_DIR --depth=1
+  fi
 
   echo "-- Updating code.angularjs.org"
 
@@ -44,6 +56,8 @@ function prepare {
     #
     mkdir $REPO_DIR/$NEW_VERSION
     cp -r $BUILD_DIR/* $REPO_DIR/$NEW_VERSION/
+    cp -r $RX_BUNDLE_DIR/* $REPO_DIR/$NEW_VERSION/
+    node ./add-license-to-rx.js --license-path=$RX_LICENSE --build-path=$REPO_DIR/$NEW_VERSION
   fi
 
   #