Refactoring MutableObject

* Include all bundles in artifact

change bundle registry such that all bundles are immediately registered,
but must be specifically enabled.  A default registry class enables bundles
that make sense for demonstration purposes.

Added methods to the registry to allow enabling and disabling of bundles
without having to load additional files.

* support alternate asset/worker paths

Change the gulp glob for assets to copy over a more minimal
set of files-- only css, fonts, and images.  Results in a
smaller distributable archive.

Update stylesheet loader to use a constant for the assets path.

This can be customized at run time via MCT.setAssetPath() to
allow MCT to be hosted in various locations.

Update worker loader to support loading workers from blobs to
support packaging as standalone file.

* Load templates via requirejs

* [gulp] lazy-require where reasonable

Require things right before starting tasks to reduce gulp start up time.

* document setAssetPath

API.md

@@ -0,0 +1,114 @@
+# Open MCT API
+
+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.
+
+Open MCT supports AMD, CommonJS, and standard browser loading; it's easy to use
+in your project.
+
+## Overview
+
+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.  
+
+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. 
+
+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.
+
+And then we have Views.  Views allow you to visualize a domain object.  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.
+
+## The API
+
+### `MCT.Type(options)`
+Status: First Draft
+
+Returns a `typeInstance`.  `options` is an object supporting the following properties:
+
+* `metadata`: `object` defining metadata used in displaying the object; has the following properties:
+  * `label`: `string`, the human-readible name of the type.  used in menus and inspector.
+  * `glyph`: `string`, the name of the icon to display for this type, used in labels.
+  * `description`: `string`, a human readible description of the object and what it is for.
+* `initialize`: `function` which initializes new instances of this type.  it is called with an object, should add any default properties to that object.
+* `creatable`: `boolean`, if true, this object will be visible in the create menu.
+* `form`: `Array` an array of form fields, as defined... somewhere!  Generates a property sheet that is visible while editing this object.
+
+### `MCT.type(typeKey, typeInstance)`
+Status: First Draft
+
+Register a `typeInstance` with a given Type `key` (a `string`).  There can only be one `typeInstance` registered per type `key`.  typeInstances must be registered before they can be utilized.
+
+### `MCT.Objects`
+Status: First Draft
+
+Allows you to register object providers, which allows you to integrate domain objects from various different sources.  Also implements methods for mutation and persistence of objects.  See [Object API](src/api/objects/README.md) for more details.
+
+### `MCT.Composition`
+Status: First Draft
+
+Objects can contain other objects, and the Composition API allows you to fetch the composition of any given domain object, or implement custom methods for defining composition as necessary.  
+
+### `MCT.view(region, definition)`
+Status: First Draft
+
+Register a view factory for a specific region.  View factories receive an instance of a domain object and return a `View` for that object, or return undefined if they do not know how to generate a view for that object.
+
+* `ViewDefinition`: an object with the following properties:
+    * `canView(domainObject)`: should return truthy if the view is valid for a given domain object, falsy if it is not capable of generating a view for that object.
+    * `view(domainObject)`: should instantate and return a `View` for the given object.
+    * `metadata()`: a function that returns metadata about this view.  Optional.
+* `View`: an object containing a number of lifecycle methods:
+    * `view.show(container)`:  instantiate a view (a set of dom elements) and attach it to the container.
+    * `view.destroy(container)`:  remove any listeners and expect your dom elements to be destroyed.
+    
+For a basic introduction to views & types, check out these tutorials: 
+
+* [custom-view](custom-view.html) -- Implementing a custom view with vanilla javascript.
+* [custom-view-react](custom-view-react.html) -- Implementing a custom view with React.
+
+### `MCT.conductor`
+Status: First Draft
+
+The time conductor is an API that facilitates time synchronization across multiple components.  Components that would like to be "time aware" may attach listeners to the time conductor API to allow them to remain synchronized with other components.  For more information ont he time conductor API, please look at the API draft here: https://github.com/nasa/openmct/blob/66220b89ca568075f107505ba414de9457dc0427/platform/features/conductor-redux/src/README.md
+
+### `MCT.selection`
+Status: First Draft
+
+Tracks the application's selection state (which elements of a view has a user selected?)
+
+One or more JavaScript objects may be selected at any given time. User code is responsible for any necessary type-checking.
+
+The following methods are exposed from this object:
+
+* `select(value)`: Add `value` to the current selection.
+* `deselect(value)`: Remove `value` from the current selection.
+* `selected()`: Get array of all selected objects.
+* `clear()`: Deselect all selected objects.
+
+MCT.selection is an EventEmitter; a `change` event is emitted whenever the selection changes.
+
+### `MCT.systems`
+Status: Not Implemented, Needs to be ported from old system.
+
+A registry for different time system definitions.  Based upon the previous time format system which utilized the "formats" extension category.  
+
+### `MCT.run([container])`
+Status: Stable Draft
+
+Run the MCT application, loading the application into the `container`, a DOM element.  If a container is not specified, the application is injected into the body of the page.
+
+### `MCT.install(plugin)`
+Status: Stable Draft
+
+Install a plugin in MCT.  Must be called before calling `run`.  Plugins are functions which are invoked with the `MCT` instance as their first argument, and are expected to use the MCT public API to add functionality.
+
+For an example of writing a plugin, check out [plugin-example.html](plugin-example.html)
+
+### `MCT.setAssetPath(path)`
+
+Sets the path (absolute or relative) at which the Open MCT static files are being hosted.  The default value is '.'.  
+
+Note that this API is transitional and will be removed in a future version.
+

bower.json

@@ -18,6 +18,9 @@
     "node-uuid": "^1.4.7",
     "comma-separated-values": "^3.6.4",
     "FileSaver.js": "^0.0.2",
-    "zepto": "^1.1.6"
+    "zepto": "^1.1.6",
+    "eventemitter3": "^1.2.0",
+    "lodash": "3.10.1",
+    "almond": "~0.3.2"
   }
 }

composition-test.html

@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a composition provider</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    var widgetParts = ['foo', 'bar', 'baz', 'bing', 'frobnak']
+
+    function fabricateName() {
+        return [
+            widgetParts[Math.floor(Math.random() * widgetParts.length)],
+            widgetParts[Math.floor(Math.random() * widgetParts.length)],
+            Math.floor(Math.random() * 1000)
+        ].join('_');
+    }
+
+    MCT.type('example.widget-factory', new MCT.Type({
+        metadata: {
+            label: "Widget Factory",
+            glyph: "s",
+            description: "A factory for making widgets"
+        },
+        initialize: function (object) {
+            object.widgetCount = 5;
+            object.composition = [];
+        },
+        creatable: true,
+        form: [
+            {
+                name: "Widget Count",
+                control: "textfield",
+                key: "widgetCount",
+                property: "widgetCount",
+                required: true
+            }
+        ]
+    }));
+
+    MCT.Composition.addProvider({
+        appliesTo: function (domainObject) {
+            return domainObject.type === 'example.widget-factory';
+        },
+        load: function (domainObject) {
+            var widgets = [];
+            while (widgets.length < domainObject.widgetCount) {
+                widgets.push({
+                    name: fabricateName(),
+                    key: {
+                        namespace: 'widget-factory',
+                        identifier: '' + widgets.length
+                    }
+                });
+            }
+            return Promise.resolve(widgets);
+        }
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

custom-view-react.html

@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a Custom Type and View </title>
+  <script src="dist/main.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.2.1/react.js"></script>
+      <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.2.1/react-dom.js"></script>
+      <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-core/5.8.34/browser.min.js"></script>
+</head>
+<body>
+<script type="text/babel">
+
+    // First, we're going to create the Todo List type, so that users can create
+    // todo lists.
+
+    MCT.type('example.todo', new MCT.Type({
+        metadata: {
+            label: "To-Do List",
+            glyph: "2",
+            description: "A list of things that need to be done."
+        },
+        initialize: function (object) {
+            object.tasks = [
+                { description: "This is a task." }
+            ];
+        },
+        creatable: true
+    }));
+
+    /*
+    Refresh the page, and you should be able to create new Todo Lists.
+    unfortunately, when you navigate to a Todo list, you see a blank page. let's
+    fix that by adding a main view for that todo list.
+
+    If you're wondering why this is commented out, well, it's because we'll
+    write a new version later.
+    */
+
+    var Task = React.createClass({
+      render: function() {
+        return (
+            <li>
+                <input type="checkbox"
+                       checked={this.props.checked}/>
+                <span>{this.props.description}</span>
+            </li>
+        );
+      }
+    });
+
+    var TaskList = React.createClass({
+        render: function () {
+            var taskNodes = this.props.tasks.map(function(task) {
+                return (
+                    <Task checked={task.checked}
+                          description={task.description}/>
+                );
+            });
+            return (
+              <ul>
+                {taskNodes}
+              </ul>
+            );
+        }
+    });
+
+    MCT.view(MCT.regions.main, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            return {
+                show: function (container) {
+                    ReactDOM.render(
+                        <TaskList tasks={domainObject.tasks}/>,
+                        container
+                    );
+                    mutableObject.on('tasks', function (tasks) {
+                        ReactDOM.render(
+                            <TaskList tasks={tasks}/>,
+                            container
+                        );
+                    });
+                }
+            };
+        }
+    });
+
+    /*
+     Refresh the page and you should see a todo list with checkboxes!  Now let's
+     Allow you to add tasks by mutating the object.  We'll add a toolbar view to
+     do this.
+    */
+
+    var TaskToolbar = React.createClass({
+        render: function () {
+            return (
+                <button onClick={this.props.addTask}>Add Task</button>
+            );
+        }
+    });
+
+    MCT.view(MCT.regions.toolbar, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function addTask(event) {
+                var description = prompt('Task description');
+                var tasks = mutableObject.get('tasks');
+                tasks.push({
+                    description: description,
+                    complete: false
+                });
+                mutableObject.set('tasks', tasks);
+            }
+
+            return {
+                show: function (container) {
+                    ReactDOM.render(
+                        <TaskToolbar addTask={addTask}/>,
+                        container
+                    );
+                },
+            }
+        }
+    });
+
+    /*
+     Refresh the page, edit the todo list, and you'll have a button that allows
+     you to add tasks!  Unfortunately, new tasks don't show in the list.  Why?
+     Well, if your view should update on mutation, you need to set up the correct
+     listeners.  Let's update the TodoView we made earlier:
+    */
+
+    MCT.run();
+</script>
+</body>
+</html>

custom-view.html

@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a Custom Type and View </title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    // First, we're going to create the Todo List type, so that users can create
+    // todo lists.
+
+    MCT.type('example.todo', new MCT.Type({
+        metadata: {
+            label: "To-Do List",
+            glyph: "2",
+            description: "A list of things that need to be done."
+        },
+        initialize: function (object) {
+            object.tasks = [
+                { description: "This is a task." }
+            ];
+        },
+        creatable: true
+    }));
+
+    /*
+    Refresh the page, and you should be able to create new Todo Lists.
+    unfortunately, when you navigate to a Todo list, you see a blank page. let's
+    fix that by adding a main view for that todo list.
+
+    If you're wondering why this is commented out, well, it's because we'll
+    write a new version later.
+    */
+
+    // MCT.view(MCT.regions.main, {
+    //     canView: function (domainObject) {
+    //         return domainObject.type === 'example.todo';
+    //     },
+    //     view: function (domainObject) {
+    //         function renderTask(task) {
+    //             return [
+    //                 '<li>',
+    //                 '<input type="checkbox"' + (task.complete ? ' checked="true"' : '') + '>',
+    //                 '<span>' + task.description + '</span>',
+    //                 '</li>'
+    //             ].join('');
+    //         };
+    //
+    //         function renderTaskList() {
+    //             return [
+    //                 '<ul>',
+    //                 domainObject.tasks.map(renderTask).join(''),
+    //                 '</ul>'
+    //             ].join('');
+    //         };
+    //
+    //         return {
+    //             show: function (container) {
+    //                 container.innerHTML = renderTaskList();
+    //             }
+    //         };
+    //     }
+    // });
+
+    /*
+     Refresh the page and you should see a todo list with checkboxes!  Now let's
+     Allow you to add tasks by mutating the object.  We'll add a toolbar view to
+     do this.
+    */
+
+    MCT.view(MCT.regions.toolbar, {
+        canView: function (domainObject) {
+            return domainObject.type === 'example.todo';
+        },
+        view: function (domainObject) {
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function addTask(event) {
+                var description = prompt('Task description');
+                var tasks = mutableObject.get('tasks');
+                tasks.push({
+                    description: description,
+                    complete: false
+                });
+                mutableObject.set('tasks', tasks);
+            }
+
+            return {
+                show: function (container) {
+                    container.addEventListener('click', addTask);
+                    container.innerHTML = '<button>Add Task</button>';
+                },
+                destroy: function (container) {
+                    container.removeEventListener('click', addTask);
+                }
+            }
+        }
+    });
+
+    /*
+     Refresh the page, edit the todo list, and you'll have a button that allows
+     you to add tasks!  Unfortunately, new tasks don't show in the list.  Why?
+     Well, if your view should update on mutation, you need to set up the correct
+     listeners.  Let's update the TodoView we made earlier:
+    */
+
+    MCT.view(MCT.regions.main, {
+        canView: function(domainObject) {
+            return domainObject.type === 'example.todo'
+        },
+        view: function (domainObject) {
+
+            var mutableObject = MCT.Objects.getMutable(domainObject);
+
+            function renderTask(task) {
+                return [
+                    '<li>',
+                    '<input type="checkbox"' + (task.complete ? ' checked="true"' : '') + '>',
+                    '<span>' + task.description + '</span>',
+                    '</li>'
+                ].join('');
+            }
+
+            function renderTaskList(tasks) {
+                return [
+                    '<ul>',
+                    tasks.map(renderTask).join(''),
+                    '</ul>'
+                ].join('');
+            }
+
+            function onCheckboxChange(event) {
+                var checkbox = event.target;
+                var taskEl = checkbox.parentNode;
+                var taskList = taskEl.parentNode;
+                var taskIndex = [].slice.apply(taskList.children).indexOf(taskEl);
+                mutableObject.set('tasks[' + taskIndex + '].complete', checkbox.checked);
+            }
+
+            return {
+                show: function (container) {
+                    container.innerHTML = renderTaskList(domainObject.tasks);
+                    mutableObject.on('tasks', function (tasks) {
+                        container.innerHTML = renderTaskList(tasks);
+                    });
+                    container.addEventListener('change', onCheckboxChange);
+                },
+                destroy: function () {
+                    mutableObject.stopListening();
+                }
+            };
+        }
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

example/msl/bundle.js

@@ -36,7 +36,7 @@ define([
     legacyRegistry
 ) {
     "use strict";
-    legacyRegistry.register("example/notifications", {
+    legacyRegistry.register("example/msl-adapter", {
         "name" : "Mars Science Laboratory Data Adapter",
         "extensions" : {
         "types": [

gulpfile.js

@@ -21,40 +21,33 @@
  *****************************************************************************/
 
 /*global require,__dirname*/
+
 var gulp = require('gulp'),
-    requirejsOptimize = require('gulp-requirejs-optimize'),
     sourcemaps = require('gulp-sourcemaps'),
-    rename = require('gulp-rename'),
-    sass = require('gulp-sass'),
-    bourbon = require('node-bourbon'),
-    jshint = require('gulp-jshint'),
-    jscs = require('gulp-jscs'),
-    replace = require('gulp-replace-task'),
-    karma = require('karma'),
     path = require('path'),
     fs = require('fs'),
     git = require('git-rev-sync'),
     moment = require('moment'),
-    merge = require('merge-stream'),
     project = require('./package.json'),
     _ = require('lodash'),
     paths = {
         main: 'main.js',
         dist: 'dist',
-        assets: 'dist/assets',
         scss: ['./platform/**/*.scss', './example/**/*.scss'],
+        assets: [
+            './{example,platform}/**/*.{css,css.map,png,svg,ico,woff,eot,ttf}'
+        ],
         scripts: [ 'main.js', 'platform/**/*.js', 'src/**/*.js' ],
         specs: [ 'platform/**/*Spec.js', 'src/**/*Spec.js' ],
-        static: [
-            'index.html',
-            'platform/**/*',
-            'example/**/*',
-            'bower_components/**/*'
-        ]
     },
     options = {
         requirejsOptimize: {
-            name: paths.main.replace(/\.js$/, ''),
+            name: 'bower_components/almond/almond.js',
+            include: paths.main.replace('.js', ''),
+            wrap: {
+                startFile: "src/start.frag",
+                endFile: "src/end.frag"
+            },
             mainConfigFile: paths.main,
             wrapShim: true
         },
@@ -63,7 +56,6 @@ var gulp = require('gulp'),
             singleRun: true
         },
         sass: {
-            includePaths: bourbon.includePaths,
             sourceComments: true
         },
         replace: {
@@ -77,6 +69,8 @@ var gulp = require('gulp'),
     };
 
 gulp.task('scripts', function () {
+    var requirejsOptimize = require('gulp-requirejs-optimize');
+    var replace = require('gulp-replace-task');
     return gulp.src(paths.main)
         .pipe(sourcemaps.init())
         .pipe(requirejsOptimize(options.requirejsOptimize))
@@ -86,10 +80,16 @@ gulp.task('scripts', function () {
 });
 
 gulp.task('test', function (done) {
+    var karma = require('karma');
     new karma.Server(options.karma, done).start();
 });
 
 gulp.task('stylesheets', function () {
+    var sass = require('gulp-sass');
+    var rename = require('gulp-rename');
+    var bourbon = require('node-bourbon');
+    options.sass.includePaths = bourbon.includePaths;
+
     return gulp.src(paths.scss, {base: '.'})
         .pipe(sourcemaps.init())
         .pipe(sass(options.sass).on('error', sass.logError))
@@ -103,6 +103,9 @@ gulp.task('stylesheets', function () {
 });
 
 gulp.task('lint', function () {
+    var jshint = require('gulp-jshint');
+    var merge = require('merge-stream');
+
     var nonspecs = paths.specs.map(function (glob) {
             return "!" + glob;
         }),
@@ -117,6 +120,8 @@ gulp.task('lint', function () {
 });
 
 gulp.task('checkstyle', function () {
+    var jscs = require('gulp-jscs');
+
     return gulp.src(paths.scripts)
         .pipe(jscs())
         .pipe(jscs.reporter())
@@ -124,18 +129,20 @@ gulp.task('checkstyle', function () {
 });
 
 gulp.task('fixstyle', function () {
+    var jscs = require('gulp-jscs');
+
     return gulp.src(paths.scripts, { base: '.' })
         .pipe(jscs({ fix: true }))
         .pipe(gulp.dest('.'));
 });
 
-gulp.task('static', ['stylesheets'], function () {
-    return gulp.src(paths.static, { base: '.' })
+gulp.task('assets', ['stylesheets'], function () {
+    return gulp.src(paths.assets)
         .pipe(gulp.dest(paths.dist));
 });
 
 gulp.task('watch', function () {
-    gulp.watch(paths.scss, ['stylesheets']);
+    return gulp.watch(paths.scss, ['stylesheets', 'assets']);
 });
 
 gulp.task('serve', function () {
@@ -143,9 +150,9 @@ gulp.task('serve', function () {
     var app = require('./app.js');
 });
 
-gulp.task('develop', ['serve', 'stylesheets', 'watch']);
+gulp.task('develop', ['serve', 'install', 'watch']);
 
-gulp.task('install', [ 'static', 'scripts' ]);
+gulp.task('install', [ 'assets', 'scripts' ]);
 
 gulp.task('verify', [ 'lint', 'test', 'checkstyle' ]);
 

index.html

@@ -31,10 +31,14 @@
     <script type="text/javascript">
         require(['main'], function (mct) {
             require([
+                './tutorials/todo/todo',
                 './example/imagery/bundle',
                 './example/eventGenerator/bundle',
                 './example/generator/bundle'
-            ], mct.run.bind(mct));
+            ], function (TodoPlugin) {
+                mct.install(TodoPlugin);
+                mct.run();
+            })
         });
     </script>
     <link rel="stylesheet" href="platform/commonUI/general/res/css/startup-base.css">
@@ -48,7 +52,5 @@
     <div class="l-splash-holder s-splash-holder">
         <div class="l-splash s-splash"></div>
     </div>
-
-    <div ng-view></div>
 </body>
 </html>

main.js

@@ -28,13 +28,15 @@ requirejs.config({
         "angular-route": "bower_components/angular-route/angular-route.min",
         "csv": "bower_components/comma-separated-values/csv.min",
         "es6-promise": "bower_components/es6-promise/promise.min",
+        "EventEmitter": "bower_components/eventemitter3/index",
         "moment": "bower_components/moment/moment",
         "moment-duration-format": "bower_components/moment-duration-format/lib/moment-duration-format",
         "saveAs": "bower_components/FileSaver.js/FileSaver.min",
         "screenfull": "bower_components/screenfull/dist/screenfull.min",
         "text": "bower_components/text/text",
         "uuid": "bower_components/node-uuid/uuid",
-        "zepto": "bower_components/zepto/zepto.min"
+        "zepto": "bower_components/zepto/zepto.min",
+        "lodash": "bower_components/lodash/lodash"
     },
     "shim": {
         "angular": {
@@ -43,6 +45,9 @@ requirejs.config({
         "angular-route": {
             "deps": ["angular"]
         },
+        "EventEmitter": {
+            "exports": "EventEmitter"
+        },
         "moment-duration-format": {
             "deps": ["moment"]
         },
@@ -51,53 +56,32 @@ requirejs.config({
         },
         "zepto": {
             "exports": "Zepto"
+        },
+        "lodash": {
+            "exports": "lodash"
         }
     }
 });
 
 define([
     './platform/framework/src/Main',
-    'legacyRegistry',
+    './src/defaultRegistry',
+    './src/MCT'
+], function (Main, defaultRegistry, MCT) {
+    var mct = new MCT();
 
-    './platform/framework/bundle',
-    './platform/core/bundle',
-    './platform/representation/bundle',
-    './platform/commonUI/about/bundle',
-    './platform/commonUI/browse/bundle',
-    './platform/commonUI/edit/bundle',
-    './platform/commonUI/dialog/bundle',
-    './platform/commonUI/formats/bundle',
-    './platform/commonUI/general/bundle',
-    './platform/commonUI/inspect/bundle',
-    './platform/commonUI/mobile/bundle',
-    './platform/commonUI/themes/espresso/bundle',
-    './platform/commonUI/notification/bundle',
-    './platform/containment/bundle',
-    './platform/execution/bundle',
-    './platform/exporters/bundle',
-    './platform/telemetry/bundle',
-    './platform/features/clock/bundle',
-    './platform/features/imagery/bundle',
-    './platform/features/layout/bundle',
-    './platform/features/pages/bundle',
-    './platform/features/plot/bundle',
-    './platform/features/timeline/bundle',
-    './platform/features/table/bundle',
-    './platform/forms/bundle',
-    './platform/identity/bundle',
-    './platform/persistence/aggregator/bundle',
-    './platform/persistence/local/bundle',
-    './platform/persistence/queue/bundle',
-    './platform/policy/bundle',
-    './platform/entanglement/bundle',
-    './platform/search/bundle',
-    './platform/status/bundle',
-    './platform/commonUI/regions/bundle'
-], function (Main, legacyRegistry) {
-    return {
-        legacyRegistry: legacyRegistry,
-        run: function () {
-            return new Main().run(legacyRegistry);
-        }
+    mct.legacyRegistry = defaultRegistry;
+    mct.run = function (domElement) {
+        if (!domElement) { domElement = document.body; }
+        var appDiv = document.createElement('div');
+        appDiv.setAttribute('ng-view', '');
+        appDiv.className = 'user-environ';
+        domElement.appendChild(appDiv);
+        mct.start();
     };
+    mct.on('start', function () {
+        return new Main().run(defaultRegistry);
+    });
+
+    return mct;
 });

object-provider.html

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Groot Tutorial</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    // First, we need a source of objects, so we're going to define a few
+    // objects that we wish to expose.  The first object is a folder which
+    // contains the other objects.
+
+
+    var GROOT_ROOT = {
+        name: 'I am groot',
+        type: 'folder',
+        composition: [
+            {
+                namespace: 'groot',
+                identifier: 'arms'
+            },
+            {
+                namespace: 'groot',
+                identifier: 'legs'
+            },
+            {
+                namespace: 'groot',
+                identifier: 'torso'
+            }
+        ]
+    };
+
+    // Now, we will define an object provider.  This will allow us to fetch the
+    // GROOT_ROOT object, plus any other objects in the `groot` namespace.
+    // For more info, see the Object API documentation.
+
+    MCT.Objects.addProvider('groot', {
+        // we'll only define a get function, objects from this provider will
+        // not be mutable.
+        get: function (key) {
+            if (key.identifier === 'groot') {
+                return Promise.resolve(GROOT_ROOT);
+            }
+            return Promise.resolve({
+                name: 'Groot\'s ' + key.identifier
+            });
+        }
+    });
+
+    // Finally, we need to add a "ROOT."  This is an identifier for an object
+    // that Open MCT will load at run time and show at the top-level of the
+    // navigation tree.
+
+    MCT.Objects.addRoot({
+        namespace: 'groot',
+        identifier: 'groot'
+    });
+
+    MCT.run();
+</script>
+</body>
+</html>

platform/commonUI/browse/bundle.js

@@ -39,6 +39,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,
@@ -59,6 +60,7 @@ define([
     itemsTemplate,
     objectPropertiesTemplate,
     inspectorRegionTemplate,
+    viewObjectTemplate,
     legacyRegistry
 ) {
 
@@ -129,7 +131,7 @@ define([
             "representations": [
                 {
                     "key": "view-object",
-                    "templateUrl": "templates/view-object.html"
+                    "template": viewObjectTemplate
                 },
                 {
                     "key": "browse-object",

platform/commonUI/general/bundle.js

@@ -48,6 +48,7 @@ define([
     "./src/directives/MCTSplitPane",
     "./src/directives/MCTSplitter",
     "./src/directives/MCTTree",
+    "./src/filters/ReverseFilter.js",
     "text!./res/templates/bottombar.html",
     "text!./res/templates/controls/action-button.html",
     "text!./res/templates/controls/input-filter.html",
@@ -96,6 +97,7 @@ define([
     MCTSplitPane,
     MCTSplitter,
     MCTTree,
+    ReverseFilter,
     bottombarTemplate,
     actionButtonTemplate,
     inputFilterTemplate,
@@ -146,7 +148,8 @@ define([
                     "depends": [
                         "stylesheets[]",
                         "$document",
-                        "THEME"
+                        "THEME",
+                        "ASSETS_PATH"
                     ]
                 },
                 {
@@ -158,7 +161,7 @@ define([
             ],
             "filters": [
                 {
-                    "implementation": "filters/ReverseFilter.js",
+                    "implementation": ReverseFilter,
                     "key": "reverse"
                 }
             ],
@@ -404,6 +407,11 @@ define([
                     "key": "THEME",
                     "value": "unspecified",
                     "priority": "fallback"
+                },
+                {
+                    "key": "ASSETS_PATH",
+                    "value": ".",
+                    "priority": "fallback"
                 }
             ],
             "containers": [

platform/commonUI/general/src/StyleSheetLoader.js

@@ -38,7 +38,7 @@ define(
          * @param $document Angular's jqLite-wrapped document element
          * @param {string} activeTheme the theme in use
          */
-        function StyleSheetLoader(stylesheets, $document, activeTheme) {
+        function StyleSheetLoader(stylesheets, $document, activeTheme, assetPath) {
             var head = $document.find('head'),
                 document = $document[0];
 
@@ -47,6 +47,7 @@ define(
                 // Create a link element, and construct full path
                 var link = document.createElement('link'),
                     path = [
+                        assetPath,
                         stylesheet.bundle.path,
                         stylesheet.bundle.resources,
                         stylesheet.stylesheetUrl

platform/execution/src/WorkerService.js

@@ -42,11 +42,19 @@ define(
             function addWorker(worker) {
                 var key = worker.key;
                 if (!workerUrls[key]) {
-                    workerUrls[key] = [
-                        worker.bundle.path,
-                        worker.bundle.sources,
-                        worker.scriptUrl
-                    ].join("/");
+                    if (worker.scriptUrl) {
+                        workerUrls[key] = [
+                            worker.bundle.path,
+                            worker.bundle.sources,
+                            worker.scriptUrl
+                        ].join("/");
+                    } else if (worker.scriptText) {
+                        var blob = new Blob(
+                            [worker.scriptText],
+                            {type: 'application/javascript'}
+                        );
+                        workerUrls[key] = URL.createObjectURL(blob);
+                    }
                     sharedWorkers[key] = worker.shared;
                 }
             }

platform/features/table/bundle.js

@@ -27,6 +27,9 @@ define([
     "./src/controllers/TableOptionsController",
     '../../commonUI/regions/src/Region',
     '../../commonUI/browse/src/InspectorRegion',
+    "text!./res/templates/table-options-edit.html",
+    "text!./res/templates/rt-table.html",
+    "text!./res/templates/historical-table.html",
     "legacyRegistry"
 ], function (
     MCTTable,
@@ -35,6 +38,9 @@ define([
     TableOptionsController,
     Region,
     InspectorRegion,
+    tableOptionsEditTemplate,
+    rtTableTemplate,
+    historicalTableTemplate,
     legacyRegistry
 ) {
     /**
@@ -128,7 +134,7 @@ define([
                     "name": "Historical Table",
                     "key": "table",
                     "glyph": "\ue604",
-                    "templateUrl": "templates/historical-table.html",
+                    "template": historicalTableTemplate,
                     "needs": [
                         "telemetry"
                     ],
@@ -139,7 +145,7 @@ define([
                     "name": "Real-time Table",
                     "key": "rt-table",
                     "glyph": "\ue620",
-                    "templateUrl": "templates/rt-table.html",
+                    "template": rtTableTemplate,
                     "needs": [
                         "telemetry"
                     ],
@@ -157,7 +163,7 @@ define([
             "representations": [
                 {
                     "key": "table-options-edit",
-                    "templateUrl": "templates/table-options-edit.html"
+                    "template": tableOptionsEditTemplate
                 }
             ],
             "stylesheets": [

platform/search/bundle.js

@@ -28,6 +28,7 @@ define([
     "text!./res/templates/search-item.html",
     "text!./res/templates/search.html",
     "text!./res/templates/search-menu.html",
+    "text!./src/services/GenericSearchWorker.js",
     'legacyRegistry'
 ], function (
     SearchController,
@@ -37,6 +38,7 @@ define([
     searchItemTemplate,
     searchTemplate,
     searchMenuTemplate,
+    searchWorkerText,
     legacyRegistry
 ) {
 
@@ -114,7 +116,7 @@ define([
             "workers": [
                 {
                     "key": "genericSearchWorker",
-                    "scriptUrl": "services/GenericSearchWorker.js"
+                    "scriptText": searchWorkerText
                 }
             ]
         }

plugin-example.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>Implementing a basic plugin</title>
+  <script src="dist/main.js"></script>
+</head>
+<body>
+<script>
+
+    function WebPlugin(websites) {
+        this.websites = websites;
+
+        var ROOTS = websites.reduce(function (rootMap, website) {
+            rootMap[website] = {
+                namespace: website,
+                identifier: 'page'
+            };
+            return rootMap;
+        }, {});
+
+        function installPlugin(MCT) {
+            Object.keys(ROOTS).forEach(function (rootUrl) {
+                MCT.Objects.addRoot(ROOTS[rootUrl]);
+                MCT.Objects.addProvider(rootUrl, {
+                    get: function () {
+                        return Promise.resolve({
+                            type: 'example.page',
+                            url: rootUrl,
+                            name: rootUrl
+                        });
+                    }
+                });
+            });
+        }
+
+        return installPlugin;
+    }
+
+    var myWebPlugin = WebPlugin([
+        'http://www.wikipedia.org/',
+        'http://nasa.github.io/openmct'
+    ]);
+
+    MCT.install(myWebPlugin);
+
+    MCT.run();
+</script>
+</body>
+</html>

src/BundleRegistry.js

@@ -24,10 +24,27 @@ define(function () {
 
     function BundleRegistry() {
         this.bundles = {};
+        this.knownBundles = {};
     }
 
     BundleRegistry.prototype.register = function (path, definition) {
-        this.bundles[path] = definition;
+        if (this.knownBundles.hasOwnProperty(path)) {
+            throw new Error('Cannot register bundle with duplicate path', path);
+        }
+        this.knownBundles[path] = definition;
+    };
+
+    BundleRegistry.prototype.enable = function (path) {
+        if (!this.knownBundles[path]) {
+            throw new Error('Unknown bundle ' + path);
+        }
+        this.bundles[path] = this.knownBundles[path];
+    };
+
+    BundleRegistry.prototype.disable = function (path) {
+        if (!this.bundles[path]) {
+            throw new Error('Tried to disable inactive bundle ' + path);
+        }
     };
 
     BundleRegistry.prototype.contains = function (path) {
@@ -42,8 +59,14 @@ define(function () {
         return Object.keys(this.bundles);
     };
 
-    BundleRegistry.prototype.remove = function (path) {
+    BundleRegistry.prototype.remove = BundleRegistry.prototype.disable;
+
+    BundleRegistry.prototype.delete = function (path) {
+        if (!this.knownBundles[path]) {
+            throw new Error('Cannot remove Unknown Bundle ' + path);
+        }
         delete this.bundles[path];
+        delete this.knownBundles[path];
     };
 
     return BundleRegistry;

src/MCT.js

@@ -0,0 +1,154 @@
+define([
+    'EventEmitter',
+    'legacyRegistry',
+    'uuid',
+    './api/api',
+    'text!./adapter/templates/edit-object-replacement.html',
+    './ui/Dialog',
+    './Selection',
+    './api/objects/object-utils'
+], function (
+    EventEmitter,
+    legacyRegistry,
+    uuid,
+    api,
+    editObjectTemplate,
+    Dialog,
+    Selection,
+    objectUtils
+) {
+    function MCT() {
+        EventEmitter.call(this);
+        this.legacyBundle = { extensions: {} };
+
+        this.selection = new Selection();
+        this.on('navigation', this.selection.clear.bind(this.selection));
+    }
+
+    MCT.prototype = Object.create(EventEmitter.prototype);
+
+    Object.keys(api).forEach(function (k) {
+        MCT.prototype[k] = api[k];
+    });
+    MCT.prototype.MCT = MCT;
+
+    MCT.prototype.legacyExtension = function (category, extension) {
+        this.legacyBundle.extensions[category] =
+            this.legacyBundle.extensions[category] || [];
+        this.legacyBundle.extensions[category].push(extension);
+    };
+
+    /**
+     * Set path to where assets are hosted.  This should be the path to main.js.
+     */
+    MCT.prototype.setAssetPath = function (path) {
+        this.legacyExtension('constants', {
+            key: "ASSETS_PATH",
+            value: path
+        });
+    };
+
+    /**
+     * Register a new type of view.
+     *
+     * @param region the region identifier (see mct.regions)
+     * @param {ViewDefinition} definition the definition for this view
+     */
+    MCT.prototype.view = function (region, definition) {
+        var viewKey = region + uuid();
+        var adaptedViewKey = "adapted-view-" + region;
+
+        this.legacyExtension(
+            region === this.regions.main ? 'views' : 'representations',
+            {
+                name: "A view",
+                key: adaptedViewKey,
+                editable: true,
+                template: '<mct-view region="\'' +
+                    region +
+                    '\'" ' +
+                    'key="\'' +
+                    viewKey +
+                    '\'" ' +
+                    'mct-object="domainObject">' +
+                    '</mct-view>'
+            }
+        );
+
+        this.legacyExtension('policies', {
+            category: "view",
+            implementation: function Policy() {
+                this.allow = function (view, domainObject) {
+                    if (view.key === adaptedViewKey) {
+                        var model = domainObject.getModel();
+                        var newDO = objectUtils.toNewFormat(model);
+                        return definition.canView(newDO);
+                    }
+                    return true;
+                };
+            }
+        });
+
+        this.legacyExtension('newViews', {
+            factory: definition,
+            region: region,
+            key: viewKey
+        });
+
+        this.legacyExtension('services', {
+            key: 'PublicAPI',
+            implementation: function () {
+                return this;
+            }.bind(this)
+        });
+    };
+
+    MCT.prototype.type = function (key, type) {
+        var legacyDef = type.toLegacyDefinition();
+        legacyDef.key = key;
+        type.key = key;
+
+        this.legacyExtension('types', legacyDef);
+        this.legacyExtension('representations', {
+            key: "edit-object",
+            priority: "preferred",
+            template: editObjectTemplate,
+            type: key
+        });
+    };
+
+    MCT.prototype.dialog = function (view, title) {
+        return new Dialog(view, title).show();
+    };
+
+    MCT.prototype.start = function () {
+        this.legacyExtension('runs', {
+            depends: ['navigationService'],
+            implementation: function (navigationService) {
+                navigationService
+                    .addListener(this.emit.bind(this, 'navigation'));
+            }.bind(this)
+        });
+
+        legacyRegistry.register('adapter', this.legacyBundle);
+        legacyRegistry.enable('adapter');
+        this.emit('start');
+    };
+
+    /**
+     * Install a plugin in MCT.
+     *
+     * @param `Function` plugin -- a plugin install function which will be
+     *     invoked with the mct instance.
+     */
+    MCT.prototype.install = function (plugin) {
+        plugin(this);
+    };
+
+    MCT.prototype.regions = {
+        main: "MAIN",
+        toolbar: "TOOLBAR"
+    };
+
+    return MCT;
+});

src/Selection.js

@@ -0,0 +1,32 @@
+define(['EventEmitter'], function (EventEmitter) {
+    function Selection() {
+        EventEmitter.call(this);
+        this.selectedValues = [];
+    }
+
+    Selection.prototype = Object.create(EventEmitter.prototype);
+
+    Selection.prototype.select = function (value) {
+        this.selectedValues.push(value);
+        this.emit('change');
+        return this.deselect.bind(this, value);
+    };
+
+    Selection.prototype.deselect = function (value) {
+        this.selectedValues = this.selectedValues.filter(function (v) {
+            return v !== value;
+        });
+        this.emit('change');
+    };
+
+    Selection.prototype.selected = function () {
+        return this.selectedValues;
+    };
+
+    Selection.prototype.clear = function () {
+        this.selectedValues = [];
+        this.emit('change');
+    };
+
+    return Selection;
+});

src/adapter/bundle.js

@@ -0,0 +1,48 @@
+define([
+    'legacyRegistry',
+    './directives/MCTView',
+    './services/Instantiate',
+    './capabilities/APICapabilityDecorator'
+], function (
+    legacyRegistry,
+    MCTView,
+    Instantiate,
+    APICapabilityDecorator
+) {
+    legacyRegistry.register('src/adapter', {
+        "extensions": {
+            "directives": [
+                {
+                    key: "mctView",
+                    implementation: MCTView,
+                    depends: [
+                        "newViews[]",
+                        "PublicAPI"
+                    ]
+                }
+            ],
+            services: [
+                {
+                    key: "instantiate",
+                    priority: "mandatory",
+                    implementation: Instantiate,
+                    depends: [
+                        "capabilityService",
+                        "identifierService",
+                        "cacheService"
+                    ]
+                }
+            ],
+            components: [
+                {
+                    type: "decorator",
+                    provides: "capabilityService",
+                    implementation: APICapabilityDecorator,
+                    depends: [
+                        "$injector"
+                    ]
+                }
+            ]
+        }
+    });
+});

src/adapter/capabilities/APICapabilityDecorator.js

@@ -0,0 +1,37 @@
+define([
+    './synchronizeMutationCapability',
+    './AlternateCompositionCapability'
+], function (
+    synchronizeMutationCapability,
+    AlternateCompositionCapability
+) {
+
+    /**
+     * Overrides certain capabilities to keep consistency between old API
+     * and new API.
+     */
+    function APICapabilityDecorator($injector, capabilityService) {
+        this.$injector = $injector;
+        this.capabilityService = capabilityService;
+    }
+
+    APICapabilityDecorator.prototype.getCapabilities = function (
+        model
+    ) {
+        var capabilities = this.capabilityService.getCapabilities(model);
+        if (capabilities.mutation) {
+            capabilities.mutation =
+                synchronizeMutationCapability(capabilities.mutation);
+        }
+        if (AlternateCompositionCapability.appliesTo(model)) {
+            capabilities.composition = function (domainObject) {
+                return new AlternateCompositionCapability(this.$injector, domainObject)
+            }.bind(this);
+        }
+
+        return capabilities;
+    };
+
+    return APICapabilityDecorator;
+
+});

src/adapter/capabilities/AlternateCompositionCapability.js

@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
+
+/**
+ * Module defining AlternateCompositionCapability. Created by vwoeltje on 11/7/14.
+ */
+define([
+    '../../api/objects/object-utils',
+    '../../api/composition/CompositionAPI'
+], function (objectUtils, CompositionAPI) {
+
+        function AlternateCompositionCapability($injector, domainObject) {
+            this.domainObject = domainObject;
+
+            this.getDependencies = function () {
+                this.instantiate = $injector.get("instantiate");
+                this.contextualize = $injector.get("contextualize");
+                this.getDependencies = undefined;
+            }.bind(this);
+        }
+
+        AlternateCompositionCapability.prototype.add = function (child, index) {
+            if (typeof index !== 'undefined') {
+                // At first glance I don't see a location in the existing
+                // codebase where add is called with an index.  Won't support.
+                throw new Error(
+                    'Composition Capability does not support adding at index'
+                );
+            }
+
+            function addChildToComposition(model) {
+                var existingIndex = model.composition.indexOf(child.getId());
+                if (existingIndex === -1) {
+                    model.composition.push(child.getId())
+                }
+            }
+
+            return this.domainObject.useCapability(
+                    'mutation',
+                    addChildToComposition
+                )
+                .then(this.invoke.bind(this))
+                .then(function (children) {
+                    return children.filter(function (c) {
+                        return c.getId() === child.getId();
+                    })[0];
+                });
+        };
+
+        AlternateCompositionCapability.prototype.contextualizeChild = function (
+            child
+        ) {
+            if (this.getDependencies) {
+                this.getDependencies();
+            }
+
+            var keyString = objectUtils.makeKeyString(child.key);
+            var oldModel = objectUtils.toOldFormat(child);
+            var newDO = this.instantiate(oldModel, keyString);
+            return this.contextualize(newDO, this.domainObject);
+
+        };
+
+        AlternateCompositionCapability.prototype.invoke = function () {
+            var newFormatDO = objectUtils.toNewFormat(
+                this.domainObject.getModel(),
+                this.domainObject.getId()
+            );
+            var collection = CompositionAPI(newFormatDO);
+            return collection.load()
+                .then(function (children) {
+                    collection.destroy();
+                    return children.map(this.contextualizeChild, this);
+                }.bind(this));
+        };
+
+        AlternateCompositionCapability.appliesTo = function (model) {
+            return !!CompositionAPI(objectUtils.toNewFormat(model, model.id));
+        };
+
+        return AlternateCompositionCapability;
+    }
+);

src/adapter/capabilities/synchronizeMutationCapability.js

@@ -0,0 +1,27 @@
+define([
+
+], function (
+
+) {
+
+    /**
+     * Wraps the mutation capability and synchronizes the mutation
+     */
+    function synchronizeMutationCapability(mutationConstructor) {
+
+        return function makeCapability(domainObject) {
+            var capability = mutationConstructor(domainObject);
+            var oldListen = capability.listen.bind(capability);
+            capability.listen = function (listener) {
+                return oldListen(function (newModel) {
+                    capability.domainObject.model =
+                        JSON.parse(JSON.stringify(newModel));
+                    listener(newModel);
+                });
+            };
+            return capability;
+        }
+    };
+
+    return synchronizeMutationCapability;
+});

src/adapter/directives/MCTView.js

@@ -0,0 +1,65 @@
+define([
+    'angular',
+    './Region',
+    '../../api/objects/object-utils'
+], function (
+    angular,
+    Region,
+    objectUtils
+) {
+    function MCTView(newViews, PublicAPI) {
+        var definitions = {};
+
+        newViews.forEach(function (newView) {
+            definitions[newView.region] = definitions[newView.region] || {};
+            definitions[newView.region][newView.key] = newView.factory;
+        });
+
+        return {
+            restrict: 'E',
+            link: function (scope, element, attrs) {
+                var key, mctObject, regionId, region;
+
+                function maybeShow() {
+                    if (!definitions[regionId] || !definitions[regionId][key] || !mctObject) {
+                        return;
+                    }
+
+                    region.show(definitions[regionId][key].view(mctObject));
+                }
+
+                function setKey(k) {
+                    key = k;
+                    maybeShow();
+                }
+
+                function setObject(obj) {
+                    mctObject = undefined;
+                    PublicAPI.Objects.get(objectUtils.parseKeyString(obj.getId()))
+                        .then(function (mobj) {
+                            mctObject = mobj;
+                            maybeShow();
+                        });
+                }
+
+                function setRegionId(r) {
+                    regionId = r;
+                    maybeShow();
+                }
+
+                region = new Region(element[0]);
+
+                scope.$watch('key', setKey);
+                scope.$watch('region', setRegionId);
+                scope.$watch('mctObject', setObject);
+            },
+            scope: {
+                key: "=",
+                region: "=",
+                mctObject: "="
+            }
+        };
+    }
+
+    return MCTView;
+});

src/adapter/directives/Region.js

@@ -0,0 +1,23 @@
+define([], function () {
+    function Region(element) {
+        this.activeView = undefined;
+        this.element = element;
+    }
+
+    Region.prototype.clear = function () {
+        if (this.activeView) {
+            this.activeView.destroy();
+            this.activeView = undefined;
+        }
+    };
+
+    Region.prototype.show = function (view) {
+        this.clear();
+        this.activeView = view;
+        if (this.activeView) {
+            this.activeView.show(this.element);
+        }
+    };
+
+    return Region;
+});

src/adapter/services/Instantiate.js

@@ -0,0 +1,49 @@
+/*****************************************************************************
+ * 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(
+    ['../../../platform/core/src/objects/DomainObjectImpl'],
+    function (DomainObjectImpl) {
+
+        /**
+         * Overrides platform version of instantiate, passes Id with model such
+         * that capability detection can utilize new format domain objects.
+         */
+        function Instantiate(
+            capabilityService,
+            identifierService,
+            cacheService
+        ) {
+            return function (model, id) {
+                id = id || identifierService.generate();
+                var old_id = model.id;
+                model.id = id;
+                var capabilities = capabilityService.getCapabilities(model);
+                model.id = old_id;
+                cacheService.put(id, model);
+                return new DomainObjectImpl(id, model, capabilities);
+            };
+        }
+
+        return Instantiate;
+    }
+);

src/adapter/templates/edit-object-replacement.html

@@ -0,0 +1,46 @@
+<div class="abs l-flex-col" ng-controller="EditObjectController as EditObjectController">
+    <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"
+                                class="flex-elem l-back"></mct-representation>
+            <mct-representation key="'object-header'"
+                                mct-object="domainObject"
+                                class="l-flex-row flex-elem grows object-header">
+            </mct-representation>
+        </div>
+        <div class="btn-bar right l-flex-row flex-elem flex-justify-end flex-fixed">
+            <mct-representation key="'switcher'"
+                                mct-object="domainObject"
+                                ng-model="representation">
+            </mct-representation>
+            <!-- Temporarily, on mobile, the action buttons are hidden-->
+            <mct-representation key="'action-group'"
+                                mct-object="domainObject"
+                                parameters="{ category: 'view-control' }"
+                                class="mobile-hide">
+            </mct-representation>
+        </div>
+    </div>
+    <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">
+                <mct-representation key="'adapted-view-TOOLBAR'"
+                                    mct-object="domainObject"
+                                    class="flex-elem grows">
+                </mct-representation>
+                <mct-representation key="'edit-action-buttons'"
+                                    mct-object="domainObject"
+                                    class='flex-elem conclude-editing'>
+                </mct-representation>
+            </div>
+            <mct-representation key="representation.selected.key"
+                                mct-object="representation.selected.key && domainObject"
+                                class="abs flex-elem grows object-holder-main scroll"
+                                toolbar="toolbar">
+            </mct-representation>
+        </div><!--/ l-object-wrapper-inner -->
+    </div>
+</div>

src/api/TimeConductor.js

@@ -0,0 +1,183 @@
+/*****************************************************************************
+ * 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(['EventEmitter'], function (EventEmitter) {
+
+    /**
+     * The public API for setting and querying time conductor state. The
+     * time conductor is the means by which the temporal bounds of a view
+     * are controlled. Time-sensitive views will typically respond to
+     * changes to bounds or other properties of the time conductor and
+     * update the data displayed based on the time conductor state.
+     *
+     * The TimeConductor extends the EventEmitter class. A number of events are
+     * fired when properties of the time conductor change, which are
+     * documented below.
+     * @constructor
+     */
+    function TimeConductor() {
+        EventEmitter.call(this);
+
+        //The Time System
+        this.system = undefined;
+        //The Time Of Interest
+        this.toi = undefined;
+
+        this.boundsVal = {
+            start: undefined,
+            end: undefined
+        };
+
+        //Default to fixed mode
+        this.followMode = false;
+    }
+
+    TimeConductor.prototype = Object.create(EventEmitter.prototype);
+
+    /**
+     * Validate the given bounds. This can be used for pre-validation of
+     * bounds, for example by views validating user inputs.
+     * @param bounds The start and end time of the conductor.
+     * @returns {string | true} A validation error, or true if valid
+     */
+    TimeConductor.prototype.validateBounds = function (bounds) {
+        if ((bounds.start === undefined) ||
+            (bounds.end === undefined) ||
+            isNaN(bounds.start) ||
+            isNaN(bounds.end)
+        ) {
+            return "Start and end must be specified as integer values";
+        } else if (bounds.start > bounds.end) {
+            return "Specified start date exceeds end bound";
+        }
+        return true;
+    };
+
+    function throwOnError(validationResult) {
+        if (validationResult !== true) {
+            throw new Error(validationResult);
+        }
+    }
+
+    /**
+     * Get or set the follow mode of the time conductor. In follow mode the
+     * time conductor ticks, regularly updating the bounds from a timing
+     * source appropriate to the selected time system and mode of the time
+     * conductor.
+     * @fires TimeConductor#follow
+     * @param {boolean} followMode
+     * @returns {boolean}
+     */
+    TimeConductor.prototype.follow = function (followMode) {
+        if (arguments.length > 0) {
+            this.followMode = followMode;
+            /**
+             * @event TimeConductor#follow The TimeConductor has toggled
+             * into or out of follow mode.
+             * @property {boolean} followMode true if follow mode is
+             * enabled, otherwise false.
+             */
+            this.emit('follow', this.followMode);
+        }
+        return this.followMode;
+    };
+
+    /**
+     * @typedef {Object} TimeConductorBounds
+     * @property {number} start The start time displayed by the time conductor in ms since epoch. Epoch determined by current time system
+     * @property {number} end The end time displayed by the time conductor in ms since epoch.
+     */
+    /**
+     * Get or set the start and end time of the time conductor. Basic validation
+     * of bounds is performed.
+     *
+     * @param {TimeConductorBounds} newBounds
+     * @throws {Error} Validation error
+     * @fires TimeConductor#bounds
+     * @returns {TimeConductorBounds}
+     */
+    TimeConductor.prototype.bounds = function (newBounds) {
+        if (arguments.length > 0) {
+            throwOnError(this.validateBounds(newBounds));
+            this.boundsVal = newBounds;
+            /**
+             * @event TimeConductor#bounds The start time, end time, or
+             * both have been updated
+             * @property {TimeConductorBounds} bounds
+             */
+            this.emit('bounds', this.boundsVal);
+        }
+        return this.boundsVal;
+    };
+
+    /**
+     * Get or set the time system of the TimeConductor. Time systems determine
+     * units, epoch, and other aspects of time representation. When changing
+     * the time system in use, new valid bounds must also be provided.
+     * @param {TimeSystem} newTimeSystem
+     * @param {TimeConductorBounds} bounds
+     * @fires TimeConductor#timeSystem
+     * @returns {TimeSystem} The currently applied time system
+     */
+    TimeConductor.prototype.timeSystem = function (newTimeSystem, bounds) {
+        if (arguments.length >= 2) {
+            this.system = newTimeSystem;
+            /**
+             * @event TimeConductor#timeSystem The time system used by the time
+             * conductor has changed. A change in Time System will always be
+             * followed by a bounds event specifying new query bounds
+             * @property {TimeSystem} The value of the currently applied
+             * Time System
+             * */
+            this.emit('timeSystem', this.system);
+            // Do something with bounds here. Try and convert between
+            // time systems? Or just set defaults when time system changes?
+            // eg.
+            this.bounds(bounds);
+        } else if (arguments.length === 1) {
+            throw new Error('Must set bounds when changing time system');
+        }
+        return this.system;
+    };
+
+    /**
+     * Get or set the Time of Interest. The Time of Interest is the temporal
+     * focus of the current view. It can be manipulated by the user from the
+     * time conductor or from other views.
+     * @fires TimeConductor#timeOfInterest
+     * @param newTOI
+     * @returns {number} the current time of interest
+     */
+    TimeConductor.prototype.timeOfInterest = function (newTOI) {
+        if (arguments.length > 0) {
+            this.toi = newTOI;
+            /**
+             * @event TimeConductor#timeOfInterest The Time of Interest has moved.
+             * @property {number} Current time of interest
+             */
+            this.emit('timeOfInterest', this.toi);
+        }
+        return this.toi;
+    };
+
+    return TimeConductor;
+});

src/api/TimeConductorSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * 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(['./TimeConductor'], function (TimeConductor) {
+    describe("The Time Conductor", function () {
+        var tc,
+            timeSystem,
+            bounds,
+            eventListener,
+            toi,
+            follow;
+
+        beforeEach(function () {
+            tc = new TimeConductor();
+            timeSystem = {};
+            bounds = {start: 0, end: 0};
+            eventListener = jasmine.createSpy("eventListener");
+            toi = 111;
+            follow = true;
+        });
+
+        it("Supports setting and querying of time of interest and and follow mode", function () {
+            expect(tc.timeOfInterest()).not.toBe(toi);
+            tc.timeOfInterest(toi);
+            expect(tc.timeOfInterest()).toBe(toi);
+
+            expect(tc.follow()).not.toBe(follow);
+            tc.follow(follow);
+            expect(tc.follow()).toBe(follow);
+        });
+
+        it("Allows setting of valid bounds", function () {
+            bounds = {start: 0, end: 1};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).not.toThrow();
+            expect(tc.bounds()).toBe(bounds);
+        });
+
+        it("Disallows setting of invalid bounds", function () {
+            bounds = {start: 1, end: 0};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).toThrow();
+            expect(tc.bounds()).not.toBe(bounds);
+
+            bounds = {start: 1};
+            expect(tc.bounds()).not.toBe(bounds);
+            expect(tc.bounds.bind(tc, bounds)).toThrow();
+            expect(tc.bounds()).not.toBe(bounds);
+        });
+
+        it("Allows setting of time system with bounds", function () {
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+            expect(tc.timeSystem.bind(tc, timeSystem, bounds)).not.toThrow();
+            expect(tc.timeSystem()).toBe(timeSystem);
+        });
+
+        it("Disallows setting of time system without bounds", function () {
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+            expect(tc.timeSystem.bind(tc, timeSystem)).toThrow();
+            expect(tc.timeSystem()).not.toBe(timeSystem);
+        });
+
+        it("Emits an event when time system changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("timeSystem", eventListener);
+            tc.timeSystem(timeSystem, bounds);
+            expect(eventListener).toHaveBeenCalledWith(timeSystem);
+        });
+
+        it("Emits an event when time of interest changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("timeOfInterest", eventListener);
+            tc.timeOfInterest(toi);
+            expect(eventListener).toHaveBeenCalledWith(toi);
+        });
+
+        it("Emits an event when bounds change", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("bounds", eventListener);
+            tc.bounds(bounds);
+            expect(eventListener).toHaveBeenCalledWith(bounds);
+        });
+
+        it("Emits an event when follow mode changes", function () {
+            expect(eventListener).not.toHaveBeenCalled();
+            tc.on("follow", eventListener);
+            tc.follow(follow);
+            expect(eventListener).toHaveBeenCalledWith(follow);
+        });
+    });
+});

src/api/Type.js

@@ -0,0 +1,54 @@
+define(function () {
+    /**
+     * @typedef TypeDefinition
+     * @property {Metadata} metadata displayable metadata about this type
+     * @property {function (object)} [initialize] a function which initializes
+     *           the model for new domain objects of this type
+     * @property {boolean} [creatable] true if users should be allowed to
+     *           create this type (default: false)
+     */
+
+    /**
+     *
+     * @param {TypeDefinition} definition
+     * @constructor
+     */
+    function Type(definition) {
+        this.definition = definition;
+    }
+
+    /**
+     * Check if a domain object is an instance of this type.
+     * @param domainObject
+     * @returns {boolean} true if the domain object is of this type
+     */
+    Type.prototype.check = function (domainObject) {
+        // Depends on assignment from MCT.
+        return domainObject.type === this.key;
+    };
+
+    /**
+     * Get a definition for this type that can be registered using the
+     * legacy bundle format.
+     * @private
+     */
+    Type.prototype.toLegacyDefinition = function () {
+        var def = {};
+        def.name = this.definition.metadata.label;
+        def.glyph = this.definition.metadata.glyph;
+        def.description = this.definition.metadata.description;
+        def.properties = this.definition.form;
+
+        if (this.definition.initialize) {
+            def.model = {};
+            this.definition.initialize(def.model);
+        }
+
+        if (this.definition.creatable) {
+            def.features = ['creation'];
+        }
+        return def;
+    };
+
+    return Type;
+});

src/api/View.js

@@ -0,0 +1,38 @@
+define([], function () {
+
+    /**
+     * A View is used to provide displayable content, and to react to
+     * associated life cycle events.
+     *
+     * @interface
+     */
+    function View() {
+
+    }
+
+    /**
+     * Populate the supplied DOM element with the contents of this view.
+     *
+     * View implementations should use this method to attach any
+     * listeners or acquire other resources that are necessary to keep
+     * the contents of this view up-to-date.
+     *
+     * @param {HTMLElement} container the DOM element to populate
+     */
+    View.prototype.show = function (container) {
+
+    };
+
+    /**
+     * Release any resources associated with this view.
+     *
+     * View implementations should use this method to detach any
+     * listeners or release other resources that are no longer necessary
+     * once a view is no longer used.
+     */
+    View.prototype.destroy = function () {
+
+    };
+
+    return View;
+});

src/api/ViewDefinition.js

@@ -0,0 +1,44 @@
+define(function () {
+
+    /**
+     * Defines a kind of view.
+     * @interface
+     */
+    function ViewDefinition() {
+    }
+
+    /**
+     * Get metadata about this view, as may be used in the user interface
+     * to present options for this view.
+     * @param {*} object the object to be shown in this view
+     * @returns {mct.ViewMetadata} metadata about this view
+     */
+    ViewDefinition.prototype.metadata = function (object) {
+    };
+
+    /**
+     * Instantiate a new view of this object. Callers of this method are
+     * responsible for calling `canView` before instantiating views in this
+     * manner.
+     *
+     * @param {*} object the object to be shown in this view
+     * @returns {mct.View} a view of this object
+     */
+    ViewDefinition.prototype.view = function (object) {
+    };
+
+    /**
+     * Check if this view is capable of showing this object. Users of
+     * views should use this method before calling `show`.
+     *
+     * Subclasses should override this method to control the applicability
+     * of this view to other objects.
+     *
+     * @param {*} object the object to be shown in this view
+     * @returns {boolean} true if this view is applicable to this object
+     */
+    ViewDefinition.prototype.canView = function (object) {
+    };
+
+    return ViewDefinition;
+});

src/api/api.js

@@ -0,0 +1,21 @@
+define([
+    './Type',
+    './TimeConductor',
+    './View',
+    './objects/ObjectAPI',
+    './composition/CompositionAPI'
+], function (
+    Type,
+    TimeConductor,
+    View,
+    ObjectAPI,
+    CompositionAPI
+) {
+    return {
+        Type: Type,
+        TimeConductor: new TimeConductor(),
+        View: View,
+        Objects: ObjectAPI,
+        Composition: CompositionAPI
+    };
+});

src/api/composition/CompositionAPI.js

@@ -0,0 +1,39 @@
+define([
+    'lodash',
+    'EventEmitter',
+    './DefaultCompositionProvider',
+    './CompositionCollection'
+], function (
+    _,
+    EventEmitter,
+    DefaultCompositionProvider,
+    CompositionCollection
+) {
+
+    var PROVIDER_REGISTRY = [];
+
+    function getProvider (object) {
+        return _.find(PROVIDER_REGISTRY, function (p) {
+            return p.appliesTo(object);
+        });
+    };
+
+    function composition(object) {
+        var provider = getProvider(object);
+
+        if (!provider) {
+            return;
+        }
+
+        return new CompositionCollection(object, provider);
+    };
+
+    composition.addProvider = function (provider) {
+        PROVIDER_REGISTRY.unshift(provider);
+    };
+
+    composition.addProvider(new DefaultCompositionProvider());
+
+    return composition;
+
+});

src/api/composition/CompositionCollection.js

@@ -0,0 +1,115 @@
+define([
+    'EventEmitter',
+    'lodash',
+    '../objects/object-utils'
+], function (
+    EventEmitter,
+    _,
+    objectUtils
+) {
+
+    function CompositionCollection(domainObject, provider) {
+        EventEmitter.call(this);
+        this.domainObject = domainObject;
+        this.provider = provider;
+        if (this.provider.on) {
+            this.provider.on(
+                this.domainObject,
+                'add',
+                this.onProviderAdd,
+                this
+            );
+            this.provider.on(
+                this.domainObject,
+                'remove',
+                this.onProviderRemove,
+                this
+            );
+        }
+    };
+
+    CompositionCollection.prototype = Object.create(EventEmitter.prototype);
+
+    CompositionCollection.prototype.onProviderAdd = function (child) {
+        this.add(child, true);
+    };
+
+    CompositionCollection.prototype.onProviderRemove = function (child) {
+        this.remove(child, true);
+    };
+
+    CompositionCollection.prototype.indexOf = function (child) {
+        return _.findIndex(this._children, function (other) {
+            return objectUtils.equals(child, other);
+        });
+    };
+
+    CompositionCollection.prototype.contains = function (child) {
+        return this.indexOf(child) !== -1;
+    };
+
+    CompositionCollection.prototype.add = function (child, skipMutate) {
+        if (!this._children) {
+            throw new Error("Must load composition before you can add!");
+        }
+        if (this.contains(child)) {
+            if (skipMutate) {
+                return; // don't add twice, don't error.
+            }
+            throw new Error("Unable to add child: already in composition");
+        }
+        this._children.push(child);
+        this.emit('add', child);
+        if (!skipMutate) {
+            // add after we have added.
+            this.provider.add(this.domainObject, child);
+        }
+    };
+
+    CompositionCollection.prototype.load = function () {
+        return this.provider.load(this.domainObject)
+            .then(function (children) {
+                this._children = [];
+                children.map(function (c) {
+                    this.add(c, true);
+                }, this);
+                this.emit('load');
+                return this._children.slice();
+            }.bind(this));
+    };
+
+    CompositionCollection.prototype.remove = function (child, skipMutate) {
+        if (!this.contains(child)) {
+            if (skipMutate) {
+                return;
+            }
+            throw new Error("Unable to remove child: not found in composition");
+        }
+        var index = this.indexOf(child);
+        var removed = this._children.splice(index, 1)[0];
+        this.emit('remove', index, child);
+        if (!skipMutate) {
+            // trigger removal after we have internally removed it.
+            this.provider.remove(this.domainObject, removed);
+        }
+    };
+
+    CompositionCollection.prototype.destroy = function () {
+        if (this.provider.off) {
+            this.provider.off(
+                this.domainObject,
+                'add',
+                this.onProviderAdd,
+                this
+            );
+            this.provider.off(
+                this.domainObject,
+                'remove',
+                this.onProviderRemove,
+                this
+            );
+        }
+    };
+
+    return CompositionCollection
+});

src/api/composition/DefaultCompositionProvider.js

@@ -0,0 +1,76 @@
+define([
+    'lodash',
+    'EventEmitter',
+    '../objects/ObjectAPI',
+    '../objects/object-utils'
+], function (
+    _,
+    EventEmitter,
+    ObjectAPI,
+    objectUtils
+) {
+
+    function makeEventName(domainObject, event) {
+        return event + ':' + objectUtils.makeKeyString(domainObject.key);
+    }
+
+    function DefaultCompositionProvider() {
+        EventEmitter.call(this);
+    }
+
+    DefaultCompositionProvider.prototype =
+        Object.create(EventEmitter.prototype);
+
+    DefaultCompositionProvider.prototype.appliesTo = function (domainObject) {
+        return !!domainObject.composition;
+    };
+
+    DefaultCompositionProvider.prototype.load = function (domainObject) {
+        return Promise.all(domainObject.composition.map(ObjectAPI.get));
+    };
+
+    DefaultCompositionProvider.prototype.on = function (
+        domainObject,
+        event,
+        listener,
+        context
+    ) {
+        // these can likely be passed through to the mutation service instead
+        // of using an eventemitter.
+        this.addListener(
+            makeEventName(domainObject, event),
+            listener,
+            context
+        );
+    };
+
+    DefaultCompositionProvider.prototype.off = function (
+        domainObject,
+        event,
+        listener,
+        context
+    ) {
+        // these can likely be passed through to the mutation service instead
+        // of using an eventemitter.
+        this.removeListener(
+            makeEventName(domainObject, event),
+            listener,
+            context
+        );
+    };
+
+    DefaultCompositionProvider.prototype.remove = function (domainObject, child) {
+        // TODO: this needs to be synchronized via mutation
+        var index = domainObject.composition.indexOf(child);
+        domainObject.composition.splice(index, 1);
+        this.emit(makeEventName(domainObject, 'remove'), child);
+    };
+
+    DefaultCompositionProvider.prototype.add = function (domainObject, child) {
+        // TODO: this needs to be synchronized via mutation
+        domainObject.composition.push(child.key);
+        this.emit(makeEventName(domainObject, 'add'), child);
+    };
+
+    return DefaultCompositionProvider;
+});

src/api/composition/README.md

@@ -0,0 +1,37 @@
+# Composition API - Overview
+
+The composition API is straightforward:
+
+MCT.composition(object) -- returns a `CompositionCollection` if the object has 
+composition, returns undefined if it doesn't.
+
+## CompositionCollection
+
+Has three events:
+* `load`: when the collection has completed loading.
+* `add`: when a new object has been added to the collection.
+* `remove` when an object has been removed from the collection.
+
+Has three methods:
+
+`Collection.load()` -- returns a promise that is fulfilled when the composition 
+    has loaded.
+`Collection.add(object)` -- add a domain object to the composition.
+`Collection.remove(object)` -- remove the object from the composition.
+
+## Composition providers
+composition providers are anything that meets the following interface:
+
+* `provider.appliesTo(domainObject)` -> return true if this provider can provide 
+    composition for a given domain object.
+* `provider.add(domainObject, childObject)` -> adds object 
+* `provider.remove(domainObject, childObject)` -> immediately removes objects
+* `provider.load(domainObject)` -> returns promise for array of children
+
+TODO: need to figure out how to make the provider event listeners invisible to the provider.
+
+There is a default composition provider which handles loading composition for 
+any object with a `composition` property.  If you want specialized composition 
+loading behavior, implement your own composition provider and register it with
+
+`MCT.composition.addProvider(myProvider)`

src/api/objects/LegacyObjectAPIInterceptor.js

@@ -0,0 +1,70 @@
+define([
+    './object-utils',
+    './ObjectAPI'
+], function (
+    utils,
+    ObjectAPI
+) {
+    function ObjectServiceProvider(objectService, instantiate) {
+        this.objectService = objectService;
+        this.instantiate = instantiate;
+    }
+
+    ObjectServiceProvider.prototype.save = function (object) {
+        var key = object.key,
+            keyString = utils.makeKeyString(key),
+            newObject = this.instantiate(utils.toOldFormat(object), keyString);
+
+        return object.getCapability('persistence')
+                .persist()
+                .then(function () {
+                    return utils.toNewFormat(object, key);
+                });
+    };
+
+    ObjectServiceProvider.prototype.delete = function (object) {
+        // TODO!
+    };
+
+    ObjectServiceProvider.prototype.get = function (key) {
+        var keyString = utils.makeKeyString(key);
+        return this.objectService.getObjects([keyString])
+            .then(function (results) {
+                var model = results[keyString].getModel();
+                return utils.toNewFormat(model, key);
+            });
+    };
+
+    // Injects new object API as a decorator so that it hijacks all requests.
+    // Object providers implemented on new API should just work, old API should just work, many things may break.
+    function LegacyObjectAPIInterceptor(ROOTS, instantiate, objectService) {
+        this.getObjects = function (keys) {
+            var results = {},
+                promises = keys.map(function (keyString) {
+                    var key = utils.parseKeyString(keyString);
+                    return ObjectAPI.get(key)
+                        .then(function (object) {
+                            object = utils.toOldFormat(object)
+                            results[keyString] = instantiate(object, keyString);
+                        });
+                });
+
+            return Promise.all(promises)
+                .then(function () {
+                    return results;
+                });
+        };
+
+        ObjectAPI._supersecretSetFallbackProvider(
+            new ObjectServiceProvider(objectService, instantiate)
+        );
+
+        ROOTS.forEach(function (r) {
+            ObjectAPI.addRoot(utils.parseKeyString(r.id));
+        });
+
+        return this;
+    }
+
+    return LegacyObjectAPIInterceptor;
+});

src/api/objects/MutableObject.js

@@ -0,0 +1,56 @@
+define([
+    'lodash'
+], function (
+    _
+) {
+    /**
+     * The MutableObject wraps a DomainObject and provides getters and
+     * setters for
+     * @param eventEmitter
+     * @param object
+     * @constructor
+     */
+    function MutableObject(eventEmitter, object) {
+        this.eventEmitter = eventEmitter;
+        this.object = object;
+        this.unlisteners = [];
+    }
+
+    function qualifiedEventName(object, eventName) {
+        return [object.key.identifier, eventName].join(':');
+    }
+
+    MutableObject.prototype.stopListening = function () {
+        this.unlisteners.forEach(function (unlisten) {
+            unlisten();
+        })
+    };
+
+    MutableObject.prototype.on = function(path, callback) {
+        function synchronizeModel(value) {
+            if (path === '*'){
+                this.object = value;
+            } else {
+                _.set(object, path, value)
+            }
+            callback(value);
+        }
+        var fullPath = qualifiedEventName(this.object, path);
+        var wrappedFunction = synchronizeModel.bind(this);
+
+        this.eventEmitter.on(fullPath, wrappedFunction);
+        this.unlisteners.push(this.eventEmitter.off.bind(this.eventEmitter, fullPath, wrappedFunction));
+    };
+
+    MutableObject.prototype.set = function (path, value) {
+
+        _.set(this.object, path, value);
+
+        //Emit event specific to property
+        this.eventEmitter.emit(qualifiedEventName(this.object, path), value);
+        //Emit wildcare event
+        this.eventEmitter.emit(qualifiedEventName(this.object, '*'), this.object);
+    };
+
+    return MutableObject;
+});

src/api/objects/MutableObjectSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * 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(['./MutableObject'], function (MutableObject) {
+    describe('Mutable Domain Objects', function () {
+        var domainObject,
+            mutableObject,
+            eventEmitter,
+            arrayProperty,
+            objectProperty,
+            identifier;
+
+        beforeEach(function () {
+            identifier = 'objectId';
+            arrayProperty = [
+                'First array element',
+                'Second array element',
+                'Third array element'
+            ];
+            objectProperty = {
+                prop1: 'val1',
+                prop2: 'val2',
+                prop3: {
+                    propA: 'valA',
+                    propB: 'valB',
+                    propC: []
+                }
+            };
+            domainObject = {
+                    key: {
+                        identifier: identifier
+                    },
+                    stringProperty: 'stringValue',
+                    objectProperty: objectProperty,
+                    arrayProperty: arrayProperty
+                };
+            eventEmitter = jasmine.createSpyObj('eventEmitter', [
+                'emit'
+            ]);
+            mutableObject = new MutableObject(eventEmitter, domainObject);
+        });
+
+        it('Supports getting and setting of object properties', function () {
+            expect(domainObject.stringProperty).toEqual('stringValue');
+            mutableObject.set('stringProperty', 'updated');
+            expect(domainObject.stringProperty).toEqual('updated');
+
+            var newArrayProperty = [];
+            expect(domainObject.arrayProperty).toEqual(arrayProperty);
+            mutableObject.set('arrayProperty', newArrayProperty);
+            expect(domainObject.arrayProperty).toEqual(newArrayProperty);
+
+            var newObjectProperty = [];
+            expect(domainObject.objectProperty).toEqual(objectProperty);
+            mutableObject.set('objectProperty', newObjectProperty);
+            expect(domainObject.objectProperty).toEqual(newObjectProperty);
+        });
+
+        it('Supports getting and setting of nested properties', function () {
+            expect(domainObject.objectProperty).toEqual(objectProperty);
+            expect(domainObject.objectProperty.prop1).toEqual(objectProperty.prop1);
+            expect(domainObject.objectProperty.prop3.propA).toEqual(objectProperty.prop3.propA);
+
+            mutableObject.set('objectProperty.prop1', 'new-prop-1');
+            expect(domainObject.objectProperty.prop1).toEqual('new-prop-1');
+
+            mutableObject.set('objectProperty.prop3.propA', 'new-prop-A');
+            expect(domainObject.objectProperty.prop3.propA).toEqual('new-prop-A');
+
+            mutableObject.set('arrayProperty.1', 'New Second Array Element');
+            expect(arrayProperty[1]).toEqual('New Second Array Element');
+        });
+
+        it('Fires events when properties change', function () {
+            var newString = 'updated'
+            mutableObject.set('stringProperty', newString);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, 'stringProperty'].join(':'), newString);
+
+            var newArray = [];
+            mutableObject.set('arrayProperty', newArray);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, 'arrayProperty'].join(':'), newArray);
+
+        });
+
+        it('Fires wildcard event when any property changes', function () {
+            var newString = 'updated'
+            mutableObject.set('objectProperty.prop3.propA', newString);
+            expect(eventEmitter.emit).toHaveBeenCalledWith([identifier, '*'].join(':'), domainObject);
+        });
+    });
+});

src/api/objects/ObjectAPI.js

@@ -0,0 +1,90 @@
+define([
+    'lodash',
+    'EventEmitter',
+    './object-utils',
+    './MutableObject'
+], function (
+    _,
+    EventEmitter,
+    utils,
+    MutableObject
+) {
+
+    /**
+        Object API.  Intercepts the existing object API while also exposing
+        A new Object API.
+    */
+
+    var Objects = {},
+        ROOT_REGISTRY = [],
+        PROVIDER_REGISTRY = {},
+        FALLBACK_PROVIDER,
+        eventEmitter = new EventEmitter();
+
+    Objects._supersecretSetFallbackProvider = function (p) {
+        FALLBACK_PROVIDER = p;
+    };
+
+    // Root provider is hardcoded in; can't be skipped.
+    var RootProvider = {
+        'get': function () {
+            return Promise.resolve({
+                name: 'The root object',
+                type: 'root',
+                composition: ROOT_REGISTRY
+            });
+        }
+    };
+
+    // Retrieve the provider for a given key.
+    function getProvider(key) {
+        if (key.identifier === 'ROOT') {
+            return RootProvider;
+        }
+        return PROVIDER_REGISTRY[key.namespace] || FALLBACK_PROVIDER;
+    }
+
+    Objects.addProvider = function (namespace, provider) {
+        PROVIDER_REGISTRY[namespace] = provider;
+    };
+
+    [
+        'save',
+        'delete',
+        'get'
+    ].forEach(function (method) {
+        Objects[method] = function () {
+            var key = arguments[0],
+                provider = getProvider(key);
+
+            if (!provider) {
+                throw new Error('No Provider Matched');
+            }
+
+            if (!provider[method]) {
+                throw new Error('Provider does not support [' + method + '].');
+            }
+
+            return provider[method].apply(provider, arguments);
+        };
+    });
+
+    Objects.addRoot = function (key) {
+        ROOT_REGISTRY.unshift(key);
+    };
+
+    Objects.removeRoot = function (key) {
+        ROOT_REGISTRY = ROOT_REGISTRY.filter(function (k) {
+            return (
+                k.identifier !== key.identifier ||
+                k.namespace !== key.namespace
+            );
+        });
+    };
+
+    Objects.getMutable = function (object) {
+        return new MutableObject(eventEmitter, object);
+    };
+
+    return Objects;
+});

src/api/objects/README.md

@@ -0,0 +1,54 @@
+# Object API - Overview
+
+The object API provides methods for fetching domain objects.
+
+# Keys
+Keys are a composite identifier that is used to create and persist objects.  Ex:
+```javascript
+{
+    namespace: 'elastic',
+    identifier: 'myIdentifier'
+}
+```
+
+In old MCT days, we called this an "id", and we encoded it in a single string.  
+The above key would encode into the identifier, `elastic:myIdentifier`.
+
+When interacting with the API you will be dealing with key objects.
+
+## Roots
+
+"Roots" are objects that Open MCT will load at run time and form the basic entry point for users.  You can register new root objects by calling the 
+
+# Configuring the Object API
+
+The following methods should be used before calling run.  They allow you to 
+configure the persistence space of MCT.
+
+* `MCT.objects.addRoot(key)` -- add a "ROOT" to Open MCT by specifying it's key.
+* `MCT.objects.removeRoot(key)` -- Remove a "ROOT" from Open MCT by key.
+* `MCT.objects.addProvider(namespace, provider)` -- register an object provider for a specific namespace.  See below for documentation on the provider interface.
+
+# defining providers
+
+# Using the object API
+
+The object API provides methods for getting, saving, and deleting objects.  Plugin developers may not frequently need to interact with this API, as they should receive instances of the objects as needed.
+
+* MCT.objects.get(key) -> returns promise for an object
+* MCT.objects.save(object) -> returns promise that is resolved when object has been saved
+* MCT.objects.delete(object) -> returns promise that is resolved when object has been deleted
+
+## Configuration Example: Adding a groot
+
+See the tutorial in [object-provider.html](object-provider.html).
+
+### Making a custom provider:
+
+All methods on the provider interface are optional. 
+
+* `provider.get(key)` -> returns promise for a domain object.
+* `provider.save(domainObject)` -> returns promise that is fulfilled when object has been saved.
+* `provider.delete(domainObject)` -> returns promise that is fulfilled when object has been deleted.
+
+

src/api/objects/bundle.js

@@ -0,0 +1,49 @@
+/*****************************************************************************
+ * 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.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    './LegacyObjectAPIInterceptor',
+    'legacyRegistry'
+], function (
+    LegacyObjectAPIInterceptor,
+    legacyRegistry
+) {
+    legacyRegistry.register('src/api/objects', {
+        name: 'Object API',
+        description: 'The public Objects API',
+        extensions: {
+            components: [
+                {
+                    provides: "objectService",
+                    type: "decorator",
+                    priority: "mandatory",
+                    implementation: LegacyObjectAPIInterceptor,
+                    depends: [
+                        "roots[]",
+                        "instantiate"
+                    ]
+                }
+            ]
+        }
+    });
+});

src/api/objects/object-utils.js

@@ -0,0 +1,88 @@
+define([
+
+], function (
+
+) {
+
+    // take a key string and turn it into a key object
+    // 'scratch:root' ==> {namespace: 'scratch', identifier: 'root'}
+    var parseKeyString = function (key) {
+        if (typeof key === 'object') {
+            return key;
+        }
+        var namespace = '',
+            identifier = key;
+        for (var i = 0, escaped = false, len=key.length; i < key.length; i++) {
+            if (escaped) {
+                escaped = false;
+            } else {
+                if (key[i] === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (key[i] === ":") {
+                    // namespace = key.slice(0, i);
+                    identifier = key.slice(i + 1);
+                    break;
+                }
+            }
+            namespace += key[i];
+        }
+
+        if (key === namespace) {
+            namespace = '';
+        }
+
+        return {
+            namespace: namespace,
+            identifier: identifier
+        };
+    };
+
+    // take a key and turn it into a key string
+    // {namespace: 'scratch', identifier: 'root'} ==> 'scratch:root'
+    var makeKeyString = function (key) {
+        if (typeof key === 'string') {
+            return key;
+        }
+        if (!key.namespace) {
+            return key.identifier;
+        }
+        return [
+            key.namespace.replace(':', '\\:'),
+            key.identifier.replace(':', '\\:')
+        ].join(':');
+    };
+
+    // Converts composition to use key strings instead of keys
+    var toOldFormat = function (model) {
+        model = JSON.parse(JSON.stringify(model));
+        delete model.key;
+        if (model.composition) {
+            model.composition = model.composition.map(makeKeyString);
+        }
+        return model;
+    };
+
+    // converts composition to use keys instead of key strings
+    var toNewFormat = function (model, key) {
+        model = JSON.parse(JSON.stringify(model));
+        model.key = key;
+        if (model.composition) {
+            model.composition = model.composition.map(parseKeyString);
+        }
+        return model;
+    };
+
+    var equals = function (a, b) {
+        return makeKeyString(a.key) === makeKeyString(b.key);
+    };
+
+    return {
+        toOldFormat: toOldFormat,
+        toNewFormat: toNewFormat,
+        makeKeyString: makeKeyString,
+        parseKeyString: parseKeyString,
+        equals: equals
+    };
+});

src/defaultRegistry.js

@@ -0,0 +1,113 @@
+define([
+    'legacyRegistry',
+
+    '../src/adapter/bundle',
+    '../src/api/objects/bundle',
+
+    '../example/builtins/bundle',
+    '../example/composite/bundle',
+    '../example/eventGenerator/bundle',
+    '../example/export/bundle',
+    '../example/extensions/bundle',
+    '../example/forms/bundle',
+    '../example/generator/bundle',
+    '../example/identity/bundle',
+    '../example/imagery/bundle',
+    '../example/mobile/bundle',
+    '../example/msl/bundle',
+    '../example/notifications/bundle',
+    '../example/persistence/bundle',
+    '../example/plotOptions/bundle',
+    '../example/policy/bundle',
+    '../example/profiling/bundle',
+    '../example/scratchpad/bundle',
+    '../example/taxonomy/bundle',
+    '../example/worker/bundle',
+
+    '../platform/commonUI/about/bundle',
+    '../platform/commonUI/browse/bundle',
+    '../platform/commonUI/dialog/bundle',
+    '../platform/commonUI/edit/bundle',
+    '../platform/commonUI/formats/bundle',
+    '../platform/commonUI/general/bundle',
+    '../platform/commonUI/inspect/bundle',
+    '../platform/commonUI/mobile/bundle',
+    '../platform/commonUI/notification/bundle',
+    '../platform/commonUI/regions/bundle',
+    '../platform/commonUI/themes/espresso/bundle',
+    '../platform/commonUI/themes/snow/bundle',
+    '../platform/containment/bundle',
+    '../platform/core/bundle',
+    '../platform/entanglement/bundle',
+    '../platform/execution/bundle',
+    '../platform/exporters/bundle',
+    '../platform/features/clock/bundle',
+    '../platform/features/conductor/bundle',
+    '../platform/features/imagery/bundle',
+    '../platform/features/layout/bundle',
+    '../platform/features/pages/bundle',
+    '../platform/features/plot/bundle',
+    '../platform/features/static-markup/bundle',
+    '../platform/features/table/bundle',
+    '../platform/features/timeline/bundle',
+    '../platform/forms/bundle',
+    '../platform/framework/bundle',
+    '../platform/framework/src/load/Bundle',
+    '../platform/identity/bundle',
+    '../platform/persistence/aggregator/bundle',
+    '../platform/persistence/couch/bundle',
+    '../platform/persistence/elastic/bundle',
+    '../platform/persistence/local/bundle',
+    '../platform/persistence/queue/bundle',
+    '../platform/policy/bundle',
+    '../platform/representation/bundle',
+    '../platform/search/bundle',
+    '../platform/status/bundle',
+    '../platform/telemetry/bundle',
+], function (legacyRegistry) {
+
+    var DEFAULTS = [
+        'src/adapter',
+        'src/api/objects',
+        'platform/framework',
+        'platform/core',
+        'platform/representation',
+        'platform/commonUI/about',
+        'platform/commonUI/browse',
+        'platform/commonUI/edit',
+        'platform/commonUI/dialog',
+        'platform/commonUI/formats',
+        'platform/commonUI/general',
+        'platform/commonUI/inspect',
+        'platform/commonUI/mobile',
+        'platform/commonUI/themes/espresso',
+        'platform/commonUI/notification',
+        'platform/containment',
+        'platform/execution',
+        'platform/exporters',
+        'platform/telemetry',
+        'platform/features/clock',
+        'platform/features/imagery',
+        'platform/features/layout',
+        'platform/features/pages',
+        'platform/features/plot',
+        'platform/features/timeline',
+        'platform/features/table',
+        'platform/forms',
+        'platform/identity',
+        'platform/persistence/aggregator',
+        'platform/persistence/local',
+        'platform/persistence/queue',
+        'platform/policy',
+        'platform/entanglement',
+        'platform/search',
+        'platform/status',
+        'platform/commonUI/regions'
+    ];
+
+    DEFAULTS.forEach(function (bundlePath) {
+        legacyRegistry.enable(bundlePath);
+    });
+
+    return legacyRegistry;
+});

src/end.frag

@@ -0,0 +1,3 @@
+
+   return require('main'); 
+}));

src/start.frag

@@ -0,0 +1,9 @@
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define([], factory);
+    } else if (typeof exports === 'object') {
+        module.exports = factory();
+    } else {
+        root.MCT = factory();
+    }
+}(this, function() {

src/ui/Dialog.js

@@ -0,0 +1,43 @@
+define(['text!./dialog.html', 'zepto'], function (dialogTemplate, $) {
+    function Dialog(view, title) {
+        this.view = view;
+        this.title = title;
+    }
+
+    Dialog.prototype.show = function () {
+        var $body = $('body');
+        var $dialog = $(dialogTemplate);
+        var $contents = $dialog.find('.contents .editor');
+        var $close = $dialog.find('.close');
+
+        var $ok = $dialog.find('.ok');
+        var $cancel = $dialog.find('.cancel');
+
+        var view = this.view;
+
+        function dismiss() {
+            $dialog.remove();
+            view.destroy();
+        }
+
+        if (this.title) {
+            $dialog.find('.title').text(this.title);
+        }
+
+        $body.append($dialog);
+        this.view.show($contents[0]);
+
+        return new Promise(function (resolve, reject) {
+            $ok.on('click', resolve);
+            $ok.on('click', dismiss);
+
+            $cancel.on('click', reject);
+            $cancel.on('click', dismiss);
+
+            $close.on('click', reject);
+            $close.on('click', dismiss);
+        });
+    };
+
+    return Dialog;
+});

src/ui/dialog.html

@@ -0,0 +1,21 @@
+<div class="abs overlay">
+    <div class="abs blocker"></div>
+    <div class="abs holder">
+        <a class="clk-icon icon ui-symbol close">x</a>
+        <div class="abs contents">
+            <div class="abs top-bar">
+                <div class="title"></div>
+                <div class="hint"></div>
+            </div>
+            <div class='abs editor'>
+            </div>
+            <div class="abs bottom-bar">
+                <a class='s-btn major ok'>OK</a>
+                <a class='s-btn cancel'>Cancel</a>
+            </div>
+        </div>
+    </div>
+</div>
+
+
+

test-main.js

@@ -48,13 +48,15 @@ requirejs.config({
         "angular-route": "bower_components/angular-route/angular-route.min",
         "csv": "bower_components/comma-separated-values/csv.min",
         "es6-promise": "bower_components/es6-promise/promise.min",
+        "EventEmitter": "bower_components/eventemitter3/index",
         "moment": "bower_components/moment/moment",
         "moment-duration-format": "bower_components/moment-duration-format/lib/moment-duration-format",
         "saveAs": "bower_components/FileSaver.js/FileSaver.min",
         "screenfull": "bower_components/screenfull/dist/screenfull.min",
         "text": "bower_components/text/text",
         "uuid": "bower_components/node-uuid/uuid",
-        "zepto": "bower_components/zepto/zepto.min"
+        "zepto": "bower_components/zepto/zepto.min",
+        "lodash": "bower_components/lodash/lodash"
     },
 
     "shim": {
@@ -64,6 +66,9 @@ requirejs.config({
         "angular-route": {
             "deps": [ "angular" ]
         },
+        "EventEmitter": {
+            "exports": "EventEmitter"
+        },
         "moment-duration-format": {
             "deps": [ "moment" ]
         },
@@ -72,6 +77,9 @@ requirejs.config({
         },
         "zepto": {
             "exports": "Zepto"
+        },
+        "lodash": {
+            "exports": "lodash"
         }
     },
 

tutorial-server/app.js

@@ -0,0 +1,127 @@
+/*global require,process,console*/
+
+var CONFIG = {
+    port: 8081,
+    dictionary: "dictionary.json",
+    interval: 1000
+};
+
+(function () {
+    "use strict";
+
+    var WebSocketServer = require('ws').Server,
+        fs = require('fs'),
+        wss = new WebSocketServer({ port: CONFIG.port }),
+        dictionary = JSON.parse(fs.readFileSync(CONFIG.dictionary, "utf8")),
+        spacecraft = {
+            "prop.fuel": 77,
+            "prop.thrusters": "OFF",
+            "comms.recd": 0,
+            "comms.sent": 0,
+            "pwr.temp": 245,
+            "pwr.c": 8.15,
+            "pwr.v": 30
+        },
+        histories = {},
+        listeners = [];
+
+    function updateSpacecraft() {
+        spacecraft["prop.fuel"] = Math.max(
+            0,
+            spacecraft["prop.fuel"] -
+            (spacecraft["prop.thrusters"] === "ON" ? 0.5 : 0)
+        );
+        spacecraft["pwr.temp"] = spacecraft["pwr.temp"] * 0.985
+        + Math.random() * 0.25 + Math.sin(Date.now());
+        spacecraft["pwr.c"] = spacecraft["pwr.c"] * 0.985;
+        spacecraft["pwr.v"] = 30 + Math.pow(Math.random(), 3);
+    }
+
+    function generateTelemetry() {
+        var timestamp = Date.now(), sent = 0;
+        Object.keys(spacecraft).forEach(function (id) {
+            var state = { timestamp: timestamp, value: spacecraft[id] };
+            histories[id] = histories[id] || []; // Initialize
+            histories[id].push(state);
+            spacecraft["comms.sent"] += JSON.stringify(state).length;
+        });
+        listeners.forEach(function (listener) {
+            listener();
+        });
+    }
+
+    function update() {
+        updateSpacecraft();
+        generateTelemetry();
+    }
+
+    function handleConnection(ws) {
+        var subscriptions = {}, // Active subscriptions for this connection
+            handlers = {        // Handlers for specific requests
+                dictionary: function () {
+                    ws.send(JSON.stringify({
+                        type: "dictionary",
+                        value: dictionary
+                    }));
+                },
+                subscribe: function (id) {
+                    subscriptions[id] = true;
+                },
+                unsubscribe: function (id) {
+                    delete subscriptions[id];
+                },
+                history: function (id) {
+                    ws.send(JSON.stringify({
+                        type: "history",
+                        id: id,
+                        value: histories[id]
+                    }));
+                }
+            };
+
+        function notifySubscribers() {
+            Object.keys(subscriptions).forEach(function (id) {
+                var history = histories[id];
+                if (history) {
+                    ws.send(JSON.stringify({
+                        type: "data",
+                        id: id,
+                        value: history[history.length - 1]
+                    }));
+                }
+            });
+        }
+
+        // Listen for requests
+        ws.on('message', function (message) {
+            var parts = message.split(' '),
+                handler = handlers[parts[0]];
+            if (handler) {
+                handler.apply(handlers, parts.slice(1));
+            }
+        });
+
+        // Stop sending telemetry updates for this connection when closed
+        ws.on('close', function () {
+            listeners = listeners.filter(function (listener) {
+                return listener !== notifySubscribers;
+            });
+        });
+
+        // Notify subscribers when telemetry is updated
+        listeners.push(notifySubscribers);
+    }
+
+    update();
+    setInterval(update, CONFIG.interval);
+
+    wss.on('connection', handleConnection);
+
+    console.log("Example spacecraft running on port ");
+    console.log("Press Enter to toggle thruster state.");
+    process.stdin.on('data', function (data) {
+        spacecraft['prop.thrusters'] =
+            (spacecraft['prop.thrusters'] === "OFF") ? "ON" : "OFF";
+        console.log("Thrusters " + spacecraft["prop.thrusters"]);
+    });
+}());

tutorial-server/dictionary.json

@@ -0,0 +1,66 @@
+{
+    "name": "Example Spacecraft",
+    "identifier": "sc",
+    "subsystems": [
+        {
+            "name": "Propulsion",
+            "identifier": "prop",
+            "measurements": [
+                {
+                    "name": "Fuel",
+                    "identifier": "prop.fuel",
+                    "units": "kilograms",
+                    "type": "float"
+                },
+                {
+                    "name": "Thrusters",
+                    "identifier": "prop.thrusters",
+                    "units": "None",
+                    "type": "string"
+                }
+            ]
+        },
+        {
+            "name": "Communications",
+            "identifier": "comms",
+            "measurements": [
+                {
+                    "name": "Received",
+                    "identifier": "comms.recd",
+                    "units": "bytes",
+                    "type": "integer"
+                },
+                {
+                    "name": "Sent",
+                    "identifier": "comms.sent",
+                    "units": "bytes",
+                    "type": "integer"
+                }
+            ]
+        },
+        {
+            "name": "Power",
+            "identifier": "pwr",
+            "measurements": [
+                {
+                    "name": "Generator Temperature",
+                    "identifier": "pwr.temp",
+                    "units": "\u0080C",
+                    "type": "float"
+                },
+                {
+                    "name": "Generator Current",
+                    "identifier": "pwr.c",
+                    "units": "A",
+                    "type": "float"
+                },
+                {
+                    "name": "Generator Voltage",
+                    "identifier": "pwr.v",
+                    "units": "V",
+                    "type": "float"
+                }
+            ]
+        }
+    ]
+}

tutorials/bargraph/bundle.js

@@ -0,0 +1,66 @@
+define([
+    'legacyRegistry',
+    './src/controllers/BarGraphController'
+], function (
+    legacyRegistry,
+    BarGraphController
+    ) {
+    legacyRegistry.register("tutorials/bargraph", {
+        "name": "Bar Graph",
+        "description": "Provides the Bar Graph view of telemetry elements.",
+        "extensions": {
+            "views": [
+                {
+                    "name": "Bar Graph",
+                    "key": "example.bargraph",
+                    "glyph": "H",
+                    "templateUrl": "templates/bargraph.html",
+                    "needs": [ "telemetry" ],
+                    "delegation": true,
+                    "editable": true,
+                    "toolbar": {
+                        "sections": [
+                            {
+                                "items": [
+                                    {
+                                        "name": "Low",
+                                        "property": "low",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    },
+                                    {
+                                        "name": "Middle",
+                                        "property": "middle",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    },
+                                    {
+                                        "name": "High",
+                                        "property": "high",
+                                        "required": true,
+                                        "control": "textfield",
+                                        "size": 4
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            ],
+            "stylesheets": [
+                {
+                    "stylesheetUrl": "css/bargraph.css"
+                }
+            ],
+            "controllers": [
+                {
+                    "key": "BarGraphController",
+                    "implementation": BarGraphController,
+                    "depends": [ "$scope", "telemetryHandler" ]
+                }
+            ]
+        }
+    });
+});

tutorials/bargraph/res/templates/bargraph.html

@@ -0,0 +1,35 @@
+<div class="example-bargraph" ng-controller="BarGraphController">
+    <div class="example-tick-labels">
+        <div ng-repeat="value in [low, middle, high] track by $index"
+             class="example-tick-label"
+             style="bottom: {{ toPercent(value) }}%">
+            {{value}}
+        </div>
+    </div>
+
+    <div class="example-graph-area">
+        <div ng-repeat="telemetryObject in telemetryObjects"
+             style="left: {{barWidth * $index}}%; width: {{barWidth}}%"
+             class="example-bar-holder">
+            <div class="example-bar"
+                 ng-style="{
+                     bottom: getBottom(telemetryObject) + '%',
+                     top: getTop(telemetryObject) + '%'
+                 }">
+            </div>
+        </div>
+        <div style="bottom: {{ toPercent(middle) }}%"
+             class="example-graph-tick">
+        </div>
+    </div>
+
+    <div class="example-bar-labels">
+        <div ng-repeat="telemetryObject in telemetryObjects"
+             style="left: {{barWidth * $index}}%; width: {{barWidth}}%"
+             class="example-bar-holder example-label">
+            <mct-representation key="'label'"
+                                mct-object="telemetryObject">
+            </mct-representation>
+        </div>
+    </div>
+</div>

tutorials/bargraph/src/controllers/BarGraphController.js

@@ -0,0 +1,75 @@
+define(function () {
+    function BarGraphController($scope, telemetryHandler) {
+        var handle;
+
+        // Expose configuration constants directly in scope
+        function exposeConfiguration() {
+            $scope.low = $scope.configuration.low;
+            $scope.middle = $scope.configuration.middle;
+            $scope.high = $scope.configuration.high;
+        }
+
+        // Populate a default value in the configuration
+        function setDefault(key, value) {
+            if ($scope.configuration[key] === undefined) {
+                $scope.configuration[key] = value;
+            }
+        }
+
+        // Getter-setter for configuration properties (for view proxy)
+        function getterSetter(property) {
+            return function (value) {
+                value = parseFloat(value);
+                if (!isNaN(value)) {
+                    $scope.configuration[property] = value;
+                    exposeConfiguration();
+                }
+                return $scope.configuration[property];
+            };
+        }
+
+        // Add min/max defaults
+        setDefault('low', -1);
+        setDefault('middle', 0);
+        setDefault('high', 1);
+        exposeConfiguration($scope.configuration);
+
+        // Expose view configuration options
+        if ($scope.selection) {
+            $scope.selection.proxy({
+                low: getterSetter('low'),
+                middle: getterSetter('middle'),
+                high: getterSetter('high')
+            });
+        }
+
+        // Convert value to a percent between 0-100
+        $scope.toPercent = function (value) {
+            var pct = 100 * (value - $scope.low) /
+                ($scope.high - $scope.low);
+            return Math.min(100, Math.max(0, pct));
+        };
+
+        // Get bottom and top (as percentages) for current value
+        $scope.getBottom = function (telemetryObject) {
+            var value = handle.getRangeValue(telemetryObject);
+            return $scope.toPercent(Math.min($scope.middle, value));
+        };
+        $scope.getTop = function (telemetryObject) {
+            var value = handle.getRangeValue(telemetryObject);
+            return 100 - $scope.toPercent(Math.max($scope.middle, value));
+        };
+
+        // Use the telemetryHandler to get telemetry objects here
+        handle = telemetryHandler.handle($scope.domainObject, function () {
+            $scope.telemetryObjects = handle.getTelemetryObjects();
+            $scope.barWidth =
+                100 / Math.max(($scope.telemetryObjects).length, 1);
+        });
+
+        // Release subscriptions when scope is destroyed
+        $scope.$on('$destroy', handle.unsubscribe);
+    }
+
+    return BarGraphController;
+});

tutorials/telemetry/bundle.js

@@ -0,0 +1,90 @@
+define([
+    'legacyRegistry',
+    './src/ExampleTelemetryServerAdapter',
+    './src/ExampleTelemetryInitializer',
+    './src/ExampleTelemetryModelProvider'
+], function (
+    legacyRegistry,
+    ExampleTelemetryServerAdapter,
+    ExampleTelemetryInitializer,
+    ExampleTelemetryModelProvider
+) {
+    legacyRegistry.register("tutorials/telemetry", {
+        "name": "Example Telemetry Adapter",
+        "extensions": {
+            "types": [
+                {
+                    "name": "Spacecraft",
+                    "key": "example.spacecraft",
+                    "glyph": "o"
+                },
+                {
+                    "name": "Subsystem",
+                    "key": "example.subsystem",
+                    "glyph": "o",
+                    "model": { "composition": [] }
+                },
+                {
+                    "name": "Measurement",
+                    "key": "example.measurement",
+                    "glyph": "T",
+                    "model": { "telemetry": {} },
+                    "telemetry": {
+                        "source": "example.source",
+                        "domains": [
+                            {
+                                "name": "Time",
+                                "key": "timestamp"
+                            }
+                        ]
+                    }
+                }
+            ],
+            "roots": [
+                {
+                    "id": "example:sc",
+                    "priority": "preferred",
+                    "model": {
+                        "type": "example.spacecraft",
+                        "name": "My Spacecraft",
+                        "composition": []
+                    }
+                }
+            ],
+            "services": [
+                {
+                    "key": "example.adapter",
+                    "implementation": "ExampleTelemetryServerAdapter.js",
+                    "depends": [ "$q", "EXAMPLE_WS_URL" ]
+                }
+            ],
+            "constants": [
+                {
+                    "key": "EXAMPLE_WS_URL",
+                    "priority": "fallback",
+                    "value": "ws://localhost:8081"
+                }
+            ],
+            "runs": [
+                {
+                    "implementation": "ExampleTelemetryInitializer.js",
+                    "depends": [ "example.adapter", "objectService" ]
+                }
+            ],
+            "components": [
+                {
+                    "provides": "modelService",
+                    "type": "provider",
+                    "implementation": "ExampleTelemetryModelProvider.js",
+                    "depends": [ "example.adapter", "$q" ]
+                },
+                {
+                    "provides": "telemetryService",
+                    "type": "provider",
+                    "implementation": "ExampleTelemetryProvider.js",
+                    "depends": [ "example.adapter", "$q" ]
+                }
+            ]
+        }
+    });
+});

tutorials/telemetry/src/ExampleTelemetryInitializer.js

@@ -0,0 +1,47 @@
+define(
+    function () {
+        "use strict";
+
+        var TAXONOMY_ID = "example:sc",
+            PREFIX = "example_tlm:";
+
+        function ExampleTelemetryInitializer(adapter, objectService) {
+            // Generate a domain object identifier for a dictionary element
+            function makeId(element) {
+                return PREFIX + element.identifier;
+            }
+
+            // When the dictionary is available, add all subsystems
+            // to the composition of My Spacecraft
+            function initializeTaxonomy(dictionary) {
+                // Get the top-level container for dictionary objects
+                // from a group of domain objects.
+                function getTaxonomyObject(domainObjects) {
+                    return domainObjects[TAXONOMY_ID];
+                }
+
+                // Populate
+                function populateModel(taxonomyObject) {
+                    return taxonomyObject.useCapability(
+                        "mutation",
+                        function (model) {
+                            model.name =
+                                dictionary.name;
+                            model.composition =
+                                dictionary.subsystems.map(makeId);
+                        }
+                    );
+                }
+
+                // Look up My Spacecraft, and populate it accordingly.
+                objectService.getObjects([TAXONOMY_ID])
+                    .then(getTaxonomyObject)
+                    .then(populateModel);
+            }
+
+            adapter.dictionary().then(initializeTaxonomy);
+        }
+
+        return ExampleTelemetryInitializer;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryModelProvider.js

@@ -0,0 +1,78 @@
+define(
+    function () {
+        "use strict";
+
+        var PREFIX = "example_tlm:",
+            FORMAT_MAPPINGS = {
+                float: "number",
+                integer: "number",
+                string: "string"
+            };
+
+        function ExampleTelemetryModelProvider(adapter, $q) {
+            var modelPromise, empty = $q.when({});
+
+            // Check if this model is in our dictionary (by prefix)
+            function isRelevant(id) {
+                return id.indexOf(PREFIX) === 0;
+            }
+
+            // Build a domain object identifier by adding a prefix
+            function makeId(element) {
+                return PREFIX + element.identifier;
+            }
+
+            // Create domain object models from this dictionary
+            function buildTaxonomy(dictionary) {
+                var models = {};
+
+                // Create & store a domain object model for a measurement
+                function addMeasurement(measurement) {
+                    var format = FORMAT_MAPPINGS[measurement.type];
+                    models[makeId(measurement)] = {
+                        type: "example.measurement",
+                        name: measurement.name,
+                        telemetry: {
+                            key: measurement.identifier,
+                            ranges: [{
+                                key: "value",
+                                name: "Value",
+                                units: measurement.units,
+                                format: format
+                            }]
+                        }
+                    };
+                }
+
+                // Create & store a domain object model for a subsystem
+                function addSubsystem(subsystem) {
+                    var measurements =
+                        (subsystem.measurements || []);
+                    models[makeId(subsystem)] = {
+                        type: "example.subsystem",
+                        name: subsystem.name,
+                        composition: measurements.map(makeId)
+                    };
+                    measurements.forEach(addMeasurement);
+                }
+
+                (dictionary.subsystems || []).forEach(addSubsystem);
+
+                return models;
+            }
+
+            // Begin generating models once the dictionary is available
+            modelPromise = adapter.dictionary().then(buildTaxonomy);
+
+            return {
+                getModels: function (ids) {
+                    // Return models for the dictionary only when they
+                    // are relevant to the request.
+                    return ids.some(isRelevant) ? modelPromise : empty;
+                }
+            };
+        }
+
+        return ExampleTelemetryModelProvider;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryProvider.js

@@ -0,0 +1,80 @@
+define(
+    ['./ExampleTelemetrySeries'],
+    function (ExampleTelemetrySeries) {
+        "use strict";
+
+        var SOURCE = "example.source";
+
+        function ExampleTelemetryProvider(adapter, $q) {
+            var subscribers = {};
+
+            // Used to filter out requests for telemetry
+            // from some other source
+            function matchesSource(request) {
+                return (request.source === SOURCE);
+            }
+
+            // Listen for data, notify subscribers
+            adapter.listen(function (message) {
+                var packaged = {};
+                packaged[SOURCE] = {};
+                packaged[SOURCE][message.id] =
+                    new ExampleTelemetrySeries([message.value]);
+                (subscribers[message.id] || []).forEach(function (cb) {
+                    cb(packaged);
+                });
+            });
+
+            return {
+                requestTelemetry: function (requests) {
+                    var packaged = {},
+                        relevantReqs = requests.filter(matchesSource);
+
+                    // Package historical telemetry that has been received
+                    function addToPackage(history) {
+                        packaged[SOURCE][history.id] =
+                            new ExampleTelemetrySeries(history.value);
+                    }
+
+                    // Retrieve telemetry for a specific measurement
+                    function handleRequest(request) {
+                        var key = request.key;
+                        return adapter.history(key).then(addToPackage);
+                    }
+
+                    packaged[SOURCE] = {};
+                    return $q.all(relevantReqs.map(handleRequest))
+                        .then(function () { return packaged; });
+                },
+                subscribe: function (callback, requests) {
+                    var keys = requests.filter(matchesSource)
+                        .map(function (req) { return req.key; });
+
+                    function notCallback(cb) {
+                        return cb !== callback;
+                    }
+
+                    function unsubscribe(key) {
+                        subscribers[key] =
+                            (subscribers[key] || []).filter(notCallback);
+                        if (subscribers[key].length < 1) {
+                            adapter.unsubscribe(key);
+                        }
+                    }
+
+                    keys.forEach(function (key) {
+                        subscribers[key] = subscribers[key] || [];
+                        adapter.subscribe(key);
+                        subscribers[key].push(callback);
+                    });
+
+                    return function () {
+                        keys.forEach(unsubscribe);
+                    };
+                }
+            };
+        }
+
+        return ExampleTelemetryProvider;
+    }
+);

tutorials/telemetry/src/ExampleTelemetrySeries.js

@@ -0,0 +1,23 @@
+/*global define*/
+
+define(
+    function () {
+        "use strict";
+
+        function ExampleTelemetrySeries(data) {
+            return {
+                getPointCount: function () {
+                    return data.length;
+                },
+                getDomainValue: function (index) {
+                    return (data[index] || {}).timestamp;
+                },
+                getRangeValue: function (index) {
+                    return (data[index] || {}).value;
+                }
+            };
+        }
+
+        return ExampleTelemetrySeries;
+    }
+);

tutorials/telemetry/src/ExampleTelemetryServerAdapter.js

@@ -0,0 +1,60 @@
+define(
+    [],
+    function () {
+        "use strict";
+
+        function ExampleTelemetryServerAdapter($q, wsUrl) {
+            var ws = new WebSocket(wsUrl),
+                histories = {},
+                listeners = [],
+                dictionary = $q.defer();
+
+            // Handle an incoming message from the server
+            ws.onmessage = function (event) {
+                var message = JSON.parse(event.data);
+
+                switch (message.type) {
+                case "dictionary":
+                    dictionary.resolve(message.value);
+                    break;
+                case "history":
+                    histories[message.id].resolve(message);
+                    delete histories[message.id];
+                    break;
+                case "data":
+                    listeners.forEach(function (listener) {
+                        listener(message);
+                    });
+                    break;
+                }
+            };
+
+            // Request dictionary once connection is established
+            ws.onopen = function () {
+                ws.send("dictionary");
+            };
+
+            return {
+                dictionary: function () {
+                    return dictionary.promise;
+                },
+                history: function (id) {
+                    histories[id] = histories[id] || $q.defer();
+                    ws.send("history " + id);
+                    return histories[id].promise;
+                },
+                subscribe: function (id) {
+                    ws.send("subscribe " + id);
+                },
+                unsubscribe: function (id) {
+                    ws.send("unsubscribe " + id);
+                },
+                listen: function (callback) {
+                    listeners.push(callback);
+                }
+            };
+        }
+
+        return ExampleTelemetryServerAdapter;
+    }
+);

tutorials/todo/todo-dialog.html

@@ -0,0 +1,3 @@
+<label>Description:
+    <input type="text" class="description">
+</label>

tutorials/todo/todo-task.html

@@ -0,0 +1,5 @@
+<li>
+    <input type="checkbox" class="example-task-checked">
+    <span class="example-task-description">
+    </span>
+</li>

tutorials/todo/todo-toolbar.html

@@ -0,0 +1,9 @@
+<div class="tool-bar btn-bar contents abs">
+    <a class="s-btn labeled example-add">
+        <span class="ui-symbol icon">+</span>
+        <span class="title-label">Add Task</span>
+    </a>
+    <a class="s-btn example-remove">
+        <span class="ui-symbol icon">Z</span>
+    </a>
+</div>

tutorials/todo/todo.css

@@ -0,0 +1,29 @@
+.example-todo div.example-button-group {
+    margin-top: 12px;
+    margin-bottom: 12px;
+}
+
+.example-todo .example-button-group a {
+    padding: 3px;
+    margin: 3px;
+}
+
+.example-todo .example-button-group a.selected {
+    border: 1px gray solid;
+    border-radius: 3px;
+    background: #444;
+}
+
+.example-todo .example-task-completed .example-task-description {
+    text-decoration: line-through;
+    opacity: 0.75;
+}
+
+.example-todo .example-task-description.selected {
+    background: #46A;
+    border-radius: 3px;
+}
+
+.example-todo .example-message {
+    font-style: italic;
+}

tutorials/todo/todo.html

@@ -0,0 +1,14 @@
+<div class="example-todo">
+    <div class="example-button-group">
+        <a class="example-todo-button-all">All</a>
+        <a class="example-todo-button-incomplete">Incomplete</a>
+        <a class="example-todo-button-complete">Complete</a>
+    </div>
+
+    <ul class="example-todo-task-list">
+    </ul>
+
+    <div class="example-message">
+        There are no tasks to show.
+    </div>
+</div>

tutorials/todo/todo.js

@@ -0,0 +1,215 @@
+define([
+    "text!./todo.html",
+    "text!./todo-task.html",
+    "text!./todo-toolbar.html",
+    "text!./todo-dialog.html",
+    "../../src/api/objects/object-utils",
+    "zepto"
+], function (todoTemplate, taskTemplate, toolbarTemplate, dialogTemplate, utils, $) {
+    /**
+     * @param {mct.MCT} mct
+     */
+    return function todoPlugin(mct) {
+        var todoType = new mct.Type({
+            metadata: {
+                label: "To-Do List",
+                glyph: "2",
+                description: "A list of things that need to be done."
+            },
+            initialize: function (model) {
+                model.tasks = [
+                    { description: "This is a task." }
+                ];
+            },
+            creatable: true
+        });
+
+        function TodoView(domainObject) {
+            this.domainObject = domainObject;
+            this.mutableObject = mct.Objects.getMutable(domainObject)
+
+            this.filterValue = "all";
+            this.render = this.render.bind(this);
+            this.objectChanged = this.objectChanged.bind(this);
+        }
+
+        TodoView.prototype.objectChanged = function (object) {
+            this.render(object);
+        };
+
+        TodoView.prototype.show = function (container) {
+            var self = this;
+            this.destroy();
+
+            self.$els = $(todoTemplate);
+            self.$buttons = {
+                all: self.$els.find('.example-todo-button-all'),
+                incomplete: self.$els.find('.example-todo-button-incomplete'),
+                complete: self.$els.find('.example-todo-button-complete')
+            };
+
+            $(container).empty().append(self.$els);
+
+
+            self.initialize();
+            self.objectChanged(this.domainObject);
+
+            mct.selection.on('change', self.render);
+
+            //If anything on object changes, re-render view
+            this.mutableObject.on("*", this.objectChanged);
+        };
+
+        TodoView.prototype.destroy = function () {
+            if (this.mutableObject) {
+                this.mutableObject.stopListening();
+            }
+            mct.selection.off('change', this.render);
+        };
+
+        TodoView.prototype.setFilter = function (value) {
+            this.filterValue = value;
+            this.render();
+        };
+
+        TodoView.prototype.initialize = function () {
+            Object.keys(this.$buttons).forEach(function (k) {
+                this.$buttons[k].on('click', this.setFilter.bind(this, k));
+            }, this);
+        };
+
+        TodoView.prototype.render = function (domainObject) {
+            var $els = this.$els;
+            var mutableObject = mct.Objects.getMutable(domainObject);
+            var tasks = domainObject.tasks;
+            var $message = $els.find('.example-message');
+            var $list = $els.find('.example-todo-task-list');
+            var $buttons = this.$buttons;
+            var filters = {
+                all: function () {
+                    return true;
+                },
+                incomplete: function (task) {
+                    return !task.completed;
+                },
+                complete: function (task) {
+                    return task.completed;
+                }
+            };
+            var filterValue = this.filterValue;
+            var selected = mct.selection.selected();
+
+            Object.keys($buttons).forEach(function (k) {
+                $buttons[k].toggleClass('selected', filterValue === k);
+            });
+            tasks = tasks.filter(filters[filterValue]);
+
+            $list.empty();
+            tasks.forEach(function (task, index) {
+                var $taskEls = $(taskTemplate);
+                var $checkbox = $taskEls.find('.example-task-checked');
+                var $desc = $taskEls.find('.example-task-description');
+                $checkbox.prop('checked', task.completed);
+                $desc.text(task.description);
+
+                $checkbox.on('change', function () {
+                    var checked = !!$checkbox.prop('checked');
+                    mutableObject.set("tasks." + index + ".completed", checked);
+                });
+
+                $desc.on('click', function () {
+                    mct.selection.clear();
+                    mct.selection.select({ index: index });
+                });
+
+                if (selected.length > 0 && selected[0].index === index) {
+                    $desc.addClass('selected');
+                }
+
+                $list.append($taskEls);
+            });
+
+            $message.toggle(tasks.length < 1);
+        };
+
+        function TodoToolbarView(domainObject) {
+            this.domainObject = domainObject;
+            this.handleSelectionChange = this.handleSelectionChange.bind(this);
+            this.mutableObject = mct.Objects.getMutable(domainObject);
+        }
+
+        TodoToolbarView.prototype.show = function (container) {
+            var self = this;
+            this.destroy();
+
+            var $els = $(toolbarTemplate);
+            var $add = $els.find('a.example-add');
+            var $remove = $els.find('a.example-remove');
+
+            $(container).append($els);
+
+            $add.on('click', function () {
+                var $dialog = $(dialogTemplate),
+                    view = {
+                        show: function (container) {
+                            $(container).append($dialog);
+                        },
+                        destroy: function () {}
+                    };
+
+                mct.dialog(view, "Add a Task").then(function () {
+                    var description = $dialog.find('input').val();
+                    var tasks = self.domainObject.tasks;
+                    tasks.push({ description: description });
+                    self.mutableObject.set('tasks', tasks);
+                });
+            });
+            $remove.on('click', function () {
+                var index = mct.selection.selected()[0].index;
+                if (index !== undefined) {
+                    var tasks = self.mutableObject.tasks.filter(function (t, i) {
+                        return i !== index;
+                    });
+                    self.mutableObject.set("tasks", tasks);
+                    self.mutableObject.set("selected", undefined);
+                    mct.selection.clear();
+                }
+            });
+            self.$remove = $remove;
+            self.handleSelectionChange();
+            mct.selection.on('change', self.handleSelectionChange);
+        };
+
+        TodoToolbarView.prototype.handleSelectionChange = function () {
+            var selected = mct.selection.selected();
+            if (this.$remove) {
+                this.$remove.toggle(selected.length > 0);
+            }
+        };
+
+        TodoToolbarView.prototype.destroy = function () {
+            mct.selection.off('change', this.handleSelectionChange);
+            this.$remove = undefined;
+            if (this.mutableObject) {
+                this.mutableObject.stopListening();
+            }
+        };
+
+        mct.type('example.todo', todoType);
+        mct.view(mct.regions.main, {
+            view: function (domainObject) {
+                return new TodoView(domainObject);
+            },
+            canView: todoType.check.bind(todoType)
+        });
+
+        mct.view(mct.regions.toolbar, {
+            view: function (domainObject) {
+                return new TodoToolbarView(domainObject);
+            },
+            canView: todoType.check.bind(todoType)
+        });
+
+        return mct;
+    };
+});