[API] Don't use new composition for legacy objects

[API] Enable bundles from spec
[API] No, don't enable bundles by default
2016-09-30 17:22:27 -07:00 · 2016-09-30 17:19:52 -07:00 · 2016-09-30 17:12:42 -07:00 · 2016-09-30 17:11:05 -07:00 · 2016-09-30 17:05:40 -07:00 · 2016-09-30 16:55:58 -07:00
398 changed files with 8120 additions and 17466 deletions
--- a/.jshintrc
+++ b/.jshintrc
@@ -14,8 +14,7 @@
    "nonew": true,
    "predef": [
        "define",
-        "Promise",
-        "WeakMap"
+        "Promise"
    ],
    "shadow": "outer",
    "strict": "implied",
--- a/API.md
+++ b/API.md
@@ -1,249 +1,147 @@
-# Building Applications With Open MCT
+# Open MCT API

-## Scope and purpose of this document
+The Open MCT framework public api can be utilized by building the application
+(`gulp install`) and then copying the file from `dist/main.js` to your
+directory of choice.

-This document is intended to serve as a reference for developing an application 
-based on Open MCT. It will provide details of the API functions necessary to extend the 
-Open MCT platform meet common use cases such as integrating with a telemetry source. 
+Open MCT supports AMD, CommonJS, and loading via a script tag; it's easy to use
+in your project. The [`openmct`]{@link module:openmct} module is exported
+via AMD and CommonJS, and is also exposed as `openmct` in the global scope
+if loaded via a script tag.

-The best place to start is with the [Open MCT Tutorials](https://github.com/nasa/openmct-tutorial). 
-These will walk you through the process of getting up and running with Open MCT, 
-as well as addressing some common developer use cases.
+## Overview

-## Building From Source 
+Open MCT's goal is to allow you to browse, create, edit, and visualize all of
+the domain knowledge you need on a daily basis.

-The latest version of Open MCT is available from [our GitHub repository](https://github.com/nasa/openmct). 
-If you have `git`, and `node` installed, you can build Open MCT with the commands 
-```
-git clone https://github.com/nasa/openmct.git
-cd openmct
-npm install
-```
-
-These commands will fetch the Open MCT source from our GitHub repository, and build 
-a minified version that can be included in your application. The output of the 
-build process is placed in a `dist` folder under the openmct source directory, 
-which can be copied out to another location as needed. The contents of this 
-folder will include a minified javascript file named `openmct.js` as well as 
-assets such as html, css, and images necessary for the UI. 
-
-## Starting an Open MCT application
-
-To start a minimally functional Open MCT application, it is necessary to include 
-the Open MCT distributable, enable some basic plugins, and bootstrap the application. 
-The tutorials walk through the process of getting Open MCT up and running from scratch,
-but provided below is a minimal HTML template that includes Open MCT, installs 
-some basic plugins, and bootstraps the application. It assumes that Open MCT is 
-installed under an `openmct` subdirectory, as described in [Building From Source](#building-from-source). 
-
-This approach includes openmct using a simple script tag, resulting in a global 
-variable named `openmct`. This `openmct` object is used subsequently to make API 
-calls. 
-
-Open MCT is packaged as a UMD (Universal Module Definition) module, so common 
-script loaders are also supported.
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Open MCT</title>
-    <script src="openmct.js"></script>
-</head>
-<body>
-    <script>
-        openmct.setAssetPath('openmct/dist');
-        openmct.install(openmct.plugins.LocalStorage());
-        openmct.install(openmct.plugins.MyItems());
-        openmct.install(openmct.plugins.UTCTimeSystem());
-        openmct.install(openmct.plugins.Espresso());
-        openmct.start();
-    </script>
-</body>
-</html>
-```
-
-The Open MCT library included above requires certain assets such as html templates, 
-images, and css. If you installed Open MCT from GitHub as described in the section 
-on [Building from Source](#building-from-source) then these assets will have been 
-downloaded along with the Open MCT javascript library. You can specify the 
-location of these assets by calling `openmct.setAssetPath()`. Typically this will 
-be the same location as the `openmct.js` library is included from.
-
-There are some plugins bundled with the application that provide UI, persistence, 
-and other default configuration which are necessary to be able to do anything with 
-the application initially. Any of these plugins can, in principle, be replaced with a custom 
-plugin. The included plugins are documented in the [Included Plugins](#included-plugins) 
-section.  
-
-## Plugins
-
-### Defining and Installing a New Plugin
-
-```javascript
-openmct.install(function install(openmctAPI) {
-    // Do things here
-    // ...
-});
-```
-
-New plugins are installed in Open MCT by calling `openmct.install`, and providing 
-a plugin installation function. This function will be invoked on application 
-startup with one parameter - the openmct API object. A common approach used in 
-the Open MCT codebase is to define a plugin as a function that returns this 
-installation function. This allows configuration to be specified when the plugin is included.
-
-eg.
-```javascript
-openmct.install(openmct.plugins.Elasticsearch("http://localhost:8002/openmct"));
-```
-This approach can be seen in all of the [plugins provided with Open MCT](https://github.com/nasa/openmct/blob/master/src/plugins/plugins.js).
-
-## Domain Objects and Identifiers
-
-_Domain Objects_ are the basic entities that represent domain knowledge in Open MCT.
-The temperature sensor on a solar panel, an overlay plot comparing 
-the results of all temperature sensors, the command dictionary for a spacecraft,
-the individual commands in that dictionary, the "My Items" folder:
+To do this, the main building block provided by Open MCT is the _domain object_.
+The temperature sensor on the starboard solar panel,
+an overlay plot comparing the results of all temperature sensor,
+the command dictionary for a spacecraft,
+the individual commands in that dictionary, your "my documents" folder:
 All of these things are domain objects.

-A _Domain Object_ is simply a javascript object with some standard attributes.  
-An example of a _Domain Object_ is the "My Items" object which is a folder in 
-which a user can persist any objects that they create. The My Items object 
-looks like this: 
+Domain objects have Types, so a specific instrument temperature sensor is a
+"Telemetry Point," and turning on a drill for a certain duration of time is
+an "Activity".  Types allow you to form an ontology of knowledge and provide
+an abstraction for grouping, visualizing, and interpreting data.

-```javascript
-{
-    identifier: {
-        namespace: ""
-        key: "mine"
-    }
-    name:"My Items",
-    type:"folder",
-    location:"ROOT",
-    composition: []
-}
+And then we have Views. Views allow you to visualize domain objects. Views can
+apply to specific domain objects; they may also apply to certain types of
+domain objects, or they may apply to everything.  Views are simply a method
+of visualizing domain objects.
+
+Regions allow you to specify what views are displayed for specific types of
+domain objects in response to different user actions. For instance, you may
+want to display a different view while editing, or you may want to update the
+toolbar display when objects are selected.  Regions allow you to map views to
+specific user actions.
+
+Domain objects can be mutated and persisted, developers can create custom
+actions and apply them to domain objects, and many more things can be done.
+For more information, read on!
+
+## Running Open MCT
+
+Once the [`openmct`](@link module:openmct) module has been loaded, you can
+simply invoke [`start`]{@link module:openmct.MCT#start} to run Open MCT:
+
+
+```
+openmct.start();
 ```

-### Object Attributes
+Generally, however, you will want to configure Open MCT by adding plugins
+before starting it. It is important to install plugins and configure Open MCT
+_before_ calling [`start`]{@link module:openmct.MCT#start}; Open MCT is not
+designed to be reconfigured once started.

-The main attributes to note are the `identifier`, and `type` attributes.
-* `identifier`: A composite key that provides a universally unique identifier for 
-this object. The `namespace` and `key` are used to identify the object. The `key` 
-must be unique within the namespace. 
-* `type`: All objects in Open MCT have a type. Types allow you to form an 
-ontology of knowledge and provide an abstraction for grouping, visualizing, and 
-interpreting data. Details on how to define a new object type are provided below. 
+## Configuring Open MCT

-Open MCT uses a number of builtin types. Typically you are going to want to 
-define your own if extending Open MCT.
+The [`openmct`]{@link module:openmct} module (more specifically, the
+[`MCT`]{@link module:openmct.MCT} class, of which `openmct` is an instance)
+exposes a variety of methods to allow the application to be configured,
+extended, and customized before running.

-### Domain Object Types
+Short examples follow; see the linked documentation for further details.

-Custom types may be registered via the `addType` function on the opencmt Type 
-registry.
+### Adding Domain Object Types

-eg.
-```javascript
-openmct.types.addType('my-type', {
+Custom types may be registered via
+[`openmct.types`]{@link module:openmct.MCT#types}:
+
+```
+openmct.types.addType('my-type', new openmct.Type({
    label: "My Type",
-    description: "This is a type that I added!",
-    creatable: true
+    description: "This is a type that I added!"
 });
 ```

-The `addType` function accepts two arguments:
-* A `string` key identifying the type. This key is used when specifying a type 
-for an object.
-* An object type specification. An object type definition supports the following 
-attributes      
-    * `label`: a `string` naming this object type
-    * `description`: a `string` specifying a longer-form description of this type
-    * `initialize`: a `function` which initializes the model for new domain objects 
-    of this type. This can be used for setting default values on an object when 
-    it is instantiated.
-    * `creatable`: A `boolean` indicating whether users should be allowed to create 
-    this type (default: `false`). This will determine whether the type appears 
-    in the `Create` menu.
-    * `cssClass`: A `string` specifying a CSS class to apply to each representation 
-    of this object. This is used for specifying an icon to appear next to each 
-    object of this type.
+### Adding Views

-The [Open MCT Tutorials](https://github.com/openmct/openmct-tutorial) provide a 
-step-by-step examples of writing code for Open MCT that includes a [section on 
-defining a new object type](https://github.com/nasa/openmct-tutorial#step-3---providing-objects).
+Custom views may be registered based on the region in the application
+where they should appear:

-## Root Objects
+* [`openmct.mainViews`]{@link module:openmct.MCT#mainViews} is a registry
+  of views of domain objects which should appear in the main viewing area.
+* [`openmct.inspectors`]{@link module:openmct.MCT#inspectors} is a registry
+  of views of domain objects and/or active selections, which should appear in
+  the Inspector.
+* [`openmct.toolbars`]{@link module:openmct.MCT#toolbars} is a registry
+  of views of domain objects and/or active selections, which should appear in
+  the toolbar area while editing.
+* [`openmct.indicators`]{@link module:openmct.MCT#inspectors} is a registry
+  of views which should appear in the status area of the application.

-In many cases, you'd like a certain object (or a certain hierarchy of objects) 
-to be accessible from the top level of the application (the tree on the left-hand 
-side of Open MCT.) For example, it is typical to expose a telemetry dictionary 
-as a hierarchy of telemetry-providing domain objects in this fashion.
+Example:

-To do so, use the `addRoot` method of the object API.
-
-eg.
-```javascript
-openmct.objects.addRoot({
-        namespace: "my-namespace",
-        key: "my-key"
-    });
 ```
-
-The `addRoot` function takes a single [object identifier](#domain-objects-and-identifiers) 
-as an argument. 
-
-Root objects are loaded just like any other objects, i.e. via an object
-provider.
-
-## Object Providers
-
-An Object Provider is used to build _Domain Objects_, typically retrieved from 
-some source such as a persistence store or telemetry dictionary. In order to 
-integrate telemetry from a new source an object provider will need to be created 
-that can build objects representing telemetry points exposed by the telemetry 
-source. The API call to define a new object provider is fairly straightforward. 
-Here's a very simple example:
-
-```javascript
-openmct.objects.addProvider('example.namespace', {
-    get: function (identifier) {
-        return Promise.resolve({
-            identifier: identifier,
-            name: 'Example Object',
-            type: 'example-object-type'
-        });
+openmct.mainViews.addProvider({
+    canView: function (domainObject) {
+        return domainObject.type === 'my-type';
+    },
+    view: function (domainObject) {
+        return new MyView(domainObject);
    }
 });
 ```
-The `addProvider` function takes two arguments:

-* `namespace`: A `string` representing the namespace that this object provider 
-will provide objects for.
-* `provider`: An `object` with a single function, `get`. This function accepts an 
-[Identifier](#domain-objects-and-identifiers) for the object to be provided. 
-It is expected that the `get` function will return a 
-[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) 
-that resolves with the object being requested.
+### Adding a Root-level Object

-In future, object providers will support other methods to enable other operations 
-with persistence stores, such as creating, updating, and deleting objects.
+In many cases, you'd like a certain object (or a certain hierarchy of
+objects) to be accessible from the top level of the application (the
+tree on the left-hand side of Open MCT.) It is typical to expose a telemetry
+dictionary as a hierarchy of telemetry-providing domain objects in this
+fashion.

-## Composition Providers
+To do so, use the [`addRoot`]{@link module:openmct.ObjectAPI#addRoot} method
+of the [object API]{@link module:openmct.ObjectAPI}:

-The _composition_ of a domain object is the list of objects it contains, as shown 
-(for example) in the tree for browsing. Open MCT provides a
-[default solution](#default-composition-provider) for composition, but there
-may be cases where you want to provide the composition of a certain object
-(or type of object) dynamically.
+```
+openmct.objects.addRoot({
+    identifier: { key: "my-key", namespace: "my-namespace" }
+    name: "My Root-level Object",
+    type: "my-type"
+});
+```
+
+You can also remove this root-level object via its identifier:
+
+```
+openmct.objects.removeRoot({ key: "my-key", namespace: "my-namespace" });
+```

 ### Adding Composition Providers

-You may want to populate a hierarchy under a custom root-level object based on 
-the contents of a telemetry dictionary. To do this, you can add a new 
-Composition Provider:
+The "composition" of a domain object is the list of objects it contains,
+as shown (for example) in the tree for browsing. Open MCT provides a
+default solution for composition, but there may be cases where you want
+to provide the composition of a certain object (or type of object) dynamically.
+For instance, you may want to populate a hierarchy under a custom root-level
+object based on the contents of a telemetry dictionary.
+To do this, you can add a new CompositionProvider:

-```javascript
+```
 openmct.composition.addProvider({
    appliesTo: function (domainObject) {
        return domainObject.type === 'my-type';
@@ -253,177 +151,135 @@ openmct.composition.addProvider({
    }
 });
 ```
-The `addProvider` function accepts a Composition Provider object as its sole 
-argument. A Composition Provider is a javascript object exposing two functions:
-* `appliesTo`: A `function` that accepts a `domainObject` argument, and returns 
-a `boolean` value indicating whether this composition provider applies to the 
-given object.
-* `load`: A `function` that accepts a `domainObject` as an argument, and returns
-a `Promise` that resolves with an array of [Identifier](#domain-objects-and-identifiers).
-These identifiers will be used to fetch Domain Objects from an [Object Provider](#object-provider)

-### Default Composition Provider
+### Adding Telemetry Providers

-The default composition provider applies to any domain object with a `composition` 
-property. The value of `composition` should be an array of identifiers, e.g.:
+When connecting to a new telemetry source, you will want to register a new
+[telemetry provider]{@link module:openmct.TelemetryAPI~TelemetryProvider}
+with the [telemetry API]{@link module:openmct.TelemetryAPI#addProvider}:

-```javascript
-var domainObject = {
-    name: "My Object",
-    type: 'folder',
-    composition: [
-        {
-            id: '412229c3-922c-444b-8624-736d85516247',
-            namespace: 'foo'
-        },
-        {
-            key: 'd6e0ce02-5b85-4e55-8006-a8a505b64c75',
-            namespace: 'foo'
-        }
-    ]
-};
 ```
-
-## Telemetry Providers
-
-When connecting to a new telemetry source, you will need to register a new
-_Telemetry Provider_. A _Telemetry Provider_ retrieves telemetry data from some telemetry 
-source, and exposes them in a way that can be used by Open MCT. A telemetry 
-provider typically can support a one off __request__ for a batch of telemetry data, 
-or it can provide the ability to __subscribe__ to receive new telemetry data when 
-it becomes available, or both.
-
-```javascript
 openmct.telemetry.addProvider({
-    supportsRequest: function (domainObject) {
-        //...
+    canProvideTelemetry: function (domainObject) {
+        return domainObject.type === 'my-type';
    },
-    supportsSubscribe: function (domainObject) {
-        //...
+    properties: function (domainObject) {
+        return [
+            { key: 'value', name: "Temperature", units: "degC" },
+            { key: 'time', name: "UTC" }
+        ];
    },
-    request: function (domainObject, options) {    
-        //...
+    request: function (domainObject, options) {
+        var telemetryId = domainObject.myTelemetryId;
+        return myAdapter.request(telemetryId, options.start, options.end);
    },
-    subscribe: function (domainObject, callback, options) {
-        //...
+    subscribe: function (domainObject, callback) {
+        var telemetryId = domainObject.myTelemetryId;
+        myAdapter.subscribe(telemetryId, callback);
+        return myAdapter.unsubscribe.bind(myAdapter, telemetryId, callback);
    }
-})
+});
 ```

-A telemetry provider is an object with the following functions defined:
-
-* `supportsRequest`: An __optional__ `function` that accepts a 
-[Domain Object](#domain-objects-and-identifiers) and returns a `boolean` value
-indicating whether or not this provider supports telemetry requests for the 
-given object. If this returns `true` then a `request` function must be defined. 
-* `supportsSubscribe`: An __optional__ `function` that accepts a 
-[Domain Object](#domain-objects-and-identifiers) and returns a `boolean` value 
-indicating whether or not this provider supports telemetry subscriptions. If this 
-returns `true` then a `subscribe` function must also be defined. As with `request`, 
-the return value will typically be conditional, and based on attributes of 
-`domainObject` such as its identifier.
-* `request`: A `function` that returns a `Promise` that will resolve with an `Array` 
-of telemetry in a single query. This function accepts as arguments a 
-[Domain Object](#domain-objects-and-identifiers) and an object containing some 
-[request options](#telemetry-requests). 
-* `subscribe`:  A `function` that accepts a [Domain Object](#domain-objects-and-identifiers),
-a callback `function`, and a [telemetry request](#telemetry-requests). The 
-callback is invoked whenever telemetry is available, and 
-
-
 The implementations for `request` and `subscribe` can vary depending on the
 nature of the endpoint which will provide telemetry. In the example above,
-it is assumed that `myAdapter` contains the implementation details
-(such as HTTP requests, WebSocket connections, etc.) associated with some telemetry
+it is assumed that `myAdapter` contains the specific implementations
+(HTTP requests, WebSocket connections, etc.) associated with some telemetry
 source.

-For a step-by-step guide to building a telemetry adapter, please see the 
-[Open MCT Tutorials](https://github.com/larkin/openmct-tutorial).
+## Using Open MCT

-### Telemetry Requests
-Telemetry requests support time bounded queries. A call to a _Telemetry Provider_'s 
-`request` function will include an `options` argument. These are simply javascript
-objects with attributes for the request parameters. An example of a telemetry 
-request object with a start and end time is included below:
-```javascript
-{
-    start: 1487981997240,
-    end: 1487982897240
-}
+When implementing new features, it is useful and sometimes necessary to
+utilize functionality exposed by Open MCT.
+
+### Retrieving Composition
+
+To limit which objects are loaded at any given time, the composition of
+a domain object must be requested asynchronously:
+
+```
+openmct.composition(myObject).load().then(function (childObjects) {
+    childObjects.forEach(doSomething);
+});
 ```

-### Telemetry Data
+### Support Common Gestures

-Telemetry data is provided to Open MCT by _[Telemetry Providers](#telemetry-providers)_
-in the form of javascript objects. A collection of telemetry values (for example, 
-retrieved in response to a `request`) is represented by an `Array` of javascript 
-objects. These telemetry javascript objects are simply key value pairs.
+Custom views may also want to support common gestures using the
+[gesture API]{@link module:openmct.GestureAPI}. For instance, to make
+a view (or part of a view) selectable:

-Typically a telemetry datum will have some timestamp associated with it. This 
-time stamp should have a key that corresponds to some time system supported by 
-Open MCT. If the `UTCTimeSystem` plugin is installed, then the key `utc` can be used.
-   
-An example of a telemetry provider request function that returns a collection of
-mock telemtry data is below:
-
-```javascript
-openmct.telemetry.addProvider({
-    supportsRequest: function (domainObject) {
-        return true
-    },
-    request: function (domainObject, options) {    
-        return Promise.resolve([
-            {
-                'utc': Date.now() - 2000,
-                'value': 1,
-            },
-            {
-                'utc': Date.now() - 1000,
-                'value': 2,
-            },
-            {
-                'utc': Date.now(),
-                'value': 3,
-            }
-        ]);
-    }
-})
+```
+openmct.gestures.selectable(myHtmlElement, myDomainObject);
 ```

-## Included Plugins
+### Working with Domain Objects

-Open MCT is packaged along with a few general-purpose plugins:
+The [object API]{@link module:openmct.ObjectAPI} provides useful methods
+for working with domain objects.
+
+To make changes to a domain object, use the
+[`mutate`]{@link module:openmct.ObjectAPI#mutate} method:

-* `openmct.plugins.CouchDB` is an adapter for using CouchDB for persistence
-  of user-created objects. This is a constructor that takes the URL for the
-  CouchDB database as a parameter, e.g.
-```javascript
-openmct.install(openmct.plugins.CouchDB('http://localhost:5984/openmct'))
 ```
-* `openmct.plugins.Elasticsearch` is an adapter for using Elasticsearch for
-  persistence of user-created objects. This is a
-  constructor that takes the URL for the Elasticsearch instance as a
-  parameter. eg.
-```javascript
-openmct.install(openmct.plugins.CouchDB('http://localhost:9200'))
+openmct.objects.mutate(myDomainObject, "name", "New name!");
 ```
-* `openmct.plugins.Espresso` and `openmct.plugins.Snow` are two different
-  themes (dark and light) available for Open MCT. Note that at least one
-  of these themes must be installed for Open MCT to appear correctly.
-* `openmct.plugins.LocalStorage` provides persistence of user-created
-  objects in browser-local storage. This is particularly useful in
-  development environments.
-* `openmct.plugins.MyItems` adds a top-level folder named "My Items"
-  when the application is first started, providing a place for a
-  user to store created items.
-* `openmct.plugins.UTCTimeSystem` provides a default time system for Open MCT.

-Generally, you will want to either install these plugins, or install
-different plugins that provide persistence and an initial folder
-hierarchy.
+Making modifications in this fashion allows other usages of the domain
+object to remain up to date using the
+[`observe`]{@link module:openmct.ObjectAPI#observe} method:

-eg.
-```javascript
-openmct.install(openmct.plugins.LocalStorage());
-openmct.install(openmct.plugins.MyItems());
 ```
+openmct.objects.observe(myDomainObject, "name", function (newName) {
+    myLabel.textContent = newName;
+});
+```
+
+### Using Telemetry
+
+Very often in Open MCT, you wish to work with telemetry data (for instance,
+to display it in a custom visualization.)
+
+
+### Synchronizing with the Time Conductor
+
+Views which wish to remain synchronized with the state of Open MCT's
+time conductor should utilize
+[`openmct.conductor`]{@link module:openmct.TimeConductor}:
+
+```
+openmct.conductor.on('bounds', function (newBounds) {
+    requestTelemetry(newBounds.start, newBounds.end).then(displayTelemetry);
+});
+```
+
+## Plugins
+
+While you can register new features with Open MCT directly, it is generally
+more useful to package these as a plugin. A plugin is a function that takes
+[`openmct`]{@link module:openmct} as an argument, and performs configuration
+upon `openmct` when invoked.
+
+### Installing Plugins
+
+To install plugins, use the [`install`]{@link module:openmct.MCT#install}
+method:
+
+```
+openmct.install(myPlugin);
+```
+
+The plugin will be invoked to configure Open MCT before it is started.
+
+### Writing Plugins
+
+Plugins configure Open MCT, and should utilize the
+[`openmct`]{@link module:openmct} module to do so, as summarized above in
+"Configuring Open MCT" and "Using Open MCT" above.
+
+### Distributing Plugins
+
+Hosting or downloading plugins is outside of the scope of this documentation.
+We recommend distributing plugins as UMD modules which export a single
+function.
+
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Open MCT [![license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0)

-Open MCT (Open Mission Control Technologies) is a next-generation mission control framework for visualization of data on desktop and mobile devices. It is developed at NASA's Ames Research Center, and is being used by NASA for data analysis of spacecraft missions, as well as planning and operation of experimental rover systems. As a generalizable and open source framework, Open MCT could be used as the basis for building applications for planning, operation, and analysis of any systems producing telemetry data.
+Open MCT is a next-generation mission control framework for visualization of data on desktop and mobile devices. It is developed at NASA's Ames Research Center, and is being used by NASA for data analysis of spacecraft missions, as well as planning and operation of experimental rover systems. As a generalizable and open source framework, Open MCT could be used as the basis for building applications for planning, operation, and analysis of any systems producing telemetry data.

 Please visit our [Official Site](https://nasa.github.io/openmct/) and [Getting Started Guide](https://nasa.github.io/openmct/getting-started/)

--- a/bower.json
+++ b/bower.json
@@ -22,7 +22,6 @@
    "eventemitter3": "^1.2.0",
    "lodash": "3.10.1",
    "almond": "~0.3.2",
-    "d3": "~4.1.0",
    "html2canvas": "^0.4.1"
  }
 }
--- a/build-docs.sh
+++ b/build-docs.sh
@@ -24,7 +24,7 @@

 # Script to build and deploy docs.

-OUTPUT_DIRECTORY="dist/docs"
+OUTPUT_DIRECTORY="target/docs"
 # Docs, once built, are pushed to the private website repo
 REPOSITORY_URL="git@github.com:nasa/openmct-website.git"
 WEBSITE_DIRECTORY="website"
--- a/docs/src/architecture/framework.md
+++ b/docs/src/architecture/framework.md
@@ -131,7 +131,7 @@ Keeping that in mind, there are a few useful patterns supported by the
 framework that are useful to keep in mind.

 The specific service infrastructure provided by the platform is described
-in the [Platform Architecture](platform.md).
+in the [Platform Architecture](Platform.md).

 ## Extension Categories

--- a/docs/src/guide/index.md
+++ b/docs/src/guide/index.md
@@ -1338,6 +1338,55 @@ are supported:

 Open MCT defines several Angular directives that are intended for use both 
 internally within the platform, and by plugins. 
+
+## Before Unload 
+
+The `mct-before-unload` directive is used to listen for (and prompt for user 
+confirmation) of navigation changes in the browser. This includes reloading, 
+following links out of Open MCT, or changing routes. It is used to hook into 
+both `onbeforeunload` event handling as well as route changes from within 
+Angular.
+
+This directive is useable as an attribute. Its value should be an Angular 
+expression. When an action that would trigger an unload and/or route change 
+occurs, this Angular expression is evaluated. Its result should be a message to 
+display to the user to confirm their navigation change; if this expression 
+evaluates to a falsy value, no message will be displayed. 
+ 
+## Chart 
+
+The `mct-chart` directive is used to support drawing of simple charts. It is 
+present to support the Plot view, and its functionality is limited to the 
+functionality that is relevant for that view.
+
+This directive is used at the element level and takes one attribute, `draw` 
+which is an Angular expression which will should evaluate to a drawing object. 
+This drawing object should contain the following properties:
+
+* `dimensions`: The size, in logical coordinates, of the chart area. A 
+two-element array or numbers. 
+* `origin`: The position, in logical coordinates, of the lower-left corner of 
+the chart area. A two-element array or numbers. 
+* `lines`: An array of lines (e.g. as a plot line) to draw, where each line is 
+expressed as an object containing: 
+    * `buffer`: A Float32Array containing points in the line, in logical 
+    coordinates, in sequential x,y pairs. 
+    * `color`: The color of the line, as a four-element RGBA array, where 
+    each element is a number in the range of 0.0-1.0. 
+    * `points`: The number of points in the line. 
+* `boxes`: An array of rectangles to draw in the chart area. Each is an object 
+containing: 
+    * `start`: The first corner of the rectangle, as a two-element array of 
+    numbers, in logical coordinates. 
+    * `end`: The opposite corner of the rectangle, as a two-element array of 
+    numbers, in logical coordinates. color : The color of the line, as a 
+    four-element RGBA array, where each element is a number in the range of 
+    0.0-1.0. 
+
+While `mct-chart` is intended to support plots specifically, it does perform 
+some useful management of canvas objects (e.g. choosing between WebGL and Canvas 
+2D APIs for drawing based on browser support) so its usage is recommended when 
+its supported drawing primitives are sufficient for other charting tasks. 
 
 ## Container 

@@ -2261,7 +2310,10 @@ The platform understands the following policy categories (specifiable as the

 * `action`: Determines whether or not a given action is allowable. The candidate 
 argument here is an Action; the context is its action context object.
-* `composition`: Determines whether or not a given domain object(first argument, `parent`) can contain a candidate child object (second argument, `child`).
+* `composition`: Determines whether or not domain objects of a given type are 
+allowed to contain domain objects of another type. The candidate argument here 
+is the container's `Type`; the context argument is the `Type` of the object to be 
+contained.
 * `view`: Determines whether or not a view is applicable for a domain object. 
 The candidate argument is the view's extension definition; the context argument 
 is the `DomainObject` to be viewed.
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -34,4 +34,5 @@ As we transition to a new API, the following documentation for the old API
 platform and the functionality that it provides.

 * The [Tutorials](tutorials/) give examples of extending the platform to add
- functionality, and integrate with data sources.
+ functionality,
+ and integrate with data sources.
--- a/docs/src/tutorials/index.md
+++ b/docs/src/tutorials/index.md
--- a/example/eventGenerator/bundle.js
+++ b/example/eventGenerator/bundle.js
@@ -49,7 +49,7 @@ define([
                {
                    "key": "eventGenerator",
                    "name": "Event Message Generator",
-                    "cssClass": "icon-folder-new",
+                    "cssclass": "icon-folder-new",
                    "description": "For development use. Creates sample event message data that mimics a live data stream.",
                    "priority": 10,
                    "features": "creation",
--- a/example/export/bundle.js
+++ b/example/export/bundle.js
@@ -36,7 +36,7 @@ define([
                    "name": "Export Telemetry as CSV",
                    "implementation": ExportTelemetryAsCSVAction,
                    "category": "contextual",
-                    "cssClass": "icon-download",
+                    "cssclass": "icon-download",
                    "depends": [ "exportService" ]
                }
            ]
--- a/example/generator/GeneratorProvider.js
+++ b/example/generator/GeneratorProvider.js
@@ -1,87 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    './WorkerInterface'
-], function (
-    WorkerInterface
-) {
-
-    var REQUEST_DEFAULTS = {
-        amplitude: 1,
-        period: 10,
-        offset: 0,
-        dataRateInHz: 1
-    };
-
-    function GeneratorProvider() {
-        this.workerInterface = new WorkerInterface();
-    }
-
-    GeneratorProvider.prototype.canProvideTelemetry = function (domainObject) {
-        return domainObject.type === 'generator';
-    };
-
-    GeneratorProvider.prototype.supportsRequest =
-        GeneratorProvider.prototype.supportsSubscribe =
-            GeneratorProvider.prototype.canProvideTelemetry;
-
-    GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request) {
-        var props = [
-            'amplitude',
-            'period',
-            'offset',
-            'dataRateInHz'
-        ];
-
-        var workerRequest = {};
-
-        props.forEach(function (prop) {
-            if (domainObject.telemetry && domainObject.telemetry.hasOwnProperty(prop)) {
-                workerRequest[prop] = domainObject.telemetry[prop];
-            }
-            if (request.hasOwnProperty(prop)) {
-                workerRequest[prop] = request[prop];
-            }
-            if (!workerRequest[prop]) {
-                workerRequest[prop] = REQUEST_DEFAULTS[prop];
-            }
-            workerRequest[prop] = Number(workerRequest[prop]);
-        });
-
-        return workerRequest;
-    };
-
-    GeneratorProvider.prototype.request = function (domainObject, request) {
-        var workerRequest = this.makeWorkerRequest(domainObject, request);
-        workerRequest.start = request.start;
-        workerRequest.end = request.end;
-        return this.workerInterface.request(workerRequest);
-    };
-
-    GeneratorProvider.prototype.subscribe = function (domainObject, callback, request) {
-        var workerRequest = this.makeWorkerRequest(domainObject, request);
-        return this.workerInterface.subscribe(workerRequest, callback);
-    };
-
-    return GeneratorProvider;
-});
--- a/example/generator/SinewaveTelemetryProvider.js
+++ b/example/generator/SinewaveTelemetryProvider.js
@@ -1,70 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-/*global define,Promise*/
-
-/**
- * Module defining SinewaveTelemetryProvider. Created by vwoeltje on 11/12/14.
- */
-define([
-    "./SinewaveTelemetrySeries",
-    "./GeneratorProvider"
-], function (
-    SinewaveTelemetrySeries,
-    GeneratorProvider
-) {
-
-    function SinewaveTelemetryProvider() {
-        this.provider = new GeneratorProvider();
-    }
-
-    SinewaveTelemetryProvider.prototype.requestTelemetry = function (requests) {
-        if (requests[0].source !== 'generator') {
-            return Promise.resolve({});
-        }
-        return this.provider.request({}, requests[0])
-            .then(function (data) {
-                var res = {
-                    generator: {}
-                };
-                res.generator[requests[0].key] = new SinewaveTelemetrySeries(data);
-                return res;
-            });
-    };
-
-    SinewaveTelemetryProvider.prototype.subscribe = function (callback, requests) {
-        if (requests[0].source !== 'generator') {
-            return function unsubscribe() {};
-        }
-
-        function wrapper(data) {
-            var res = {
-                generator: {}
-            };
-            res.generator[requests[0].key] = new SinewaveTelemetrySeries(data);
-            callback(res);
-        }
-
-        return this.provider.subscribe({}, wrapper, requests[0]);
-    };
-
-    return SinewaveTelemetryProvider;
-});
--- a/example/generator/SinewaveTelemetrySeries.js
+++ b/example/generator/SinewaveTelemetrySeries.js
@@ -1,75 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-/*global define,Promise*/
-
-/**
- * Module defining SinewaveTelemetry. Created by vwoeltje on 11/12/14.
- */
-define([
-
-], function (
-
-) {
-        "use strict";
-
-        function SinewaveTelemetrySeries(data) {
-            if (!Array.isArray(data)) {
-                data = [data];
-            }
-            this.data = data;
-        }
-
-        SinewaveTelemetrySeries.prototype.getPointCount = function () {
-            return this.data.length;
-        };
-
-
-        SinewaveTelemetrySeries.prototype.getDomainValue = function (
-            index,
-            domain
-        ) {
-            domain = domain || 'time';
-
-            return this.getDatum(index)[domain];
-        };
-
-        SinewaveTelemetrySeries.prototype.getRangeValue = function (
-            index,
-            range
-        ) {
-            range = range || 'sin';
-            return this.getDatum(index)[range];
-        };
-
-        SinewaveTelemetrySeries.prototype.getDatum = function (index) {
-            if (index > this.data.length || index < 0) {
-                throw new Error('IndexOutOfRange: index not available in series.');
-            }
-            return this.data[index];
-        };
-
-        SinewaveTelemetrySeries.prototype.getData = function () {
-            return this.data;
-        };
-
-        return SinewaveTelemetrySeries;
-});
--- a/example/generator/WorkerInterface.js
+++ b/example/generator/WorkerInterface.js
@@ -1,115 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    'text!./generatorWorker.js',
-    'uuid'
-], function (
-    workerText,
-    uuid
-) {
-
-    var workerBlob = new Blob(
-        [workerText],
-        {type: 'application/javascript'}
-    );
-    var workerUrl = URL.createObjectURL(workerBlob);
-
-    function WorkerInterface() {
-        this.worker = new Worker(workerUrl);
-        this.worker.onmessage = this.onMessage.bind(this);
-        this.callbacks = {};
-    }
-
-    WorkerInterface.prototype.onMessage = function (message) {
-        message = message.data;
-        var callback = this.callbacks[message.id];
-        if (callback) {
-            if (callback(message)) {
-                delete this.callbacks[message.id];
-            }
-        }
-    };
-
-    WorkerInterface.prototype.dispatch = function (request, data, callback) {
-        var message = {
-            request: request,
-            data: data,
-            id: uuid()
-        };
-
-        if (callback) {
-            this.callbacks[message.id] = callback;
-        }
-
-        this.worker.postMessage(message);
-
-        return message.id;
-    };
-
-    WorkerInterface.prototype.request = function (request) {
-        var deferred = {};
-        var promise = new Promise(function (resolve, reject) {
-            deferred.resolve = resolve;
-            deferred.reject = reject;
-        });
-
-        function callback(message) {
-            if (message.error) {
-                deferred.reject(message.error);
-            } else {
-                deferred.resolve(message.data);
-            }
-            return true;
-        }
-
-        this.dispatch('request', request, callback);
-
-        return promise;
-    };
-
-    WorkerInterface.prototype.subscribe = function (request, cb) {
-        var isCancelled = false;
-
-        var callback = function (message) {
-            if (isCancelled) {
-                return true;
-            }
-            cb(message.data);
-        };
-
-        var messageId = this.dispatch('subscribe', request, callback)
-
-        return function () {
-            isCancelled = true;
-            this.dispatch('unsubscribe', {
-                id: messageId
-            });
-        }.bind(this);
-
-    };
-
-
-
-
-    return WorkerInterface;
-});
--- a/example/generator/bundle.js
+++ b/example/generator/bundle.js
@@ -0,0 +1,144 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    "./src/SinewaveTelemetryProvider",
+    "./src/SinewaveLimitCapability",
+    "./src/SinewaveDeltaFormat",
+    'legacyRegistry'
+], function (
+    SinewaveTelemetryProvider,
+    SinewaveLimitCapability,
+    SinewaveDeltaFormat,
+    legacyRegistry
+) {
+    "use strict";
+
+    legacyRegistry.register("example/generator", {
+        "name": "Sine Wave Generator",
+        "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
+        "extensions": {
+            "components": [
+                {
+                    "implementation": SinewaveTelemetryProvider,
+                    "type": "provider",
+                    "provides": "telemetryService",
+                    "depends": [
+                        "$q",
+                        "$timeout"
+                    ]
+                }
+            ],
+            "capabilities": [
+                {
+                    "key": "limit",
+                    "implementation": SinewaveLimitCapability
+                }
+            ],
+            "formats": [
+                {
+                    "key": "example.delta",
+                    "implementation": SinewaveDeltaFormat
+                }
+            ],
+            "constants": [
+                {
+                    "key": "TIME_CONDUCTOR_DOMAINS",
+                    "value": [
+                        {
+                            "key": "time",
+                            "name": "Time"
+                        },
+                        {
+                            "key": "yesterday",
+                            "name": "Yesterday"
+                        },
+                        {
+                            "key": "delta",
+                            "name": "Delta",
+                            "format": "example.delta"
+                        }
+                    ],
+                    "priority": -1
+                }
+            ],
+            "types": [
+                {
+                    "key": "generator",
+                    "name": "Sine Wave Generator",
+                    "cssclass": "icon-telemetry",
+                    "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
+                    "priority": 10,
+                    "features": "creation",
+                    "model": {
+                        "telemetry": {
+                            "period": 10
+                        }
+                    },
+                    "telemetry": {
+                        "source": "generator",
+                        "domains": [
+                            {
+                                "key": "time",
+                                "name": "Time"
+                            },
+                            {
+                                "key": "yesterday",
+                                "name": "Yesterday"
+                            },
+                            {
+                                "key": "delta",
+                                "name": "Delta",
+                                "format": "example.delta"
+                            }
+                        ],
+                        "ranges": [
+                            {
+                                "key": "sin",
+                                "name": "Sine"
+                            },
+                            {
+                                "key": "cos",
+                                "name": "Cosine"
+                            }
+                        ]
+                    },
+                    "properties": [
+                        {
+                            "name": "Period",
+                            "control": "textfield",
+                            "cssclass": "l-input-sm l-numeric",
+                            "key": "period",
+                            "required": true,
+                            "property": [
+                                "telemetry",
+                                "period"
+                            ],
+                            "pattern": "^\\d*(\\.\\d*)?$"
+                        }
+                    ]
+                }
+            ]
+        }
+    });
+});
--- a/example/generator/generatorWorker.js
+++ b/example/generator/generatorWorker.js
@@ -1,155 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-/*global self*/
-
-(function () {
-
-    var FIFTEEN_MINUTES = 15 * 60 * 1000;
-
-    var handlers = {
-        subscribe: onSubscribe,
-        unsubscribe: onUnsubscribe,
-        request: onRequest
-    };
-
-    var subscriptions = {};
-
-    function workSubscriptions(timestamp) {
-        var now = Date.now();
-        var nextWork = Math.min.apply(Math, Object.values(subscriptions).map(function (subscription) {
-            return subscription(now);
-        }));
-        var wait = nextWork - now;
-        if (wait < 0) {
-            wait = 0;
-        }
-
-        if (Number.isFinite(wait)) {
-            setTimeout(workSubscriptions, wait);
-        }
-    }
-
-    function onSubscribe(message) {
-        var data = message.data;
-
-        // Keep
-        var start = Date.now();
-        var step = 1000 / data.dataRateInHz;
-        var nextStep = start - (start % step) + step;
-
-        function work(now) {
-            while (nextStep < now) {
-                self.postMessage({
-                    id: message.id,
-                    data: {
-                        utc: nextStep,
-                        yesterday: nextStep - 60*60*24*1000,
-                        delta: 60*60*24*1000,
-                        sin: sin(nextStep, data.period, data.amplitude, data.offset),
-                        cos: cos(nextStep, data.period, data.amplitude, data.offset)
-                    }
-                });
-                nextStep += step;
-            }
-            return nextStep;
-        }
-
-        subscriptions[message.id] = work;
-        workSubscriptions();
-    }
-
-    function onUnsubscribe(message) {
-        delete subscriptions[message.data.id];
-    }
-
-    function onRequest(message) {
-        var data = message.data;
-        if (data.end == undefined) {
-            data.end = Date.now();
-        }
-        if (data.start == undefined){
-            data.start = data.end - FIFTEEN_MINUTES;
-        }
-
-        var now = Date.now();
-        var start = data.start;
-        var end = data.end > now ? now : data.end;
-        var amplitude = data.amplitude;
-        var period = data.period;
-        var offset = data.offset;
-        var dataRateInHz = data.dataRateInHz;
-
-        var step = 1000 / dataRateInHz;
-        var nextStep = start - (start % step) + step;
-
-        var data = [];
-
-        for (; nextStep < end; nextStep += step) {
-            data.push({
-                utc: nextStep,
-                yesterday: nextStep - 60*60*24*1000,
-                delta: 60*60*24*1000,
-                sin: sin(nextStep, period, amplitude, offset),
-                cos: cos(nextStep, period, amplitude, offset)
-            });
-        }
-        self.postMessage({
-            id: message.id,
-            data: data
-        });
-    }
-
-    function cos(timestamp, period, amplitude, offset) {
-        return amplitude *
-            Math.cos(timestamp / period / 1000 * Math.PI * 2) + offset;
-    }
-
-    function sin(timestamp, period, amplitude, offset) {
-        return amplitude *
-            Math.sin(timestamp / period / 1000 * Math.PI * 2) + offset;
-    }
-
-    function sendError(error, message) {
-        self.postMessage({
-            error: error.name + ': ' + error.message,
-            message: message,
-            id: message.id
-        });
-    }
-
-    self.onmessage = function handleMessage(event) {
-        var message = event.data;
-        var handler = handlers[message.request];
-
-        if (!handler) {
-            sendError(new Error('unknown message type'), message);
-        } else {
-            try {
-                handler(message);
-            } catch (e) {
-                sendError(e, message);
-            }
-        }
-    };
-
-}());
--- a/example/generator/plugin.js
+++ b/example/generator/plugin.js
@@ -1,171 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-/*global define*/
-
-define([
-    "./GeneratorProvider",
-    "./SinewaveLimitCapability",
-    "./SinewaveDeltaFormat"
-], function (
-    GeneratorProvider,
-    SinewaveLimitCapability,
-    SinewaveDeltaFormat
-) {
-
-    var legacyExtensions = {
-        "capabilities": [
-            {
-                "key": "limit",
-                "implementation": SinewaveLimitCapability
-            }
-        ],
-        "formats": [
-            {
-                "key": "example.delta",
-                "implementation": SinewaveDeltaFormat
-            }
-        ],
-        "constants": [
-            {
-                "key": "TIME_CONDUCTOR_DOMAINS",
-                "value": [
-                    {
-                        "key": "time",
-                        "name": "Time"
-                    },
-                    {
-                        "key": "yesterday",
-                        "name": "Yesterday"
-                    },
-                    {
-                        "key": "delta",
-                        "name": "Delta"
-                    }
-                ],
-                "priority": -1
-            }
-        ]
-    }
-
-    return function(openmct){
-        //Register legacy extensions for things not yet supported by the new API
-        Object.keys(legacyExtensions).forEach(function (type){
-            var extensionsOfType = legacyExtensions[type];
-            extensionsOfType.forEach(function (extension) {
-                openmct.legacyExtension(type, extension)
-            })
-        });
-        openmct.types.addType("generator", {
-            label: "Sine Wave Generator",
-            description: "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
-            cssClass: "icon-telemetry",
-            creatable: true,
-            form: [
-                {
-                    name: "Period",
-                    control: "textfield",
-                    cssClass: "l-input-sm l-numeric",
-                    key: "period",
-                    required: true,
-                    property: [
-                        "telemetry",
-                        "period"
-                    ],
-                    pattern: "^\\d*(\\.\\d*)?$"
-                },
-                {
-                    name: "Amplitude",
-                    control: "textfield",
-                    cssClass: "l-input-sm l-numeric",
-                    key: "amplitude",
-                    required: true,
-                    property: [
-                        "telemetry",
-                        "amplitude"
-                    ],
-                    pattern: "^\\d*(\\.\\d*)?$"
-                },
-                {
-                    name: "Offset",
-                    control: "textfield",
-                    cssClass: "l-input-sm l-numeric",
-                    key: "offset",
-                    required: true,
-                    property: [
-                        "telemetry",
-                        "offset"
-                    ],
-                    pattern: "^\\d*(\\.\\d*)?$"
-                },
-                {
-                    name: "Data Rate (hz)",
-                    control: "textfield",
-                    cssClass: "l-input-sm l-numeric",
-                    key: "dataRateInHz",
-                    required: true,
-                    property: [
-                        "telemetry",
-                        "dataRateInHz"
-                    ],
-                    pattern: "^\\d*(\\.\\d*)?$"
-                }
-            ],
-            initialize: function (object) {
-                object.telemetry = {
-                    period: 10,
-                    amplitude: 1,
-                    offset: 0,
-                    dataRateInHz: 1,
-                    domains: [
-                        {
-                            key: "utc",
-                            name: "Time",
-                            format: "utc"
-                        },
-                        {
-                            key: "yesterday",
-                            name: "Yesterday",
-                            format: "utc"
-                        },
-                        {
-                            key: "delta",
-                            name: "Delta",
-                            format: "example.delta"
-                        }
-                    ],
-                    ranges: [
-                        {
-                            key: "sin",
-                            name: "Sine"
-                        },
-                        {
-                            key: "cos",
-                            name: "Cosine"
-                        }
-                    ]
-                };
-            }
-        });
-        openmct.telemetry.addProvider(new GeneratorProvider());
-    };
-
-});
--- a/example/generator/src/SinewaveConstants.js
+++ b/example/generator/src/SinewaveConstants.js
@@ -19,7 +19,7 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global define*/
+/*global define,Promise*/

 define({
    START_TIME: Date.now() - 24 * 60 * 60 * 1000 // Now minus a day.
--- a/example/generator/src/SinewaveDeltaFormat.js
+++ b/example/generator/src/SinewaveDeltaFormat.js
@@ -19,11 +19,12 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global define*/
+/*global define,Promise*/

 define(
    ['./SinewaveConstants', 'moment'],
    function (SinewaveConstants, moment) {
+        "use strict";

        var START_TIME = SinewaveConstants.START_TIME,
            FORMAT_REGEX = /^-?\d+:\d+:\d+$/,
--- a/example/generator/src/SinewaveLimitCapability.js
+++ b/example/generator/src/SinewaveLimitCapability.js
--- a/example/generator/src/SinewaveTelemetryProvider.js
+++ b/example/generator/src/SinewaveTelemetryProvider.js
@@ -0,0 +1,119 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining SinewaveTelemetryProvider. Created by vwoeltje on 11/12/14.
+ */
+define(
+    ["./SinewaveTelemetrySeries"],
+    function (SinewaveTelemetrySeries) {
+        "use strict";
+
+        /**
+         *
+         * @constructor
+         */
+        function SinewaveTelemetryProvider($q, $timeout) {
+            var subscriptions = [],
+                generating = false;
+
+            //
+            function matchesSource(request) {
+                return request.source === "generator";
+            }
+
+            // Used internally; this will be repacked by doPackage
+            function generateData(request) {
+                return {
+                    key: request.key,
+                    telemetry: new SinewaveTelemetrySeries(request)
+                };
+            }
+
+            //
+            function doPackage(results) {
+                var packaged = {};
+                results.forEach(function (result) {
+                    packaged[result.key] = result.telemetry;
+                });
+                // Format as expected (sources -> keys -> telemetry)
+                return { generator: packaged };
+            }
+
+            function requestTelemetry(requests) {
+                return $timeout(function () {
+                    return doPackage(requests.filter(matchesSource).map(generateData));
+                }, 0);
+            }
+
+            function handleSubscriptions() {
+                subscriptions.forEach(function (subscription) {
+                    var requests = subscription.requests;
+                    subscription.callback(doPackage(
+                        requests.filter(matchesSource).map(generateData)
+                    ));
+                });
+            }
+
+            function startGenerating() {
+                generating = true;
+                $timeout(function () {
+                    handleSubscriptions();
+                    if (generating && subscriptions.length > 0) {
+                        startGenerating();
+                    } else {
+                        generating = false;
+                    }
+                }, 1000);
+            }
+
+            function subscribe(callback, requests) {
+                var subscription = {
+                    callback: callback,
+                    requests: requests
+                };
+
+                function unsubscribe() {
+                    subscriptions = subscriptions.filter(function (s) {
+                        return s !== subscription;
+                    });
+                }
+
+                subscriptions.push(subscription);
+
+                if (!generating) {
+                    startGenerating();
+                }
+
+                return unsubscribe;
+            }
+
+            return {
+                requestTelemetry: requestTelemetry,
+                subscribe: subscribe
+            };
+        }
+
+        return SinewaveTelemetryProvider;
+    }
+);
--- a/example/generator/src/SinewaveTelemetrySeries.js
+++ b/example/generator/src/SinewaveTelemetrySeries.js
@@ -0,0 +1,78 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining SinewaveTelemetry. Created by vwoeltje on 11/12/14.
+ */
+define(
+    ['./SinewaveConstants'],
+    function (SinewaveConstants) {
+        "use strict";
+
+        var ONE_DAY = 60 * 60 * 24,
+            firstObservedTime = Math.floor(SinewaveConstants.START_TIME / 1000);
+
+        /**
+         *
+         * @constructor
+         */
+        function SinewaveTelemetrySeries(request) {
+            var timeOffset = (request.domain === 'yesterday') ? ONE_DAY : 0,
+                latestTime = Math.floor(Date.now() / 1000) - timeOffset,
+                firstTime = firstObservedTime - timeOffset,
+                endTime = (request.end !== undefined) ?
+                        Math.floor(request.end / 1000) : latestTime,
+                count = Math.min(endTime, latestTime) - firstTime,
+                period = +request.period || 30,
+                generatorData = {},
+                requestStart = (request.start === undefined) ? firstTime :
+                        Math.max(Math.floor(request.start / 1000), firstTime),
+                offset = requestStart - firstTime;
+
+            if (request.size !== undefined) {
+                offset = Math.max(offset, count - request.size);
+            }
+
+            generatorData.getPointCount = function () {
+                return count - offset;
+            };
+
+            generatorData.getDomainValue = function (i, domain) {
+                // delta uses the same numeric values as the default domain,
+                // so it's not checked for here, just formatted for display
+                // differently.
+                return (i + offset) * 1000 + firstTime * 1000 -
+                    (domain === 'yesterday' ? (ONE_DAY * 1000) : 0);
+            };
+
+            generatorData.getRangeValue = function (i, range) {
+                range = range || "sin";
+                return Math[range]((i + offset) * Math.PI * 2 / period);
+            };
+
+            return generatorData;
+        }
+
+        return SinewaveTelemetrySeries;
+    }
+);
--- a/example/imagery/bundle.js
+++ b/example/imagery/bundle.js
@@ -49,7 +49,7 @@ define([
                {
                    "key": "imagery",
                    "name": "Example Imagery",
-                    "cssClass": "icon-image",
+                    "cssclass": "icon-image",
                    "features": "creation",
                    "description": "For development use. Creates example imagery data that mimics a live imagery stream.",
                    "priority": 10,
--- a/example/imagery/src/ImageTelemetry.js
+++ b/example/imagery/src/ImageTelemetry.js
@@ -31,25 +31,10 @@ define(

        var firstObservedTime = Date.now(),
            images = [
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18731.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18732.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18733.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18734.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18735.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18736.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18737.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18738.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18739.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18740.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18741.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18742.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18743.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18744.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18745.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18746.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18747.jpg",
-                "https://www.hq.nasa.gov/alsj/a16/AS16-117-18748.jpg"
-
+                "http://www.nasa.gov/393811main_Palomar_ao_bouchez_10s_after_impact_4x3_946-710.png",
+                "http://www.nasa.gov/393821main_Palomar_ao_bouchez_15s_after_impact_4x3_946-710.png",
+                "http://www.nasa.gov/images/content/393801main_CfhtVeillet2_4x3_516-387.jpg",
+                "http://www.nasa.gov/images/content/392790main_1024_768_GeminiNorth_NightBeforeImpact_946-710.jpg"
            ].map(function (url, index) {
                return {
                    timestamp: firstObservedTime + 1000 * index,
--- a/example/localTimeSystem/bundle.js
+++ b/example/localTimeSystem/bundle.js
@@ -1,48 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    "./src/LocalTimeSystem",
-    "./src/LocalTimeFormat",
-    'legacyRegistry'
-], function (
-    LocalTimeSystem,
-    LocalTimeFormat,
-    legacyRegistry
-) {
-    legacyRegistry.register("example/localTimeSystem", {
-        "extensions": {
-            "formats": [
-                {
-                    "key": "local-format",
-                    "implementation": LocalTimeFormat
-                }
-            ],
-            "timeSystems": [
-                {
-                    "implementation": LocalTimeSystem,
-                    "depends": ["$timeout"]
-                }
-            ]
-        }
-    });
-});
--- a/example/localTimeSystem/src/LADTickSource.js
+++ b/example/localTimeSystem/src/LADTickSource.js
@@ -1,41 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(['../../../src/plugins/utcTimeSystem/LocalClock'], function (LocalClock) {
-    /**
-     * @implements TickSource
-     * @constructor
-     */
-    function LADTickSource ($timeout, period) {
-        LocalClock.call(this, $timeout, period);
-
-        this.key = 'test-lad';
-        this.mode = 'lad';
-        this.cssClass = 'icon-clock';
-        this.label = 'Latest Available Data';
-        this.name = 'Latest available data';
-        this.description = 'Monitor real-time streaming data as it comes in. The Time Conductor and displays will automatically advance themselves based on a UTC clock.';
-    }
-    LADTickSource.prototype = Object.create(LocalClock.prototype);
-
-    return LADTickSource;
-});
--- a/example/localTimeSystem/src/LocalTimeFormat.js
+++ b/example/localTimeSystem/src/LocalTimeFormat.js
@@ -1,112 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    'moment'
-], function (
-    moment
-) {
-
-    var DATE_FORMAT = "YYYY-MM-DD h:mm:ss.SSS a",
-        DATE_FORMATS = [
-            DATE_FORMAT,
-            "YYYY-MM-DD h:mm:ss a",
-            "YYYY-MM-DD h:mm a",
-            "YYYY-MM-DD"
-        ];
-
-    /**
-     * @typedef Scale
-     * @property {number} min the minimum scale value, in ms
-     * @property {number} max the maximum scale value, in ms
-     */
-
-    /**
-     * Formatter for UTC timestamps. Interprets numeric values as
-     * milliseconds since the start of 1970.
-     *
-     * @implements {Format}
-     * @constructor
-     * @memberof platform/commonUI/formats
-     */
-    function LocalTimeFormat() {
-    }
-
-    /**
-     * Returns an appropriate time format based on the provided value and
-     * the threshold required.
-     * @private
-     */
-    function getScaledFormat (d) {
-        var m = moment.utc(d);
-        /**
-         * Uses logic from d3 Time-Scales, v3 of the API. See
-         * https://github.com/d3/d3-3.x-api-reference/blob/master/Time-Scales.md
-         *
-         * Licensed
-         */
-        return [
-            [".SSS", function(m) { return m.milliseconds(); }],
-            [":ss", function(m) { return m.seconds(); }],
-            ["hh:mma", function(m) { return m.minutes(); }],
-            ["hha", function(m) { return m.hours(); }],
-            ["ddd DD", function(m) {
-                return m.days() &&
-                    m.date() != 1;
-            }],
-            ["MMM DD", function(m) { return m.date() != 1; }],
-            ["MMMM", function(m) {
-                return m.month();
-            }],
-            ["YYYY", function() { return true; }]
-        ].filter(function (row){
-            return row[1](m);
-        })[0][0];
-    };
-
-    /**
-     *
-     * @param value
-     * @param {Scale} [scale] Optionally provides context to the
-     * format request, allowing for scale-appropriate formatting.
-     * @returns {string} the formatted date
-     */
-    LocalTimeFormat.prototype.format = function (value, scale) {
-        if (scale !== undefined){
-            var scaledFormat = getScaledFormat(value, scale);
-            if (scaledFormat) {
-                return moment.utc(value).format(scaledFormat);
-            }
-        }
-        return moment(value).format(DATE_FORMAT);
-    };
-
-    LocalTimeFormat.prototype.parse = function (text) {
-        return moment(text, DATE_FORMATS).valueOf();
-    };
-
-    LocalTimeFormat.prototype.validate = function (text) {
-        return moment(text, DATE_FORMATS).isValid();
-    };
-
-    return LocalTimeFormat;
-});
--- a/example/localTimeSystem/src/LocalTimeSystem.js
+++ b/example/localTimeSystem/src/LocalTimeSystem.js
@@ -1,77 +0,0 @@
-/*****************************************************************************
- * Open MCT Web, Copyright (c) 2014-2015, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT Web is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT Web includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    '../../../src/plugins/utcTimeSystem/LocalClock',
-    './LADTickSource'
-], function (LocalClock, LADTickSource) {
-    var THIRTY_MINUTES = 30 * 60 * 1000,
-        DEFAULT_PERIOD = 1000;
-
-    /**
-     * This time system supports UTC dates and provides a ticking clock source.
-     * @implements TimeSystem
-     * @constructor
-     */
-    function LocalTimeSystem ($timeout) {
-
-        /**
-         * Some metadata, which will be used to identify the time system in
-         * the UI
-         * @type {{key: string, name: string, glyph: string}}
-         */
-        this.key = 'local';
-        this.name = 'Local';
-        this.cssClass = '\u0043';
-
-        this.fmts = ['local-format'];
-        this.sources = [new LocalClock($timeout, DEFAULT_PERIOD), new LADTickSource($timeout, DEFAULT_PERIOD)];
-    }
-
-    LocalTimeSystem.prototype.formats = function () {
-        return this.fmts;
-    };
-
-    LocalTimeSystem.prototype.deltaFormat = function () {
-        return 'duration';
-    };
-
-    LocalTimeSystem.prototype.tickSources = function () {
-        return this.sources;
-    };
-
-    LocalTimeSystem.prototype.isUTCBased = function () {
-        return true;
-    };
-
-    LocalTimeSystem.prototype.defaults = function (key) {
-        var now = Math.ceil(Date.now() / 1000) * 1000;
-        return {
-            key: 'local-default',
-            name: 'Local 12 hour time system defaults',
-            deltas: {start: THIRTY_MINUTES, end: 0},
-            bounds: {start: now - THIRTY_MINUTES, end: now}
-        };
-    };
-
-    return LocalTimeSystem;
-});
--- a/example/msl/bundle.js
+++ b/example/msl/bundle.js
@@ -23,93 +23,96 @@

 define([
    "./src/RemsTelemetryServerAdapter",
+    "./src/RemsTelemetryInitializer",
    "./src/RemsTelemetryModelProvider",
    "./src/RemsTelemetryProvider",
    'legacyRegistry',
    "module"
 ], function (
    RemsTelemetryServerAdapter,
+    RemsTelemetryInitializer,
    RemsTelemetryModelProvider,
    RemsTelemetryProvider,
    legacyRegistry
 ) {
    "use strict";
-    legacyRegistry.register("example/msl", {
+    legacyRegistry.register("example/msl-adapter", {
        "name" : "Mars Science Laboratory Data Adapter",
        "extensions" : {
-            "types": [
-                {
-                    "name":"Mars Science Laboratory",
-                    "key": "msl.curiosity",
-                    "cssClass": "icon-object"
-                },
-                {
-                    "name": "Instrument",
-                    "key": "msl.instrument",
-                    "cssClass": "icon-object",
-                    "model": {"composition": []}
-                },
-                {
-                    "name": "Measurement",
-                    "key": "msl.measurement",
-                    "cssClass": "icon-telemetry",
-                    "model": {"telemetry": {}},
-                    "telemetry": {
-                        "source": "rems.source",
-                        "domains": [
-                            {
-                                "name": "Time",
-                                "key": "utc",
-                                "format": "utc"
-                            }
-                        ]
-                    }
+        "types": [
+            {
+                "name":"Mars Science Laboratory",
+                "key": "msl.curiosity",
+                "cssclass": "icon-object"
+            },
+            {
+                "name": "Instrument",
+                "key": "msl.instrument",
+                "cssclass": "icon-object",
+                "model": {"composition": []}
+            },
+            {
+                "name": "Measurement",
+                "key": "msl.measurement",
+                "cssclass": "icon-telemetry",
+                "model": {"telemetry": {}},
+                "telemetry": {
+                    "source": "rems.source",
+                    "domains": [
+                        {
+                            "name": "Time",
+                            "key": "timestamp",
+                            "format": "utc"
+                        }
+                    ]
                }
-            ],
-            "constants": [
-                {
-                    "key": "REMS_WS_URL",
-                    "value": "/proxyUrl?url=http://cab.inta-csic.es/rems/wp-content/plugins/marsweather-widget/api.php"
+            }
+        ],
+        "constants": [
+            {
+                "key": "REMS_WS_URL",
+                "value": "/proxyUrl?url=http://cab.inta-csic.es/rems/wp-content/plugins/marsweather-widget/api.php"
+            }
+        ],
+        "roots": [
+            {
+                "id": "msl:curiosity",
+                "priority" : "preferred",
+                "model": {
+                    "type": "msl.curiosity",
+                    "name": "Mars Science Laboratory",
+                    "composition": []
                }
-            ],
-            "roots": [
-                {
-                    "id": "msl:curiosity"
-                }
-            ],
-            "models": [
-                {
-                    "id": "msl:curiosity",
-                    "priority": "preferred",
-                    "model": {
-                        "type": "msl.curiosity",
-                        "name": "Mars Science Laboratory",
-                        "composition": ["msl_tlm:rems"]
-                    }
-                }
-            ],
-            "services": [
-                {
-                    "key":"rems.adapter",
-                    "implementation": RemsTelemetryServerAdapter,
-                    "depends": ["$http", "$log", "REMS_WS_URL"]
-                }
-            ],
-            "components": [
-                {
-                    "provides": "modelService",
-                    "type": "provider",
-                    "implementation": RemsTelemetryModelProvider,
-                    "depends": ["rems.adapter"]
-                },
-                {
-                    "provides": "telemetryService",
-                    "type": "provider",
-                    "implementation": RemsTelemetryProvider,
-                    "depends": ["rems.adapter", "$q"]
-                }
-            ]
-        }
+            }
+        ],
+        "services": [
+            {
+                "key":"rems.adapter",
+                "implementation": RemsTelemetryServerAdapter,
+                "depends": ["$q", "$http", "$log", "REMS_WS_URL"]
+            }
+        ],
+        "runs": [
+            {
+                "implementation": RemsTelemetryInitializer,
+                "depends": ["rems.adapter", "objectService"]
+            }
+        ],
+        "components": [
+            {
+                "provides": "modelService",
+                "type": "provider",
+                "implementation": RemsTelemetryModelProvider,
+                "depends": ["rems.adapter"]
+            },
+            {
+                "provides": "telemetryService",
+                "type": "provider",
+                "implementation": RemsTelemetryProvider,
+                "depends": ["rems.adapter", "$q"]
+            }
+        ]
+    }
    });
 });

--- a/example/msl/src/RemsTelemetryInitializer.js
+++ b/example/msl/src/RemsTelemetryInitializer.js
@@ -0,0 +1,71 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define(
+    function (){
+        "use strict";
+
+        var TAXONOMY_ID = "msl:curiosity",
+            PREFIX = "msl_tlm:";
+
+        /**
+         * Function that is executed on application startup and populates
+         * the navigation tree with objects representing the MSL REMS
+         * telemetry points. The tree is populated based on the data
+         * dictionary on the provider.
+         *
+         * @param {RemsTelemetryServerAdapter} adapter The server adapter
+         * (necessary in order to retrieve data dictionary)
+         * @param objectService the ObjectService which allows for lookup of
+         * objects by ID
+         * @constructor
+         */
+        function RemsTelemetryInitializer(adapter, objectService) {
+            function makeId(element) {
+                return PREFIX + element.identifier;
+            }
+
+            function initializeTaxonomy(dictionary) {
+                function getTaxonomyObject(domainObjects) {
+                    return domainObjects[TAXONOMY_ID];
+                }
+
+                function populateModel (taxonomyObject) {
+                    return taxonomyObject.useCapability(
+                        "mutation",
+                        function (model) {
+                            model.name = dictionary.name;
+                            model.composition = dictionary.instruments.map(makeId);
+                        }
+                    );
+                }
+
+                objectService.getObjects([TAXONOMY_ID])
+                    .then(getTaxonomyObject)
+                    .then(populateModel);
+            }
+            initializeTaxonomy(adapter.dictionary);
+        }
+        return RemsTelemetryInitializer;
+    }
+);
--- a/example/msl/src/RemsTelemetryServerAdapter.js
+++ b/example/msl/src/RemsTelemetryServerAdapter.js
@@ -42,12 +42,14 @@ define(
         * @param REMS_WS_URL The location of the REMS telemetry data.
         * @constructor
         */
-        function RemsTelemetryServerAdapter($http, $log, REMS_WS_URL) {
+        function RemsTelemetryServerAdapter($q, $http, $log, REMS_WS_URL) {
            this.localDataURI = module.uri.substring(0, module.uri.lastIndexOf('/') + 1) + LOCAL_DATA;
+            this.deferreds = {};
            this.REMS_WS_URL = REMS_WS_URL;
+            this.$q = $q;
            this.$http = $http;
            this.$log = $log;
-            this.promise = undefined;
+            this.cache = undefined;
        }

        /**
@@ -63,10 +65,15 @@ define(
         */
        RemsTelemetryServerAdapter.prototype.requestHistory = function(request) {
            var self = this,
-                id = request.key;
+                id = request.key,
+                deferred = this.$q.defer();

            function processResponse(response){
                var data = [];
+                /*
+                 * Currently all data is returned for entire history of the mission. Cache response to avoid unnecessary re-queries.
+                 */
+                self.cache = response;
                /*
                 * History data is organised by Sol. Iterate over sols...
                 */
@@ -103,15 +110,17 @@ define(
            }

            function packageAndResolve(results){
-                return {id: id, values: results};
+                deferred.resolve({id: id, values: results});
            }


-            return (this.promise = this.promise || this.$http.get(this.REMS_WS_URL))
+            this.$q.when(this.cache || this.$http.get(this.REMS_WS_URL))
                .catch(fallbackToLocal)
                .then(processResponse)
                .then(filterResults)
                .then(packageAndResolve);
+
+            return deferred.promise;
        };

        /**
@@ -123,6 +132,7 @@ define(
         * @returns {Promise | Array<RemsTelemetryValue>} that resolves with an Array of {@link RemsTelemetryValue} objects for the request data key.
         */
        RemsTelemetryServerAdapter.prototype.history = function(request) {
+            var id = request.key;
            return this.requestHistory(request);
        };

--- a/example/plotOptions/bundle.js
+++ b/example/plotOptions/bundle.js
@@ -81,7 +81,7 @@ define([
                {
                    "key": "plot",
                    "name": "Example Telemetry Plot",
-                    "cssClass": "icon-telemetry-panel",
+                    "cssclass": "icon-telemetry-panel",
                    "description": "For development use. A plot for displaying telemetry.",
                    "priority": 10,
                    "delegates": [
@@ -129,7 +129,7 @@ define([
                        {
                            "name": "Period",
                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
+                            "cssclass": "l-input-sm l-numeric",
                            "key": "period",
                            "required": true,
                            "property": [
--- a/example/profiling/src/DigestIndicator.js
+++ b/example/profiling/src/DigestIndicator.js
@@ -63,7 +63,7 @@ define(
                 * Get the CSS class that defines the icon
                 * to display in this indicator. This will appear
                 * as a dataflow icon.
-                 * @returns {string} the cssClass of the dataflow icon
+                 * @returns {string} the cssclass of the dataflow icon
                 */
                getCssClass: function () {
                    return "icon-connectivity";
--- a/example/scratchpad/bundle.js
+++ b/example/scratchpad/bundle.js
@@ -33,11 +33,6 @@ define([
    legacyRegistry.register("example/scratchpad", {
        "extensions": {
            "roots": [
-                {
-                    "id": "scratch:root"
-                }
-            ],
-            "models": [
                {
                    "id": "scratch:root",
                    "model": {
--- a/example/taxonomy/bundle.js
+++ b/example/taxonomy/bundle.js
@@ -35,11 +35,6 @@ define([
        "description": "Example illustrating the addition of a static top-level hierarchy",
        "extensions": {
            "roots": [
-                {
-                    "id": "exampleTaxonomy"
-                }
-            ],
-            "models": [
                {
                    "id": "exampleTaxonomy",
                    "model": {
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -69,11 +69,6 @@ var gulp = require('gulp'),
        }
    };

-if (process.env.NODE_ENV === 'development') {
-    options.requirejsOptimize.optimize = 'none';
-}
-
-
 gulp.task('scripts', function () {
    var requirejsOptimize = require('gulp-requirejs-optimize');
    var replace = require('gulp-replace-task');
@@ -131,17 +126,10 @@ gulp.task('lint', function () {

 gulp.task('checkstyle', function () {
    var jscs = require('gulp-jscs');
-    var mkdirp = require('mkdirp');
-    var reportName = 'jscs-html-report.html';
-    var reportPath = path.resolve(paths.reports, 'checkstyle', reportName);
-    var moveReport = fs.rename.bind(fs, reportName, reportPath, _.noop);
-
-    mkdirp.sync(path.resolve(paths.reports, 'checkstyle'));

    return gulp.src(paths.scripts)
        .pipe(jscs())
        .pipe(jscs.reporter())
-        .pipe(jscs.reporter('jscs-html-reporter')).on('finish', moveReport)
        .pipe(jscs.reporter('fail'));
 });

@@ -167,7 +155,7 @@ gulp.task('serve', function () {
    var app = require('./app.js');
 });

-gulp.task('develop', ['serve', 'stylesheets', 'watch']);
+gulp.task('develop', ['serve', 'install', 'watch']);

 gulp.task('install', [ 'assets', 'scripts' ]);

--- a/index.html
+++ b/index.html
@@ -29,18 +29,11 @@
    </script>
    <script>
        require(['openmct'], function (openmct) {
-            [
-                'example/imagery',
-                'example/eventGenerator'
-            ].forEach(
-                openmct.legacyRegistry.enable.bind(openmct.legacyRegistry)
-            );
-            openmct.install(openmct.plugins.MyItems());
-            openmct.install(openmct.plugins.LocalStorage());
-            openmct.install(openmct.plugins.Espresso());
-            openmct.install(openmct.plugins.Generator());
-            openmct.install(openmct.plugins.UTCTimeSystem());
-            openmct.start();
+            require([
+                './example/imagery/bundle',
+                './example/eventGenerator/bundle',
+                './example/generator/bundle'
+            ], openmct.start.bind(openmct));
        });
    </script>
    <link rel="stylesheet" href="platform/commonUI/general/res/css/startup-base.css">
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -53,7 +53,7 @@ module.exports = function(config) {
        // Preprocess matching files before serving them to the browser.
        // https://npmjs.org/browse/keyword/karma-preprocessor
        preprocessors: {
-            'src/**/!(*Spec).js': [ 'coverage' ],
+            'src/**/src/**/!(*Spec).js': [ 'coverage' ],
            'platform/**/src/**/!(*Spec).js': [ 'coverage' ]
        },

@@ -76,7 +76,7 @@ module.exports = function(config) {
        // Specify browsers to run tests in.
        // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
        browsers: [
-            'Chrome'
+            'PhantomJS'
        ],

        // Code coverage reporting.
--- a/openmct.js
+++ b/openmct.js
@@ -37,8 +37,7 @@ requirejs.config({
        "text": "bower_components/text/text",
        "uuid": "bower_components/node-uuid/uuid",
        "zepto": "bower_components/zepto/zepto.min",
-        "lodash": "bower_components/lodash/lodash",
-        "d3": "bower_components/d3/d3.min"
+        "lodash": "bower_components/lodash/lodash"
    },
    "shim": {
        "angular": {
@@ -64,9 +63,6 @@ requirejs.config({
        },
        "lodash": {
            "exports": "lodash"
-        },
-        "d3": {
-            "exports": "d3"
        }
    }
 });
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "openmct",
-  "version": "0.12.1-SNAPSHOT",
+  "version": "0.12.0-SNAPSHOT",
  "description": "The Open MCT core platform",
  "dependencies": {
    "express": "^4.13.1",
@@ -21,16 +21,16 @@
    "gulp-sass": "^2.2.0",
    "gulp-sourcemaps": "^1.6.0",
    "jasmine-core": "^2.3.0",
-    "jscs-html-reporter": "^0.1.0",
    "jsdoc": "^3.3.2",
    "jshint": "^2.7.0",
    "karma": "^0.13.3",
-    "karma-chrome-launcher": "^0.1.12",
+    "karma-chrome-launcher": "^0.1.8",
    "karma-cli": "0.0.4",
    "karma-coverage": "^0.5.3",
    "karma-html-reporter": "^0.2.7",
    "karma-jasmine": "^0.1.5",
    "karma-junit-reporter": "^0.3.8",
+    "karma-phantomjs-launcher": "^1.0.0",
    "karma-requirejs": "^0.2.2",
    "lodash": "^3.10.1",
    "markdown-toc": "^0.11.7",
@@ -39,6 +39,7 @@
    "mkdirp": "^0.5.1",
    "moment": "^2.11.1",
    "node-bourbon": "^4.2.3",
+    "phantomjs-prebuilt": "2.1.11 || >2.1.12 <3.0.0",
    "requirejs": "2.1.x",
    "split": "^1.0.0"
  },
@@ -48,7 +49,7 @@
    "jshint": "jshint platform example",
    "watch": "karma start",
    "jsdoc": "jsdoc -c jsdoc.json -R API.md -r -d dist/docs/api",
-    "otherdoc": "node docs/gendocs.js --in docs/src --out dist/docs --suppress-toc 'docs/src/index.md|docs/src/process/index.md'",
+    "otherdoc": "node docs/gendocs.js --in docs/src --out target/docs --suppress-toc 'docs/src/index.md|docs/src/process/index.md'",
    "docs": "npm run jsdoc ; npm run otherdoc",
    "prepublish": "node ./node_modules/bower/bin/bower install && node ./node_modules/gulp/bin/gulp.js install"
  },
--- a/platform/commonUI/browse/bundle.js
+++ b/platform/commonUI/browse/bundle.js
@@ -41,6 +41,7 @@ define([
    "text!./res/templates/items/items.html",
    "text!./res/templates/browse/object-properties.html",
    "text!./res/templates/browse/inspector-region.html",
+    "text!./res/templates/view-object.html",
    'legacyRegistry'
 ], function (
    BrowseController,
@@ -63,6 +64,7 @@ define([
    itemsTemplate,
    objectPropertiesTemplate,
    inspectorRegionTemplate,
+    viewObjectTemplate,
    legacyRegistry
 ) {

@@ -70,13 +72,14 @@ define([
        "extensions": {
            "routes": [
                {
-                    "when": "/browse/:ids*?",
+                    "when": "/browse/:ids*",
                    "template": browseTemplate,
                    "reloadOnSearch": false
                },
                {
                    "when": "",
-                    "redirectTo": "/browse/"
+                    "template": browseTemplate,
+                    "reloadOnSearch": false
                }
            ],
            "constants": [
@@ -139,6 +142,10 @@ define([
                }
            ],
            "representations": [
+                {
+                    "key": "view-object",
+                    "template": viewObjectTemplate
+                },
                {
                    "key": "browse-object",
                    "template": browseObjectTemplate,
@@ -198,10 +205,7 @@ define([
            "services": [
                {
                    "key": "navigationService",
-                    "implementation": NavigationService,
-                    "depends": [
-                        "$window"
-                    ]
+                    "implementation": NavigationService
                }
            ],
            "actions": [
@@ -209,7 +213,10 @@ define([
                    "key": "navigate",
                    "implementation": NavigateAction,
                    "depends": [
-                        "navigationService"
+                        "navigationService",
+                        "$q",
+                        "policyService",
+                        "$window"
                    ]
                },
                {
@@ -226,7 +233,7 @@ define([
                        "$window"
                    ],
                    "group": "windowing",
-                    "cssClass": "icon-new-window",
+                    "cssclass": "icon-new-window",
                    "priority": "preferred"
                },
                {
@@ -241,7 +248,7 @@ define([
                {
                    "key": "items",
                    "name": "Items",
-                    "cssClass": "icon-thumbs-strip",
+                    "cssclass": "icon-thumbs-strip",
                    "description": "Grid of available items",
                    "template": itemsTemplate,
                    "uses": [
--- a/platform/commonUI/browse/res/templates/browse-object.html
+++ b/platform/commonUI/browse/res/templates/browse-object.html
@@ -43,7 +43,7 @@
            </mct-representation>
        </div>
    </div>
-    <div class="holder l-flex-col flex-elem grows l-object-wrapper l-controls-visible l-time-controller-visible">
+    <div class="holder l-flex-col flex-elem grows l-object-wrapper">
        <div class="holder l-flex-col flex-elem grows l-object-wrapper-inner">
            <!-- Toolbar and Save/Cancel buttons -->
            <div class="l-edit-controls flex-elem l-flex-row flex-align-end">
@@ -59,5 +59,4 @@
            </mct-representation>
        </div>
    </div>
-    <mct-include key="'conductor'" class="abs holder flex-elem flex-fixed l-flex-row l-time-conductor-holder"></mct-include>
 </div>
--- a/platform/commonUI/browse/res/templates/browse.html
+++ b/platform/commonUI/browse/res/templates/browse.html
@@ -63,7 +63,7 @@
                    <mct-split-pane class='l-object-and-inspector contents abs' anchor='right'>
                        <div class='split-pane-component t-object pane primary-pane left'>
                            <mct-representation mct-object="navigatedObject"
-                                                key="navigatedObject.getCapability('status').get('editing') ? 'edit-object' : 'browse-object'"
+                                                key="'view-object'"
                                                class="abs holder holder-object">
                            </mct-representation>
                            <a class="mini-tab-icon anchor-right mobile-hide toggle-pane toggle-inspect flush-right"
--- a/platform/commonUI/browse/res/templates/browse/object-header.html
+++ b/platform/commonUI/browse/res/templates/browse/object-header.html
@@ -22,8 +22,7 @@
 <span class='type-icon flex-elem {{type.getCssClass()}}'></span>
 <span class="l-elem-wrapper l-flex-row flex-elem grows">
    <span ng-if="parameters.mode" class='action flex-elem'>{{parameters.mode}}</span>
-    <span class='title-label flex-elem holder flex-can-shrink'>{{model.name}}</span>
-    <span class='t-object-alert t-alert-unsynced flex-elem holder' title='This object is not currently displaying real-time data'></span>
+    <span class='title-label flex-elem flex-can-shrink'>{{model.name}}</span>
    <mct-representation
        key="'menu-arrow'"
        mct-object='domainObject'
--- a/platform/commonUI/browse/res/templates/view-object.html
+++ b/platform/commonUI/browse/res/templates/view-object.html
@@ -19,4 +19,15 @@
 this source code distribution or the Licensing information page available
 at runtime from the About dialog for additional information.
 -->
-<div ng-controller="AdaptedViewController" mct-view="view"></div>
+<!--
+ A representation that allows the 'View' region of an object view to change
+ dynamically (eg. between browse and edit modes). Values correspond to a
+ representation key, and currently defaults to 'browse-object'.
+
+ In the case of edit, the EditRepresenter will change this to editable
+ representation of the object as needed.
+ -->
+<mct-representation mct-object="domainObject"
+                    key="viewObjectTemplate || 'browse-object'"
+                    class="abs holder">
+</mct-representation>
--- a/platform/commonUI/browse/src/BrowseController.js
+++ b/platform/commonUI/browse/src/BrowseController.js
@@ -28,6 +28,8 @@ define(
    [],
    function () {

+        var ROOT_ID = "ROOT";
+
        /**
         * The BrowseController is used to populate the initial scope in Browse
         * mode. It loads the root object from the objectService and makes it
@@ -47,26 +49,74 @@ define(
            urlService,
            defaultPath
        ) {
-            var initialPath = ($route.current.params.ids || defaultPath).split("/");
-            var currentIds;
+            var path = [ROOT_ID].concat(
+                ($route.current.params.ids || defaultPath).split("/")
+            );

-            $scope.treeModel = {
-                selectedObject: undefined,
-                onSelection: function (object) {
-                    navigationService.setNavigation(object, true);
-                },
-                allowSelection: function (object) {
-                    return navigationService.shouldNavigate();
-                }
-            };
+            function updateRoute(domainObject) {
+                var priorRoute = $route.current,
+                    // Act as if params HADN'T changed to avoid page reload
+                    unlisten;
+
+                unlisten = $scope.$on('$locationChangeSuccess', function () {
+                    // Checks path to make sure /browse/ is at front
+                    // if so, change $route.current
+                    if ($location.path().indexOf("/browse/") === 0) {
+                        $route.current = priorRoute;
+                    }
+                    unlisten();
+                });
+                // urlService.urlForLocation used to adjust current
+                // path to new, addressed, path based on
+                // domainObject
+                $location.path(urlService.urlForLocation("browse", domainObject));

-            function idsForObject(domainObject) {
-                return urlService
-                    .urlForLocation("", domainObject)
-                    .replace('/', '');
            }

-            // Find an object in an array of objects.
+            function setScopeObjects(domainObject, navigationAllowed) {
+                if (navigationAllowed) {
+                    $scope.navigatedObject = domainObject;
+                    $scope.treeModel.selectedObject = domainObject;
+                    updateRoute(domainObject);
+                } else {
+                    //If navigation was unsuccessful (ie. blocked), reset
+                    // the selected object in the tree to the currently
+                    // navigated object
+                    $scope.treeModel.selectedObject = $scope.navigatedObject ;
+                }
+            }
+
+            // Callback for updating the in-scope reference to the object
+            // that is currently navigated-to.
+            function setNavigation(domainObject) {
+                if (domainObject === $scope.navigatedObject) {
+                    //do nothing;
+                    return;
+                }
+                if (domainObject) {
+                    domainObject.getCapability("action").perform("navigate").then(setScopeObjects.bind(undefined, domainObject));
+                } else {
+                    setScopeObjects(domainObject, true);
+                }
+            }
+
+            function navigateTo(domainObject) {
+
+                // Check if an object has been navigated-to already...
+                // If not, or if an ID path has been explicitly set in the URL,
+                // navigate to the URL-specified object.
+                if (!navigationService.getNavigation() || $route.current.params.ids) {
+                    // If not, pick a default as the last
+                    // root-level component (usually "mine")
+                    navigationService.setNavigation(domainObject);
+                    $scope.navigatedObject = domainObject;
+                } else {
+                    // Otherwise, just expose the currently navigated object.
+                    $scope.navigatedObject = navigationService.getNavigation();
+                    updateRoute($scope.navigatedObject);
+                }
+            }
+
            function findObject(domainObjects, id) {
                var i;
                for (i = 0; i < domainObjects.length; i += 1) {
@@ -76,87 +126,63 @@ define(
                }
            }

-            // helper, fetch a single object from the object service.
-            function getObject(id) {
-                return objectService.getObjects([id])
-                    .then(function (results) {
-                        return results[id];
-                    });
-            }
-
-            // recursively locate and return an object inside of a container
-            // via a path.  If at any point in the recursion it fails to find
-            // the next object, it will return the parent.
-            function findViaComposition(containerObject, path) {
-                var nextId = path.shift();
-                if (!nextId) {
-                    return containerObject;
-                }
-                return containerObject.useCapability('composition')
-                    .then(function (composees) {
-                        var nextObject = findObject(composees, nextId);
-                        if (!nextObject) {
-                            return containerObject;
+            // Navigate to the domain object identified by path[index],
+            // which we expect to find in the composition of the passed
+            // domain object.
+            function doNavigate(domainObject, index) {
+                var composition = domainObject.useCapability("composition");
+                if (composition) {
+                    composition.then(function (c) {
+                        var nextObject = findObject(c, path[index]);
+                        if (nextObject) {
+                            if (index + 1 >= path.length) {
+                                navigateTo(nextObject);
+                            } else {
+                                doNavigate(nextObject, index + 1);
+                            }
+                        } else if (index === 1 && c.length > 0) {
+                            // Roots are in a top-level container that we don't
+                            // want to be selected, so if we couldn't find an
+                            // object at the path we wanted, at least select
+                            // one of its children.
+                            navigateTo(c[c.length - 1]);
+                        } else {
+                            // Couldn't find the next element of the path
+                            // so navigate to the last path object we did find
+                            navigateTo(domainObject);
                        }
-                        if (!nextObject.hasCapability('composition')) {
-                            return nextObject;
-                        }
-                        return findViaComposition(nextObject, path);
                    });
-            }
-
-            function navigateToObject(desiredObject) {
-                $scope.navigatedObject = desiredObject;
-                $scope.treeModel.selectedObject = desiredObject;
-                currentIds = idsForObject(desiredObject);
-                $route.current.pathParams.ids = currentIds;
-                $location.path('/browse/' + currentIds);
-            }
-
-            function navigateToPath(path) {
-                return getObject('ROOT')
-                    .then(function (root) {
-                        return findViaComposition(root, path);
-                    })
-                    .then(function (object) {
-                        navigationService.setNavigation(object);
-                    });
-            }
-
-            getObject('ROOT')
-                .then(function (root) {
-                    $scope.domainObject = root;
-                    navigateToPath(initialPath);
-                });
-
-            // Handle navigation events from view service.  Only navigates
-            // if path has changed.
-            function navigateDirectlyToModel(domainObject) {
-                var newIds = idsForObject(domainObject);
-                if (currentIds !== newIds) {
-                    currentIds = newIds;
-                    navigateToObject(domainObject);
+                } else {
+                    // Similar to above case; this object has no composition,
+                    // so navigate to it instead of subsequent path elements.
+                    navigateTo(domainObject);
                }
            }

+            // Load the root object, put it in the scope.
+            // Also, load its immediate children, and (possibly)
+            // navigate to one of them, so that navigation state has
+            // a useful initial value.
+            objectService.getObjects([path[0]]).then(function (objects) {
+                $scope.domainObject = objects[path[0]];
+                doNavigate($scope.domainObject, 1);
+            });
+
+            // Provide a model for the tree to modify
+            $scope.treeModel = {
+                selectedObject: navigationService.getNavigation()
+            };
+
            // Listen for changes in navigation state.
-            navigationService.addListener(navigateDirectlyToModel);
+            navigationService.addListener(setNavigation);

-            // Listen for route changes which are caused by browser events
-            // (e.g. bookmarks to pages in OpenMCT) and prevent them.  Instead,
-            // navigate to the path ourselves, which results in it being
-            // properly set.
-            $scope.$on('$routeChangeStart', function (event, route) {
-                if (route.$$route === $route.current.$$route &&
-                    route.pathParams.ids !== $route.current.pathParams.ids) {
-                    event.preventDefault();
-                    navigateToPath(route.pathParams.ids.split('/'));
-                }
-            });
+            // Also listen for changes which come from the tree. Changes in
+            // the tree will trigger a change in browse navigation state.
+            $scope.$watch("treeModel.selectedObject", setNavigation);

            // Clean up when the scope is destroyed
            $scope.$on("$destroy", function () {
-                navigationService.removeListener(navigateDirectlyToModel);
+                navigationService.removeListener(setNavigation);
            });
        }

--- a/platform/commonUI/browse/src/BrowseObjectController.js
+++ b/platform/commonUI/browse/src/BrowseObjectController.js
@@ -51,16 +51,24 @@ define(
            }

            function updateQueryParam(viewKey) {
-                if (viewKey && $location.search().view !== viewKey) {
+                var unlisten,
+                    priorRoute = $route.current;
+
+                if (viewKey) {
                    $location.search('view', viewKey);
+                    unlisten = $scope.$on('$locationChangeSuccess', function () {
+                        // Checks path to make sure /browse/ is at front
+                        // if so, change $route.current
+                        if ($location.path().indexOf("/browse/") === 0) {
+                            $route.current = priorRoute;
+                        }
+                        unlisten();
+                    });
                }
            }

            $scope.$watch('domainObject', setViewForDomainObject);
            $scope.$watch('representation.selected.key', updateQueryParam);
-            $scope.$on('$locationChangeSuccess', function () {
-                setViewForDomainObject($scope.domainObject);
-            });

            $scope.doAction = function (action) {
                return $scope[action] && $scope[action]();
--- a/platform/commonUI/browse/src/InspectorPaneController.js
+++ b/platform/commonUI/browse/src/InspectorPaneController.js
@@ -64,11 +64,11 @@ define(
                attachStatusListener(domainObject);
            }

-            navigationService.addListener(attachStatusListener);
+            var navigationListener = navigationService.addListener(attachStatusListener);

            $scope.$on("$destroy", function () {
                statusListener();
-                navigationService.removeListener(attachStatusListener);
+                navigationListener();
            });
        }

--- a/platform/commonUI/browse/src/navigation/NavigateAction.js
+++ b/platform/commonUI/browse/src/navigation/NavigateAction.js
@@ -33,9 +33,12 @@ define(
         * @constructor
         * @implements {Action}
         */
-        function NavigateAction(navigationService, context) {
+        function NavigateAction(navigationService, $q, policyService, $window, context) {
            this.domainObject = context.domainObject;
+            this.$q = $q;
            this.navigationService = navigationService;
+            this.policyService = policyService;
+            this.$window = $window;
        }

        /**
@@ -44,12 +47,36 @@ define(
         *          navigation has been updated
         */
        NavigateAction.prototype.perform = function () {
-            if (this.navigationService.shouldNavigate()) {
-                this.navigationService.setNavigation(this.domainObject, true);
-                return Promise.resolve({});
+            var self = this,
+                navigateTo = this.domainObject,
+                currentObject = self.navigationService.getNavigation();
+
+            function allow() {
+                var navigationAllowed = true;
+                self.policyService.allow("navigation", currentObject, navigateTo, function (message) {
+                    navigationAllowed = self.$window.confirm(message + "\r\n\r\n" +
+                        " Are you sure you want to continue?");
+                });
+                return navigationAllowed;
+            }
+
+            function cancelIfEditing() {
+                var editing = currentObject.hasCapability('editor') &&
+                    currentObject.getCapability('editor').isEditContextRoot();
+
+                return self.$q.when(editing && currentObject.getCapability("editor").finish());
+            }
+
+            function navigate() {
+                return self.navigationService.setNavigation(navigateTo);
+            }
+
+            if (allow()) {
+                return cancelIfEditing().then(navigate);
+            } else {
+                return this.$q.when(false);
            }

-            return Promise.reject('Navigation Prevented by User');
        };

        /**
--- a/platform/commonUI/browse/src/navigation/NavigationService.js
+++ b/platform/commonUI/browse/src/navigation/NavigationService.js
@@ -30,23 +30,16 @@ define(
        /**
         * The navigation service maintains the application's current
         * navigation state, and allows listening for changes thereto.
-         *
         * @memberof platform/commonUI/browse
         * @constructor
         */
-        function NavigationService($window) {
+        function NavigationService() {
            this.navigated = undefined;
            this.callbacks = [];
-            this.checks = [];
-            this.$window = $window;
-
-            this.oldUnload = $window.onbeforeunload;
-            $window.onbeforeunload = this.onBeforeUnload.bind(this);
        }

        /**
         * Get the current navigation state.
-         *
         * @returns {DomainObject} the object that is navigated-to
         */
        NavigationService.prototype.getNavigation = function () {
@@ -54,33 +47,16 @@ define(
        };

        /**
-         * Navigate to a specified object.  If navigation checks exist and
-         * return reasons to prevent navigation, it will prompt the user before
-         * continuing. Trying to navigate to the currently navigated object will
-         * do nothing.
-         *
-         * If a truthy value is passed for `force`, it will skip navigation
-         * and will not prevent navigation to an already selected object.
-         *
+         * Set the current navigation state. This will invoke listeners.
         * @param {DomainObject} domainObject the domain object to navigate to
-         * @param {Boolean} force if true, force navigation to occur.
-         * @returns {Boolean} true if navigation occured, otherwise false.
         */
-        NavigationService.prototype.setNavigation = function (domainObject, force) {
-            if (force) {
-                this.doNavigation(domainObject);
-                return true;
+        NavigationService.prototype.setNavigation = function (value) {
+            if (this.navigated !== value) {
+                this.navigated = value;
+                this.callbacks.forEach(function (callback) {
+                    callback(value);
+                });
            }
-            if (this.navigated === domainObject) {
-                return true;
-            }
-
-            var doNotNavigate = this.shouldWarnBeforeNavigate();
-            if (doNotNavigate && !this.$window.confirm(doNotNavigate)) {
-                return false;
-            }
-
-            this.doNavigation(domainObject);
            return true;
        };

@@ -88,7 +64,6 @@ define(
         * Listen for changes in navigation. The passed callback will
         * be invoked with the new domain object of navigation when
         * this changes.
-         *
         * @param {function} callback the callback to invoke when
         *        navigation state changes
         */
@@ -98,7 +73,6 @@ define(

        /**
         * Stop listening for changes in navigation state.
-         *
         * @param {function} callback the callback which should
         *        no longer be invoked when navigation state
         *        changes
@@ -109,89 +83,6 @@ define(
            });
        };

-        /**
-         * Check if navigation should proceed.  May prompt a user for input
-         * if any checkFns return messages.  Returns true if the user wishes to
-         * navigate, otherwise false.  If using this prior to calling
-         * `setNavigation`, you should call `setNavigation` with `force=true`
-         * to prevent duplicate dialogs being displayed to the user.
-         *
-         * @returns {Boolean} true if the user wishes to navigate, otherwise false.
-         */
-        NavigationService.prototype.shouldNavigate = function () {
-            var doNotNavigate = this.shouldWarnBeforeNavigate();
-            return !doNotNavigate || this.$window.confirm(doNotNavigate);
-        };
-
-        /**
-         * Register a check function to be called before any navigation occurs.
-         * Check functions should return a human readable "message" if
-         * there are any reasons to prevent navigation.  Otherwise, they should
-         * return falsy.  Returns a function which can be called to remove the
-         * check function.
-         *
-         * @param {Function} checkFn a function to call before navigation occurs.
-         * @returns {Function} removeCheck call to remove check
-         */
-        NavigationService.prototype.checkBeforeNavigation = function (checkFn) {
-            this.checks.push(checkFn);
-            return function removeCheck() {
-                this.checks = this.checks.filter(function (fn) {
-                    return checkFn !== fn;
-                });
-            }.bind(this);
-        };
-
-        /**
-         * Private method to actually perform navigation.
-         *
-         * @private
-         */
-        NavigationService.prototype.doNavigation = function (value) {
-            this.navigated = value;
-            this.callbacks.forEach(function (callback) {
-                callback(value);
-            });
-        };
-
-        /**
-         * Returns either a false value, or a string that should be displayed
-         * to the user before navigation is allowed.
-         *
-         * @private
-         */
-        NavigationService.prototype.shouldWarnBeforeNavigate = function () {
-            var reasons = [];
-
-            this.checks.forEach(function (checkFn) {
-                var reason = checkFn();
-                if (reason) {
-                    reasons.push(reason);
-                }
-            });
-
-            if (reasons.length) {
-                return reasons.join('\n');
-            }
-            return false;
-        };
-
-        /**
-         * Listener for window on before unload event-- will warn before
-         * navigation is allowed.
-         *
-         * @private
-         */
-        NavigationService.prototype.onBeforeUnload = function () {
-            var shouldWarnBeforeNavigate = this.shouldWarnBeforeNavigate();
-            if (shouldWarnBeforeNavigate) {
-                return shouldWarnBeforeNavigate;
-            }
-            if (this.oldUnload) {
-                return this.oldUnload.apply(undefined, [].slice.apply(arguments));
-            }
-        };
-
        return NavigationService;
    }
 );
--- a/platform/commonUI/browse/src/navigation/OrphanNavigationHandler.js
+++ b/platform/commonUI/browse/src/navigation/OrphanNavigationHandler.js
@@ -43,24 +43,24 @@ define([], function () {
            return context.getParent();
        }

-        function preventOrphanNavigation(domainObject) {
+        function isOrphan(domainObject) {
+            var parent = getParent(domainObject),
+                composition = parent.getModel().composition,
+                id = domainObject.getId();
+            return !composition || (composition.indexOf(id) === -1);
+        }
+
+        function navigateToParent(domainObject) {
            var parent = getParent(domainObject);
-            parent.useCapability('composition')
-                .then(function (composees) {
-                    var isOrphan = composees.every(function (c) {
-                        return c.getId() !== domainObject.getId();
-                    });
-                    if (isOrphan) {
-                        parent.getCapability('action').perform('navigate');
-                    }
-                });
+            return parent.getCapability('action').perform('navigate');
        }

        function checkNavigation() {
            var navigatedObject = navigationService.getNavigation();
-            if (navigatedObject.hasCapability('context')) {
+            if (navigatedObject.hasCapability('context') &&
+                isOrphan(navigatedObject)) {
                if (!navigatedObject.getCapability('editor').isEditContextRoot()) {
-                    preventOrphanNavigation(navigatedObject);
+                    navigateToParent(navigatedObject);
                }
            }
        }
--- a/platform/commonUI/browse/src/windowing/FullscreenAction.js
+++ b/platform/commonUI/browse/src/windowing/FullscreenAction.js
@@ -46,12 +46,12 @@ define(
        };

        FullscreenAction.prototype.getMetadata = function () {
-            // We override getMetadata, because the icon cssClass and
+            // We override getMetadata, because the icon cssclass and
            // description need to be determined at run-time
            // based on whether or not we are currently
            // full screen.
            var metadata = Object.create(FullscreenAction);
-            metadata.cssClass = screenfull.isFullscreen ? "icon-fullscreen-expand" : "icon-fullscreen-collapse";
+            metadata.cssclass = screenfull.isFullscreen ? "icon-fullscreen-expand" : "icon-fullscreen-collapse";
            metadata.description = screenfull.isFullscreen ?
                EXIT_FULLSCREEN : ENTER_FULLSCREEN;
            metadata.group = "windowing";
--- a/platform/commonUI/browse/test/BrowseControllerSpec.js
+++ b/platform/commonUI/browse/test/BrowseControllerSpec.js
@@ -24,14 +24,8 @@
 * MCTRepresentationSpec. Created by vwoeltje on 11/6/14.
 */
 define(
-    [
-        "../src/BrowseController",
-        "../src/navigation/NavigationService"
-    ],
-    function (
-        BrowseController,
-        NavigationService
-    ) {
+    ["../src/BrowseController"],
+    function (BrowseController) {

        describe("The browse controller", function () {
            var mockScope,
@@ -41,17 +35,18 @@ define(
                mockNavigationService,
                mockRootObject,
                mockUrlService,
-                mockDefaultRootObject,
-                mockOtherDomainObject,
+                mockDomainObject,
                mockNextObject,
                testDefaultRoot,
+                mockActionCapability,
                controller;

-            function waitsForNavigation() {
-                var calls = mockNavigationService.setNavigation.calls.length;
-                waitsFor(function () {
-                    return mockNavigationService.setNavigation.calls.length > calls;
-                });
+            function mockPromise(value) {
+                return {
+                    then: function (callback) {
+                        return mockPromise(callback(value));
+                    }
+                };
            }

            function instantiateController() {
@@ -73,114 +68,85 @@ define(
                    "$scope",
                    ["$on", "$watch"]
                );
-                mockRoute = { current: { params: {}, pathParams: {} } };
-                mockUrlService = jasmine.createSpyObj(
-                    "urlService",
-                    ["urlForLocation"]
-                );
-                mockUrlService.urlForLocation.andCallFake(function (mode, object) {
-                    if (object === mockDefaultRootObject) {
-                        return [mode, testDefaultRoot].join('/');
-                    }
-                    if (object === mockOtherDomainObject) {
-                        return [mode, 'other'].join('/');
-                    }
-                    if (object === mockNextObject) {
-                        return [mode, testDefaultRoot, 'next'].join('/');
-                    }
-                    throw new Error('Tried to get url for unexpected object');
-                });
+                mockRoute = { current: { params: {} } };
                mockLocation = jasmine.createSpyObj(
                    "$location",
                    ["path"]
                );
+                mockUrlService = jasmine.createSpyObj(
+                    "urlService",
+                    ["urlForLocation"]
+                );
                mockObjectService = jasmine.createSpyObj(
                    "objectService",
                    ["getObjects"]
                );
-                mockNavigationService = new NavigationService({});
-                [
-                    "getNavigation",
-                    "setNavigation",
-                    "addListener",
-                    "removeListener"
-                ].forEach(function (method) {
-                    spyOn(mockNavigationService, method)
-                        .andCallThrough();
-                });
+                mockNavigationService = jasmine.createSpyObj(
+                    "navigationService",
+                    [
+                        "getNavigation",
+                        "setNavigation",
+                        "addListener",
+                        "removeListener"
+                    ]
+                );
                mockRootObject = jasmine.createSpyObj(
-                    "rootObjectContainer",
-                    ["getId", "getCapability", "getModel", "useCapability", "hasCapability"]
+                    "domainObject",
+                    ["getId", "getCapability", "getModel", "useCapability"]
                );
-                mockDefaultRootObject = jasmine.createSpyObj(
-                    "defaultRootObject",
-                    ["getId", "getCapability", "getModel", "useCapability", "hasCapability"]
-                );
-                mockOtherDomainObject = jasmine.createSpyObj(
-                    "otherDomainObject",
-                    ["getId", "getCapability", "getModel", "useCapability", "hasCapability"]
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getId", "getCapability", "getModel", "useCapability"]
                );
                mockNextObject = jasmine.createSpyObj(
-                    "nestedDomainObject",
-                    ["getId", "getCapability", "getModel", "useCapability", "hasCapability"]
+                    "nextObject",
+                    ["getId", "getCapability", "getModel", "useCapability"]
                );
-                mockObjectService.getObjects.andReturn(Promise.resolve({
+
+                mockObjectService.getObjects.andReturn(mockPromise({
                    ROOT: mockRootObject
                }));
-                mockRootObject.useCapability.andReturn(Promise.resolve([
-                    mockOtherDomainObject,
-                    mockDefaultRootObject
+                mockRootObject.useCapability.andReturn(mockPromise([
+                    mockDomainObject
                ]));
-                mockRootObject.hasCapability.andReturn(true);
-                mockDefaultRootObject.useCapability.andReturn(Promise.resolve([
+                mockDomainObject.useCapability.andReturn(mockPromise([
                    mockNextObject
                ]));
-                mockDefaultRootObject.hasCapability.andReturn(true);
-                mockOtherDomainObject.hasCapability.andReturn(false);
                mockNextObject.useCapability.andReturn(undefined);
-                mockNextObject.hasCapability.andReturn(false);
                mockNextObject.getId.andReturn("next");
-                mockDefaultRootObject.getId.andReturn(testDefaultRoot);
+                mockDomainObject.getId.andReturn(testDefaultRoot);
+
+                mockActionCapability = jasmine.createSpyObj('actionCapability', ['perform']);

                instantiateController();
-                waitsForNavigation();
            });

            it("uses composition to set the navigated object, if there is none", function () {
                instantiateController();
-                waitsForNavigation();
-                runs(function () {
-                    expect(mockNavigationService.setNavigation)
-                        .toHaveBeenCalledWith(mockDefaultRootObject);
-                });
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockDomainObject);
            });

            it("navigates to a root-level object, even when default path is not found", function () {
-                mockDefaultRootObject.getId
+                mockDomainObject.getId
                    .andReturn("something-other-than-the-" + testDefaultRoot);
                instantiateController();
-
-                waitsForNavigation();
-                runs(function () {
-                    expect(mockNavigationService.setNavigation)
-                        .toHaveBeenCalledWith(mockDefaultRootObject);
-                });
-
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockDomainObject);
            });
-            //
+
            it("does not try to override navigation", function () {
-                mockNavigationService.getNavigation.andReturn(mockDefaultRootObject);
+                mockNavigationService.getNavigation.andReturn(mockDomainObject);
                instantiateController();
-                waitsForNavigation();
-                expect(mockScope.navigatedObject).toBe(mockDefaultRootObject);
+                expect(mockScope.navigatedObject).toBe(mockDomainObject);
            });
-            //
+
            it("updates scope when navigated object changes", function () {
                // Should have registered a listener - call it
                mockNavigationService.addListener.mostRecentCall.args[0](
-                    mockOtherDomainObject
+                    mockDomainObject
                );
-                expect(mockScope.navigatedObject).toEqual(mockOtherDomainObject);
+                expect(mockScope.navigatedObject).toEqual(mockDomainObject);
            });


@@ -200,12 +166,9 @@ define(
            it("uses route parameters to choose initially-navigated object", function () {
                mockRoute.current.params.ids = testDefaultRoot + "/next";
                instantiateController();
-                waitsForNavigation();
-                runs(function () {
-                    expect(mockScope.navigatedObject).toBe(mockNextObject);
-                    expect(mockNavigationService.setNavigation)
-                        .toHaveBeenCalledWith(mockNextObject);
-                });
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
            });

            it("handles invalid IDs by going as far as possible", function () {
@@ -214,13 +177,9 @@ define(
                // it hits an invalid ID.
                mockRoute.current.params.ids = testDefaultRoot + "/junk";
                instantiateController();
-                waitsForNavigation();
-                runs(function () {
-                    expect(mockScope.navigatedObject).toBe(mockDefaultRootObject);
-                    expect(mockNavigationService.setNavigation)
-                        .toHaveBeenCalledWith(mockDefaultRootObject);
-
-                });
+                expect(mockScope.navigatedObject).toBe(mockDomainObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockDomainObject);
            });

            it("handles compositionless objects by going as far as possible", function () {
@@ -229,33 +188,84 @@ define(
                // should stop at it since remaining IDs cannot be loaded.
                mockRoute.current.params.ids = testDefaultRoot + "/next/junk";
                instantiateController();
-                waitsForNavigation();
-                runs(function () {
-                    expect(mockScope.navigatedObject).toBe(mockNextObject);
-                    expect(mockNavigationService.setNavigation)
-                        .toHaveBeenCalledWith(mockNextObject);
-                });
+                expect(mockScope.navigatedObject).toBe(mockNextObject);
+                expect(mockNavigationService.setNavigation)
+                    .toHaveBeenCalledWith(mockNextObject);
            });

            it("updates the displayed route to reflect current navigation", function () {
-                // In order to trigger a route update and not a route change,
-                // the current route must be updated before location.path is
-                // called.
-                expect(mockRoute.current.pathParams.ids)
-                    .not
-                    .toBe(testDefaultRoot + '/next');
-                mockLocation.path.andCallFake(function () {
-                    expect(mockRoute.current.pathParams.ids)
-                        .toBe(testDefaultRoot + '/next');
+                var mockContext = jasmine.createSpyObj('context', ['getPath']),
+                    mockUnlisten = jasmine.createSpy('unlisten'),
+                    mockMode = "browse";
+
+                mockContext.getPath.andReturn(
+                    [mockRootObject, mockDomainObject, mockNextObject]
+                );
+
+                //Return true from navigate action
+                mockActionCapability.perform.andReturn(mockPromise(true));
+
+                mockNextObject.getCapability.andCallFake(function (c) {
+                    return (c === 'context' && mockContext) ||
+                        (c === 'action' && mockActionCapability);
                });
+                mockScope.$on.andReturn(mockUnlisten);
+                // Provide a navigation change
                mockNavigationService.addListener.mostRecentCall.args[0](
                    mockNextObject
                );
+
+                // Allows the path index to be checked
+                // prior to setting $route.current
+                mockLocation.path.andReturn("/browse/");
+
+                mockNavigationService.setNavigation.andReturn(true);
+                mockActionCapability.perform.andReturn(mockPromise(true));
+
+                // Exercise the Angular workaround
+                mockNavigationService.addListener.mostRecentCall.args[0]();
+                mockScope.$on.mostRecentCall.args[1]();
+                expect(mockUnlisten).toHaveBeenCalled();
+
+                // location.path to be called with the urlService's
+                // urlFor function with the next domainObject and mode
                expect(mockLocation.path).toHaveBeenCalledWith(
-                    '/browse/' + testDefaultRoot + '/next'
+                    mockUrlService.urlForLocation(mockMode, mockNextObject)
                );
            });

+            it("after successful navigation event sets the selected tree " +
+                "object", function () {
+                mockScope.navigatedObject = mockDomainObject;
+                mockNavigationService.setNavigation.andReturn(true);
+
+                mockActionCapability.perform.andReturn(mockPromise(true));
+                mockNextObject.getCapability.andReturn(mockActionCapability);
+
+                //Simulate a change in selected tree object
+                mockScope.treeModel = {selectedObject: mockDomainObject};
+                mockScope.$watch.mostRecentCall.args[1](mockNextObject);
+
+                expect(mockScope.treeModel.selectedObject).toBe(mockNextObject);
+                expect(mockScope.treeModel.selectedObject).not.toBe(mockDomainObject);
+            });
+
+            it("after failed navigation event resets the selected tree" +
+                " object", function () {
+                mockScope.navigatedObject = mockDomainObject;
+
+                //Return false from navigation action
+                mockActionCapability.perform.andReturn(mockPromise(false));
+                mockNextObject.getCapability.andReturn(mockActionCapability);
+
+                //Simulate a change in selected tree object
+                mockScope.treeModel = {selectedObject: mockDomainObject};
+                mockScope.$watch.mostRecentCall.args[1](mockNextObject);
+
+                expect(mockScope.treeModel.selectedObject).not.toBe(mockNextObject);
+                expect(mockScope.treeModel.selectedObject).toBe(mockDomainObject);
+            });
+
        });
    }
 );
--- a/platform/commonUI/browse/test/BrowseObjectControllerSpec.js
+++ b/platform/commonUI/browse/test/BrowseObjectControllerSpec.js
@@ -29,6 +29,7 @@ define(
            var mockScope,
                mockLocation,
                mockRoute,
+                mockUnlisten,
                controller;

            // Utility function; look for a $watch on scope and fire it
@@ -50,7 +51,9 @@ define(
                    "$location",
                    ["path", "search"]
                );
-                mockLocation.search.andReturn({});
+                mockUnlisten = jasmine.createSpy("unlisten");
+
+                mockScope.$on.andReturn(mockUnlisten);

                controller = new BrowseObjectController(
                    mockScope,
@@ -66,6 +69,10 @@ define(
                // Allows the path index to be checked
                // prior to setting $route.current
                mockLocation.path.andReturn("/browse/");
+
+                // Exercise the Angular workaround
+                mockScope.$on.mostRecentCall.args[1]();
+                expect(mockUnlisten).toHaveBeenCalled();
            });

            it("sets the active view from query parameters", function () {
--- a/platform/commonUI/browse/test/navigation/NavigateActionSpec.js
+++ b/platform/commonUI/browse/test/navigation/NavigateActionSpec.js
@@ -23,74 +23,145 @@
 /**
 * MCTRepresentationSpec. Created by vwoeltje on 11/6/14.
 */
-define([
-    "../../src/navigation/NavigateAction"
-], function (
-    NavigateAction
-) {
+define(
+    ["../../src/navigation/NavigateAction"],
+    function (NavigateAction) {

-    describe("The navigate action", function () {
-        var mockNavigationService,
-            mockDomainObject,
-            action;
+        describe("The navigate action", function () {
+            var mockNavigationService,
+                mockQ,
+                mockDomainObject,
+                mockPolicyService,
+                mockNavigatedObject,
+                mockWindow,
+                capabilities,
+                action;

+            function mockPromise(value) {
+                return {
+                    then: function (callback) {
+                        return mockPromise(callback(value));
+                    }
+                };
+            }

-        function waitForCall() {
-            var called = false;
-            waitsFor(function () {
-                return called;
+            beforeEach(function () {
+                capabilities = {};
+
+                mockQ = { when: mockPromise };
+                mockNavigatedObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getId",
+                        "getModel",
+                        "hasCapability",
+                        "getCapability"
+                    ]
+                );
+
+                capabilities.editor = jasmine.createSpyObj("editorCapability", [
+                    "isEditContextRoot",
+                    "finish"
+                ]);
+
+                mockNavigatedObject.getCapability.andCallFake(function (capability) {
+                    return capabilities[capability];
+                });
+                mockNavigatedObject.hasCapability.andReturn(false);
+
+                mockNavigationService = jasmine.createSpyObj(
+                    "navigationService",
+                    [
+                        "setNavigation",
+                        "getNavigation"
+                    ]
+                );
+                mockNavigationService.getNavigation.andReturn(mockNavigatedObject);
+
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [
+                        "getId",
+                        "getModel"
+                    ]
+                );
+
+                mockPolicyService = jasmine.createSpyObj("policyService",
+                    [
+                        "allow"
+                    ]);
+                mockWindow = jasmine.createSpyObj("$window",
+                    [
+                        "confirm"
+                    ]);
+
+                action = new NavigateAction(
+                    mockNavigationService,
+                    mockQ,
+                    mockPolicyService,
+                    mockWindow,
+                    { domainObject: mockDomainObject }
+                );
            });
-            return function () {
-                called = true;
-            };
-        }

-        beforeEach(function () {
-            mockNavigationService = jasmine.createSpyObj(
-                "navigationService",
-                [
-                    "shouldNavigate",
-                    "setNavigation"
-                ]
-            );
-
-            mockDomainObject = {};
-
-            action = new NavigateAction(
-                mockNavigationService,
-                { domainObject: mockDomainObject }
-            );
-        });
-
-        it("sets navigation if it is allowed", function () {
-            mockNavigationService.shouldNavigate.andReturn(true);
-            action.perform()
-                .then(waitForCall());
-            runs(function () {
-                expect(mockNavigationService.setNavigation)
-                    .toHaveBeenCalledWith(mockDomainObject, true);
+            it("invokes the policy service to determine if navigation" +
+                " allowed", function () {
+                action.perform();
+                expect(mockPolicyService.allow)
+                    .toHaveBeenCalledWith("navigation", jasmine.any(Object), jasmine.any(Object), jasmine.any(Function));
            });
-        });

-        it("does not set navigation if it is not allowed", function () {
-            mockNavigationService.shouldNavigate.andReturn(false);
-            var onSuccess = jasmine.createSpy('onSuccess');
-            action.perform()
-                .then(onSuccess, waitForCall());
-            runs(function () {
-                expect(onSuccess).not.toHaveBeenCalled();
-                expect(mockNavigationService.setNavigation)
-                    .not
-                    .toHaveBeenCalledWith(mockDomainObject);
+            it("prompts user if policy rejection", function () {
+                action.perform();
+                expect(mockPolicyService.allow).toHaveBeenCalled();
+                mockPolicyService.allow.mostRecentCall.args[3]();
+                expect(mockWindow.confirm).toHaveBeenCalled();
            });
-        });

-        it("is only applicable when a domain object is in context", function () {
-            expect(NavigateAction.appliesTo({})).toBeFalsy();
-            expect(NavigateAction.appliesTo({
-                domainObject: mockDomainObject
-            })).toBeTruthy();
-        });
+            describe("shows a prompt", function () {
+                beforeEach(function () {
+                    // Ensure the allow callback is called synchronously
+                    mockPolicyService.allow.andCallFake(function () {
+                        return arguments[3]();
+                    });
+                });
+                it("does not navigate on prompt rejection", function () {
+                    mockWindow.confirm.andReturn(false);
+                    action.perform();
+                    expect(mockNavigationService.setNavigation)
+                        .not.toHaveBeenCalled();
+                });

-    });
-});
+                it("does navigate on prompt acceptance", function () {
+                    mockWindow.confirm.andReturn(true);
+                    action.perform();
+                    expect(mockNavigationService.setNavigation)
+                        .toHaveBeenCalled();
+                });
+            });
+
+            describe("in edit mode", function () {
+                beforeEach(function () {
+                    mockNavigatedObject.hasCapability.andCallFake(function (capability) {
+                        return capability === "editor";
+                    });
+                    capabilities.editor.isEditContextRoot.andReturn(true);
+                });
+
+                it("finishes editing if in edit mode", function () {
+                    action.perform();
+                    expect(capabilities.editor.finish)
+                        .toHaveBeenCalled();
+                });
+            });
+
+            it("is only applicable when a domain object is in context", function () {
+                expect(NavigateAction.appliesTo({})).toBeFalsy();
+                expect(NavigateAction.appliesTo({
+                    domainObject: mockDomainObject
+                })).toBeTruthy();
+            });
+
+        });
+    }
+);
--- a/platform/commonUI/browse/test/navigation/NavigationServiceSpec.js
+++ b/platform/commonUI/browse/test/navigation/NavigationServiceSpec.js
@@ -28,12 +28,10 @@ define(
    function (NavigationService) {

        describe("The navigation service", function () {
-            var $window,
-                navigationService;
+            var navigationService;

            beforeEach(function () {
-                $window = jasmine.createSpyObj('$window', ['confirm']);
-                navigationService = new NavigationService($window);
+                navigationService = new NavigationService();
            });

            it("stores navigation state", function () {
--- a/platform/commonUI/browse/test/navigation/OrphanNavigationHandlerSpec.js
+++ b/platform/commonUI/browse/test/navigation/OrphanNavigationHandlerSpec.js
@@ -33,7 +33,7 @@ define([
            mockContext,
            mockActionCapability,
            mockEditor,
-            testParentComposition,
+            testParentModel,
            testId,
            mockThrottledFns;

@@ -41,6 +41,7 @@ define([
            testId = 'some-identifier';

            mockThrottledFns = [];
+            testParentModel = {};

            mockTopic = jasmine.createSpy('topic');
            mockThrottle = jasmine.createSpy('throttle');
@@ -54,12 +55,14 @@ define([
            mockDomainObject = jasmine.createSpyObj('domainObject', [
                'getId',
                'getCapability',
+                'getModel',
                'hasCapability'
            ]);
            mockParentObject = jasmine.createSpyObj('domainObject', [
                'getId',
                'getCapability',
-                'useCapability'
+                'getModel',
+                'hasCapability'
            ]);
            mockContext = jasmine.createSpyObj('context', ['getParent']);
            mockActionCapability = jasmine.createSpyObj('action', ['perform']);
@@ -72,7 +75,9 @@ define([
                mockThrottledFns.push(mockThrottledFn);
                return mockThrottledFn;
            });
-            mockTopic.andReturn(mockMutationTopic);
+            mockTopic.andCallFake(function (k) {
+                return k === 'mutation' && mockMutationTopic;
+            });
            mockDomainObject.getId.andReturn(testId);
            mockDomainObject.getCapability.andCallFake(function (c) {
                return {
@@ -83,13 +88,12 @@ define([
            mockDomainObject.hasCapability.andCallFake(function (c) {
                return !!mockDomainObject.getCapability(c);
            });
+            mockParentObject.getModel.andReturn(testParentModel);
            mockParentObject.getCapability.andCallFake(function (c) {
                return {
                    action: mockActionCapability
                }[c];
            });
-            testParentComposition = [];
-            mockParentObject.useCapability.andReturn(Promise.resolve(testParentComposition));
            mockContext.getParent.andReturn(mockParentObject);
            mockNavigationService.getNavigation.andReturn(mockDomainObject);
            mockEditor.isEditContextRoot.andReturn(false);
@@ -122,9 +126,7 @@ define([
            var prefix = isOrphan ? "" : "non-";
            describe("for " + prefix + "orphan objects", function () {
                beforeEach(function () {
-                    if (!isOrphan) {
-                        testParentComposition.push(mockDomainObject);
-                    }
+                    testParentModel.composition = isOrphan ? [] : [testId];
                });

                [false, true].forEach(function (isEditRoot) {
@@ -134,31 +136,13 @@ define([
                    function itNavigatesAsExpected() {
                        if (isOrphan && !isEditRoot) {
                            it("navigates to the parent", function () {
-                                var done = false;
-                                waitsFor(function () {
-                                    return done;
-                                });
-                                setTimeout(function () {
-                                    done = true;
-                                }, 5);
-                                runs(function () {
-                                    expect(mockActionCapability.perform)
-                                        .toHaveBeenCalledWith('navigate');
-                                });
+                                expect(mockActionCapability.perform)
+                                    .toHaveBeenCalledWith('navigate');
                            });
                        } else {
                            it("does nothing", function () {
-                                var done = false;
-                                waitsFor(function () {
-                                    return done;
-                                });
-                                setTimeout(function () {
-                                    done = true;
-                                }, 5);
-                                runs(function () {
-                                    expect(mockActionCapability.perform)
-                                        .not.toHaveBeenCalled();
-                                });
+                                expect(mockActionCapability.perform)
+                                    .not.toHaveBeenCalled();
                            });
                        }
                    }
@@ -173,6 +157,7 @@ define([
                                mockNavigationService.addListener.mostRecentCall
                                    .args[0](mockDomainObject);
                            });
+
                            itNavigatesAsExpected();
                        });

--- a/platform/commonUI/browse/test/windowing/FullscreenActionSpec.js
+++ b/platform/commonUI/browse/test/windowing/FullscreenActionSpec.js
@@ -51,7 +51,7 @@ define(
            });

            it("provides displayable metadata", function () {
-                expect(action.getMetadata().cssClass).toBeDefined();
+                expect(action.getMetadata().cssclass).toBeDefined();
            });

        });
--- a/platform/commonUI/dialog/bundle.js
+++ b/platform/commonUI/dialog/bundle.js
@@ -53,8 +53,7 @@ define([
                    "depends": [
                        "overlayService",
                        "$q",
-                        "$log",
-                        "$document"
+                        "$log"
                    ]
                },
                {
--- a/platform/commonUI/dialog/src/DialogService.js
+++ b/platform/commonUI/dialog/src/DialogService.js
@@ -35,15 +35,11 @@ define(
         * @memberof platform/commonUI/dialog
         * @constructor
         */
-        function DialogService(overlayService, $q, $log, $document) {
+        function DialogService(overlayService, $q, $log) {
            this.overlayService = overlayService;
            this.$q = $q;
            this.$log = $log;
            this.activeOverlay = undefined;
-
-            this.findBody = function () {
-                return $document.find('body');
-            };
        }

        /**
@@ -64,8 +60,7 @@ define(
            // input is asynchronous.
            var deferred = this.$q.defer(),
                self = this,
-                overlay,
-                handleEscKeydown;
+                overlay;

            // Confirm function; this will be passed in to the
            // overlay-dialog template and associated with a
@@ -81,22 +76,13 @@ define(
            // Cancel or X button click
            function cancel() {
                deferred.reject();
-                self.findBody().off('keydown', handleEscKeydown);
                self.dismissOverlay(overlay);
            }

-            handleEscKeydown = function (event) {
-                if (event.keyCode === 27) {
-                    cancel();
-                }
-            };
-
            // Add confirm/cancel callbacks
            model.confirm = confirm;
            model.cancel = cancel;

-            this.findBody().on('keydown', handleEscKeydown);
-
            if (this.canShowDialog(model)) {
                // Add the overlay using the OverlayService, which
                // will handle actual insertion into the DOM
--- a/platform/commonUI/dialog/test/DialogServiceSpec.js
+++ b/platform/commonUI/dialog/test/DialogServiceSpec.js
@@ -33,8 +33,6 @@ define(
                mockLog,
                mockOverlay,
                mockDeferred,
-                mockDocument,
-                mockBody,
                dialogService;

            beforeEach(function () {
@@ -58,13 +56,6 @@ define(
                    "deferred",
                    ["resolve", "reject"]
                );
-                mockDocument = jasmine.createSpyObj(
-                  "$document",
-                  ["find"]
-                );
-                mockBody = jasmine.createSpyObj('body', ['on', 'off']);
-                mockDocument.find.andReturn(mockBody);
-
                mockDeferred.promise = "mock promise";

                mockQ.defer.andReturn(mockDeferred);
@@ -73,8 +64,7 @@ define(
                dialogService = new DialogService(
                    mockOverlayService,
                    mockQ,
-                    mockLog,
-                    mockDocument
+                    mockLog
                );
            });

@@ -140,36 +130,6 @@ define(
                );
            });

-            it("adds a keydown event listener to the body", function () {
-                dialogService.getUserInput({}, {});
-                expect(mockDocument.find).toHaveBeenCalledWith("body");
-                expect(mockBody.on).toHaveBeenCalledWith("keydown", jasmine.any(Function));
-            });
-
-            it("destroys the event listener when the dialog is cancelled", function () {
-                dialogService.getUserInput({}, {});
-                mockOverlayService.createOverlay.mostRecentCall.args[1].cancel();
-                expect(mockBody.off).toHaveBeenCalledWith("keydown", jasmine.any(Function));
-            });
-
-            it("cancels the dialog when an escape keydown event is triggered", function () {
-                dialogService.getUserInput({}, {});
-                mockBody.on.mostRecentCall.args[1]({
-                    keyCode: 27
-                });
-                expect(mockDeferred.reject).toHaveBeenCalled();
-                expect(mockDeferred.resolve).not.toHaveBeenCalled();
-            });
-
-            it("ignores non escape keydown events", function () {
-                dialogService.getUserInput({}, {});
-                mockBody.on.mostRecentCall.args[1]({
-                    keyCode: 13
-                });
-                expect(mockDeferred.reject).not.toHaveBeenCalled();
-                expect(mockDeferred.resolve).not.toHaveBeenCalled();
-            });
-
            describe("the blocking message dialog", function () {
                var dialogModel = {};
                var dialogHandle;
--- a/platform/commonUI/edit/README.md
+++ b/platform/commonUI/edit/README.md
@@ -2,6 +2,25 @@ Contains sources and resources associated with Edit mode.

 # Extensions

+## Directives
+
+This bundle introduces the `mct-before-unload` directive, primarily for
+internal use (to prompt the user to confirm navigation away from unsaved
+changes in Edit mode.)
+
+The `mct-before-unload` directive is used as an attribute whose value is
+an Angular expression that is evaluated when navigation changes (either
+via browser-level changes, such as the refresh button, or changes to
+the Angular route, which happens when hitting the back button in Edit
+mode.) The result of this evaluation, when truthy, is shown in a browser
+dialog to allow the user to confirm navigation. When falsy, no prompt is
+shown, allowing these dialogs to be shown conditionally. (For instance, in
+Edit mode, prompts are only shown if user-initiated changes have
+occurred.)
+
+This directive may be attached to any element; its behavior will be enforced
+so long as that element remains within the DOM.
+
 # Toolbars

 Views may specify the contents of a toolbar through a `toolbar`
--- a/platform/commonUI/edit/bundle.js
+++ b/platform/commonUI/edit/bundle.js
@@ -25,6 +25,7 @@ define([
    "./src/controllers/EditPanesController",
    "./src/controllers/ElementsController",
    "./src/controllers/EditObjectController",
+    "./src/directives/MCTBeforeUnload",
    "./src/actions/EditAndComposeAction",
    "./src/actions/EditAction",
    "./src/actions/PropertiesAction",
@@ -34,9 +35,9 @@ define([
    "./src/actions/SaveAsAction",
    "./src/actions/CancelAction",
    "./src/policies/EditActionPolicy",
-    "./src/policies/EditPersistableObjectsPolicy",
    "./src/policies/EditableLinkPolicy",
    "./src/policies/EditableMovePolicy",
+    "./src/policies/EditNavigationPolicy",
    "./src/policies/EditContextualActionPolicy",
    "./src/representers/EditRepresenter",
    "./src/representers/EditToolbarRepresenter",
@@ -64,6 +65,7 @@ define([
    EditPanesController,
    ElementsController,
    EditObjectController,
+    MCTBeforeUnload,
    EditAndComposeAction,
    EditAction,
    PropertiesAction,
@@ -73,9 +75,9 @@ define([
    SaveAsAction,
    CancelAction,
    EditActionPolicy,
-    EditPersistableObjectsPolicy,
    EditableLinkPolicy,
    EditableMovePolicy,
+    EditNavigationPolicy,
    EditContextualActionPolicy,
    EditRepresenter,
    EditToolbarRepresenter,
@@ -130,7 +132,7 @@ define([
                    "depends": [
                        "$scope",
                        "$location",
-                        "navigationService"
+                        "policyService"
                    ]
                },
                {
@@ -150,6 +152,15 @@ define([
                    ]
                }
            ],
+            "directives": [
+                {
+                    "key": "mctBeforeUnload",
+                    "implementation": MCTBeforeUnload,
+                    "depends": [
+                        "$window"
+                    ]
+                }
+            ],
            "actions": [
                {
                    "key": "compose",
@@ -165,7 +176,7 @@ define([
                    ],
                    "description": "Edit",
                    "category": "view-control",
-                    "cssClass": "major icon-pencil"
+                    "cssclass": "major icon-pencil"
                },
                {
                    "key": "properties",
@@ -174,7 +185,7 @@ define([
                        "view-control"
                    ],
                    "implementation": PropertiesAction,
-                    "cssClass": "major icon-pencil",
+                    "cssclass": "major icon-pencil",
                    "name": "Edit Properties...",
                    "description": "Edit properties of this object.",
                    "depends": [
@@ -185,10 +196,11 @@ define([
                    "key": "remove",
                    "category": "contextual",
                    "implementation": RemoveAction,
-                    "cssClass": "icon-trash",
+                    "cssclass": "icon-trash",
                    "name": "Remove",
                    "description": "Remove this object from its containing object.",
                    "depends": [
+                        "$q",
                        "navigationService"
                    ]
                },
@@ -197,11 +209,10 @@ define([
                    "category": "save",
                    "implementation": SaveAndStopEditingAction,
                    "name": "Save and Finish Editing",
-                    "cssClass": "icon-save labeled",
+                    "cssclass": "icon-save labeled",
                    "description": "Save changes made to these objects.",
                    "depends": [
-                        "dialogService",
-                        "notificationService"
+                        "dialogService"
                    ]
                },
                {
@@ -209,11 +220,10 @@ define([
                    "category": "save",
                    "implementation": SaveAction,
                    "name": "Save and Continue Editing",
-                    "cssClass": "icon-save labeled",
+                    "cssclass": "icon-save labeled",
                    "description": "Save changes made to these objects.",
                    "depends": [
-                        "dialogService",
-                        "notificationService"
+                        "dialogService"
                    ]
                },
                {
@@ -221,14 +231,13 @@ define([
                    "category": "save",
                    "implementation": SaveAsAction,
                    "name": "Save As...",
-                    "cssClass": "icon-save labeled",
+                    "cssclass": "icon-save labeled",
                    "description": "Save changes made to these objects.",
                    "depends": [
                        "$injector",
                        "policyService",
                        "dialogService",
-                        "copyService",
-                        "notificationService"
+                        "copyService"
                    ],
                    "priority": "mandatory"
                },
@@ -236,10 +245,8 @@ define([
                    "key": "cancel",
                    "category": "conclude-editing",
                    "implementation": CancelAction,
-                    // Because we use the name as label for edit buttons and mct-control buttons need
-                    // the label to be set to undefined in order to not apply the labeled CSS rule.
-                    "name": undefined,
-                    "cssClass": "icon-x no-label",
+                    "name": "Cancel",
+                    "cssclass": "icon-x no-label",
                    "description": "Discard changes made to these objects.",
                    "depends": []
                }
@@ -249,11 +256,6 @@ define([
                    "category": "action",
                    "implementation": EditActionPolicy
                },
-                {
-                    "category": "action",
-                    "implementation": EditPersistableObjectsPolicy,
-                    "depends": ["openmct"]
-                },
                {
                    "category": "action",
                    "implementation": EditContextualActionPolicy,
@@ -267,6 +269,11 @@ define([
                    "category": "action",
                    "implementation": EditableLinkPolicy
                },
+                {
+                    "category": "navigation",
+                    "message": "Continuing will cause the loss of any unsaved changes.",
+                    "implementation": EditNavigationPolicy
+                },
                {
                    "implementation": CreationPolicy,
                    "category": "creation"
@@ -339,8 +346,7 @@ define([
                    "implementation": TransactionService,
                    "depends": [
                        "$q",
-                        "$log",
-                        "cacheService"
+                        "$log"
                    ]
                },
                {
@@ -381,6 +387,7 @@ define([
                {
                    "implementation": EditRepresenter,
                    "depends": [
+                        "$q",
                        "$log"
                    ]
                },
--- a/platform/commonUI/edit/res/templates/create/create-menu.html
+++ b/platform/commonUI/edit/res/templates/create/create-menu.html
@@ -25,14 +25,14 @@
            <li ng-repeat="createAction in createActions" ng-click="createAction.perform()">
                <a ng-mouseover="representation.activeMetadata = createAction.getMetadata()"
                   ng-mouseleave="representation.activeMetadata = undefined"
-                   class="menu-item-a {{ createAction.getMetadata().cssClass }}">
+                   class="menu-item-a {{ createAction.getMetadata().cssclass }}">
                    {{createAction.getMetadata().name}}
                </a>
            </li>
        </ul>
    </div>
    <div class="pane right menu-item-description">
-        <div class="desc-area icon {{ representation.activeMetadata.cssClass }}"></div>
+        <div class="desc-area icon {{ representation.activeMetadata.cssclass }}"></div>
        <div class="desc-area title">
            {{representation.activeMetadata.name}}
        </div>
--- a/platform/commonUI/edit/res/templates/edit-action-buttons.html
+++ b/platform/commonUI/edit/res/templates/edit-action-buttons.html
@@ -25,8 +25,8 @@
        <mct-control key="'button'"
                     structure="{
                        text: saveActions[0].getMetadata().name,
-                        click: actionPerformer(saveActions[0]),
-                        cssClass: 'major ' + saveActions[0].getMetadata().cssClass
+                        click: saveActions[0].perform,
+                        cssclass: 'major ' + saveActions[0].getMetadata().cssclass
                     }">
        </mct-control>
    </span>
@@ -36,18 +36,17 @@
                     structure="{
                        options: saveActionsAsMenuOptions,
                        click: saveActionMenuClickHandler,
-                        cssClass: 'btn-bar right icon-save no-label major'
+                        cssclass: 'btn-bar right icon-save no-label major'
                     }">
        </mct-control>
    </span>

    <span ng-repeat="currentAction in otherEditActions">
-        <mct-control key="'button'"
-                     structure="{
-                        text: currentAction.getMetadata().name,
-                        click: actionPerformer(currentAction),
-                        cssClass: currentAction.getMetadata().cssClass
-                     }">
-        </mct-control>
+        <a class='s-button {{currentAction.getMetadata().cssclass}}'
+           title='{{currentAction.getMetadata().name}}'
+           ng-click="currentAction.perform()"
+           ng-class="{ major: $index === 0 && saveActions.length === 0 }">
+            <span class="title-label">{{currentAction.getMetadata().name}}</span>
+        </a>
    </span>
 </span>
--- a/platform/commonUI/edit/res/templates/edit-object.html
+++ b/platform/commonUI/edit/res/templates/edit-object.html
@@ -20,7 +20,8 @@
 at runtime from the About dialog for additional information.
 -->
 <div class="abs l-flex-col" ng-controller="EditObjectController as EditObjectController">
-    <div class="holder flex-elem l-flex-row object-browse-bar ">
+    <div mct-before-unload="EditObjectController.getUnloadWarning()"
+         class="holder flex-elem l-flex-row object-browse-bar ">
        <div class="items-select left flex-elem l-flex-row grows">
            <mct-representation key="'back-arrow'"
                                mct-object="domainObject"
@@ -65,9 +66,4 @@
            </mct-representation>
        </div><!--/ l-object-wrapper-inner -->
    </div>
-    <mct-representation mct-object="domainObject"
-                        key="'time-conductor'"
-                        class="abs holder flex-elem flex-fixed l-flex-row l-time-conductor-holder">
-    </mct-representation>
-
 </div>
--- a/platform/commonUI/edit/src/actions/CancelAction.js
+++ b/platform/commonUI/edit/src/actions/CancelAction.js
@@ -56,13 +56,13 @@ define(
                    //navigate back to parent because nothing to show.
                    return domainObject.getCapability("location").getOriginal().then(function (original) {
                        parent = original.getCapability("context").getParent();
-                        return parent.getCapability("action").perform("navigate");
+                        parent.getCapability("action").perform("navigate");
                    });
                }
            }

-            function cancel() {
-                return domainObject.getCapability("editor").finish();
+            function cancel(allowed) {
+                return allowed && domainObject.getCapability("editor").finish();
            }

            //Do navigation first in order to trigger unsaved changes dialog
--- a/platform/commonUI/edit/src/actions/EditAndComposeAction.js
+++ b/platform/commonUI/edit/src/actions/EditAndComposeAction.js
@@ -40,11 +40,19 @@ define(
            var self = this,
                editAction = this.domainObject.getCapability('action').getActions("edit")[0];

+            // Persist changes to the domain object
+            function doPersist() {
+                var persistence =
+                    self.domainObject.getCapability('persistence');
+                return persistence.persist();
+            }
+
            // Link these objects
            function doLink() {
                var composition = self.domainObject &&
                        self.domainObject.getCapability('composition');
-                return composition && composition.add(self.selectedObject);
+                return composition && composition.add(self.selectedObject)
+                        .then(doPersist);
            }

            if (editAction) {
--- a/platform/commonUI/edit/src/actions/PropertiesAction.js
+++ b/platform/commonUI/edit/src/actions/PropertiesAction.js
@@ -50,6 +50,12 @@ define(
                domainObject = this.domainObject,
                dialogService = this.dialogService;

+            // Persist modifications to this domain object
+            function doPersist() {
+                var persistence = domainObject.getCapability('persistence');
+                return persistence && persistence.persist();
+            }
+
            // Update the domain object model based on user input
            function updateModel(userInput, dialog) {
                return domainObject.useCapability('mutation', function (model) {
@@ -67,9 +73,11 @@ define(
                    dialog.getFormStructure(),
                    dialog.getInitialFormValue()
                ).then(function (userInput) {
-                    // Update the model, if user input was provided
-                    return userInput && updateModel(userInput, dialog);
-                });
+                        // Update the model, if user input was provided
+                        return userInput && updateModel(userInput, dialog);
+                    }).then(function (result) {
+                        return result && doPersist();
+                    });
            }

            return type && showDialog(type);
@@ -86,7 +94,9 @@ define(
                creatable = type && type.hasFeature('creation');

            // Only allow creatable types to be edited
-            return domainObject && creatable;
+            return domainObject &&
+                domainObject.hasCapability("persistence") &&
+                creatable;
        };

        return PropertiesAction;
--- a/platform/commonUI/edit/src/actions/RemoveAction.js
+++ b/platform/commonUI/edit/src/actions/RemoveAction.js
@@ -39,8 +39,9 @@ define(
         * @constructor
         * @implements {Action}
         */
-        function RemoveAction(navigationService, context) {
+        function RemoveAction($q, navigationService, context) {
            this.domainObject = (context || {}).domainObject;
+            this.$q = $q;
            this.navigationService = navigationService;
        }

@@ -50,7 +51,8 @@ define(
         *         fulfilled when the action has completed.
         */
        RemoveAction.prototype.perform = function () {
-            var navigationService = this.navigationService,
+            var $q = this.$q,
+                navigationService = this.navigationService,
                domainObject = this.domainObject;
            /*
             * Check whether an object ID matches the ID of the object being
@@ -69,6 +71,15 @@ define(
                model.composition = model.composition.filter(isNotObject);
            }

+            /*
+             * Invoke persistence on a domain object. This will be called upon
+             * the removed object's parent (as its composition will have changed.)
+             */
+            function doPersist(domainObj) {
+                var persistence = domainObj.getCapability('persistence');
+                return persistence && persistence.persist();
+            }
+
            /*
             * Checks current object and ascendants of current
             * object with object being removed, if the current
@@ -108,10 +119,15 @@ define(
                // navigates to existing object up tree
                checkObjectNavigation(object, parent);

-                return parent.useCapability('mutation', doMutate);
+                return $q.when(
+                    parent.useCapability('mutation', doMutate)
+                ).then(function () {
+                    return doPersist(parent);
+                });
            }

-            return removeFromContext(domainObject);
+            return $q.when(domainObject)
+                .then(removeFromContext);
        };

        // Object needs to have a parent for Remove to be applicable
--- a/platform/commonUI/edit/src/actions/SaveAction.js
+++ b/platform/commonUI/edit/src/actions/SaveAction.js
@@ -33,12 +33,10 @@ define(
         */
        function SaveAction(
            dialogService,
-            notificationService,
            context
        ) {
            this.domainObject = (context || {}).domainObject;
            this.dialogService = dialogService;
-            this.notificationService = notificationService;
        }

        /**
@@ -49,8 +47,7 @@ define(
         * @memberof platform/commonUI/edit.SaveAction#
         */
        SaveAction.prototype.perform = function () {
-            var self = this,
-                domainObject = this.domainObject,
+            var domainObject = this.domainObject,
                dialog = new SaveInProgressDialog(this.dialogService);

            // Invoke any save behavior introduced by the editor capability;
@@ -61,21 +58,15 @@ define(
                return domainObject.getCapability("editor").save();
            }

-            function onSuccess() {
+            function hideBlockingDialog() {
                dialog.hide();
-                self.notificationService.info("Save Succeeded");
-            }
-
-            function onFailure() {
-                dialog.hide();
-                self.notificationService.error("Save Failed");
            }

            dialog.show();

            return doSave()
-                .then(onSuccess)
-                .catch(onFailure);
+                .then(hideBlockingDialog)
+                .catch(hideBlockingDialog);
        };

        /**
--- a/platform/commonUI/edit/src/actions/SaveAndStopEditingAction.js
+++ b/platform/commonUI/edit/src/actions/SaveAndStopEditingAction.js
@@ -33,13 +33,11 @@ define(
         */
        function SaveAndStopEditingAction(
            dialogService,
-            notificationService,
            context
        ) {
            this.context = context;
            this.domainObject = (context || {}).domainObject;
            this.dialogService = dialogService;
-            this.notificationService = notificationService;
        }

        /**
@@ -51,7 +49,7 @@ define(
         */
        SaveAndStopEditingAction.prototype.perform = function () {
            var domainObject = this.domainObject,
-                saveAction = new SaveAction(this.dialogService, this.notificationService, this.context);
+                saveAction = new SaveAction(this.dialogService, this.context);

            function closeEditor() {
                return domainObject.getCapability("editor").finish();
--- a/platform/commonUI/edit/src/actions/SaveAsAction.js
+++ b/platform/commonUI/edit/src/actions/SaveAsAction.js
@@ -43,7 +43,6 @@ define([
            policyService,
            dialogService,
            copyService,
-            notificationService,
            context
        ) {
            this.domainObject = (context || {}).domainObject;
@@ -53,7 +52,6 @@ define([
            this.policyService = policyService;
            this.dialogService = dialogService;
            this.copyService = copyService;
-            this.notificationService = notificationService;
        }

        /**
@@ -119,10 +117,8 @@ define([

                return self.dialogService
                    .getUserInput(wizard.getFormStructure(true),
-                        wizard.getInitialFormValue())
-                    .then(wizard.populateObjectFromInput.bind(wizard), function (failureReason) {
-                        return Promise.reject("user canceled");
-                    });
+                        wizard.getInitialFormValue()
+                    ).then(wizard.populateObjectFromInput.bind(wizard));
            }

            function showBlockingDialog(object) {
@@ -175,21 +171,11 @@ define([

            function finishEditing(clonedObject) {
                return domainObject.getCapability("editor").finish()
-                    .then(function () {
-                        return fetchObject(clonedObject.getId());
-                    });
+                    .then(resolveWith(clonedObject));
            }

-            function onSuccess(object) {
-                self.notificationService.info("Save Succeeded");
-                return object;
-            }
-
-            function onFailure(reason) {
+            function onFailure() {
                hideBlockingDialog();
-                if (reason !== "user canceled") {
-                    self.notificationService.error("Save Failed");
-                }
                return false;
            }

@@ -202,7 +188,6 @@ define([
                .then(saveAfterClone)
                .then(finishEditing)
                .then(hideBlockingDialog)
-                .then(onSuccess)
                .catch(onFailure);
        };

--- a/platform/commonUI/edit/src/capabilities/TransactionCapabilityDecorator.js
+++ b/platform/commonUI/edit/src/capabilities/TransactionCapabilityDecorator.js
@@ -48,10 +48,9 @@ define(
         * Decorate PersistenceCapability to queue persistence calls when a
         * transaction is in progress.
         */
-        TransactionCapabilityDecorator.prototype.getCapabilities = function () {
+        TransactionCapabilityDecorator.prototype.getCapabilities = function (model) {
            var self = this,
-                capabilities = this.capabilityService.getCapabilities
-                    .apply(this.capabilityService, arguments),
+                capabilities = this.capabilityService.getCapabilities(model),
                persistenceCapability = capabilities.persistence;

            capabilities.persistence = function (domainObject) {
--- a/platform/commonUI/edit/src/capabilities/TransactionalPersistenceCapability.js
+++ b/platform/commonUI/edit/src/capabilities/TransactionalPersistenceCapability.js
@@ -81,10 +81,6 @@ define(
            return this.persistenceCapability.getSpace();
        };

-        TransactionalPersistenceCapability.prototype.persisted = function () {
-            return this.persistenceCapability.persisted();
-        };
-
        return TransactionalPersistenceCapability;
    }
 );
--- a/platform/commonUI/edit/src/controllers/EditActionController.js
+++ b/platform/commonUI/edit/src/controllers/EditActionController.js
@@ -41,7 +41,7 @@ define(
                return {
                    key: action,
                    name: action.getMetadata().name,
-                    cssClass: action.getMetadata().cssClass
+                    cssclass: action.getMetadata().cssclass
                };
            }

@@ -61,12 +61,6 @@ define(
                $scope.otherEditActions = $scope.action ?
                        $scope.action.getActions(OTHERS_ACTION_CONTEXT) :
                        [];
-
-                // Required because Angular does not allow 'bind'
-                // in expressions.
-                $scope.actionPerformer = function (action) {
-                    return action.perform.bind(action);
-                };
            }

            // Update set of actions whenever the action capability
--- a/platform/commonUI/edit/src/controllers/EditObjectController.js
+++ b/platform/commonUI/edit/src/controllers/EditObjectController.js
@@ -28,49 +28,18 @@ define(
    [],
    function () {

-        function isDirty(domainObject) {
-            var navigatedObject = domainObject,
-                editorCapability = navigatedObject &&
-                    navigatedObject.getCapability("editor");
-
-            return editorCapability &&
-                editorCapability.isEditContextRoot() &&
-                editorCapability.dirty();
-        }
-
-        function cancelEditing(domainObject) {
-            var navigatedObject = domainObject,
-                editorCapability = navigatedObject &&
-                    navigatedObject.getCapability("editor");
-
-            return editorCapability &&
-                editorCapability.finish();
-        }
-
        /**
         * Controller which is responsible for populating the scope for
         * Edit mode
         * @memberof platform/commonUI/edit
         * @constructor
         */
-        function EditObjectController($scope, $location, navigationService) {
+        function EditObjectController($scope, $location, policyService) {
            this.scope = $scope;
-            var domainObject = $scope.domainObject;
+            this.policyService = policyService;

-            var removeCheck = navigationService
-                .checkBeforeNavigation(function () {
-                    if (isDirty(domainObject)) {
-                        return "Continuing will cause the loss of any unsaved changes.";
-                    }
-                    return false;
-                });
-
-            $scope.$on('$destroy', function () {
-                removeCheck();
-                cancelEditing(domainObject);
-            });
-
-            function setViewForDomainObject() {
+            var navigatedObject;
+            function setViewForDomainObject(domainObject) {

                var locationViewKey = $location.search().view;

@@ -85,15 +54,34 @@ define(
                    ((domainObject && domainObject.useCapability('view')) || [])
                        .forEach(selectViewIfMatching);
                }
+                navigatedObject = domainObject;
            }

-            setViewForDomainObject();
+            $scope.$watch('domainObject', setViewForDomainObject);

            $scope.doAction = function (action) {
                return $scope[action] && $scope[action]();
            };
        }

+        /**
+         * Get the warning to show if the user attempts to navigate
+         * away from Edit mode while unsaved changes are present.
+         * @returns {string} the warning to show, or undefined if
+         *          there are no unsaved changes
+         */
+        EditObjectController.prototype.getUnloadWarning = function () {
+            var navigatedObject = this.scope.domainObject,
+                policyMessage;
+
+            this.policyService.allow("navigation", navigatedObject, undefined, function (message) {
+                policyMessage = message;
+            });
+
+            return policyMessage;
+
+        };
+
        return EditObjectController;
    }
 );
--- a/platform/commonUI/edit/src/creation/AddAction.js
+++ b/platform/commonUI/edit/src/creation/AddAction.js
@@ -51,7 +51,7 @@ define(
        function AddAction(type, parent, context, $q, dialogService, policyService) {
            this.metadata = {
                key: 'add',
-                cssClass: type.getCssClass(),
+                cssclass: type.getCssClass(),
                name: type.getName(),
                type: type.getKey(),
                description: type.getDescription(),
--- a/platform/commonUI/edit/src/creation/AddActionProvider.js
+++ b/platform/commonUI/edit/src/creation/AddActionProvider.js
@@ -54,7 +54,8 @@ define(
        AddActionProvider.prototype.getActions = function (actionContext) {
            var context = actionContext || {},
                key = context.key,
-                destination = context.domainObject;
+                destination = context.domainObject,
+                self = this;

            // We only provide Add actions, and we need a
            // domain object to serve as the container for the
@@ -65,16 +66,18 @@ define(
            }

            // Introduce one create action per type
-            return ['timeline', 'activity'].map(function (type) {
+            return this.typeService.listTypes().filter(function (type) {
+                return self.policyService.allow("creation", type) && self.policyService.allow("composition", destination.getCapability('type'), type);
+            }).map(function (type) {
                return new AddAction(
-                    this.typeService.getType(type),
+                    type,
                    destination,
                    context,
-                    this.$q,
-                    this.dialogService,
-                    this.policyService
+                    self.$q,
+                    self.dialogService,
+                    self.policyService
                );
-            }, this);
+            });
        };

        return AddActionProvider;
--- a/platform/commonUI/edit/src/creation/CreateAction.js
+++ b/platform/commonUI/edit/src/creation/CreateAction.js
@@ -47,7 +47,7 @@ define(
        function CreateAction(type, parent, context) {
            this.metadata = {
                key: 'create',
-                cssClass: type.getCssClass(),
+                cssclass: type.getCssClass(),
                name: type.getName(),
                type: type.getKey(),
                description: type.getDescription(),
--- a/platform/commonUI/edit/src/creation/CreateWizard.js
+++ b/platform/commonUI/edit/src/creation/CreateWizard.js
@@ -56,14 +56,16 @@ define(
         */
        CreateWizard.prototype.getFormStructure = function (includeLocation) {
            var sections = [],
-                domainObject = this.domainObject,
+                type = this.type,
                policyService = this.policyService;

-            function validateLocation(parent) {
-                return parent && policyService.allow(
+            function validateLocation(locatingObject) {
+                var locatingType = locatingObject &&
+                    locatingObject.getCapability('type');
+                return locatingType && policyService.allow(
                    "composition",
-                    parent,
-                    domainObject
+                    locatingType,
+                    type
                );
            }

@@ -89,7 +91,7 @@ define(
            if (includeLocation) {
                sections.push({
                    name: 'Location',
-                    cssClass: "grows",
+                    cssclass: "grows",
                    rows: [{
                        name: "Save In",
                        control: "locator",
--- a/platform/commonUI/edit/src/directives/MCTBeforeUnload.js
+++ b/platform/commonUI/edit/src/directives/MCTBeforeUnload.js
@@ -0,0 +1,104 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(
+    [],
+    function () {
+
+        /**
+         * Defines the `mct-before-unload` directive. The expression bound
+         * to this attribute will be evaluated during page navigation events
+         * and, if it returns a truthy value, will be used to populate a
+         * prompt to the user to confirm this navigation.
+         * @memberof platform/commonUI/edit
+         * @constructor
+         * @param $window the window
+         */
+        function MCTBeforeUnload($window) {
+            var unloads = [],
+                oldBeforeUnload = $window.onbeforeunload;
+
+            // Run all unload functions, returning the first returns truthily.
+            function checkUnloads() {
+                var result;
+                unloads.forEach(function (unload) {
+                    result = result || unload();
+                });
+                return result;
+            }
+
+            // Link function for an mct-before-unload directive usage
+            function link(scope, element, attrs) {
+                // Invoke the
+                function unload() {
+                    return scope.$eval(attrs.mctBeforeUnload);
+                }
+
+                // Stop using this unload expression
+                function removeUnload() {
+                    unloads = unloads.filter(function (callback) {
+                        return callback !== unload;
+                    });
+                    if (unloads.length === 0) {
+                        $window.onbeforeunload = oldBeforeUnload;
+                    }
+                }
+
+                // Show a dialog before allowing a location change
+                function checkLocationChange(event) {
+                    // Get an unload message (if any)
+                    var warning = unload();
+                    // Prompt the user if there's an unload message
+                    if (warning && !$window.confirm(warning)) {
+                        // ...and prevent the route change if it was confirmed
+                        event.preventDefault();
+                    }
+                }
+
+                // If this is the first active instance of this directive,
+                // register as the window's beforeunload handler
+                if (unloads.length === 0) {
+                    $window.onbeforeunload = checkUnloads;
+                }
+
+                // Include this instance of the directive's unload function
+                unloads.push(unload);
+
+                // Remove it when the scope is destroyed
+                scope.$on("$destroy", removeUnload);
+
+                // Also handle route changes
+                scope.$on("$locationChangeStart", checkLocationChange);
+            }
+
+            return {
+                // Applicable as an attribute
+                restrict: "A",
+                // Link with the provided function
+                link: link
+            };
+        }
+
+        return MCTBeforeUnload;
+
+    }
+);
--- a/platform/commonUI/edit/src/policies/EditNavigationPolicy.js
+++ b/platform/commonUI/edit/src/policies/EditNavigationPolicy.js
@@ -0,0 +1,64 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+define(
+    [],
+    function () {
+
+        /**
+         * Policy controlling whether navigation events should proceed
+         * when object is being edited.
+         * @memberof platform/commonUI/edit
+         * @constructor
+         * @implements {Policy.<Action, ActionContext>}
+         */
+        function EditNavigationPolicy(policyService) {
+            this.policyService = policyService;
+        }
+
+        /**
+         * @private
+         */
+        EditNavigationPolicy.prototype.isDirty = function (domainObject) {
+            var navigatedObject = domainObject,
+                editorCapability = navigatedObject &&
+                    navigatedObject.getCapability("editor");
+
+            return editorCapability &&
+                editorCapability.isEditContextRoot() &&
+                editorCapability.dirty();
+        };
+
+        /**
+         * Allow navigation if an object is not dirty, or if the user elects
+         * to proceed anyway.
+         * @param currentNavigation
+         * @returns {boolean|*} true if the object model is clean; or if
+         * it's dirty and the user wishes to proceed anyway.
+         */
+        EditNavigationPolicy.prototype.allow = function (currentNavigation) {
+            return !this.isDirty(currentNavigation);
+        };
+
+        return EditNavigationPolicy;
+    }
+);
--- a/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js
+++ b/platform/commonUI/edit/src/policies/EditPersistableObjectsPolicy.js
@@ -1,59 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    ['../../../../../src/api/objects/object-utils'],
-    function (objectUtils) {
-
-        /**
-         * Policy that prevents editing of any object from a provider that does not
-         * support persistence (ie. the 'save' operation). Editing is prevented
-         * as a subsequent save would fail, causing the loss of a user's changes.
-         * @param openmct
-         * @constructor
-         */
-        function EditPersistableObjectsPolicy(openmct) {
-            this.openmct = openmct;
-        }
-
-        EditPersistableObjectsPolicy.prototype.allow = function (action, context) {
-            var identifier;
-            var provider;
-            var domainObject = context.domainObject;
-            var key = action.getMetadata().key;
-            var category = (context || {}).category;
-
-            // Use category to selectively block edit from the view. Edit action
-            // is also invoked during the create process which should be allowed,
-            // because it may be saved elsewhere
-            if ((key === 'edit' && category === 'view-control') || key === 'properties') {
-                identifier = objectUtils.parseKeyString(domainObject.getId());
-                provider = this.openmct.objects.getProvider(identifier);
-                return provider.save !== undefined;
-            }
-
-            return true;
-        };
-
-        return EditPersistableObjectsPolicy;
-    }
-);
--- a/platform/commonUI/edit/src/representers/EditRepresenter.js
+++ b/platform/commonUI/edit/src/representers/EditRepresenter.js
@@ -43,55 +43,102 @@ define(
         * @implements {Representer}
         * @constructor
         */
-        function EditRepresenter($log, $scope) {
-            this.$log = $log;
-            this.$scope = $scope;
+        function EditRepresenter($q, $log, scope) {
+            var self = this;

-            this.$scope.commit = this.commit.bind(this);
-        }
+            this.scope = scope;
+            this.listenHandle = undefined;

-        /**
-         * Commit any changes made to the in-scope model to the domain object.
-         * Also commits any changes made to $scope.configuration to the proper
-         * configuration value for the current representation.
-         *
-         * @param {String} message a message to log with the commit message.
-         */
-        EditRepresenter.prototype.commit = function (message) {
-            var model = this.$scope.model,
-                configuration = this.$scope.configuration,
-                domainObject = this.domainObject;
+            // Mutate and persist a new version of a domain object's model.
+            function doPersist(model) {
+                var domainObject = self.domainObject;

-            this.$log.debug([
-                "Committing ",
-                domainObject && domainObject.getModel().name,
-                "(" + (domainObject && domainObject.getId()) + "):",
-                message
-            ].join(" "));
-
-            if (this.domainObject) {
-                if (this.key && configuration) {
-                    model.configuration = model.configuration || {};
-                    model.configuration[this.key] = configuration;
-                }
-                domainObject.useCapability('mutation', function () {
+                // First, mutate; then, persist.
+                return $q.when(domainObject.useCapability("mutation", function () {
                    return model;
+                })).then(function (result) {
+                    // Only persist when mutation was successful
+                    return result &&
+                        domainObject.getCapability("persistence").persist();
                });
            }
-        };
+
+            // Handle changes to model and/or view configuration
+            function commit(message) {
+                // Look up from scope; these will have been populated by
+                // mct-representation.
+                var model = scope.model,
+                    configuration = scope.configuration,
+                    domainObject = self.domainObject;
+
+                // Log the commit message
+                $log.debug([
+                    "Committing ",
+                    domainObject && domainObject.getModel().name,
+                    "(" + (domainObject && domainObject.getId()) + "):",
+                    message
+                ].join(" "));
+
+                // Update the configuration stored in the model, and persist.
+                if (domainObject && domainObject.hasCapability("persistence")) {
+                    // Configurations for specific views are stored by
+                    // key in the "configuration" field of the model.
+                    if (self.key && configuration) {
+                        model.configuration = model.configuration || {};
+                        model.configuration[self.key] = configuration;
+                    }
+                    doPersist(model);
+                }
+            }
+
+            // Place the "commit" method in the scope
+            scope.commit = commit;
+
+            // Clean up when the scope is destroyed
+            scope.$on("$destroy", function () {
+                self.destroy();
+            });
+
+        }

        // Handle a specific representation of a specific domain object
-        EditRepresenter.prototype.represent = function (representation, representedObject) {
+        EditRepresenter.prototype.represent = function represent(representation, representedObject) {
+            var scope = this.scope;
+
+            // Track the key, to know which view configuration to save to.
+            this.key = (representation || {}).key;
+            // Track the represented object
            this.domainObject = representedObject;
-            if (representation) {
-                this.key = representation.key;
-            } else {
-                delete this.key;
+
+            // Ensure existing watches are released
+            this.destroy();
+
+            function setEditing() {
+                scope.viewObjectTemplate = 'edit-object';
+            }
+
+            /**
+             * Listen for changes in object state. If the object becomes
+             * editable then change the view and inspector regions
+             * object representation accordingly
+             */
+            this.listenHandle = this.domainObject.getCapability('status').listen(function (statuses) {
+                if (statuses.indexOf('editing') !== -1) {
+                    setEditing();
+                } else {
+                    delete scope.viewObjectTemplate;
+                }
+            });
+
+            if (representedObject.hasCapability('editor') && representedObject.getCapability('editor').isEditContextRoot()) {
+                setEditing();
            }
        };

        // Respond to the destruction of the current representation.
-        EditRepresenter.prototype.destroy = function () {};
+        EditRepresenter.prototype.destroy = function destroy() {
+            return this.listenHandle && this.listenHandle();
+        };

        return EditRepresenter;
    }
--- a/platform/commonUI/edit/src/services/NestedTransaction.js
+++ b/platform/commonUI/edit/src/services/NestedTransaction.js
@@ -1,48 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-define(['./Transaction'], function (Transaction) {
-    /**
-     * A nested transaction is a transaction which takes place in the context
-     * of a larger parent transaction. It becomes part of the parent
-     * transaction when (and only when) committed.
-     * @param parent
-     * @constructor
-     * @extends {platform/commonUI/edit/services.Transaction}
-     * @memberof platform/commonUI/edit/services
-     */
-    function NestedTransaction(parent) {
-        this.parent = parent;
-        Transaction.call(this, parent.$log);
-    }
-
-    NestedTransaction.prototype = Object.create(Transaction.prototype);
-
-    NestedTransaction.prototype.commit = function () {
-        this.parent.add(
-            Transaction.prototype.commit.bind(this),
-            Transaction.prototype.cancel.bind(this)
-        );
-        return Promise.resolve(true);
-    };
-
-    return NestedTransaction;
-});
--- a/platform/commonUI/edit/src/services/Transaction.js
+++ b/platform/commonUI/edit/src/services/Transaction.js
@@ -1,96 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-define([], function () {
-    /**
-     * A Transaction represents a set of changes that are intended to
-     * be kept or discarded as a unit.
-     * @param $log Angular's `$log` service, for logging messages
-     * @constructor
-     * @memberof platform/commonUI/edit/services
-     */
-    function Transaction($log) {
-        this.$log = $log;
-        this.callbacks = [];
-    }
-
-    /**
-     * Add a change to the current transaction, as expressed by functions
-     * to either keep or discard the change.
-     * @param {Function} commit called when the transaction is committed
-     * @param {Function} cancel called when the transaction is cancelled
-     * @returns {Function) a function which may be called to remove this
-     *          pair of callbacks from the transaction
-     */
-    Transaction.prototype.add = function (commit, cancel) {
-        var callback = { commit: commit, cancel: cancel };
-        this.callbacks.push(callback);
-        return function () {
-            this.callbacks = this.callbacks.filter(function (c) {
-                return c !== callback;
-            });
-        }.bind(this);
-    };
-
-    /**
-     * Get the number of changes in the current transaction.
-     * @returns {number} the size of the current transaction
-     */
-    Transaction.prototype.size = function () {
-        return this.callbacks.length;
-    };
-
-    /**
-     * Keep all changes associated with this transaction.
-     * @method {platform/commonUI/edit/services.Transaction#commit}
-     * @returns {Promise} a promise which will resolve when all callbacks
-     *          have been handled.
-     */
-
-    /**
-     * Discard all changes associated with this transaction.
-     * @method {platform/commonUI/edit/services.Transaction#cancel}
-     * @returns {Promise} a promise which will resolve when all callbacks
-     *          have been handled.
-     */
-
-    ['commit', 'cancel'].forEach(function (method) {
-        Transaction.prototype[method] = function () {
-            var promises = [];
-            var callback;
-
-            while (this.callbacks.length > 0) {
-                callback = this.callbacks.shift();
-                try {
-                    promises.push(callback[method]());
-                } catch (e) {
-                    this.$log
-                        .error("Error trying to " + method + " transaction.");
-                }
-            }
-
-            return Promise.all(promises);
-        };
-    });
-
-
-    return Transaction;
-});
--- a/platform/commonUI/edit/src/services/TransactionService.js
+++ b/platform/commonUI/edit/src/services/TransactionService.js
@@ -21,8 +21,8 @@
 *****************************************************************************/
 /*global define*/
 define(
-    ['./Transaction', './NestedTransaction'],
-    function (Transaction, NestedTransaction) {
+    [],
+    function () {
        /**
         * Implements an application-wide transaction state. Once a
         * transaction is started, calls to
@@ -34,11 +34,13 @@ define(
         * @param $q
         * @constructor
         */
-        function TransactionService($q, $log, cacheService) {
+        function TransactionService($q, $log) {
            this.$q = $q;
            this.$log = $log;
-            this.cacheService = cacheService;
-            this.transactions = [];
+            this.transaction = false;
+
+            this.onCommits = [];
+            this.onCancels = [];
        }

        /**
@@ -48,18 +50,18 @@ define(
         * #cancel} are called
         */
        TransactionService.prototype.startTransaction = function () {
-            var transaction = this.isActive() ?
-                new NestedTransaction(this.transactions[0]) :
-                new Transaction(this.$log);
-
-            this.transactions.push(transaction);
+            if (this.transaction) {
+                //Log error because this is a programming error if it occurs.
+                this.$log.error("Transaction already in progress");
+            }
+            this.transaction = true;
        };

        /**
         * @returns {boolean} If true, indicates that a transaction is in progress
         */
        TransactionService.prototype.isActive = function () {
-            return this.transactions.length > 0;
+            return this.transaction;
        };

        /**
@@ -70,43 +72,52 @@ define(
         * @param onCancel A function to call on cancel
         */
        TransactionService.prototype.addToTransaction = function (onCommit, onCancel) {
-            if (this.isActive()) {
-                return this.activeTransaction().add(onCommit, onCancel);
+            if (this.transaction) {
+                this.onCommits.push(onCommit);
+                if (onCancel) {
+                    this.onCancels.push(onCancel);
+                }
            } else {
                //Log error because this is a programming error if it occurs.
                this.$log.error("No transaction in progress");
            }
-        };

-        /**
-         * Get the transaction at the top of the stack.
-         * @private
-         */
-        TransactionService.prototype.activeTransaction = function () {
-            return this.transactions[this.transactions.length - 1];
+            return function () {
+                this.onCommits = this.onCommits.filter(function (callback) {
+                    return callback !== onCommit;
+                });
+                this.onCancels = this.onCancels.filter(function (callback) {
+                    return callback !== onCancel;
+                });
+            }.bind(this);
        };

        /**
         * All persist calls deferred since the beginning of the transaction
-         * will be committed.  If this is the last transaction, clears the
-         * cache.
+         * will be committed.
         *
         * @returns {Promise} resolved when all persist operations have
         * completed. Will reject if any commit operations fail
         */
        TransactionService.prototype.commit = function () {
-            var transaction = this.transactions.pop();
-            if (!transaction) {
-                return Promise.reject();
+            var self = this,
+                promises = [],
+                onCommit;
+
+            while (this.onCommits.length > 0) { // ...using a while in case some onCommit adds to transaction
+                onCommit = this.onCommits.pop();
+                try { // ...also don't want to fail mid-loop...
+                    promises.push(onCommit());
+                } catch (e) {
+                    this.$log.error("Error committing transaction.");
+                }
            }
-            if (!this.isActive()) {
-                return transaction.commit()
-                    .then(function (r) {
-                        this.cacheService.flush();
-                        return r;
-                    }.bind(this));
-            }
-            return transaction.commit();
+            return this.$q.all(promises).then(function () {
+                self.transaction = false;
+
+                self.onCommits = [];
+                self.onCancels = [];
+            });
        };

        /**
@@ -118,17 +129,28 @@ define(
         * @returns {*}
         */
        TransactionService.prototype.cancel = function () {
-            var transaction = this.transactions.pop();
-            return transaction ? transaction.cancel() : Promise.reject();
+            var self = this,
+                results = [],
+                onCancel;
+
+            while (this.onCancels.length > 0) {
+                onCancel = this.onCancels.pop();
+                try {
+                    results.push(onCancel());
+                } catch (error) {
+                    this.$log.error("Error cancelling transaction.");
+                }
+            }
+            return this.$q.all(results).then(function () {
+                self.transaction = false;
+
+                self.onCommits = [];
+                self.onCancels = [];
+            });
        };

-        /**
-         * Get the size (the number of commit/cancel callbacks) of
-         * the active transaction.
-         * @returns {number} size of the active transaction
-         */
        TransactionService.prototype.size = function () {
-            return this.isActive() ? this.activeTransaction().size() : 0;
+            return this.onCommits.length;
        };

        return TransactionService;
--- a/platform/commonUI/edit/test/actions/EditAndComposeActionSpec.js
+++ b/platform/commonUI/edit/test/actions/EditAndComposeActionSpec.js
@@ -30,6 +30,7 @@ define(
                mockParent,
                mockContext,
                mockComposition,
+                mockPersistence,
                mockActionCapability,
                mockEditAction,
                mockType,
@@ -67,6 +68,7 @@ define(
                };
                mockContext = jasmine.createSpyObj("context", ["getParent"]);
                mockComposition = jasmine.createSpyObj("composition", ["invoke", "add"]);
+                mockPersistence = jasmine.createSpyObj("persistence", ["persist"]);
                mockType = jasmine.createSpyObj("type", ["hasFeature", "getKey"]);
                mockActionCapability = jasmine.createSpyObj("actionCapability", ["getActions"]);
                mockEditAction = jasmine.createSpyObj("editAction", ["perform"]);
@@ -82,6 +84,7 @@ define(

                capabilities = {
                    composition: mockComposition,
+                    persistence: mockPersistence,
                    action: mockActionCapability,
                    type: mockType
                };
@@ -104,6 +107,11 @@ define(
                    .toHaveBeenCalledWith(mockDomainObject);
            });

+            it("persists changes afterward", function () {
+                action.perform();
+                expect(mockPersistence.persist).toHaveBeenCalled();
+            });
+
            it("enables edit mode for objects that have an edit action", function () {
                mockActionCapability.getActions.andReturn([mockEditAction]);
                action.perform();
--- a/platform/commonUI/edit/test/actions/PropertiesActionSpec.js
+++ b/platform/commonUI/edit/test/actions/PropertiesActionSpec.js
@@ -43,6 +43,7 @@ define(
                        },
                        hasFeature: jasmine.createSpy('hasFeature')
                    },
+                    persistence: jasmine.createSpyObj("persistence", ["persist"]),
                    mutation: jasmine.createSpy("mutation")
                };
                model = {};
@@ -77,18 +78,25 @@ define(
                action = new PropertiesAction(dialogService, context);
            });

+            it("persists when an action is performed", function () {
+                action.perform();
+                expect(capabilities.persistence.persist)
+                    .toHaveBeenCalled();
+            });
+
+            it("does not persist any changes upon cancel", function () {
+                input = undefined;
+                action.perform();
+                expect(capabilities.persistence.persist)
+                    .not.toHaveBeenCalled();
+            });
+
            it("mutates an object when performed", function () {
                action.perform();
                expect(capabilities.mutation).toHaveBeenCalled();
                capabilities.mutation.mostRecentCall.args[0]({});
            });

-            it("does not muate object upon cancel", function () {
-                input = undefined;
-                action.perform();
-                expect(capabilities.mutation).not.toHaveBeenCalled();
-            });
-
            it("is only applicable when a domain object is in context", function () {
                expect(PropertiesAction.appliesTo(context)).toBeTruthy();
                expect(PropertiesAction.appliesTo({})).toBeFalsy();
--- a/platform/commonUI/edit/test/actions/RemoveActionSpec.js
+++ b/platform/commonUI/edit/test/actions/RemoveActionSpec.js
@@ -37,6 +37,7 @@ define(
                mockGrandchildContext,
                mockRootContext,
                mockMutation,
+                mockPersistence,
                mockType,
                actionContext,
                model,
@@ -52,6 +53,8 @@ define(
            }

            beforeEach(function () {
+
+
                mockDomainObject = jasmine.createSpyObj(
                    "domainObject",
                    ["getId", "getCapability"]
@@ -85,6 +88,7 @@ define(
                mockGrandchildContext = jasmine.createSpyObj("context", ["getParent"]);
                mockRootContext = jasmine.createSpyObj("context", ["getParent"]);
                mockMutation = jasmine.createSpyObj("mutation", ["invoke"]);
+                mockPersistence = jasmine.createSpyObj("persistence", ["persist"]);
                mockType = jasmine.createSpyObj("type", ["hasFeature"]);
                mockNavigationService = jasmine.createSpyObj(
                    "navigationService",
@@ -105,6 +109,7 @@ define(

                capabilities = {
                    mutation: mockMutation,
+                    persistence: mockPersistence,
                    type: mockType
                };
                model = {
@@ -113,7 +118,7 @@ define(

                actionContext = { domainObject: mockDomainObject };

-                action = new RemoveAction(mockNavigationService, actionContext);
+                action = new RemoveAction(mockQ, mockNavigationService, actionContext);
            });

            it("only applies to objects with parents", function () {
@@ -149,6 +154,9 @@ define(
                // Should have removed "test" - that was our
                // mock domain object's id.
                expect(result.composition).toEqual(["a", "b"]);
+
+                // Finally, should have persisted
+                expect(mockPersistence.persist).toHaveBeenCalled();
            });

            it("removes parent of object currently navigated to", function () {
--- a/platform/commonUI/edit/test/actions/SaveActionSpec.js
+++ b/platform/commonUI/edit/test/actions/SaveActionSpec.js
@@ -19,7 +19,6 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global describe,it,expect,beforeEach,jasmine,waitsFor,runs*/

 define(
    ["../../src/actions/SaveAction"],
@@ -29,8 +28,7 @@ define(
            var mockDomainObject,
                mockEditorCapability,
                actionContext,
-                mockDialogService,
-                mockNotificationService,
+                dialogService,
                mockActionCapability,
                capabilities = {},
                action;
@@ -70,17 +68,11 @@ define(
                actionContext = {
                    domainObject: mockDomainObject
                };
-
-                mockDialogService = jasmine.createSpyObj(
+                dialogService = jasmine.createSpyObj(
                    "dialogService",
                    ["showBlockingMessage"]
                );

-                mockNotificationService = jasmine.createSpyObj(
-                    "notificationService",
-                    ["info", "error"]
-                );
-
                mockDomainObject.hasCapability.andReturn(true);
                mockDomainObject.getCapability.andCallFake(function (capability) {
                    return capabilities[capability];
@@ -89,7 +81,7 @@ define(
                mockEditorCapability.save.andReturn(mockPromise(true));
                mockEditorCapability.isEditContextRoot.andReturn(true);

-                action = new SaveAction(mockDialogService, mockNotificationService, actionContext);
+                action = new SaveAction(dialogService, actionContext);
            });

            it("only applies to domain object with an editor capability", function () {
@@ -113,54 +105,30 @@ define(
                    expect(mockEditorCapability.save).toHaveBeenCalled();
                });

-            describe("in order to keep the user in the loop", function () {
+            describe("a blocking dialog", function () {
                var mockDialogHandle;

                beforeEach(function () {
                    mockDialogHandle = jasmine.createSpyObj("dialogHandle", ["dismiss"]);
-                    mockDialogService.showBlockingMessage.andReturn(mockDialogHandle);
+                    dialogService.showBlockingMessage.andReturn(mockDialogHandle);
                });

+
                it("shows a dialog while saving", function () {
                    mockEditorCapability.save.andReturn(new Promise(function () {
                    }));
                    action.perform();
-                    expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
+                    expect(dialogService.showBlockingMessage).toHaveBeenCalled();
                    expect(mockDialogHandle.dismiss).not.toHaveBeenCalled();
                });

-                it("hides the dialog when saving is complete", function () {
+                it("hides a dialog when saving is complete", function () {
                    action.perform();
-                    expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
+                    expect(dialogService.showBlockingMessage).toHaveBeenCalled();
                    expect(mockDialogHandle.dismiss).toHaveBeenCalled();
                });
-
-                it("notifies if saving succeeded", function () {
-                    var mockCallback = jasmine.createSpy("callback");
-                    mockEditorCapability.save.andReturn(Promise.resolve("success"));
-                    action.perform().then(mockCallback);
-                    waitsFor(function () {
-                        return mockCallback.calls.length > 0;
-                    });
-                    runs(function () {
-                        expect(mockNotificationService.info).toHaveBeenCalled();
-                        expect(mockNotificationService.error).not.toHaveBeenCalled();
-                    });
-                });
-
-                it("notifies if saving failed", function () {
-                    var mockCallback = jasmine.createSpy("callback");
-                    mockEditorCapability.save.andReturn(Promise.reject("some failure reason"));
-                    action.perform().then(mockCallback);
-                    waitsFor(function () {
-                        return mockCallback.calls.length > 0;
-                    });
-                    runs(function () {
-                        expect(mockNotificationService.error).toHaveBeenCalled();
-                        expect(mockNotificationService.info).not.toHaveBeenCalled();
-                    });
-                });
            });
+
        });
    }
 );
--- a/platform/commonUI/edit/test/actions/SaveAndStopEditingActionSpec.js
+++ b/platform/commonUI/edit/test/actions/SaveAndStopEditingActionSpec.js
@@ -19,7 +19,6 @@
 * this source code distribution or the Licensing information page available
 * at runtime from the About dialog for additional information.
 *****************************************************************************/
-/*global describe,it,expect,beforeEach,jasmine*/

 define(
    ["../../src/actions/SaveAndStopEditingAction"],
@@ -36,7 +35,6 @@ define(
                mockEditorCapability,
                actionContext,
                dialogService,
-                notificationService,
                mockActionCapability,
                capabilities = {},
                action;
@@ -81,11 +79,6 @@ define(
                    ["showBlockingMessage"]
                );

-                notificationService = jasmine.createSpyObj(
-                    "notificationService",
-                    ["info", "error"]
-                );
-
                mockDomainObject.hasCapability.andReturn(true);
                mockDomainObject.getCapability.andCallFake(function (capability) {
                    return capabilities[capability];
@@ -94,7 +87,7 @@ define(
                mockEditorCapability.save.andReturn(mockPromise(true));
                mockEditorCapability.isEditContextRoot.andReturn(true);

-                action = new SaveAndStopEditingAction(dialogService, notificationService, actionContext);
+                action = new SaveAndStopEditingAction(dialogService, actionContext);
            });


--- a/platform/commonUI/edit/test/actions/SaveAsActionSpec.js
+++ b/platform/commonUI/edit/test/actions/SaveAsActionSpec.js
@@ -27,13 +27,11 @@ define(

        describe("The Save As action", function () {
            var mockDomainObject,
-                mockClonedObject,
                mockEditorCapability,
                mockActionCapability,
                mockObjectService,
                mockDialogService,
                mockCopyService,
-                mockNotificationService,
                mockParent,
                actionContext,
                capabilities = {},
@@ -59,8 +57,7 @@ define(
                    [
                        "getCapability",
                        "hasCapability",
-                        "getModel",
-                        "getId"
+                        "getModel"
                    ]
                );
                mockDomainObject.hasCapability.andReturn(true);
@@ -68,15 +65,6 @@ define(
                    return capabilities[capability];
                });
                mockDomainObject.getModel.andReturn({location: 'a', persisted: undefined});
-                mockDomainObject.getId.andReturn(0);
-
-                mockClonedObject = jasmine.createSpyObj(
-                    "clonedObject",
-                    [
-                        "getId"
-                    ]
-                );
-                mockClonedObject.getId.andReturn(1);

                mockParent = jasmine.createSpyObj(
                    "parentObject",
@@ -123,27 +111,12 @@ define(
                        "perform"
                    ]
                );
-                mockCopyService.perform.andReturn(mockPromise(mockClonedObject));
-
-                mockNotificationService = jasmine.createSpyObj(
-                    "notificationService",
-                    [
-                        "info",
-                        "error"
-                    ]
-                );

                actionContext = {
                    domainObject: mockDomainObject
                };

-                action = new SaveAsAction(
-                    undefined,
-                    undefined,
-                    mockDialogService,
-                    mockCopyService,
-                    mockNotificationService,
-                    actionContext);
+                action = new SaveAsAction(undefined, undefined, mockDialogService, mockCopyService, actionContext);

                spyOn(action, "getObjectService");
                action.getObjectService.andReturn(mockObjectService);
@@ -213,7 +186,7 @@ define(
                expect(mockDialogService.getUserInput).toHaveBeenCalled();
            });

-            describe("in order to keep the user in the loop", function () {
+            describe("a blocking dialog", function () {
                var mockDialogHandle;

                beforeEach(function () {
@@ -221,14 +194,14 @@ define(
                    mockDialogService.showBlockingMessage.andReturn(mockDialogHandle);
                });

-                it("shows a blocking dialog indicating that saving is in progress", function () {
+                it("indicates that a save is taking place", function () {
                    mockEditorCapability.save.andReturn(new Promise(function () {}));
                    action.perform();
                    expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
                    expect(mockDialogHandle.dismiss).not.toHaveBeenCalled();
                });

-                it("hides the blocking dialog after saving finishes", function () {
+                it("is hidden after saving", function () {
                    var mockCallback = jasmine.createSpy();
                    action.perform().then(mockCallback);
                    expect(mockDialogService.showBlockingMessage).toHaveBeenCalled();
@@ -239,31 +212,6 @@ define(
                        expect(mockDialogHandle.dismiss).toHaveBeenCalled();
                    });
                });
-
-                it("notifies if saving succeeded", function () {
-                    var mockCallback = jasmine.createSpy();
-                    action.perform().then(mockCallback);
-                    waitsFor(function () {
-                        return mockCallback.calls.length > 0;
-                    });
-                    runs(function () {
-                        expect(mockNotificationService.info).toHaveBeenCalled();
-                        expect(mockNotificationService.error).not.toHaveBeenCalled();
-                    });
-                });
-
-                it("notifies if saving failed", function () {
-                    mockCopyService.perform.andReturn(Promise.reject("some failure reason"));
-                    var mockCallback = jasmine.createSpy();
-                    action.perform().then(mockCallback);
-                    waitsFor(function () {
-                        return mockCallback.calls.length > 0;
-                    });
-                    runs(function () {
-                        expect(mockNotificationService.error).toHaveBeenCalled();
-                        expect(mockNotificationService.info).not.toHaveBeenCalled();
-                    });
-                });
            });
        });
    }
--- a/platform/commonUI/edit/test/controllers/EditActionControllerSpec.js
+++ b/platform/commonUI/edit/test/controllers/EditActionControllerSpec.js
@@ -28,7 +28,7 @@ define(
        describe("The Edit Action controller", function () {
            var mockSaveActionMetadata = {
                name: "mocked-save-action",
-                cssClass: "mocked-save-action-css"
+                cssclass: "mocked-save-action-css"
            };

            function fakeGetActions(actionContext) {
@@ -86,7 +86,7 @@ define(
                expect(menuOptions[1].key).toEqual(mockScope.saveActions[1]);
                menuOptions.forEach(function (option) {
                    expect(option.name).toEqual(mockSaveActionMetadata.name);
-                    expect(option.cssClass).toEqual(mockSaveActionMetadata.cssClass);
+                    expect(option.cssclass).toEqual(mockSaveActionMetadata.cssclass);
                });
            });

--- a/platform/commonUI/edit/test/controllers/EditObjectControllerSpec.js
+++ b/platform/commonUI/edit/test/controllers/EditObjectControllerSpec.js
@@ -24,19 +24,32 @@ define(
    ["../../src/controllers/EditObjectController"],
    function (EditObjectController) {

-        describe("The Edit Object controller", function () {
+        describe("The Edit mode controller", function () {
            var mockScope,
                mockObject,
-                testViews,
-                mockEditorCapability,
+                mockType,
                mockLocation,
-                mockNavigationService,
-                removeCheck,
                mockStatusCapability,
                mockCapabilities,
+                mockPolicyService,
                controller;

+            // Utility function; look for a $watch on scope and fire it
+            function fireWatch(expr, value) {
+                mockScope.$watch.calls.forEach(function (call) {
+                    if (call.args[0] === expr) {
+                        call.args[1](value);
+                    }
+                });
+            }
+
            beforeEach(function () {
+                mockPolicyService = jasmine.createSpyObj(
+                    "policyService",
+                    [
+                        "allow"
+                    ]
+                );
                mockScope = jasmine.createSpyObj(
                    "$scope",
                    ["$on", "$watch"]
@@ -45,16 +58,16 @@ define(
                    "domainObject",
                    ["getId", "getModel", "getCapability", "hasCapability", "useCapability"]
                );
-                mockEditorCapability = jasmine.createSpyObj(
-                    "mockEditorCapability",
-                    ["isEditContextRoot", "dirty", "finish"]
+                mockType = jasmine.createSpyObj(
+                    "type",
+                    ["hasFeature"]
                );
                mockStatusCapability = jasmine.createSpyObj('statusCapability',
                    ["get"]
                );

                mockCapabilities = {
-                    "editor" : mockEditorCapability,
+                    "type" : mockType,
                    "status": mockStatusCapability
                };

@@ -62,70 +75,52 @@ define(
                    ["search"]
                );
                mockLocation.search.andReturn({"view": "fixed"});
-                mockNavigationService = jasmine.createSpyObj('navigationService',
-                    ["checkBeforeNavigation"]
-                );
-
-                removeCheck = jasmine.createSpy('removeCheck');
-                mockNavigationService.checkBeforeNavigation.andReturn(removeCheck);

                mockObject.getId.andReturn("test");
                mockObject.getModel.andReturn({ name: "Test object" });
                mockObject.getCapability.andCallFake(function (key) {
                    return mockCapabilities[key];
                });
-
-                testViews = [
-                    { key: 'abc' },
-                    { key: 'def', someKey: 'some value' },
-                    { key: 'xyz' }
-                ];
-
-                mockObject.useCapability.andCallFake(function (c) {
-                    return (c === 'view') && testViews;
-                });
-                mockLocation.search.andReturn({ view: 'def' });
+                mockType.hasFeature.andReturn(true);

                mockScope.domainObject = mockObject;

                controller = new EditObjectController(
                    mockScope,
                    mockLocation,
-                    mockNavigationService
+                    mockPolicyService
                );
            });

-            it("adds a check before navigation", function () {
-                expect(mockNavigationService.checkBeforeNavigation)
-                    .toHaveBeenCalledWith(jasmine.any(Function));
+            it("exposes a warning message for unload", function () {
+                var errorMessage = "Unsaved changes";

-                var checkFn = mockNavigationService.checkBeforeNavigation.mostRecentCall.args[0];
+                // Normally, should be undefined
+                expect(controller.getUnloadWarning()).toBeUndefined();

-                mockEditorCapability.isEditContextRoot.andReturn(false);
-                mockEditorCapability.dirty.andReturn(false);
-
-                expect(checkFn()).toBe(false);
-
-                mockEditorCapability.isEditContextRoot.andReturn(true);
-                expect(checkFn()).toBe(false);
-
-                mockEditorCapability.dirty.andReturn(true);
-                expect(checkFn())
-                    .toBe("Continuing will cause the loss of any unsaved changes.");
+                // Override the policy service to prevent navigation
+                mockPolicyService.allow.andCallFake(function (category, object, context, callback) {
+                    callback(errorMessage);
+                });

+                // Should have some warning message here now
+                expect(controller.getUnloadWarning()).toEqual(errorMessage);
            });

-            it("cleans up on destroy", function () {
-                expect(mockScope.$on)
-                    .toHaveBeenCalledWith("$destroy", jasmine.any(Function));
-
-                mockScope.$on.mostRecentCall.args[1]();
-
-                expect(mockEditorCapability.finish).toHaveBeenCalled();
-                expect(removeCheck).toHaveBeenCalled();
-            });

            it("sets the active view from query parameters", function () {
+                var testViews = [
+                        { key: 'abc' },
+                        { key: 'def', someKey: 'some value' },
+                        { key: 'xyz' }
+                    ];
+
+                mockObject.useCapability.andCallFake(function (c) {
+                    return (c === 'view') && testViews;
+                });
+                mockLocation.search.andReturn({ view: 'def' });
+
+                fireWatch('domainObject', mockObject);
                expect(mockScope.representation.selected)
                    .toEqual(testViews[1]);
            });
--- a/platform/commonUI/edit/test/creation/AddActionProviderSpec.js
+++ b/platform/commonUI/edit/test/creation/AddActionProviderSpec.js
@@ -31,7 +31,9 @@ define(
            var mockTypeService,
                mockDialogService,
                mockPolicyService,
-                mockTypeMap,
+                mockCreationPolicy,
+                mockCompositionPolicy,
+                mockPolicyMap = {},
                mockTypes,
                mockDomainObject,
                mockQ,
@@ -53,33 +55,49 @@ define(
                );
                mockType.hasFeature.andReturn(true);
                mockType.getName.andReturn(name);
-                mockType.getKey.andReturn(name);
                return mockType;
            }

            beforeEach(function () {
                mockTypeService = jasmine.createSpyObj(
                    "typeService",
-                    ["getType"]
+                    ["listTypes"]
+                );
+                mockDialogService = jasmine.createSpyObj(
+                    "dialogService",
+                    ["getUserInput"]
+                );
+                mockPolicyService = jasmine.createSpyObj(
+                    "policyService",
+                    ["allow"]
                );
-                mockDialogService = {};
-                mockPolicyService = {};
-                mockDomainObject = {};

-                mockTypes = [
-                    "timeline",
-                    "activity",
-                    "other"
-                ].map(createMockType);
-                mockTypeMap = {};
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    ["getCapability"]
+                );
+
+                //Mocking getCapability because AddActionProvider uses the
+                // type capability of the destination object.
+                mockDomainObject.getCapability.andReturn({});
+
+                mockTypes = ["A", "B", "C"].map(createMockType);

                mockTypes.forEach(function (type) {
-                    mockTypeMap[type.getKey()] = type;
+                    mockPolicyMap[type.getName()] = true;
                });

-                mockTypeService.getType.andCallFake(function (key) {
-                    return mockTypeMap[key];
-                });
+                mockCreationPolicy = function (type) {
+                    return mockPolicyMap[type.getName()];
+                };
+
+                mockCompositionPolicy = function () {
+                    return true;
+                };
+
+                mockPolicyService.allow.andReturn(true);
+
+                mockTypeService.listTypes.andReturn(mockTypes);

                provider = new AddActionProvider(
                    mockQ,
@@ -89,16 +107,29 @@ define(
                );
            });

-            it("provides actions for timeline and activity", function () {
-                var actions = provider.getActions({
+            it("checks for creatability", function () {
+                provider.getActions({
                    key: "add",
                    domainObject: mockDomainObject
                });
-                expect(actions.length).toBe(2);
-                expect(actions[0].metadata.type).toBe('timeline');
-                expect(actions[1].metadata.type).toBe('activity');
-
                // Make sure it was creation which was used to check
+                expect(mockPolicyService.allow)
+                    .toHaveBeenCalledWith("creation", mockTypes[0]);
+            });
+
+            it("checks for composability of type", function () {
+                provider.getActions({
+                    key: "add",
+                    domainObject: mockDomainObject
+                });
+
+                expect(mockPolicyService.allow).toHaveBeenCalledWith(
+                    "composition",
+                    jasmine.any(Object),
+                    jasmine.any(Object)
+                );
+
+                expect(mockDomainObject.getCapability).toHaveBeenCalledWith('type');
            });
        });
    }
--- a/platform/commonUI/edit/test/creation/CreateActionSpec.js
+++ b/platform/commonUI/edit/test/creation/CreateActionSpec.js
@@ -138,7 +138,7 @@ define(

                expect(metadata.name).toEqual("Test");
                expect(metadata.description).toEqual("a test type");
-                expect(metadata.cssClass).toEqual("icon-telemetry");
+                expect(metadata.cssclass).toEqual("icon-telemetry");
            });

            describe("the perform function", function () {
--- a/platform/commonUI/edit/test/creation/CreateWizardSpec.js
+++ b/platform/commonUI/edit/test/creation/CreateWizardSpec.js
@@ -161,7 +161,6 @@ define(
                        'otherType',
                        ['getKey']
                    ),
-
                    //Create a form structure with location
                    structure = wizard.getFormStructure(true),
                    sections = structure.sections,
@@ -175,8 +174,8 @@ define(
                // can actually contain objects of this type
                expect(mockPolicyService.allow).toHaveBeenCalledWith(
                    'composition',
-                    mockDomainObj,
-                    mockDomainObject
+                    mockOtherType,
+                    mockType
                );
            });

--- a/Show More
+++ b/Show More