ember-rails 0.4.0 → 0.5.0

data/vendor/{assets/javascripts → ember}/production/ember-runtime.js

@@ -10,7 +10,7 @@ if ('undefined' === typeof Ember) {
 /**
   @namespace
   @name Ember
-  @version 0.9.7.1
+  @version 0.9.8.1
 
   All Ember methods and functions are defined inside of this namespace.
   You generally should not add new properties to this namespace as it may be
@@ -30,7 +30,7 @@ if ('undefined' === typeof Ember) {
 
 // Create core object. Make it act like an instance of Ember.Namespace so that
 // objects assigned to it are given a sane string representation.
-Ember = { isNamespace: true, toString: function() { return "Ember"; } };
+Ember = {};
 
 // aliases needed to keep minifiers from removing the global context
 if ('undefined' !== typeof window) {
@@ -39,13 +39,20 @@ if ('undefined' !== typeof window) {
 
 }
 
+// Make sure these are set whether Ember was already defined or not
+
+Ember.isNamespace = true;
+
+Ember.toString = function() { return "Ember"; };
+
+
 /**
   @static
   @type String
-  @default '0.9.7.1'
+  @default '0.9.8.1'
   @constant
 */
-Ember.VERSION = '0.9.7.1';
+Ember.VERSION = '0.9.8.1';
 
 /**
   @static
@@ -92,6 +99,56 @@ Ember.EXTEND_PROTOTYPES = (Ember.ENV.EXTEND_PROTOTYPES !== false);
 Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
 
 
+/**
+  @static
+  @type Boolean
+  @default false
+  @constant
+
+  Determines whether computed properties are cacheable by default.
+  In future releases this will default to `true`. For the 1.0 release,
+  the option to turn off caching by default will be removed entirely.
+
+  When caching is enabled by default, you can use `volatile()` to disable
+  caching on individual computed properties.
+*/
+Ember.CP_DEFAULT_CACHEABLE = !!Ember.ENV.CP_DEFAULT_CACHEABLE;
+
+/**
+  @static
+  @type Boolean
+  @default false
+  @constant
+
+  Determines whether views render their templates using themselves
+  as the context, or whether it is inherited from the parent. In
+  future releases, this will default to `true`. For the 1.0 release,
+  the option to have views change context by default will be removed entirely.
+
+  If you need to update your application to use the new context rules, simply
+  prefix property access with `view.`:
+
+      // Before:
+      {{#each App.photosController}}
+        Photo Title: {{title}}
+        {{#view App.InfoView contentBinding="this"}}
+          {{content.date}}
+          {{content.cameraType}}
+          {{otherViewProperty}}
+        {{/view}}
+      {{/each}}
+
+      // After:
+      {{#each App.photosController}}
+        Photo Title: {{title}}
+        {{#view App.InfoView}}
+          {{date}}
+          {{cameraType}}
+          {{view.otherViewProperty}}
+        {{/view}}
+      {{/each}}
+*/
+Ember.VIEW_PRESERVES_CONTEXT = !!Ember.ENV.VIEW_PRESERVES_CONTEXT;
 
 /**
   Empty function.  Useful for some operations.
@@ -110,18 +167,24 @@ Ember.K = function() { return this; };
 
 // Stub out the methods defined by the ember-debug package in case it's not loaded
 
-if ('undefined' === typeof ember_assert) {
-  window.ember_assert = Ember.K;
+if ('undefined' === typeof Ember.assert) { Ember.assert = Ember.K; }
+if ('undefined' === typeof Ember.warn) { Ember.warn = Ember.K; }
+if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = Ember.K; }
+if ('undefined' === typeof Ember.deprecateFunc) {
+  Ember.deprecateFunc = function(_, func) { return func; };
 }
 
-if ('undefined' === typeof ember_warn) { window.ember_warn = Ember.K; }
+// These are deprecated but still supported
 
+if ('undefined' === typeof ember_assert) { window.ember_assert = Ember.K; }
+if ('undefined' === typeof ember_warn) { window.ember_warn = Ember.K; }
 if ('undefined' === typeof ember_deprecate) { window.ember_deprecate = Ember.K; }
-
 if ('undefined' === typeof ember_deprecateFunc) {
+  /** @private */
   window.ember_deprecateFunc = function(_, func) { return func; };
 }
 
+
 // ..........................................................
 // LOGGER
 //
@@ -655,7 +718,6 @@ Ember.makeArray = function(obj) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
 var USE_ACCESSORS = Ember.platform.hasPropertyAccessors && Ember.ENV.USE_ACCESSORS;
 Ember.USE_ACCESSORS = !!USE_ACCESSORS;
 
@@ -793,14 +855,24 @@ Ember.set = set;
 // PATHS
 //
 
+/** @private */
+function cleanupStars(path) {
+  if (path.indexOf('*') === -1 || path === '*') return path;
+
+
+  return path.replace(/(^|.)\*/, function(match, char){
+    return (char === '.') ? match : (char + '.');
+  });
+}
+
 /** @private */
 function normalizePath(path) {
 
+  path = cleanupStars(path);
 
   if (path==='*') return path; //special case...
   var first = path.charAt(0);
   if(first==='.') return 'this'+path;
-  if (first==='*' && path.charAt(1)!=='.') return 'this.'+path.slice(1);
   return path;
 }
 
@@ -809,10 +881,7 @@ function normalizePath(path) {
 function getPath(target, path) {
   var len = path.length, idx, next, key;
 
-  idx = path.indexOf('*');
-  if (idx>0 && path.charAt(idx-1)!=='.') {
-    return getPath(getPath(target, path.slice(0, idx)), path.slice(idx+1));
-  }
+  path = cleanupStars(path);
 
   idx = 0;
   while(target && idx<len) {
@@ -849,19 +918,9 @@ function normalizeTuple(target, path) {
   if (!target || isGlobal) target = window;
   if (hasThis) path = path.slice(5);
 
-  var idx = path.indexOf('*');
-  if (idx>0 && path.charAt(idx-1)!=='.') {
-
-    // should not do lookup on a prototype object because the object isn't
-    // really live yet.
-    if (target && meta(target,false).proto!==target) {
-      target = getPath(target, path.slice(0, idx));
-    } else {
-      target = null;
-    }
-    path   = path.slice(idx+1);
+  path = cleanupStars(path);
 
-  } else if (target === window) {
+  if (target === window) {
     key = firstKey(path);
     target = get(target, key);
     path   = path.slice(key.length+1);
@@ -915,8 +974,8 @@ Ember.getWithDefault = function(root, key, defaultValue) {
   return value;
 };
 
-Ember.getPath = function(root, path, _checkGlobal) {
-  var pathOnly, hasThis, hasStar, isGlobal, ret;
+Ember.getPath = function(root, path) {
+  var hasThis, isGlobal, ret;
 
   // Helpers that operate with 'this' within an #each
   if (path === '') {
@@ -926,37 +985,27 @@ Ember.getPath = function(root, path, _checkGlobal) {
   if (!path && 'string'===typeof root) {
     path = root;
     root = null;
-    pathOnly = true;
   }
 
-  hasStar = path.indexOf('*') > -1;
+  path = cleanupStars(path);
 
   // If there is no root and path is a key name, return that
   // property from the global object.
   // E.g. getPath('Ember') -> Ember
-  if (root === null && !hasStar && path.indexOf('.') < 0) { return get(window, path); }
+  if (root === null && path.indexOf('.') < 0) { return get(window, path); }
 
   // detect complicated paths and normalize them
   path = normalizePath(path);
   hasThis  = HAS_THIS.test(path);
 
-  if (!root || hasThis || hasStar) {
-
-
+  if (!root || hasThis) {
     var tuple = normalizeTuple(root, path);
     root = tuple[0];
     path = tuple[1];
     tuple.length = 0;
   }
 
-  ret = getPath(root, path);
-
-  if (ret === undefined && !pathOnly && !hasThis && root !== window && IS_GLOBAL.test(path) && _checkGlobal !== false) {
-
-    return Ember.getPath(window, path);
-  } else {
-    return ret;
-  }
+  return getPath(root, path);
 };
 
 Ember.setPath = function(root, path, value, tolerant) {
@@ -969,25 +1018,12 @@ Ember.setPath = function(root, path, value, tolerant) {
   }
 
   path = normalizePath(path);
-  if (path.indexOf('*')>0) {
-
-
-    var tuple = normalizeTuple(root, path);
-    root = tuple[0];
-    path = tuple[1];
-    tuple.length = 0;
-  }
 
   if (path.indexOf('.') > 0) {
     keyName = path.slice(path.lastIndexOf('.')+1);
     path    = path.slice(0, path.length-(keyName.length+1));
     if (path !== 'this') {
-      // Remove the `false` when we're done with this deprecation
-      root = Ember.getPath(root, path, false);
-      if (!root && IS_GLOBAL.test(path)) {
-
-        root = Ember.getPath(window, path);
-      }
+      root = Ember.getPath(root, path);
     }
 
   } else {
@@ -1045,7 +1081,6 @@ Ember.isGlobalPath = function(path) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
 var USE_ACCESSORS = Ember.USE_ACCESSORS;
 var GUID_KEY = Ember.GUID_KEY;
 var META_KEY = Ember.META_KEY;
@@ -1458,7 +1493,9 @@ Ember.createPrototype = function(obj, props) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
+
+
+
 var meta = Ember.meta;
 var guidFor = Ember.guidFor;
 var USE_ACCESSORS = Ember.USE_ACCESSORS;
@@ -1529,7 +1566,7 @@ function addDependentKeys(desc, obj, keyName) {
 /** @private */
 function ComputedProperty(func, opts) {
   this.func = func;
-  this._cacheable = opts && opts.cacheable;
+  this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : Ember.CP_DEFAULT_CACHEABLE;
   this._dependentKeys = opts && opts.dependentKeys;
 }
 
@@ -1614,11 +1651,10 @@ var Cp = ComputedProperty.prototype;
         }.property('firstName', 'lastName').cacheable()
       });
 
-  It is common to use `cacheable()` on nearly every computed property
-  you define. 
+  Properties are cacheable by default.
 
   @name Ember.ComputedProperty.cacheable
-  @param {Boolean} aFlag optional set to false to disable cacheing
+  @param {Boolean} aFlag optional set to false to disable caching
   @returns {Ember.ComputedProperty} receiver
 */
 Cp.cacheable = function(aFlag) {
@@ -1626,6 +1662,23 @@ Cp.cacheable = function(aFlag) {
   return this;
 };
 
+/**
+  Call on a computed property to set it into non-cached mode.  When in this
+  mode the computed property will not automatically cache the return value.
+
+      MyApp.outsideService = Ember.Object.create({
+        value: function() {
+          return OutsideService.getValue();
+        }.property().volatile()
+      });
+
+  @name Ember.ComputedProperty.volatile
+  @returns {Ember.ComputedProperty} receiver
+*/
+Cp.volatile = function() {
+  return this.cacheable(false);
+};
+
 /**
   Sets the dependent keys on this computed property.  Pass any number of
   arguments containing key paths that this computed property depends on.
@@ -1806,7 +1859,7 @@ Ember.computed = function(func) {
 Ember.cacheFor = function(obj, key) {
   var cache = meta(obj, false).cache;
 
-  if (cache && cache[key]) {
+  if (cache && key in cache) {
     return cache[key];
   }
 };
@@ -2203,7 +2256,6 @@ Ember.notifyBeforeObservers = function(obj, keyName) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
 var guidFor = Ember.guidFor;
 var meta    = Ember.meta;
 var get = Ember.get, set = Ember.set;
@@ -2312,16 +2364,14 @@ var pendingQueue = [];
 // back in the queue and reschedule is true, schedules a timeout to try
 // again.
 /** @private */
-function flushPendingChains(reschedule) {
+function flushPendingChains() {
   if (pendingQueue.length===0) return ; // nothing to do
 
   var queue = pendingQueue;
   pendingQueue = [];
 
   forEach(queue, function(q) { q[0].add(q[1]); });
-  if (reschedule!==false && pendingQueue.length>0) {
-    setTimeout(flushPendingChains, 1);
-  }
+
 }
 
 /** @private */
@@ -2691,14 +2741,6 @@ Ember.rewatch = function(obj) {
   // make sure any chained watchers update.
   if (chains && chains.value() !== obj) chainsFor(obj);
 
-  // if the object has bindings then sync them..
-  if (bindings && m.proto!==obj) {
-    for (key in bindings) {
-      b = !DEP_SKIP[key] && obj[key];
-      if (b && b instanceof Ember.Binding) b.fromDidChange(obj);
-    }
-  }
-
   return this;
 };
 
@@ -2817,7 +2859,6 @@ Ember.destroy = function (obj) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
 var o_create = Ember.platform.create;
 var meta = Ember.meta;
 var guidFor = Ember.guidFor;
@@ -2937,7 +2978,7 @@ function addListener(obj, eventName, target, method, xform) {
   }
 
   var actionSet = actionSetFor(obj, eventName, target, true),
-      methodGuid = guidFor(method), ret;
+      methodGuid = guidFor(method);
 
   if (!actionSet[methodGuid]) {
     actionSet[methodGuid] = { target: target, method: method, xform: xform };
@@ -2948,8 +2989,6 @@ function addListener(obj, eventName, target, method, xform) {
   if ('function' === typeof obj.didAddListener) {
     obj.didAddListener(eventName, target, method);
   }
-
-  return ret; // return true if this is the first listener.
 }
 
 /** @memberOf Ember */
@@ -3081,562 +3120,597 @@ Ember.deferEvent = deferEvent;
 (function() {
 // ==========================================================================
 // Project:  Ember Runtime
-// Copyright: ©2011 Strobe Inc. and contributors.
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-var Mixin, MixinDelegate, REQUIRED, Alias;
-var classToString, superClassString;
+// Ember.Logger
+// Ember.watch.flushPending
+// Ember.beginPropertyChanges, Ember.endPropertyChanges
+// Ember.guidFor
+// Ember.ArrayUtils
 
-var a_map = Ember.ArrayUtils.map;
-var a_indexOf = Ember.ArrayUtils.indexOf;
-var a_forEach = Ember.ArrayUtils.forEach;
-var a_slice = Array.prototype.slice;
-var EMPTY_META = {}; // dummy for non-writable meta
-var META_SKIP = { __emberproto__: true, __ember_count__: true };
+// ..........................................................
+// HELPERS
+//
 
-var o_create = Ember.platform.create;
+var slice = Array.prototype.slice;
+var forEach = Ember.ArrayUtils.forEach;
 
+// invokes passed params - normalizing so you can pass target/func,
+// target/string or just func
 /** @private */
-function meta(obj, writable) {
-  var m = Ember.meta(obj, writable!==false), ret = m.mixins;
-  if (writable===false) return ret || EMPTY_META;
+function invoke(target, method, args, ignore) {
 
-  if (!ret) {
-    ret = m.mixins = { __emberproto__: obj };
-  } else if (ret.__emberproto__ !== obj) {
-    ret = m.mixins = o_create(ret);
-    ret.__emberproto__ = obj;
+  if (method===undefined) {
+    method = target;
+    target = undefined;
   }
-  return ret;
-}
 
-/** @private */
-function initMixin(mixin, args) {
-  if (args && args.length > 0) {
-    mixin.mixins = a_map(args, function(x) {
-      if (x instanceof Mixin) return x;
+  if ('string'===typeof method) method = target[method];
+  if (args && ignore>0) {
+    args = args.length>ignore ? slice.call(args, ignore) : null;
+  }
 
-      // Note: Manually setup a primitive mixin here.  This is the only
-      // way to actually get a primitive mixin.  This way normal creation
-      // of mixins will give you combined mixins...
-      var mixin = new Mixin();
-      mixin.properties = x;
-      return mixin;
-    });
+  // Unfortunately in some browsers we lose the backtrace if we rethrow the existing error,
+  // so in the event that we don't have an `onerror` handler we don't wrap in a try/catch
+  if ('function' === typeof Ember.onerror) {
+    try {
+      // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
+      return method.apply(target || this, args || []);
+    } catch (error) {
+      Ember.onerror(error);
+    }
+  } else {
+    // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
+    return method.apply(target || this, args || []);
   }
-  return mixin;
 }
 
-var NATIVES = [Boolean, Object, Number, Array, Date, String];
+
+// ..........................................................
+// RUNLOOP
+//
+
+var timerMark; // used by timers...
+
 /** @private */
-function isMethod(obj) {
-  if ('function' !== typeof obj || obj.isMethod===false) return false;
-  return a_indexOf(NATIVES, obj)<0;
-}
+var K = function() {};
 
 /** @private */
-function mergeMixins(mixins, m, descs, values, base) {
-  var len = mixins.length, idx, mixin, guid, props, value, key, ovalue, concats;
+var RunLoop = function(prev) {
+  var self;
 
-  /** @private */
-  function removeKeys(keyName) {
-    delete descs[keyName];
-    delete values[keyName];
+  if (this instanceof RunLoop) {
+    self = this;
+  } else {
+    self = new K();
   }
 
-  for(idx=0;idx<len;idx++) {
+  self._prev = prev || null;
+  self.onceTimers = {};
 
-    mixin = mixins[idx];
-    if (!mixin) throw new Error('Null value found in Ember.mixin()');
+  return self;
+};
 
-    if (mixin instanceof Mixin) {
-      guid = Ember.guidFor(mixin);
-      if (m[guid]) continue;
-      m[guid] = mixin;
-      props = mixin.properties;
-    } else {
-      props = mixin; // apply anonymous mixin properties
-    }
+K.prototype = RunLoop.prototype;
 
-    if (props) {
+RunLoop.prototype = {
+  end: function() {
+    this.flush();
+  },
 
-      // reset before adding each new mixin to pickup concats from previous
-      concats = values.concatenatedProperties || base.concatenatedProperties;
-      if (props.concatenatedProperties) {
-        concats = concats ? concats.concat(props.concatenatedProperties) : props.concatenatedProperties;
-      }
+  prev: function() {
+    return this._prev;
+  },
 
-      for (key in props) {
-        if (!props.hasOwnProperty(key)) continue;
-        value = props[key];
-        if (value instanceof Ember.Descriptor) {
-          if (value === REQUIRED && descs[key]) { continue; }
+  // ..........................................................
+  // Delayed Actions
+  //
 
-          descs[key]  = value;
-          values[key] = undefined;
-        } else {
+  schedule: function(queueName, target, method) {
+    var queues = this._queues, queue;
+    if (!queues) queues = this._queues = {};
+    queue = queues[queueName];
+    if (!queue) queue = queues[queueName] = [];
 
-          // impl super if needed...
-          if (isMethod(value)) {
-            ovalue = (descs[key] === Ember.SIMPLE_PROPERTY) && values[key];
-            if (!ovalue) ovalue = base[key];
-            if ('function' !== typeof ovalue) ovalue = null;
-            if (ovalue) {
-              var o = value.__ember_observes__, ob = value.__ember_observesBefore__;
-              value = Ember.wrap(value, ovalue);
-              value.__ember_observes__ = o;
-              value.__ember_observesBefore__ = ob;
-            }
-          } else if ((concats && a_indexOf(concats, key)>=0) || key === 'concatenatedProperties') {
-            var baseValue = values[key] || base[key];
-            value = baseValue ? baseValue.concat(value) : Ember.makeArray(value);
-          }
+    var args = arguments.length>3 ? slice.call(arguments, 3) : null;
+    queue.push({ target: target, method: method, args: args });
+    return this;
+  },
 
-          descs[key]  = Ember.SIMPLE_PROPERTY;
-          values[key] = value;
-        }
-      }
+  flush: function(queueName) {
+    var queues = this._queues, queueNames, idx, len, queue, log;
 
-      // manually copy toString() because some JS engines do not enumerate it
-      if (props.hasOwnProperty('toString')) {
-        base.toString = props.toString;
-      }
+    if (!queues) return this; // nothing to do
 
-    } else if (mixin.mixins) {
-      mergeMixins(mixin.mixins, m, descs, values, base);
-      if (mixin._without) a_forEach(mixin._without, removeKeys);
+    function iter(item) {
+      invoke(item.target, item.method, item.args);
     }
-  }
-}
 
-/** @private */
-var defineProperty = Ember.defineProperty;
+    Ember.watch.flushPending(); // make sure all chained watchers are setup
 
-/** @private */
-function writableReq(obj) {
-  var m = Ember.meta(obj), req = m.required;
-  if (!req || (req.__emberproto__ !== obj)) {
-    req = m.required = req ? o_create(req) : { __ember_count__: 0 };
-    req.__emberproto__ = obj;
-  }
-  return req;
-}
-
-/** @private */
-function getObserverPaths(value) {
-  return ('function' === typeof value) && value.__ember_observes__;
-}
-
-/** @private */
-function getBeforeObserverPaths(value) {
-  return ('function' === typeof value) && value.__ember_observesBefore__;
-}
-
-Ember._mixinBindings = function(obj, key, value, m) {
-  return value;
-};
-
-/** @private */
-function applyMixin(obj, mixins, partial) {
-  var descs = {}, values = {}, m = Ember.meta(obj), req = m.required;
-  var key, willApply, didApply, value, desc;
-
-  var mixinBindings = Ember._mixinBindings;
-
-  // Go through all mixins and hashes passed in, and:
-  //
-  // * Handle concatenated properties
-  // * Set up _super wrapping if necessary
-  // * Set up descriptors (simple, watched or computed properties)
-  // * Copying `toString` in broken browsers
-  mergeMixins(mixins, meta(obj), descs, values, obj);
-
-  if (MixinDelegate.detect(obj)) {
-    willApply = values.willApplyProperty || obj.willApplyProperty;
-    didApply  = values.didApplyProperty || obj.didApplyProperty;
-  }
+    if (queueName) {
+      while (this._queues && (queue = this._queues[queueName])) {
+        this._queues[queueName] = null;
 
-  for(key in descs) {
-    if (!descs.hasOwnProperty(key)) continue;
+        // the sync phase is to allow property changes to propagate.  don't
+        // invoke observers until that is finished.
+        if (queueName === 'sync') {
+          log = Ember.LOG_BINDINGS;
+          if (log) Ember.Logger.log('Begin: Flush Sync Queue');
 
-    desc = descs[key];
-    value = values[key];
+          Ember.beginPropertyChanges();
+          try {
+            forEach(queue, iter);
+          } finally {
+            Ember.endPropertyChanges();
+          }
 
-    if (desc === REQUIRED) {
-      if (!(key in obj)) {
-        if (!partial) throw new Error('Required property not defined: '+key);
+          if (log) Ember.Logger.log('End: Flush Sync Queue');
 
-        // for partial applies add to hash of required keys
-        req = writableReq(obj);
-        req.__ember_count__++;
-        req[key] = true;
+        } else {
+          forEach(queue, iter);
+        }
       }
 
     } else {
+      queueNames = Ember.run.queues;
+      len = queueNames.length;
+      do {
+        this._queues = null;
+        for(idx=0;idx<len;idx++) {
+          queueName = queueNames[idx];
+          queue = queues[queueName];
 
-      while (desc instanceof Alias) {
+          if (queue) {
+            // the sync phase is to allow property changes to propagate.  don't
+            // invoke observers until that is finished.
+            if (queueName === 'sync') {
+              log = Ember.LOG_BINDINGS;
+              if (log) Ember.Logger.log('Begin: Flush Sync Queue');
 
-        var altKey = desc.methodName;
-        if (descs[altKey]) {
-          value = values[altKey];
-          desc  = descs[altKey];
-        } else if (m.descs[altKey]) {
-          desc  = m.descs[altKey];
-          value = desc.val(obj, altKey);
-        } else {
-          value = obj[altKey];
-          desc  = Ember.SIMPLE_PROPERTY;
+              Ember.beginPropertyChanges();
+              try {
+                forEach(queue, iter);
+              } finally {
+                Ember.endPropertyChanges();
+              }
+
+              if (log) Ember.Logger.log('End: Flush Sync Queue');
+            } else {
+              forEach(queue, iter);
+            }
+          }
         }
-      }
+      } while (queues = this._queues); // go until queues stay clean
+    }
 
-      if (willApply) willApply.call(obj, key);
+    timerMark = null;
 
-      var observerPaths = getObserverPaths(value),
-          curObserverPaths = observerPaths && getObserverPaths(obj[key]),
-          beforeObserverPaths = getBeforeObserverPaths(value),
-          curBeforeObserverPaths = beforeObserverPaths && getBeforeObserverPaths(obj[key]),
-          len, idx;
+    return this;
+  }
 
-      if (curObserverPaths) {
-        len = curObserverPaths.length;
-        for(idx=0;idx<len;idx++) {
-          Ember.removeObserver(obj, curObserverPaths[idx], null, key);
-        }
-      }
+};
 
-      if (curBeforeObserverPaths) {
-        len = curBeforeObserverPaths.length;
-        for(idx=0;idx<len;idx++) {
-          Ember.removeBeforeObserver(obj, curBeforeObserverPaths[idx], null,key);
-        }
-      }
+Ember.RunLoop = RunLoop;
+
+// ..........................................................
+// Ember.run - this is ideally the only public API the dev sees
+//
+/** 
+* @namespace Ember.run is both a function and a namespace for
+* RunLoop-related functions.
+* @name Ember.run
+*/ 
 
-      // TODO: less hacky way for ember-runtime to add bindings.
-      value = mixinBindings(obj, key, value, m);
+/**
+  Runs the passed target and method inside of a RunLoop, ensuring any
+  deferred actions including bindings and views updates are flushed at the
+  end.
 
-      defineProperty(obj, key, desc, value);
+  Normally you should not need to invoke this method yourself.  However if
+  you are implementing raw event handlers when interfacing with other
+  libraries or plugins, you should probably wrap all of your code inside this
+  call.
 
-      if (observerPaths) {
-        len = observerPaths.length;
-        for(idx=0;idx<len;idx++) {
-          Ember.addObserver(obj, observerPaths[idx], null, key);
-        }
-      }
+      Ember.run(function(){
+        // code to be execute within a RunLoop 
+      });
 
-      if (beforeObserverPaths) {
-        len = beforeObserverPaths.length;
-        for(idx=0;idx<len;idx++) {
-          Ember.addBeforeObserver(obj, beforeObserverPaths[idx], null, key);
-        }
-      }
+  @name run^2
+  @methodOf Ember.run
+  @param {Object} target
+    (Optional) target of method to call
 
-      if (req && req[key]) {
-        req = writableReq(obj);
-        req.__ember_count__--;
-        req[key] = false;
-      }
+  @param {Function|String} method
+    Method to invoke.  May be a function or a string.  If you pass a string
+    then it will be looked up on the passed target.
 
-      if (didApply) didApply.call(obj, key);
+  @param {Object...} args
+    Any additional arguments you wish to pass to the method.
 
-    }
-  }
+  @returns {Object} return value from invoking the passed function.
+*/
+Ember.run = function(target, method) {
 
-  // Make sure no required attrs remain
-  if (!partial && req && req.__ember_count__>0) {
-    var keys = [];
-    for(key in req) {
-      if (META_SKIP[key]) continue;
-      keys.push(key);
-    }
-    throw new Error('Required properties not defined: '+keys.join(','));
+  var ret, loop;
+  run.begin();
+  try {
+    if (target || method) ret = invoke(target, method, arguments, 2);
+  } finally {
+    run.end();
   }
-  return obj;
-}
-
-Ember.mixin = function(obj) {
-  var args = a_slice.call(arguments, 1);
-  return applyMixin(obj, args, false);
+  return ret;
 };
 
+/** @private */
+var run = Ember.run;
+
 
 /**
-  @constructor
-*/
-Ember.Mixin = function() { return initMixin(this, arguments); };
+  Begins a new RunLoop.  Any deferred actions invoked after the begin will
+  be buffered until you invoke a matching call to Ember.run.end().  This is
+  an lower-level way to use a RunLoop instead of using Ember.run().
 
-/** @private */
-Mixin = Ember.Mixin;
+      Ember.run.begin();
+      // code to be execute within a RunLoop 
+      Ember.run.end();
 
-/** @private */
-Mixin._apply = applyMixin;
 
-Mixin.applyPartial = function(obj) {
-  var args = a_slice.call(arguments, 1);
-  return applyMixin(obj, args, true);
+  @returns {void}
+*/
+Ember.run.begin = function() {
+  run.currentRunLoop = new RunLoop(run.currentRunLoop);
 };
 
-Mixin.create = function() {
-  classToString.processed = false;
-  var M = this;
-  return initMixin(new M(), arguments);
-};
+/**
+  Ends a RunLoop.  This must be called sometime after you call Ember.run.begin()
+  to flush any deferred actions.  This is a lower-level way to use a RunLoop
+  instead of using Ember.run().
 
-Mixin.prototype.reopen = function() {
+      Ember.run.begin();
+      // code to be execute within a RunLoop 
+      Ember.run.end();
 
-  var mixin, tmp;
+  @returns {void}
+*/
+Ember.run.end = function() {
 
-  if (this.properties) {
-    mixin = Mixin.create();
-    mixin.properties = this.properties;
-    delete this.properties;
-    this.mixins = [mixin];
+  try {
+    run.currentRunLoop.end();
   }
+  finally {
+    run.currentRunLoop = run.currentRunLoop.prev();
+  }
+};
 
-  var len = arguments.length, mixins = this.mixins, idx;
-
-  for(idx=0;idx<len;idx++) {
-    mixin = arguments[idx];
-    if (mixin instanceof Mixin) {
-      mixins.push(mixin);
-    } else {
-      tmp = Mixin.create();
-      tmp.properties = mixin;
-      mixins.push(tmp);
-    }
-  }
+/**
+  Array of named queues.  This array determines the order in which queues
+  are flushed at the end of the RunLoop.  You can define your own queues by
+  simply adding the queue name to this array.  Normally you should not need
+  to inspect or modify this property.
 
-  return this;
-};
+  @property {String}
+  @default ['sync', 'actions', 'destroy', 'timers']
+*/
+Ember.run.queues = ['sync', 'actions', 'destroy', 'timers'];
 
-var TMP_ARRAY = [];
-Mixin.prototype.apply = function(obj) {
-  TMP_ARRAY[0] = this;
-  var ret = applyMixin(obj, TMP_ARRAY, false);
-  TMP_ARRAY.length=0;
-  return ret;
-};
+/**
+  Adds the passed target/method and any optional arguments to the named
+  queue to be executed at the end of the RunLoop.  If you have not already
+  started a RunLoop when calling this method one will be started for you
+  automatically.
 
-Mixin.prototype.applyPartial = function(obj) {
-  TMP_ARRAY[0] = this;
-  var ret = applyMixin(obj, TMP_ARRAY, true);
-  TMP_ARRAY.length=0;
-  return ret;
-};
+  At the end of a RunLoop, any methods scheduled in this way will be invoked.
+  Methods will be invoked in an order matching the named queues defined in
+  the run.queues property.
 
-/** @private */
-function _detect(curMixin, targetMixin, seen) {
-  var guid = Ember.guidFor(curMixin);
+      Ember.run.schedule('timers', this, function(){
+        // this will be executed at the end of the RunLoop, when timers are run
+        console.log("scheduled on timers queue");
+      });
+      Ember.run.schedule('sync', this, function(){
+        // this will be executed at the end of the RunLoop, when bindings are synced
+        console.log("scheduled on sync queue");
+      });
+      // Note the functions will be run in order based on the run queues order. Output would be:
+      //   scheduled on sync queue
+      //   scheduled on timers queue
 
-  if (seen[guid]) return false;
-  seen[guid] = true;
+  @param {String} queue
+    The name of the queue to schedule against.  Default queues are 'sync' and
+    'actions'
 
-  if (curMixin === targetMixin) return true;
-  var mixins = curMixin.mixins, loc = mixins ? mixins.length : 0;
-  while(--loc >= 0) {
-    if (_detect(mixins[loc], targetMixin, seen)) return true;
-  }
-  return false;
-}
+  @param {Object} target
+    (Optional) target object to use as the context when invoking a method.
 
-Mixin.prototype.detect = function(obj) {
-  if (!obj) return false;
-  if (obj instanceof Mixin) return _detect(obj, this, {});
-  return !!meta(obj, false)[Ember.guidFor(this)];
-};
+  @param {String|Function} method
+    The method to invoke.  If you pass a string it will be resolved on the
+    target object at the time the scheduled item is invoked allowing you to
+    change the target function.
 
-Mixin.prototype.without = function() {
-  var ret = new Mixin(this);
-  ret._without = a_slice.call(arguments);
-  return ret;
+  @param {Object} arguments...
+    Optional arguments to be passed to the queued method.
+
+  @returns {void}
+*/
+Ember.run.schedule = function(queue, target, method) {
+  var loop = run.autorun();
+  loop.schedule.apply(loop, arguments);
 };
 
+var autorunTimer;
+
 /** @private */
-function _keys(ret, mixin, seen) {
-  if (seen[Ember.guidFor(mixin)]) return;
-  seen[Ember.guidFor(mixin)] = true;
+function autorun() {
+  autorunTimer = null;
+  if (run.currentRunLoop) run.end();
+}
 
-  if (mixin.properties) {
-    var props = mixin.properties;
-    for(var key in props) {
-      if (props.hasOwnProperty(key)) ret[key] = true;
+/**
+  Begins a new RunLoop if necessary and schedules a timer to flush the
+  RunLoop at a later time.  This method is used by parts of Ember to
+  ensure the RunLoop always finishes.  You normally do not need to call this
+  method directly.  Instead use Ember.run().
+
+      Ember.run.autorun();
+
+  @returns {Ember.RunLoop} the new current RunLoop
+*/
+Ember.run.autorun = function() {
+
+  if (!run.currentRunLoop) {
+    run.begin();
+
+    // TODO: throw during tests
+    if (Ember.testing) {
+      run.end();
+    } else if (!autorunTimer) {
+      autorunTimer = setTimeout(autorun, 1);
     }
-  } else if (mixin.mixins) {
-    a_forEach(mixin.mixins, function(x) { _keys(ret, x, seen); });
   }
-}
 
-Mixin.prototype.keys = function() {
-  var keys = {}, seen = {}, ret = [];
-  _keys(keys, this, seen);
-  for(var key in keys) {
-    if (keys.hasOwnProperty(key)) ret.push(key);
-  }
-  return ret;
+  return run.currentRunLoop;
 };
 
-/** @private - make Mixin's have nice displayNames */
+/**
+  Immediately flushes any events scheduled in the 'sync' queue.  Bindings
+  use this queue so this method is a useful way to immediately force all
+  bindings in the application to sync.
 
-var NAME_KEY = Ember.GUID_KEY+'_name';
-var get = Ember.get;
+  You should call this method anytime you need any changed state to propagate
+  throughout the app immediately without repainting the UI.
 
-/** @private */
-function processNames(paths, root, seen) {
-  var idx = paths.length;
-  for(var key in root) {
-    if (!root.hasOwnProperty || !root.hasOwnProperty(key)) continue;
-    var obj = root[key];
-    paths[idx] = key;
+      Ember.run.sync();
 
-    if (obj && obj.toString === classToString) {
-      obj[NAME_KEY] = paths.join('.');
-    } else if (obj && get(obj, 'isNamespace')) {
-      if (seen[Ember.guidFor(obj)]) continue;
-      seen[Ember.guidFor(obj)] = true;
-      processNames(paths, obj, seen);
-    }
+  @returns {void}
+*/
+Ember.run.sync = function() {
+  run.autorun();
+  run.currentRunLoop.flush('sync');
+};
+
+// ..........................................................
+// TIMERS
+//
+
+var timers = {}; // active timers...
 
+var laterScheduled = false;
+/** @private */
+function invokeLaterTimers() {
+  var now = (+ new Date()), earliest = -1;
+  for(var key in timers) {
+    if (!timers.hasOwnProperty(key)) continue;
+    var timer = timers[key];
+    if (timer && timer.expires) {
+      if (now >= timer.expires) {
+        delete timers[key];
+        invoke(timer.target, timer.method, timer.args, 2);
+      } else {
+        if (earliest<0 || (timer.expires < earliest)) earliest=timer.expires;
+      }
+    }
   }
-  paths.length = idx; // cut out last item
+
+  // schedule next timeout to fire...
+  if (earliest>0) setTimeout(invokeLaterTimers, earliest-(+ new Date()));
 }
 
-/** @private */
-function findNamespaces() {
-  var Namespace = Ember.Namespace, obj;
+/**
+  Invokes the passed target/method and optional arguments after a specified
+  period if time.  The last parameter of this method must always be a number
+  of milliseconds.
 
-  if (Namespace.PROCESSED) { return; }
+  You should use this method whenever you need to run some action after a
+  period of time instead of using setTimeout().  This method will ensure that
+  items that expire during the same script execution cycle all execute
+  together, which is often more efficient than using a real setTimeout.
 
-  for (var prop in window) {
-    //  get(window.globalStorage, 'isNamespace') would try to read the storage for domain isNamespace and cause exception in Firefox.
-    // globalStorage is a storage obsoleted by the WhatWG storage specification. See https://developer.mozilla.org/en/DOM/Storage#globalStorage
-    if (prop === "globalStorage" && window.StorageList && window.globalStorage instanceof window.StorageList) { continue; }
-    // Unfortunately, some versions of IE don't support window.hasOwnProperty
-    if (window.hasOwnProperty && !window.hasOwnProperty(prop)) { continue; }
+      Ember.run.later(myContext, function(){
+        // code here will execute within a RunLoop in about 500ms with this == myContext
+      }, 500);
 
-    try {
-      obj = window[prop];
-    } catch (e) {
-      continue;
-    }
+  @param {Object} target
+    (optional) target of method to invoke
 
-    if (obj && get(obj, 'isNamespace')) {
+  @param {Function|String} method
+    The method to invoke.  If you pass a string it will be resolved on the
+    target at the time the method is invoked.
 
-      obj[NAME_KEY] = prop;
-    }
-  }
-}
+  @param {Object...} args
+    Optional arguments to pass to the timeout.
 
-Ember.identifyNamespaces = findNamespaces;
+  @param {Number} wait
+    Number of milliseconds to wait.
+
+  @returns {Timer} an object you can use to cancel a timer at a later time.
+*/
+Ember.run.later = function(target, method) {
+  var args, expires, timer, guid, wait;
+
+  // setTimeout compatibility...
+  if (arguments.length===2 && 'function' === typeof target) {
+    wait   = method;
+    method = target;
+    target = undefined;
+    args   = [target, method];
 
-/** @private */
-superClassString = function(mixin) {
-  var superclass = mixin.superclass;
-  if (superclass) {
-    if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; }
-    else { return superClassString(superclass); }
   } else {
-    return;
+    args = slice.call(arguments);
+    wait = args.pop();
   }
+
+  expires = (+ new Date())+wait;
+  timer   = { target: target, method: method, expires: expires, args: args };
+  guid    = Ember.guidFor(timer);
+  timers[guid] = timer;
+  run.once(timers, invokeLaterTimers);
+  return guid;
 };
 
 /** @private */
-classToString = function() {
-  var Namespace = Ember.Namespace, namespace;
+function invokeOnceTimer(guid, onceTimers) {
+  if (onceTimers[this.tguid]) delete onceTimers[this.tguid][this.mguid];
+  if (timers[guid]) invoke(this.target, this.method, this.args, 2);
+  delete timers[guid];
+}
 
-  // TODO: Namespace should really be in Metal
-  if (Namespace) {
-    if (!this[NAME_KEY] && !classToString.processed) {
-      if (!Namespace.PROCESSED) {
-        findNamespaces();
-        Namespace.PROCESSED = true;
-      }
+/**
+  Schedules an item to run one time during the current RunLoop.  Calling
+  this method with the same target/method combination will have no effect.
 
-      classToString.processed = true;
+  Note that although you can pass optional arguments these will not be
+  considered when looking for duplicates.  New arguments will replace previous
+  calls.
 
-      var namespaces = Namespace.NAMESPACES;
-      for (var i=0, l=namespaces.length; i<l; i++) {
-        namespace = namespaces[i];
-        processNames([namespace.toString()], namespace, {});
-      }
-    }
-  }
+      Ember.run(function(){
+        var doFoo = function() { foo(); }
+        Ember.run.once(myContext, doFoo);
+        Ember.run.once(myContext, doFoo);
+        // doFoo will only be executed once at the end of the RunLoop
+      });
 
-  if (this[NAME_KEY]) {
-    return this[NAME_KEY];
-  } else {
-    var str = superClassString(this);
-    if (str) {
-      return "(subclass of " + str + ")";
-    } else {
-      return "(unknown mixin)";
-    }
-  }
-};
+  @param {Object} target
+    (optional) target of method to invoke
 
-Mixin.prototype.toString = classToString;
+  @param {Function|String} method
+    The method to invoke.  If you pass a string it will be resolved on the
+    target at the time the method is invoked.
 
-// returns the mixins currently applied to the specified object
-// TODO: Make Ember.mixin
-Mixin.mixins = function(obj) {
-  var ret = [], mixins = meta(obj, false), key, mixin;
-  for(key in mixins) {
-    if (META_SKIP[key]) continue;
-    mixin = mixins[key];
+  @param {Object...} args
+    Optional arguments to pass to the timeout.
 
-    // skip primitive mixins since these are always anonymous
-    if (!mixin.properties) ret.push(mixins[key]);
-  }
-  return ret;
-};
 
-REQUIRED = new Ember.Descriptor();
-REQUIRED.toString = function() { return '(Required Property)'; };
+  @returns {Object} timer
+*/
+Ember.run.once = function(target, method) {
+  var tguid = Ember.guidFor(target), mguid = Ember.guidFor(method), guid, timer;
 
-Ember.required = function() {
-  return REQUIRED;
+  var onceTimers = run.autorun().onceTimers;
+  guid = onceTimers[tguid] && onceTimers[tguid][mguid];
+  if (guid && timers[guid]) {
+    timers[guid].args = slice.call(arguments); // replace args
+
+  } else {
+    timer = {
+      target: target,
+      method: method,
+      args:   slice.call(arguments),
+      tguid:  tguid,
+      mguid:  mguid
+    };
+
+    guid  = Ember.guidFor(timer);
+    timers[guid] = timer;
+    if (!onceTimers[tguid]) onceTimers[tguid] = {};
+    onceTimers[tguid][mguid] = guid; // so it isn't scheduled more than once
+
+    run.schedule('actions', timer, invokeOnceTimer, guid, onceTimers);
+  }
+
+  return guid;
 };
 
+var scheduledNext = false;
 /** @private */
-Alias = function(methodName) {
-  this.methodName = methodName;
-};
-Alias.prototype = new Ember.Descriptor();
+function invokeNextTimers() {
+  scheduledNext = null;
+  for(var key in timers) {
+    if (!timers.hasOwnProperty(key)) continue;
+    var timer = timers[key];
+    if (timer.next) {
+      delete timers[key];
+      invoke(timer.target, timer.method, timer.args, 2);
+    }
+  }
+}
 
-Ember.alias = function(methodName) {
-  return new Alias(methodName);
-};
+/**
+  Schedules an item to run after control has been returned to the system.
+  This is often equivalent to calling setTimeout(function...,1).
 
-Ember.MixinDelegate = Mixin.create({
+      Ember.run.next(myContext, function(){
+        // code to be executed in the next RunLoop, which will be scheduled after the current one
+      });
 
-  willApplyProperty: Ember.required(),
-  didApplyProperty:  Ember.required()
+  @param {Object} target
+    (optional) target of method to invoke
 
-});
+  @param {Function|String} method
+    The method to invoke.  If you pass a string it will be resolved on the
+    target at the time the method is invoked.
 
-/** @private */
-MixinDelegate = Ember.MixinDelegate;
+  @param {Object...} args
+    Optional arguments to pass to the timeout.
 
+  @returns {Object} timer
+*/
+Ember.run.next = function(target, method) {
+  var timer, guid;
 
-// ..........................................................
-// OBSERVER HELPER
-//
+  timer = {
+    target: target,
+    method: method,
+    args: slice.call(arguments),
+    next: true
+  };
 
-Ember.observer = function(func) {
-  var paths = a_slice.call(arguments, 1);
-  func.__ember_observes__ = paths;
-  return func;
-};
+  guid = Ember.guidFor(timer);
+  timers[guid] = timer;
 
-Ember.beforeObserver = function(func) {
-  var paths = a_slice.call(arguments, 1);
-  func.__ember_observesBefore__ = paths;
-  return func;
+  if (!scheduledNext) scheduledNext = setTimeout(invokeNextTimers, 1);
+  return guid;
 };
 
+/**
+  Cancels a scheduled item.  Must be a value returned by `Ember.run.later()`,
+  `Ember.run.once()`, or `Ember.run.next()`.
 
+      var runNext = Ember.run.next(myContext, function(){
+        // will not be executed
+      });
+      Ember.run.cancel(runNext);
 
+      var runLater = Ember.run.next(myContext, function(){
+        // will not be executed
+      }, 500);
+      Ember.run.cancel(runLater);
 
+      var runOnce = Ember.run.once(myContext, function(){
+        // will not be executed
+      });
+      Ember.run.cancel(runOnce);
 
+  @param {Object} timer
+    Timer object to cancel
 
+  @returns {void}
+*/
+Ember.run.cancel = function(timer) {
+  delete timers[timer];
+};
 
 })();
 
@@ -3645,1539 +3719,1552 @@ Ember.beforeObserver = function(func) {
 (function() {
 // ==========================================================================
 // Project:  Ember Runtime
-// Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ember_assert */
 // Ember.Logger
-// Ember.watch.flushPending
-// Ember.beginPropertyChanges, Ember.endPropertyChanges
-// Ember.guidFor
-// Ember.ArrayUtils
+// get, getPath, setPath, trySetPath
+// guidFor, isArray, meta
+// addObserver, removeObserver
+// Ember.run.schedule
 
 // ..........................................................
-// HELPERS
+// CONSTANTS
 //
 
-var slice = Array.prototype.slice;
-var forEach = Ember.ArrayUtils.forEach;
 
-// invokes passed params - normalizing so you can pass target/func,
-// target/string or just func
-/** @private */
-function invoke(target, method, args, ignore) {
+/**
+  @static
 
-  if (method===undefined) {
-    method = target;
-    target = undefined;
-  }
+  Debug parameter you can turn on. This will log all bindings that fire to
+  the console. This should be disabled in production code. Note that you
+  can also enable this from the console or temporarily.
 
-  if ('string'===typeof method) method = target[method];
-  if (args && ignore>0) {
-    args = args.length>ignore ? slice.call(args, ignore) : null;
-  }
+  @type Boolean
+  @default false
+*/
+Ember.LOG_BINDINGS = false || !!Ember.ENV.LOG_BINDINGS;
 
-  // Unfortunately in some browsers we lose the backtrace if we rethrow the existing error,
-  // so in the event that we don't have an `onerror` handler we don't wrap in a try/catch
-  if ('function' === typeof Ember.onerror) {
-    try {
-      // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
-      return method.apply(target || this, args || []);
-    } catch (error) {
-      Ember.onerror(error);
-    }
-  } else {
-    // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
-    return method.apply(target || this, args || []);
-  }
-}
+/**
+  @static
 
+  Performance paramter. This will benchmark the time spent firing each
+  binding.
 
-// ..........................................................
-// RUNLOOP
-//
+  @type Boolean
+*/
+Ember.BENCHMARK_BINDING_NOTIFICATIONS = !!Ember.ENV.BENCHMARK_BINDING_NOTIFICATIONS;
 
-var timerMark; // used by timers...
+/**
+  @static
 
-/** @private */
-var K = function() {};
+  Performance parameter. This will benchmark the time spend configuring each
+  binding.
 
-/** @private */
-var RunLoop = function(prev) {
-  var self;
+  @type Boolean
+*/
+Ember.BENCHMARK_BINDING_SETUP = !!Ember.ENV.BENCHMARK_BINDING_SETUP;
 
-  if (this instanceof RunLoop) {
-    self = this;
-  } else {
-    self = new K();
-  }
-
-  self._prev = prev || null;
-  self.onceTimers = {};
-
-  return self;
-};
 
-K.prototype = RunLoop.prototype;
+/**
+  @static
 
-RunLoop.prototype = {
-  end: function() {
-    this.flush();
-  },
+  Default placeholder for multiple values in bindings.
 
-  prev: function() {
-    return this._prev;
-  },
+  @type String
+  @default '@@MULT@@'
+*/
+Ember.MULTIPLE_PLACEHOLDER = '@@MULT@@';
 
-  // ..........................................................
-  // Delayed Actions
-  //
+/**
+  @static
 
-  schedule: function(queueName, target, method) {
-    var queues = this._queues, queue;
-    if (!queues) queues = this._queues = {};
-    queue = queues[queueName];
-    if (!queue) queue = queues[queueName] = [];
+  Default placeholder for empty values in bindings.  Used by notEmpty()
+  helper unless you specify an alternative.
 
-    var args = arguments.length>3 ? slice.call(arguments, 3) : null;
-    queue.push({ target: target, method: method, args: args });
-    return this;
-  },
+  @type String
+  @default '@@EMPTY@@'
+*/
+Ember.EMPTY_PLACEHOLDER = '@@EMPTY@@';
 
-  flush: function(queueName) {
-    var queues = this._queues, queueNames, idx, len, queue, log;
+// ..........................................................
+// TYPE COERCION HELPERS
+//
 
-    if (!queues) return this; // nothing to do
+// Coerces a non-array value into an array.
+/** @private */
+function MULTIPLE(val) {
+  if (val instanceof Array) return val;
+  if (val === undefined || val === null) return [];
+  return [val];
+}
 
-    function iter(item) {
-      invoke(item.target, item.method, item.args);
-    }
+// Treats a single-element array as the element. Otherwise
+// returns a placeholder.
+/** @private */
+function SINGLE(val, placeholder) {
+  if (val instanceof Array) {
+    if (val.length>1) return placeholder;
+    else return val[0];
+  }
+  return val;
+}
 
-    Ember.watch.flushPending(); // make sure all chained watchers are setup
+// Coerces the binding value into a Boolean.
 
-    if (queueName) {
-      while (this._queues && (queue = this._queues[queueName])) {
-        this._queues[queueName] = null;
+var BOOL = {
+  to: function (val) {
+    return !!val;
+  }
+};
 
-        // the sync phase is to allow property changes to propagate.  don't
-        // invoke observers until that is finished.
-        if (queueName === 'sync') {
-          log = Ember.LOG_BINDINGS;
-          if (log) Ember.Logger.log('Begin: Flush Sync Queue');
+// Returns the Boolean inverse of the value.
+var NOT = {
+  to: function NOT(val) {
+    return !val;
+  }
+};
 
-          Ember.beginPropertyChanges();
-          try {
-            forEach(queue, iter);
-          } finally {
-            Ember.endPropertyChanges();
-          }
+var get     = Ember.get,
+    getPath = Ember.getPath,
+    setPath = Ember.setPath,
+    guidFor = Ember.guidFor,
+    isGlobalPath = Ember.isGlobalPath;
 
-          if (log) Ember.Logger.log('End: Flush Sync Queue');
+// Applies a binding's transformations against a value.
+/** @private */
+function getTransformedValue(binding, val, obj, dir) {
 
-        } else {
-          forEach(queue, iter);
-        }
-      }
+  // First run a type transform, if it exists, that changes the fundamental
+  // type of the value. For example, some transforms convert an array to a
+  // single object.
 
-    } else {
-      queueNames = Ember.run.queues;
-      len = queueNames.length;
-      do {
-        this._queues = null;
-        for(idx=0;idx<len;idx++) {
-          queueName = queueNames[idx];
-          queue = queues[queueName];
+  var typeTransform = binding._typeTransform;
+  if (typeTransform) { val = typeTransform(val, binding._placeholder); }
 
-          if (queue) {
-            // the sync phase is to allow property changes to propagate.  don't
-            // invoke observers until that is finished.
-            if (queueName === 'sync') {
-              log = Ember.LOG_BINDINGS;
-              if (log) Ember.Logger.log('Begin: Flush Sync Queue');
+  // handle transforms
+  var transforms = binding._transforms,
+      len        = transforms ? transforms.length : 0,
+      idx;
 
-              Ember.beginPropertyChanges();
-              try {
-                forEach(queue, iter);
-              } finally {
-                Ember.endPropertyChanges();
-              }
+  for(idx=0;idx<len;idx++) {
+    var transform = transforms[idx][dir];
+    if (transform) { val = transform.call(this, val, obj); }
+  }
+  return val;
+}
 
-              if (log) Ember.Logger.log('End: Flush Sync Queue');
-            } else {
-              forEach(queue, iter);
-            }
-          }
-        }
-      } while (queues = this._queues); // go until queues stay clean
-    }
+/** @private */
+function empty(val) {
+  return val===undefined || val===null || val==='' || (Ember.isArray(val) && get(val, 'length')===0) ;
+}
 
-    timerMark = null;
+/** @private */
+function getPathWithGlobals(obj, path) {
+  return getPath(isGlobalPath(path) ? window : obj, path);
+}
 
-    return this;
+/** @private */
+function getTransformedFromValue(obj, binding) {
+  var operation = binding._operation,
+      fromValue;
+  if (operation) {
+    fromValue = operation(obj, binding._from, binding._operand);
+  } else {
+    fromValue = getPathWithGlobals(obj, binding._from);
   }
+  return getTransformedValue(binding, fromValue, obj, 'to');
+}
+
+/** @private */
+function getTransformedToValue(obj, binding) {
+  var toValue = getPath(obj, binding._to);
+  return getTransformedValue(binding, toValue, obj, 'from');
+}
 
+/** @private */
+var AND_OPERATION = function(obj, left, right) {
+  return getPathWithGlobals(obj, left) && getPathWithGlobals(obj, right);
 };
 
-Ember.RunLoop = RunLoop;
+/** @private */
+var OR_OPERATION = function(obj, left, right) {
+  return getPathWithGlobals(obj, left) || getPathWithGlobals(obj, right);
+};
 
 // ..........................................................
-// Ember.run - this is ideally the only public API the dev sees
+// BINDING
 //
-/** 
-* @namespace Ember.run is both a function and a namespace for
-* RunLoop-related functions.
-* @name Ember.run
-*/ 
-
-/**
-  Runs the passed target and method inside of a RunLoop, ensuring any
-  deferred actions including bindings and views updates are flushed at the
-  end.
-
-  Normally you should not need to invoke this method yourself.  However if
-  you are implementing raw event handlers when interfacing with other
-  libraries or plugins, you should probably wrap all of your code inside this
-  call.
-
-      Ember.run(function(){
-        // code to be execute within a RunLoop 
-      });
+/** @private */
+var K = function() {};
 
-  @name run^2
-  @methodOf Ember.run
-  @param {Object} target
-    (Optional) target of method to call
+/** @private */
+var Binding = function(toPath, fromPath) {
+  var self;
 
-  @param {Function|String} method
-    Method to invoke.  May be a function or a string.  If you pass a string
-    then it will be looked up on the passed target.
+  if (this instanceof Binding) {
+    self = this;
+  } else {
+    self = new K();
+  }
 
-  @param {Object...} args
-    Any additional arguments you wish to pass to the method.
+  /** @private */
+  self._direction = 'fwd';
 
-  @returns {Object} return value from invoking the passed function.
-*/
-Ember.run = function(target, method) {
+  /** @private */
+  self._from = fromPath;
+  self._to   = toPath;
 
-  var ret, loop;
-  run.begin();
-  try {
-    if (target || method) ret = invoke(target, method, arguments, 2);
-  } finally {
-    run.end();
-  }
-  return ret;
+  return self;
 };
 
-/** @private */
-var run = Ember.run;
+K.prototype = Binding.prototype;
 
+Binding.prototype = /** @scope Ember.Binding.prototype */ {
+  /**
+    This copies the Binding so it can be connected to another object.
+    @returns {Ember.Binding}
+  */
+  copy: function () {
+    var copy = new Binding(this._to, this._from);
+    if (this._oneWay) {
+      copy._oneWay = true;
+    }
+    if (this._transforms) {
+      copy._transforms = this._transforms.slice(0);
+    }
+    if (this._typeTransform) {
+      copy._typeTransform = this._typeTransform;
+      copy._placeholder = this._placeholder;
+    }
+    if (this._operand) {
+      copy._operand = this._operand;
+      copy._operation = this._operation;
+    }
+    return copy;
+  },
 
-/**
-  Begins a new RunLoop.  Any deferred actions invoked after the begin will
-  be buffered until you invoke a matching call to Ember.run.end().  This is
-  an lower-level way to use a RunLoop instead of using Ember.run().
+  // ..........................................................
+  // CONFIG
+  //
 
-      Ember.run.begin();
-      // code to be execute within a RunLoop 
-      Ember.run.end();
+  /**
+    This will set "from" property path to the specified value. It will not
+    attempt to resolve this property path to an actual object until you
+    connect the binding.
 
+    The binding will search for the property path starting at the root object
+    you pass when you connect() the binding.  It follows the same rules as
+    `getPath()` - see that method for more information.
 
-  @returns {void}
-*/
-Ember.run.begin = function() {
-  run.currentRunLoop = new RunLoop(run.currentRunLoop);
-};
+    @param {String} propertyPath the property path to connect to
+    @returns {Ember.Binding} receiver
+  */
+  from: function(path) {
+    this._from = path;
+    return this;
+  },
 
-/**
-  Ends a RunLoop.  This must be called sometime after you call Ember.run.begin()
-  to flush any deferred actions.  This is a lower-level way to use a RunLoop
-  instead of using Ember.run().
+  /**
+    This will set the "to" property path to the specified value. It will not
+    attempt to resolve this property path to an actual object until you
+    connect the binding.
 
-      Ember.run.begin();
-      // code to be execute within a RunLoop 
-      Ember.run.end();
+    The binding will search for the property path starting at the root object
+    you pass when you connect() the binding.  It follows the same rules as
+    `getPath()` - see that method for more information.
 
-  @returns {void}
-*/
-Ember.run.end = function() {
+    @param {String|Tuple} propertyPath A property path or tuple
+    @param {Object} [root] Root object to use when resolving the path.
+    @returns {Ember.Binding} this
+  */
+  to: function(path) {
+    this._to = path;
+    return this;
+  },
 
-  try {
-    run.currentRunLoop.end();
-  }
-  finally {
-    run.currentRunLoop = run.currentRunLoop.prev();
-  }
-};
+  /**
+    Configures the binding as one way. A one-way binding will relay changes
+    on the "from" side to the "to" side, but not the other way around. This
+    means that if you change the "to" side directly, the "from" side may have
+    a different value.
 
-/**
-  Array of named queues.  This array determines the order in which queues
-  are flushed at the end of the RunLoop.  You can define your own queues by
-  simply adding the queue name to this array.  Normally you should not need
-  to inspect or modify this property.
+    @param {Boolean} flag
+      (Optional) passing nothing here will make the binding oneWay.  You can
+      instead pass false to disable oneWay, making the binding two way again.
 
-  @property {String}
-  @default ['sync', 'actions', 'destroy', 'timers']
-*/
-Ember.run.queues = ['sync', 'actions', 'destroy', 'timers'];
+    @returns {Ember.Binding} receiver
+  */
+  oneWay: function(flag) {
+    this._oneWay = flag===undefined ? true : !!flag;
+    return this;
+  },
 
-/**
-  Adds the passed target/method and any optional arguments to the named
-  queue to be executed at the end of the RunLoop.  If you have not already
-  started a RunLoop when calling this method one will be started for you
-  automatically.
+  /**
+    Adds the specified transform to the array of transform functions.
 
-  At the end of a RunLoop, any methods scheduled in this way will be invoked.
-  Methods will be invoked in an order matching the named queues defined in
-  the run.queues property.
+    A transform is a hash with `to` and `from` properties. Each property
+    should be a function that performs a transformation in either the
+    forward or back direction.
 
-      Ember.run.schedule('timers', this, function(){
-        // this will be executed at the end of the RunLoop, when timers are run
-        console.log("scheduled on timers queue");
-      });
-      Ember.run.schedule('sync', this, function(){
-        // this will be executed at the end of the RunLoop, when bindings are synced
-        console.log("scheduled on sync queue");
-      });
-      // Note the functions will be run in order based on the run queues order. Output would be:
-      //   scheduled on sync queue
-      //   scheduled on timers queue
+    The functions you pass must have the following signature:
 
-  @param {String} queue
-    The name of the queue to schedule against.  Default queues are 'sync' and
-    'actions'
+          function(value) {};
 
-  @param {Object} target
-    (Optional) target object to use as the context when invoking a method.
+    They must also return the transformed value.
 
-  @param {String|Function} method
-    The method to invoke.  If you pass a string it will be resolved on the
-    target object at the time the scheduled item is invoked allowing you to
-    change the target function.
+    Transforms are invoked in the order they were added. If you are
+    extending a binding and want to reset the transforms, you can call
+    `resetTransform()` first.
 
-  @param {Object} arguments...
-    Optional arguments to be passed to the queued method.
+    @param {Function} transformFunc the transform function.
+    @returns {Ember.Binding} this
+  */
+  transform: function(transform) {
+    if ('function' === typeof transform) {
+      transform = { to: transform };
+    }
 
-  @returns {void}
-*/
-Ember.run.schedule = function(queue, target, method) {
-  var loop = run.autorun();
-  loop.schedule.apply(loop, arguments);
-};
+    if (!this._transforms) this._transforms = [];
+    this._transforms.push(transform);
+    return this;
+  },
 
-var autorunTimer;
+  /**
+    Resets the transforms for the binding. After calling this method the
+    binding will no longer transform values. You can then add new transforms
+    as needed.
 
-/** @private */
-function autorun() {
-  autorunTimer = null;
-  if (run.currentRunLoop) run.end();
-}
+    @returns {Ember.Binding} this
+  */
+  resetTransforms: function() {
+    this._transforms = null;
+    return this;
+  },
 
-/**
-  Begins a new RunLoop if necessary and schedules a timer to flush the
-  RunLoop at a later time.  This method is used by parts of Ember to
-  ensure the RunLoop always finishes.  You normally do not need to call this
-  method directly.  Instead use Ember.run().
+  /**
+    Adds a transform to the chain that will allow only single values to pass.
+    This will allow single values and nulls to pass through. If you pass an
+    array, it will be mapped as so:
 
-      Ember.run.autorun();
+      - [] => null
+      - [a] => a
+      - [a,b,c] => Multiple Placeholder
 
-  @returns {Ember.RunLoop} the new current RunLoop
-*/
-Ember.run.autorun = function() {
+    You can pass in an optional multiple placeholder or it will use the
+    default.
 
-  if (!run.currentRunLoop) {
-    run.begin();
+    Note that this transform will only happen on forwarded valued. Reverse
+    values are send unchanged.
 
-    // TODO: throw during tests
-    if (Ember.testing) {
-      run.end();
-    } else if (!autorunTimer) {
-      autorunTimer = setTimeout(autorun, 1);
-    }
-  }
+    @param {String} fromPath from path or null
+    @param {Object} [placeholder] Placeholder value.
+    @returns {Ember.Binding} this
+  */
+  single: function(placeholder) {
+    if (placeholder===undefined) placeholder = Ember.MULTIPLE_PLACEHOLDER;
+    this._typeTransform = SINGLE;
+    this._placeholder = placeholder;
+    return this;
+  },
 
-  return run.currentRunLoop;
-};
+  /**
+    Adds a transform that will convert the passed value to an array. If
+    the value is null or undefined, it will be converted to an empty array.
 
-/**
-  Immediately flushes any events scheduled in the 'sync' queue.  Bindings
-  use this queue so this method is a useful way to immediately force all
-  bindings in the application to sync.
+    @param {String} [fromPath]
+    @returns {Ember.Binding} this
+  */
+  multiple: function() {
+    this._typeTransform = MULTIPLE;
+    this._placeholder = null;
+    return this;
+  },
 
-  You should call this method anytime you need any changed state to propagate
-  throughout the app immediately without repainting the UI.
+  /**
+    Adds a transform to convert the value to a bool value. If the value is
+    an array it will return true if array is not empty. If the value is a
+    string it will return true if the string is not empty.
 
-      Ember.run.sync();
+    @returns {Ember.Binding} this
+  */
+  bool: function() {
+    this.transform(BOOL);
+    return this;
+  },
 
-  @returns {void}
-*/
-Ember.run.sync = function() {
-  run.autorun();
-  run.currentRunLoop.flush('sync');
-};
+  /**
+    Adds a transform that will return the placeholder value if the value is
+    null, undefined, an empty array or an empty string. See also notNull().
 
-// ..........................................................
-// TIMERS
-//
+    @param {Object} [placeholder] Placeholder value.
+    @returns {Ember.Binding} this
+  */
+  notEmpty: function(placeholder) {
+    if (placeholder === null || placeholder === undefined) {
+      placeholder = Ember.EMPTY_PLACEHOLDER;
+    }
 
-var timers = {}; // active timers...
+    this.transform({
+      to: function(val) { return empty(val) ? placeholder : val; }
+    });
 
-var laterScheduled = false;
-/** @private */
-function invokeLaterTimers() {
-  var now = (+ new Date()), earliest = -1;
-  for(var key in timers) {
-    if (!timers.hasOwnProperty(key)) continue;
-    var timer = timers[key];
-    if (timer && timer.expires) {
-      if (now >= timer.expires) {
-        delete timers[key];
-        invoke(timer.target, timer.method, timer.args, 2);
-      } else {
-        if (earliest<0 || (timer.expires < earliest)) earliest=timer.expires;
-      }
-    }
-  }
+    return this;
+  },
 
-  // schedule next timeout to fire...
-  if (earliest>0) setTimeout(invokeLaterTimers, earliest-(+ new Date()));
-}
+  /**
+    Adds a transform that will return the placeholder value if the value is
+    null or undefined. Otherwise it will passthrough untouched. See also notEmpty().
 
-/**
-  Invokes the passed target/method and optional arguments after a specified
-  period if time.  The last parameter of this method must always be a number
-  of milliseconds.
+    @param {String} fromPath from path or null
+    @param {Object} [placeholder] Placeholder value.
+    @returns {Ember.Binding} this
+  */
+  notNull: function(placeholder) {
+    if (placeholder === null || placeholder === undefined) {
+      placeholder = Ember.EMPTY_PLACEHOLDER;
+    }
 
-  You should use this method whenever you need to run some action after a
-  period of time instead of using setTimeout().  This method will ensure that
-  items that expire during the same script execution cycle all execute
-  together, which is often more efficient than using a real setTimeout.
+    this.transform({
+      to: function(val) { return (val === null || val === undefined) ? placeholder : val; }
+    });
 
-      Ember.run.later(myContext, function(){
-        // code here will execute within a RunLoop in about 500ms with this == myContext
-      }, 500);
+    return this;
+  },
 
-  @param {Object} target
-    (optional) target of method to invoke
+  /**
+    Adds a transform to convert the value to the inverse of a bool value. This
+    uses the same transform as bool() but inverts it.
 
-  @param {Function|String} method
-    The method to invoke.  If you pass a string it will be resolved on the
-    target at the time the method is invoked.
+    @returns {Ember.Binding} this
+  */
+  not: function() {
+    this.transform(NOT);
+    return this;
+  },
 
-  @param {Object...} args
-    Optional arguments to pass to the timeout.
+  /**
+    Adds a transform that will return true if the value is null or undefined, false otherwise.
 
-  @param {Number} wait
-    Number of milliseconds to wait.
+    @returns {Ember.Binding} this
+  */
+  isNull: function() {
+    this.transform(function(val) { return val === null || val === undefined; });
+    return this;
+  },
 
-  @returns {Timer} an object you can use to cancel a timer at a later time.
-*/
-Ember.run.later = function(target, method) {
-  var args, expires, timer, guid, wait;
+  /** @private */
+  toString: function() {
+    var oneWay = this._oneWay ? '[oneWay]' : '';
+    return "Ember.Binding<" + guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
+  },
 
-  // setTimeout compatibility...
-  if (arguments.length===2 && 'function' === typeof target) {
-    wait   = method;
-    method = target;
-    target = undefined;
-    args   = [target, method];
+  // ..........................................................
+  // CONNECT AND SYNC
+  //
 
-  } else {
-    args = slice.call(arguments);
-    wait = args.pop();
-  }
+  /**
+    Attempts to connect this binding instance so that it can receive and relay
+    changes. This method will raise an exception if you have not set the
+    from/to properties yet.
 
-  expires = (+ new Date())+wait;
-  timer   = { target: target, method: method, expires: expires, args: args };
-  guid    = Ember.guidFor(timer);
-  timers[guid] = timer;
-  run.once(timers, invokeLaterTimers);
-  return guid;
-};
+    @param {Object} obj
+      The root object for this binding.
 
-/** @private */
-function invokeOnceTimer(guid, onceTimers) {
-  if (onceTimers[this.tguid]) delete onceTimers[this.tguid][this.mguid];
-  if (timers[guid]) invoke(this.target, this.method, this.args, 2);
-  delete timers[guid];
-}
+    @param {Boolean} preferFromParam
+      private: Normally, `connect` cannot take an object if `from` already set
+      an object. Internally, we would like to be able to provide a default object
+      to be used if no object was provided via `from`, so this parameter turns
+      off the assertion.
 
-/**
-  Schedules an item to run one time during the current RunLoop.  Calling
-  this method with the same target/method combination will have no effect.
+    @returns {Ember.Binding} this
+  */
+  connect: function(obj) {
 
-  Note that although you can pass optional arguments these will not be
-  considered when looking for duplicates.  New arguments will replace previous
-  calls.
 
-      Ember.run(function(){
-        var doFoo = function() { foo(); }
-        Ember.run.once(myContext, doFoo);
-        Ember.run.once(myContext, doFoo);
-        // doFoo will only be executed once at the end of the RunLoop
-      });
+    var oneWay = this._oneWay, operand = this._operand;
 
-  @param {Object} target
-    (optional) target of method to invoke
+    // add an observer on the object to be notified when the binding should be updated
+    Ember.addObserver(obj, this._from, this, this.fromDidChange);
 
-  @param {Function|String} method
-    The method to invoke.  If you pass a string it will be resolved on the
-    target at the time the method is invoked.
+    // if there is an operand, add an observer onto it as well
+    if (operand) { Ember.addObserver(obj, operand, this, this.fromDidChange); }
 
-  @param {Object...} args
-    Optional arguments to pass to the timeout.
+    // if the binding is a two-way binding, also set up an observer on the target
+    // object.
+    if (!oneWay) { Ember.addObserver(obj, this._to, this, this.toDidChange); }
 
+    if (Ember.meta(obj,false).proto !== obj) { this._scheduleSync(obj, 'fwd'); }
 
-  @returns {Object} timer
-*/
-Ember.run.once = function(target, method) {
-  var tguid = Ember.guidFor(target), mguid = Ember.guidFor(method), guid, timer;
+    this._readyToSync = true;
+    return this;
+  },
 
-  var onceTimers = run.autorun().onceTimers;
-  guid = onceTimers[tguid] && onceTimers[tguid][mguid];
-  if (guid && timers[guid]) {
-    timers[guid].args = slice.call(arguments); // replace args
+  /**
+    Disconnects the binding instance. Changes will no longer be relayed. You
+    will not usually need to call this method.
 
-  } else {
-    timer = {
-      target: target,
-      method: method,
-      args:   slice.call(arguments),
-      tguid:  tguid,
-      mguid:  mguid
-    };
+    @param {Object} obj
+      The root object you passed when connecting the binding.
 
-    guid  = Ember.guidFor(timer);
-    timers[guid] = timer;
-    if (!onceTimers[tguid]) onceTimers[tguid] = {};
-    onceTimers[tguid][mguid] = guid; // so it isn't scheduled more than once
+    @returns {Ember.Binding} this
+  */
+  disconnect: function(obj) {
 
-    run.schedule('actions', timer, invokeOnceTimer, guid, onceTimers);
-  }
 
-  return guid;
-};
+    var oneWay = this._oneWay, operand = this._operand;
 
-var scheduledNext = false;
-/** @private */
-function invokeNextTimers() {
-  scheduledNext = null;
-  for(var key in timers) {
-    if (!timers.hasOwnProperty(key)) continue;
-    var timer = timers[key];
-    if (timer.next) {
-      delete timers[key];
-      invoke(timer.target, timer.method, timer.args, 2);
-    }
-  }
-}
+    // remove an observer on the object so we're no longer notified of
+    // changes that should update bindings.
+    Ember.removeObserver(obj, this._from, this, this.fromDidChange);
 
-/**
-  Schedules an item to run after control has been returned to the system.
-  This is often equivalent to calling setTimeout(function...,1).
+    // if there is an operand, remove the observer from it as well
+    if (operand) Ember.removeObserver(obj, operand, this, this.fromDidChange);
 
-      Ember.run.next(myContext, function(){
-        // code to be executed in the next RunLoop, which will be scheduled after the current one
-      });
+    // if the binding is two-way, remove the observer from the target as well
+    if (!oneWay) Ember.removeObserver(obj, this._to, this, this.toDidChange);
 
-  @param {Object} target
-    (optional) target of method to invoke
+    this._readyToSync = false; // disable scheduled syncs...
+    return this;
+  },
 
-  @param {Function|String} method
-    The method to invoke.  If you pass a string it will be resolved on the
-    target at the time the method is invoked.
+  // ..........................................................
+  // PRIVATE
+  //
 
-  @param {Object...} args
-    Optional arguments to pass to the timeout.
+  /** @private - called when the from side changes */
+  fromDidChange: function(target) {
+    this._scheduleSync(target, 'fwd');
+  },
 
-  @returns {Object} timer
-*/
-Ember.run.next = function(target, method) {
-  var timer, guid;
+  /** @private - called when the to side changes */
+  toDidChange: function(target) {
+    this._scheduleSync(target, 'back');
+  },
 
-  timer = {
-    target: target,
-    method: method,
-    args: slice.call(arguments),
-    next: true
-  };
+  /** @private */
+  _scheduleSync: function(obj, dir) {
+    var guid = guidFor(obj), existingDir = this[guid];
 
-  guid = Ember.guidFor(timer);
-  timers[guid] = timer;
+    // if we haven't scheduled the binding yet, schedule it
+    if (!existingDir) {
+      Ember.run.schedule('sync', this, this._sync, obj);
+      this[guid] = dir;
+    }
 
-  if (!scheduledNext) scheduledNext = setTimeout(invokeNextTimers, 1);
-  return guid;
-};
+    // If both a 'back' and 'fwd' sync have been scheduled on the same object,
+    // default to a 'fwd' sync so that it remains deterministic.
+    if (existingDir === 'back' && dir === 'fwd') {
+      this[guid] = 'fwd';
+    }
+  },
 
-/**
-  Cancels a scheduled item.  Must be a value returned by `Ember.run.later()`,
-  `Ember.run.once()`, or `Ember.run.next()`.
+  /** @private */
+  _sync: function(obj) {
+    var log = Ember.LOG_BINDINGS;
 
-      var runNext = Ember.run.next(myContext, function(){
-        // will not be executed
-      });
-      Ember.run.cancel(runNext);
+    // don't synchronize destroyed objects or disconnected bindings
+    if (obj.isDestroyed || !this._readyToSync) { return; }
 
-      var runLater = Ember.run.next(myContext, function(){
-        // will not be executed
-      }, 500);
-      Ember.run.cancel(runLater);
+    // get the direction of the binding for the object we are
+    // synchronizing from
+    var guid = guidFor(obj), direction = this[guid];
 
-      var runOnce = Ember.run.once(myContext, function(){
-        // will not be executed
-      });
-      Ember.run.cancel(runOnce);
+    var fromPath = this._from, toPath = this._to;
 
-  @param {Object} timer
-    Timer object to cancel
+    delete this[guid];
+
+    // if we're synchronizing from the remote object...
+    if (direction === 'fwd') {
+      var fromValue = getTransformedFromValue(obj, this);
+      if (log) {
+        Ember.Logger.log(' ', this.toString(), '->', fromValue, obj);
+      }
+      if (this._oneWay) {
+        Ember.trySetPath(Ember.isGlobalPath(toPath) ? window : obj, toPath, fromValue);
+      } else {
+        Ember._suspendObserver(obj, toPath, this, this.toDidChange, function () {
+          Ember.trySetPath(Ember.isGlobalPath(toPath) ? window : obj, toPath, fromValue);
+        });
+      }
+    // if we're synchronizing *to* the remote object
+    } else if (direction === 'back') {// && !this._oneWay) {
+      var toValue = getTransformedToValue(obj, this);
+      if (log) {
+        Ember.Logger.log(' ', this.toString(), '<-', toValue, obj);
+      }
+      Ember._suspendObserver(obj, fromPath, this, this.fromDidChange, function () {
+        Ember.trySetPath(Ember.isGlobalPath(fromPath) ? window : obj, fromPath, toValue);
+      });
+    }
+  }
 
-  @returns {void}
-*/
-Ember.run.cancel = function(timer) {
-  delete timers[timer];
 };
 
-// ..........................................................
-// DEPRECATED API
-//
+/** @private */
+function mixinProperties(to, from) {
+  for (var key in from) {
+    if (from.hasOwnProperty(key)) {
+      to[key] = from[key];
+    }
+  }
+}
 
-/**
-  @namespace Compatibility for Ember.run
-  @name Ember.RunLoop
-  @deprecated
-*/
+mixinProperties(Binding,
+/** @scope Ember.Binding */ {
 
-/**
-  @deprecated
-  @method
+  /**
+    @see Ember.Binding.prototype.from
+  */
+  from: function() {
+    var C = this, binding = new C();
+    return binding.from.apply(binding, arguments);
+  },
 
-  Use `#js:Ember.run.begin()` instead
-*/
-Ember.RunLoop.begin = ember_deprecateFunc("Use Ember.run.begin instead of Ember.RunLoop.begin.", Ember.run.begin);
+  /**
+    @see Ember.Binding.prototype.to
+  */
+  to: function() {
+    var C = this, binding = new C();
+    return binding.to.apply(binding, arguments);
+  },
 
-/**
-  @deprecated
-  @method
+  /**
+    @see Ember.Binding.prototype.oneWay
+  */
+  oneWay: function(from, flag) {
+    var C = this, binding = new C(null, from);
+    return binding.oneWay(flag);
+  },
 
-  Use `#js:Ember.run.end()` instead
-*/
-Ember.RunLoop.end = ember_deprecateFunc("Use Ember.run.end instead of Ember.RunLoop.end.", Ember.run.end);
+  /**
+    @see Ember.Binding.prototype.single
+  */
+  single: function(from, placeholder) {
+    var C = this, binding = new C(null, from);
+    return binding.single(placeholder);
+  },
 
+  /**
+    @see Ember.Binding.prototype.multiple
+  */
+  multiple: function(from) {
+    var C = this, binding = new C(null, from);
+    return binding.multiple();
+  },
 
+  /**
+    @see Ember.Binding.prototype.transform
+  */
+  transform: function(from, func) {
+    if (!func) {
+      func = from;
+      from = null;
+    }
+    var C = this, binding = new C(null, from);
+    return binding.transform(func);
+  },
 
-})();
+  /**
+    @see Ember.Binding.prototype.notEmpty
+  */
+  notEmpty: function(from, placeholder) {
+    var C = this, binding = new C(null, from);
+    return binding.notEmpty(placeholder);
+  },
 
+  /**
+    @see Ember.Binding.prototype.notNull
+  */
+  notNull: function(from, placeholder) {
+    var C = this, binding = new C(null, from);
+    return binding.notNull(placeholder);
+  },
 
 
-(function() {
-// ==========================================================================
-// Project:  Ember Runtime
-// Copyright: ©2011 Strobe Inc. and contributors.
-// License:   Licensed under MIT license (see license.js)
-// ==========================================================================
-/*globals ember_assert */
-// Ember.Logger
-// get, getPath, setPath, trySetPath
-// guidFor, isArray, meta
-// addObserver, removeObserver
-// Ember.run.schedule
+  /**
+    @see Ember.Binding.prototype.bool
+  */
+  bool: function(from) {
+    var C = this, binding = new C(null, from);
+    return binding.bool();
+  },
 
-// ..........................................................
-// CONSTANTS
-//
+  /**
+    @see Ember.Binding.prototype.not
+  */
+  not: function(from) {
+    var C = this, binding = new C(null, from);
+    return binding.not();
+  },
 
+  /**
+    @see Ember.Binding.prototype.isNull
+  */
+  isNull: function(from) {
+    var C = this, binding = new C(null, from);
+    return binding.isNull();
+  },
 
-/**
-  @static
+  /**
+    Adds a transform that forwards the logical 'AND' of values at 'pathA' and
+    'pathB' whenever either source changes. Note that the transform acts
+    strictly as a one-way binding, working only in the direction
 
-  Debug parameter you can turn on. This will log all bindings that fire to
-  the console. This should be disabled in production code. Note that you
-  can also enable this from the console or temporarily.
+        'pathA' AND 'pathB' --> value  (value returned is the result of ('pathA' && 'pathB'))
 
-  @type Boolean
-  @default false
-*/
-Ember.LOG_BINDINGS = false || !!Ember.ENV.LOG_BINDINGS;
+    Usage example where a delete button's `isEnabled` value is determined by
+    whether something is selected in a list and whether the current user is
+    allowed to delete:
 
-/**
-  @static
+        deleteButton: Ember.ButtonView.design({
+          isEnabledBinding: Ember.Binding.and('MyApp.itemsController.hasSelection', 'MyApp.userController.canDelete')
+        })
 
-  Performance paramter. This will benchmark the time spent firing each
-  binding.
+    @param {String} pathA The first part of the conditional
+    @param {String} pathB The second part of the conditional
+  */
+  and: function(pathA, pathB) {
+    var C = this, binding = new C(null, pathA).oneWay();
+    binding._operand = pathB;
+    binding._operation = AND_OPERATION;
+    return binding;
+  },
 
-  @type Boolean
-*/
-Ember.BENCHMARK_BINDING_NOTIFICATIONS = !!Ember.ENV.BENCHMARK_BINDING_NOTIFICATIONS;
+  /**
+    Adds a transform that forwards the 'OR' of values at 'pathA' and
+    'pathB' whenever either source changes. Note that the transform acts
+    strictly as a one-way binding, working only in the direction
 
-/**
-  @static
+        'pathA' AND 'pathB' --> value  (value returned is the result of ('pathA' || 'pathB'))
 
-  Performance parameter. This will benchmark the time spend configuring each
-  binding.
+    @param {String} pathA The first part of the conditional
+    @param {String} pathB The second part of the conditional
+  */
+  or: function(pathA, pathB) {
+    var C = this, binding = new C(null, pathA).oneWay();
+    binding._operand = pathB;
+    binding._operation = OR_OPERATION;
+    return binding;
+  },
 
-  @type Boolean
-*/
-Ember.BENCHMARK_BINDING_SETUP = !!Ember.ENV.BENCHMARK_BINDING_SETUP;
+  /**
+    Registers a custom transform for use in bindings.
+
+    @param {String} name The name of the transform
+    @param {Function} transform The transformation function
+  */
+  registerTransform: function(name, transform) {
+    this.prototype[name] = transform;
+    this[name] = function(from) {
+      var C = this, binding = new C(null, from), args;
+      args = Array.prototype.slice.call(arguments, 1);
+      return binding[name].apply(binding, args);
+    };
+  }
 
+});
 
 /**
-  @static
+  @class
 
-  Default placeholder for multiple values in bindings.
+  A binding simply connects the properties of two objects so that whenever the
+  value of one property changes, the other property will be changed also. You
+  do not usually work with Binding objects directly but instead describe
+  bindings in your class definition using something like:
 
-  @type String
-  @default '@@MULT@@'
-*/
-Ember.MULTIPLE_PLACEHOLDER = '@@MULT@@';
+        valueBinding: "MyApp.someController.title"
 
-/**
-  @static
+  This will create a binding from `MyApp.someController.title` to the `value`
+  property of your object instance automatically. Now the two values will be
+  kept in sync.
 
-  Default placeholder for empty values in bindings.  Used by notEmpty()
-  helper unless you specify an alternative.
+  ## Customizing Your Bindings
 
-  @type String
-  @default '@@EMPTY@@'
-*/
-Ember.EMPTY_PLACEHOLDER = '@@EMPTY@@';
-
-// ..........................................................
-// TYPE COERCION HELPERS
-//
+  In addition to synchronizing values, bindings can also perform some basic
+  transforms on values. These transforms can help to make sure the data fed
+  into one object always meets the expectations of that object regardless of
+  what the other object outputs.
 
-// Coerces a non-array value into an array.
-/** @private */
-function MULTIPLE(val) {
-  if (val instanceof Array) return val;
-  if (val === undefined || val === null) return [];
-  return [val];
-}
+  To customize a binding, you can use one of the many helper methods defined
+  on Ember.Binding like so:
 
-// Treats a single-element array as the element. Otherwise
-// returns a placeholder.
-/** @private */
-function SINGLE(val, placeholder) {
-  if (val instanceof Array) {
-    if (val.length>1) return placeholder;
-    else return val[0];
-  }
-  return val;
-}
+        valueBinding: Ember.Binding.single("MyApp.someController.title")
 
-// Coerces the binding value into a Boolean.
+  This will create a binding just like the example above, except that now the
+  binding will convert the value of `MyApp.someController.title` to a single
+  object (removing any arrays) before applying it to the `value` property of
+  your object.
 
-var BOOL = {
-  to: function (val) {
-    return !!val;
-  }
-};
+  You can also chain helper methods to build custom bindings like so:
 
-// Returns the Boolean inverse of the value.
-var NOT = {
-  to: function NOT(val) {
-    return !val;
-  }
-};
+        valueBinding: Ember.Binding.single("MyApp.someController.title").notEmpty("(EMPTY)")
 
-var get     = Ember.get,
-    getPath = Ember.getPath,
-    setPath = Ember.setPath,
-    guidFor = Ember.guidFor,
-    isGlobalPath = Ember.isGlobalPath;
+  This will force the value of MyApp.someController.title to be a single value
+  and then check to see if the value is "empty" (null, undefined, empty array,
+  or an empty string). If it is empty, the value will be set to the string
+  "(EMPTY)".
 
-// Applies a binding's transformations against a value.
-/** @private */
-function getTransformedValue(binding, val, obj, dir) {
+  ## One Way Bindings
 
-  // First run a type transform, if it exists, that changes the fundamental
-  // type of the value. For example, some transforms convert an array to a
-  // single object.
+  One especially useful binding customization you can use is the `oneWay()`
+  helper. This helper tells Ember that you are only interested in
+  receiving changes on the object you are binding from. For example, if you
+  are binding to a preference and you want to be notified if the preference
+  has changed, but your object will not be changing the preference itself, you
+  could do:
 
-  var typeTransform = binding._typeTransform;
-  if (typeTransform) { val = typeTransform(val, binding._placeholder); }
+        bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
 
-  // handle transforms
-  var transforms = binding._transforms,
-      len        = transforms ? transforms.length : 0,
-      idx;
+  This way if the value of MyApp.preferencesController.bigTitles changes the
+  "bigTitles" property of your object will change also. However, if you
+  change the value of your "bigTitles" property, it will not update the
+  preferencesController.
 
-  for(idx=0;idx<len;idx++) {
-    var transform = transforms[idx][dir];
-    if (transform) { val = transform.call(this, val, obj); }
-  }
-  return val;
-}
+  One way bindings are almost twice as fast to setup and twice as fast to
+  execute because the binding only has to worry about changes to one side.
 
-/** @private */
-function empty(val) {
-  return val===undefined || val===null || val==='' || (Ember.isArray(val) && get(val, 'length')===0) ;
-}
+  You should consider using one way bindings anytime you have an object that
+  may be created frequently and you do not intend to change a property; only
+  to monitor it for changes. (such as in the example above).
 
-/** @private */
-function getPathWithGlobals(obj, path) {
-  return getPath(isGlobalPath(path) ? window : obj, path);
-}
+  ## Adding Custom Transforms
 
-/** @private */
-function getTransformedFromValue(obj, binding) {
-  var operation = binding._operation,
-      fromValue;
-  if (operation) {
-    fromValue = operation(obj, binding._from, binding._operand);
-  } else {
-    fromValue = getPathWithGlobals(obj, binding._from);
-  }
-  return getTransformedValue(binding, fromValue, obj, 'to');
-}
+  In addition to using the standard helpers provided by Ember, you can
+  also defined your own custom transform functions which will be used to
+  convert the value. To do this, just define your transform function and add
+  it to the binding with the transform() helper. The following example will
+  not allow Integers less than ten. Note that it checks the value of the
+  bindings and allows all other values to pass:
 
-/** @private */
-function getTransformedToValue(obj, binding) {
-  var toValue = getPath(obj, binding._to);
-  return getTransformedValue(binding, toValue, obj, 'from');
-}
+        valueBinding: Ember.Binding.transform(function(value, binding) {
+          return ((Ember.typeOf(value) === 'number') && (value < 10)) ? 10 : value;
+        }).from("MyApp.someController.value")
 
-/** @private */
-var AND_OPERATION = function(obj, left, right) {
-  return getPathWithGlobals(obj, left) && getPathWithGlobals(obj, right);
-};
+  If you would like to instead use this transform on a number of bindings,
+  you can also optionally add your own helper method to Ember.Binding. This
+  method should simply return the value of `this.transform()`. The example
+  below adds a new helper called `notLessThan()` which will limit the value to
+  be not less than the passed minimum:
 
-/** @private */
-var OR_OPERATION = function(obj, left, right) {
-  return getPathWithGlobals(obj, left) || getPathWithGlobals(obj, right);
-};
+      Ember.Binding.registerTransform('notLessThan', function(minValue) {
+        return this.transform(function(value, binding) {
+          return ((Ember.typeOf(value) === 'number') && (value < minValue)) ? minValue : value;
+        });
+      });
 
-// ..........................................................
-// BINDING
-//
-/** @private */
-var K = function() {};
+  You could specify this in your core.js file, for example. Then anywhere in
+  your application you can use it to define bindings like so:
 
-/** @private */
-var Binding = function(toPath, fromPath) {
-  var self;
+        valueBinding: Ember.Binding.from("MyApp.someController.value").notLessThan(10)
 
-  if (this instanceof Binding) {
-    self = this;
-  } else {
-    self = new K();
-  }
+  Also, remember that helpers are chained so you can use your helper along
+  with any other helpers. The example below will create a one way binding that
+  does not allow empty values or values less than 10:
 
-  /** @private */
-  self._direction = 'fwd';
+        valueBinding: Ember.Binding.oneWay("MyApp.someController.value").notEmpty().notLessThan(10)
 
-  /** @private */
-  self._from = fromPath;
-  self._to   = toPath;
+  Finally, it's also possible to specify bi-directional transforms. To do this,
+  you can pass a hash to `transform` with `to` and `from`. In the following
+  example, we are expecting a lowercase string that we want to transform to
+  uppercase.
 
-  return self;
-};
+        valueBinding: Ember.Binding.transform({
+          to:   function(value, binding) { return value.toUpperCase(); },
+          from: function(value, binding) { return value.toLowerCase(); }
 
-K.prototype = Binding.prototype;
+  ## How to Manually Adding Binding
 
-Binding.prototype = /** @scope Ember.Binding.prototype */ {
-  // ..........................................................
-  // CONFIG
-  //
+  All of the examples above show you how to configure a custom binding, but
+  the result of these customizations will be a binding template, not a fully
+  active binding. The binding will actually become active only when you
+  instantiate the object the binding belongs to. It is useful however, to
+  understand what actually happens when the binding is activated.
 
-  /**
-    This will set "from" property path to the specified value. It will not
-    attempt to resolve this property path to an actual object until you
-    connect the binding.
+  For a binding to function it must have at least a "from" property and a "to"
+  property. The from property path points to the object/key that you want to
+  bind from while the to path points to the object/key you want to bind to.
 
-    The binding will search for the property path starting at the root object
-    you pass when you connect() the binding.  It follows the same rules as
-    `getPath()` - see that method for more information.
+  When you define a custom binding, you are usually describing the property
+  you want to bind from (such as "MyApp.someController.value" in the examples
+  above). When your object is created, it will automatically assign the value
+  you want to bind "to" based on the name of your binding key. In the
+  examples above, during init, Ember objects will effectively call
+  something like this on your binding:
 
-    @param {String} propertyPath the property path to connect to
-    @returns {Ember.Binding} receiver
-  */
-  from: function(path) {
-    this._from = path;
-    return this;
-  },
+        binding = Ember.Binding.from(this.valueBinding).to("value");
 
-  /**
-    This will set the "to" property path to the specified value. It will not
-    attempt to resolve this property path to an actual object until you
-    connect the binding.
+  This creates a new binding instance based on the template you provide, and
+  sets the to path to the "value" property of the new object. Now that the
+  binding is fully configured with a "from" and a "to", it simply needs to be
+  connected to become active. This is done through the connect() method:
 
-    The binding will search for the property path starting at the root object
-    you pass when you connect() the binding.  It follows the same rules as
-    `getPath()` - see that method for more information.
+        binding.connect(this);
 
-    @param {String|Tuple} propertyPath A property path or tuple
-    @param {Object} [root] Root object to use when resolving the path.
-    @returns {Ember.Binding} this
-  */
-  to: function(path) {
-    this._to = path;
-    return this;
-  },
+  Note that when you connect a binding you pass the object you want it to be
+  connected to.  This object will be used as the root for both the from and
+  to side of the binding when inspecting relative paths.  This allows the
+  binding to be automatically inherited by subclassed objects as well.
 
-  /**
-    Configures the binding as one way. A one-way binding will relay changes
-    on the "from" side to the "to" side, but not the other way around. This
-    means that if you change the "to" side directly, the "from" side may have
-    a different value.
+  Now that the binding is connected, it will observe both the from and to side
+  and relay changes.
 
-    @param {Boolean} flag
-      (Optional) passing nothing here will make the binding oneWay.  You can
-      instead pass false to disable oneWay, making the binding two way again.
+  If you ever needed to do so (you almost never will, but it is useful to
+  understand this anyway), you could manually create an active binding by
+  using the Ember.bind() helper method. (This is the same method used by
+  to setup your bindings on objects):
 
-    @returns {Ember.Binding} receiver
-  */
-  oneWay: function(flag) {
-    this._oneWay = flag===undefined ? true : !!flag;
-    return this;
-  },
+        Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
 
-  /**
-    Adds the specified transform to the array of transform functions.
+  Both of these code fragments have the same effect as doing the most friendly
+  form of binding creation like so:
 
-    A transform is a hash with `to` and `from` properties. Each property
-    should be a function that performs a transformation in either the
-    forward or back direction.
+        MyApp.anotherObject = Ember.Object.create({
+          valueBinding: "MyApp.someController.value",
 
-    The functions you pass must have the following signature:
+          // OTHER CODE FOR THIS OBJECT...
 
-          function(value) {};
+        });
 
-    They must also return the transformed value.
+  Ember's built in binding creation method makes it easy to automatically
+  create bindings for you. You should always use the highest-level APIs
+  available, even if you understand how it works underneath.
 
-    Transforms are invoked in the order they were added. If you are
-    extending a binding and want to reset the transforms, you can call
-    `resetTransform()` first.
+  @since Ember 0.9
+*/
+Ember.Binding = Binding;
 
-    @param {Function} transformFunc the transform function.
-    @returns {Ember.Binding} this
-  */
-  transform: function(transform) {
-    if ('function' === typeof transform) {
-      transform = { to: transform };
-    }
+/**
+  Global helper method to create a new binding.  Just pass the root object
+  along with a to and from path to create and connect the binding.  The new
+  binding object will be returned which you can further configure with
+  transforms and other conditions.
 
-    if (!this._transforms) this._transforms = [];
-    this._transforms.push(transform);
-    return this;
-  },
+  @param {Object} obj
+    The root object of the transform.
 
-  /**
-    Resets the transforms for the binding. After calling this method the
-    binding will no longer transform values. You can then add new transforms
-    as needed.
+  @param {String} to
+    The path to the 'to' side of the binding.  Must be relative to obj.
 
-    @returns {Ember.Binding} this
-  */
-  resetTransforms: function() {
-    this._transforms = null;
-    return this;
-  },
+  @param {String} from
+    The path to the 'from' side of the binding.  Must be relative to obj or
+    a global path.
 
-  /**
-    Adds a transform to the chain that will allow only single values to pass.
-    This will allow single values and nulls to pass through. If you pass an
-    array, it will be mapped as so:
+  @returns {Ember.Binding} binding instance
+*/
+Ember.bind = function(obj, to, from) {
+  return new Ember.Binding(to, from).connect(obj);
+};
 
-      - [] => null
-      - [a] => a
-      - [a,b,c] => Multiple Placeholder
+Ember.oneWay = function(obj, to, from) {
+  return new Ember.Binding(to, from).oneWay().connect(obj);
+};
 
-    You can pass in an optional multiple placeholder or it will use the
-    default.
+})();
 
-    Note that this transform will only happen on forwarded valued. Reverse
-    values are send unchanged.
 
-    @param {String} fromPath from path or null
-    @param {Object} [placeholder] Placeholder value.
-    @returns {Ember.Binding} this
-  */
-  single: function(placeholder) {
-    if (placeholder===undefined) placeholder = Ember.MULTIPLE_PLACEHOLDER;
-    this._typeTransform = SINGLE;
-    this._placeholder = placeholder;
-    return this;
-  },
 
-  /**
-    Adds a transform that will convert the passed value to an array. If
-    the value is null or undefined, it will be converted to an empty array.
+(function() {
+// ==========================================================================
+// Project:  Ember Runtime
+// Copyright: ©2011 Strobe Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+var Mixin, MixinDelegate, REQUIRED, Alias;
+var classToString, superClassString;
 
-    @param {String} [fromPath]
-    @returns {Ember.Binding} this
-  */
-  multiple: function() {
-    this._typeTransform = MULTIPLE;
-    this._placeholder = null;
-    return this;
-  },
+var a_map = Ember.ArrayUtils.map;
+var a_indexOf = Ember.ArrayUtils.indexOf;
+var a_forEach = Ember.ArrayUtils.forEach;
+var a_slice = Array.prototype.slice;
+var EMPTY_META = {}; // dummy for non-writable meta
+var META_SKIP = { __emberproto__: true, __ember_count__: true };
 
-  /**
-    Adds a transform to convert the value to a bool value. If the value is
-    an array it will return true if array is not empty. If the value is a
-    string it will return true if the string is not empty.
+var o_create = Ember.platform.create;
 
-    @returns {Ember.Binding} this
-  */
-  bool: function() {
-    this.transform(BOOL);
-    return this;
-  },
+/** @private */
+function meta(obj, writable) {
+  var m = Ember.meta(obj, writable!==false), ret = m.mixins;
+  if (writable===false) return ret || EMPTY_META;
 
-  /**
-    Adds a transform that will return the placeholder value if the value is
-    null, undefined, an empty array or an empty string. See also notNull().
+  if (!ret) {
+    ret = m.mixins = { __emberproto__: obj };
+  } else if (ret.__emberproto__ !== obj) {
+    ret = m.mixins = o_create(ret);
+    ret.__emberproto__ = obj;
+  }
+  return ret;
+}
 
-    @param {Object} [placeholder] Placeholder value.
-    @returns {Ember.Binding} this
-  */
-  notEmpty: function(placeholder) {
-    if (placeholder === null || placeholder === undefined) {
-      placeholder = Ember.EMPTY_PLACEHOLDER;
-    }
+/** @private */
+function initMixin(mixin, args) {
+  if (args && args.length > 0) {
+    mixin.mixins = a_map(args, function(x) {
+      if (x instanceof Mixin) return x;
 
-    this.transform({
-      to: function(val) { return empty(val) ? placeholder : val; }
+      // Note: Manually setup a primitive mixin here.  This is the only
+      // way to actually get a primitive mixin.  This way normal creation
+      // of mixins will give you combined mixins...
+      var mixin = new Mixin();
+      mixin.properties = x;
+      return mixin;
     });
+  }
+  return mixin;
+}
 
-    return this;
-  },
+var NATIVES = [Boolean, Object, Number, Array, Date, String];
+/** @private */
+function isMethod(obj) {
+  if ('function' !== typeof obj || obj.isMethod===false) return false;
+  return a_indexOf(NATIVES, obj)<0;
+}
 
-  /**
-    Adds a transform that will return the placeholder value if the value is
-    null or undefined. Otherwise it will passthrough untouched. See also notEmpty().
+/** @private */
+function mergeMixins(mixins, m, descs, values, base) {
+  var len = mixins.length, idx, mixin, guid, props, value, key, ovalue, concats;
 
-    @param {String} fromPath from path or null
-    @param {Object} [placeholder] Placeholder value.
-    @returns {Ember.Binding} this
-  */
-  notNull: function(placeholder) {
-    if (placeholder === null || placeholder === undefined) {
-      placeholder = Ember.EMPTY_PLACEHOLDER;
-    }
+  /** @private */
+  function removeKeys(keyName) {
+    delete descs[keyName];
+    delete values[keyName];
+  }
 
-    this.transform({
-      to: function(val) { return (val === null || val === undefined) ? placeholder : val; }
-    });
+  for(idx=0;idx<len;idx++) {
 
-    return this;
-  },
+    mixin = mixins[idx];
+    if (!mixin) throw new Error('Null value found in Ember.mixin()');
 
-  /**
-    Adds a transform to convert the value to the inverse of a bool value. This
-    uses the same transform as bool() but inverts it.
+    if (mixin instanceof Mixin) {
+      guid = Ember.guidFor(mixin);
+      if (m[guid]) continue;
+      m[guid] = mixin;
+      props = mixin.properties;
+    } else {
+      props = mixin; // apply anonymous mixin properties
+    }
 
-    @returns {Ember.Binding} this
-  */
-  not: function() {
-    this.transform(NOT);
-    return this;
-  },
+    if (props) {
 
-  /**
-    Adds a transform that will return true if the value is null or undefined, false otherwise.
+      // reset before adding each new mixin to pickup concats from previous
+      concats = values.concatenatedProperties || base.concatenatedProperties;
+      if (props.concatenatedProperties) {
+        concats = concats ? concats.concat(props.concatenatedProperties) : props.concatenatedProperties;
+      }
 
-    @returns {Ember.Binding} this
-  */
-  isNull: function() {
-    this.transform(function(val) { return val === null || val === undefined; });
-    return this;
-  },
+      for (key in props) {
+        if (!props.hasOwnProperty(key)) continue;
+        value = props[key];
+        if (value instanceof Ember.Descriptor) {
+          if (value === REQUIRED && descs[key]) { continue; }
 
-  /** @private */
-  toString: function() {
-    var oneWay = this._oneWay ? '[oneWay]' : '';
-    return "Ember.Binding<" + guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
-  },
+          descs[key]  = value;
+          values[key] = undefined;
+        } else {
 
-  // ..........................................................
-  // CONNECT AND SYNC
-  //
+          // impl super if needed...
+          if (isMethod(value)) {
+            ovalue = (descs[key] === Ember.SIMPLE_PROPERTY) && values[key];
+            if (!ovalue) ovalue = base[key];
+            if ('function' !== typeof ovalue) ovalue = null;
+            if (ovalue) {
+              var o = value.__ember_observes__, ob = value.__ember_observesBefore__;
+              value = Ember.wrap(value, ovalue);
+              value.__ember_observes__ = o;
+              value.__ember_observesBefore__ = ob;
+            }
+          } else if ((concats && a_indexOf(concats, key)>=0) || key === 'concatenatedProperties') {
+            var baseValue = values[key] || base[key];
+            value = baseValue ? baseValue.concat(value) : Ember.makeArray(value);
+          }
 
-  /**
-    Attempts to connect this binding instance so that it can receive and relay
-    changes. This method will raise an exception if you have not set the
-    from/to properties yet.
-
-    @param {Object} obj
-      The root object for this binding.
+          descs[key]  = Ember.SIMPLE_PROPERTY;
+          values[key] = value;
+        }
+      }
 
-    @param {Boolean} preferFromParam
-      private: Normally, `connect` cannot take an object if `from` already set
-      an object. Internally, we would like to be able to provide a default object
-      to be used if no object was provided via `from`, so this parameter turns
-      off the assertion.
+      // manually copy toString() because some JS engines do not enumerate it
+      if (props.hasOwnProperty('toString')) {
+        base.toString = props.toString;
+      }
 
-    @returns {Ember.Binding} this
-  */
-  connect: function(obj) {
+    } else if (mixin.mixins) {
+      mergeMixins(mixin.mixins, m, descs, values, base);
+      if (mixin._without) a_forEach(mixin._without, removeKeys);
+    }
+  }
+}
 
+/** @private */
+var defineProperty = Ember.defineProperty;
 
-    var oneWay = this._oneWay, operand = this._operand;
+/** @private */
+function writableReq(obj) {
+  var m = Ember.meta(obj), req = m.required;
+  if (!req || (req.__emberproto__ !== obj)) {
+    req = m.required = req ? o_create(req) : { __ember_count__: 0 };
+    req.__emberproto__ = obj;
+  }
+  return req;
+}
 
-    // add an observer on the object to be notified when the binding should be updated
-    Ember.addObserver(obj, this._from, this, this.fromDidChange);
+/** @private */
+function getObserverPaths(value) {
+  return ('function' === typeof value) && value.__ember_observes__;
+}
 
-    // if there is an operand, add an observer onto it as well
-    if (operand) { Ember.addObserver(obj, operand, this, this.fromDidChange); }
+/** @private */
+function getBeforeObserverPaths(value) {
+  return ('function' === typeof value) && value.__ember_observesBefore__;
+}
 
-    // if the binding is a two-way binding, also set up an observer on the target
-    // object.
-    if (!oneWay) { Ember.addObserver(obj, this._to, this, this.toDidChange); }
+var IS_BINDING = Ember.IS_BINDING = /^.+Binding$/;
 
-    if (Ember.meta(obj,false).proto !== obj) { this._scheduleSync(obj, 'fwd'); }
+function detectBinding(obj, key, m) {
+  if (IS_BINDING.test(key)) {
+    var bindings = m.bindings;
+    if (!bindings) {
+      bindings = m.bindings = { __emberproto__: obj };
+    } else if (bindings.__emberproto__ !== obj) {
+      bindings = m.bindings = o_create(m.bindings);
+      bindings.__emberproto__ = obj;
+    }
+    bindings[key] = true;
+  }
+}
 
-    this._readyToSync = true;
-    return this;
-  },
+function connectBindings(obj, m) {
+  if (m === undefined) {
+    m = Ember.meta(obj);
+  }
+  var bindings = m.bindings, key, binding;
+  if (bindings) {
+    for (key in bindings) {
+      binding = key !== '__emberproto__' && obj[key];
+      if (binding) {
+        if (binding instanceof Ember.Binding) {
+          binding = binding.copy(); // copy prototypes' instance
+          binding.to(key.slice(0, -7));
+        } else {
+          binding = new Ember.Binding(key.slice(0,-7), binding);
+        }
+        binding.connect(obj);
+        obj[key] = binding;
+      }
+    }
+  }
+}
 
-  /**
-    Disconnects the binding instance. Changes will no longer be relayed. You
-    will not usually need to call this method.
+/** @private */
+function applyMixin(obj, mixins, partial) {
+  var descs = {}, values = {}, m = Ember.meta(obj), req = m.required;
+  var key, willApply, didApply, value, desc;
 
-    @param {Object} obj
-      The root object you passed when connecting the binding.
+  // Go through all mixins and hashes passed in, and:
+  //
+  // * Handle concatenated properties
+  // * Set up _super wrapping if necessary
+  // * Set up descriptors (simple, watched or computed properties)
+  // * Copying `toString` in broken browsers
+  mergeMixins(mixins, meta(obj), descs, values, obj);
 
-    @returns {Ember.Binding} this
-  */
-  disconnect: function(obj) {
+  if (MixinDelegate.detect(obj)) {
+    willApply = values.willApplyProperty || obj.willApplyProperty;
+    didApply  = values.didApplyProperty || obj.didApplyProperty;
+  }
 
+  for(key in descs) {
+    if (!descs.hasOwnProperty(key)) continue;
 
-    var oneWay = this._oneWay, operand = this._operand;
+    desc = descs[key];
+    value = values[key];
 
-    // remove an observer on the object so we're no longer notified of
-    // changes that should update bindings.
-    Ember.removeObserver(obj, this._from, this, this.fromDidChange);
+    if (desc === REQUIRED) {
+      if (!(key in obj)) {
+        if (!partial) throw new Error('Required property not defined: '+key);
 
-    // if there is an operand, remove the observer from it as well
-    if (operand) Ember.removeObserver(obj, operand, this, this.fromDidChange);
+        // for partial applies add to hash of required keys
+        req = writableReq(obj);
+        req.__ember_count__++;
+        req[key] = true;
+      }
 
-    // if the binding is two-way, remove the observer from the target as well
-    if (!oneWay) Ember.removeObserver(obj, this._to, this, this.toDidChange);
+    } else {
 
-    this._readyToSync = false; // disable scheduled syncs...
-    return this;
-  },
+      while (desc instanceof Alias) {
 
-  // ..........................................................
-  // PRIVATE
-  //
+        var altKey = desc.methodName;
+        if (descs[altKey]) {
+          value = values[altKey];
+          desc  = descs[altKey];
+        } else if (m.descs[altKey]) {
+          desc  = m.descs[altKey];
+          value = desc.val(obj, altKey);
+        } else {
+          value = obj[altKey];
+          desc  = Ember.SIMPLE_PROPERTY;
+        }
+      }
 
-  /** @private - called when the from side changes */
-  fromDidChange: function(target) {
-    this._scheduleSync(target, 'fwd');
-  },
+      if (willApply) willApply.call(obj, key);
 
-  /** @private - called when the to side changes */
-  toDidChange: function(target) {
-    this._scheduleSync(target, 'back');
-  },
+      var observerPaths = getObserverPaths(value),
+          curObserverPaths = observerPaths && getObserverPaths(obj[key]),
+          beforeObserverPaths = getBeforeObserverPaths(value),
+          curBeforeObserverPaths = beforeObserverPaths && getBeforeObserverPaths(obj[key]),
+          len, idx;
 
-  /** @private */
-  _scheduleSync: function(obj, dir) {
-    var guid = guidFor(obj), existingDir = this[guid];
+      if (curObserverPaths) {
+        len = curObserverPaths.length;
+        for(idx=0;idx<len;idx++) {
+          Ember.removeObserver(obj, curObserverPaths[idx], null, key);
+        }
+      }
 
-    // if we haven't scheduled the binding yet, schedule it
-    if (!existingDir) {
-      Ember.run.schedule('sync', this, this._sync, obj);
-      this[guid] = dir;
-    }
+      if (curBeforeObserverPaths) {
+        len = curBeforeObserverPaths.length;
+        for(idx=0;idx<len;idx++) {
+          Ember.removeBeforeObserver(obj, curBeforeObserverPaths[idx], null,key);
+        }
+      }
 
-    // If both a 'back' and 'fwd' sync have been scheduled on the same object,
-    // default to a 'fwd' sync so that it remains deterministic.
-    if (existingDir === 'back' && dir === 'fwd') {
-      this[guid] = 'fwd';
-    }
-  },
+      detectBinding(obj, key, m);
 
-  /** @private */
-  _sync: function(obj) {
-    var log = Ember.LOG_BINDINGS;
+      defineProperty(obj, key, desc, value);
 
-    // don't synchronize destroyed objects or disconnected bindings
-    if (obj.isDestroyed || !this._readyToSync) { return; }
+      if (observerPaths) {
+        len = observerPaths.length;
+        for(idx=0;idx<len;idx++) {
+          Ember.addObserver(obj, observerPaths[idx], null, key);
+        }
+      }
 
-    // get the direction of the binding for the object we are
-    // synchronizing from
-    var guid = guidFor(obj), direction = this[guid];
+      if (beforeObserverPaths) {
+        len = beforeObserverPaths.length;
+        for(idx=0;idx<len;idx++) {
+          Ember.addBeforeObserver(obj, beforeObserverPaths[idx], null, key);
+        }
+      }
 
-    var fromPath = this._from, toPath = this._to;
+      if (req && req[key]) {
+        req = writableReq(obj);
+        req.__ember_count__--;
+        req[key] = false;
+      }
 
-    delete this[guid];
+      if (didApply) didApply.call(obj, key);
 
-    // if we're synchronizing from the remote object...
-    if (direction === 'fwd') {
-      var fromValue = getTransformedFromValue(obj, this);
-      if (log) {
-        Ember.Logger.log(' ', this.toString(), '->', fromValue, obj);
-      }
-      if (this._oneWay) {
-        Ember.trySetPath(Ember.isGlobalPath(toPath) ? window : obj, toPath, fromValue);
-      } else {
-        Ember._suspendObserver(obj, toPath, this, this.toDidChange, function () {
-          Ember.trySetPath(Ember.isGlobalPath(toPath) ? window : obj, toPath, fromValue);
-        });
-      }
-    // if we're synchronizing *to* the remote object
-    } else if (direction === 'back') {// && !this._oneWay) {
-      var toValue = getTransformedToValue(obj, this);
-      if (log) {
-        Ember.Logger.log(' ', this.toString(), '<-', toValue, obj);
-      }
-      Ember._suspendObserver(obj, fromPath, this, this.fromDidChange, function () {
-        Ember.trySetPath(Ember.isGlobalPath(fromPath) ? window : obj, fromPath, toValue);
-      });
     }
   }
 
-};
+  if (!partial) { // don't apply to prototype
+    value = connectBindings(obj, m);
+  }
 
-/** @private */
-function mixinProperties(to, from) {
-  for (var key in from) {
-    if (from.hasOwnProperty(key)) {
-      to[key] = from[key];
+  // Make sure no required attrs remain
+  if (!partial && req && req.__ember_count__>0) {
+    var keys = [];
+    for(key in req) {
+      if (META_SKIP[key]) continue;
+      keys.push(key);
     }
+    throw new Error('Required properties not defined: '+keys.join(','));
   }
+  return obj;
 }
 
-mixinProperties(Binding,
-/** @scope Ember.Binding */ {
-
-  /**
-    @see Ember.Binding.prototype.from
-  */
-  from: function() {
-    var C = this, binding = new C();
-    return binding.from.apply(binding, arguments);
-  },
-
-  /**
-    @see Ember.Binding.prototype.to
-  */
-  to: function() {
-    var C = this, binding = new C();
-    return binding.to.apply(binding, arguments);
-  },
-
-  /**
-    @see Ember.Binding.prototype.oneWay
-  */
-  oneWay: function(from, flag) {
-    var C = this, binding = new C(null, from);
-    return binding.oneWay(flag);
-  },
-
-  /**
-    @see Ember.Binding.prototype.single
-  */
-  single: function(from, placeholder) {
-    var C = this, binding = new C(null, from);
-    return binding.single(placeholder);
-  },
-
-  /**
-    @see Ember.Binding.prototype.multiple
-  */
-  multiple: function(from) {
-    var C = this, binding = new C(null, from);
-    return binding.multiple();
-  },
-
-  /**
-    @see Ember.Binding.prototype.transform
-  */
-  transform: function(from, func) {
-    if (!func) {
-      func = from;
-      from = null;
-    }
-    var C = this, binding = new C(null, from);
-    return binding.transform(func);
-  },
-
-  /**
-    @see Ember.Binding.prototype.notEmpty
-  */
-  notEmpty: function(from, placeholder) {
-    var C = this, binding = new C(null, from);
-    return binding.notEmpty(placeholder);
-  },
-
-  /**
-    @see Ember.Binding.prototype.notNull
-  */
-  notNull: function(from, placeholder) {
-    var C = this, binding = new C(null, from);
-    return binding.notNull(placeholder);
-  },
-
-
-  /**
-    @see Ember.Binding.prototype.bool
-  */
-  bool: function(from) {
-    var C = this, binding = new C(null, from);
-    return binding.bool();
-  },
-
-  /**
-    @see Ember.Binding.prototype.not
-  */
-  not: function(from) {
-    var C = this, binding = new C(null, from);
-    return binding.not();
-  },
+Ember.mixin = function(obj) {
+  var args = a_slice.call(arguments, 1);
+  return applyMixin(obj, args, false);
+};
 
-  /**
-    @see Ember.Binding.prototype.isNull
-  */
-  isNull: function(from) {
-    var C = this, binding = new C(null, from);
-    return binding.isNull();
-  },
 
-  /**
-    Adds a transform that forwards the logical 'AND' of values at 'pathA' and
-    'pathB' whenever either source changes. Note that the transform acts
-    strictly as a one-way binding, working only in the direction
+/**
+  @constructor
+*/
+Ember.Mixin = function() { return initMixin(this, arguments); };
 
-        'pathA' AND 'pathB' --> value  (value returned is the result of ('pathA' && 'pathB'))
+/** @private */
+Mixin = Ember.Mixin;
 
-    Usage example where a delete button's `isEnabled` value is determined by
-    whether something is selected in a list and whether the current user is
-    allowed to delete:
+/** @private */
+Mixin._apply = applyMixin;
 
-        deleteButton: Ember.ButtonView.design({
-          isEnabledBinding: Ember.Binding.and('MyApp.itemsController.hasSelection', 'MyApp.userController.canDelete')
-        })
+Mixin.applyPartial = function(obj) {
+  var args = a_slice.call(arguments, 1);
+  return applyMixin(obj, args, true);
+};
 
-    @param {String} pathA The first part of the conditional
-    @param {String} pathB The second part of the conditional
-  */
-  and: function(pathA, pathB) {
-    var C = this, binding = new C(null, pathA).oneWay();
-    binding._operand = pathB;
-    binding._operation = AND_OPERATION;
-    return binding;
-  },
+Mixin.finishPartial = function(obj) {
+  connectBindings(obj);
+  return obj;
+};
 
-  /**
-    Adds a transform that forwards the 'OR' of values at 'pathA' and
-    'pathB' whenever either source changes. Note that the transform acts
-    strictly as a one-way binding, working only in the direction
+Mixin.create = function() {
+  classToString.processed = false;
+  var M = this;
+  return initMixin(new M(), arguments);
+};
 
-        'pathA' AND 'pathB' --> value  (value returned is the result of ('pathA' || 'pathB'))
+Mixin.prototype.reopen = function() {
 
-    @param {String} pathA The first part of the conditional
-    @param {String} pathB The second part of the conditional
-  */
-  or: function(pathA, pathB) {
-    var C = this, binding = new C(null, pathA).oneWay();
-    binding._operand = pathB;
-    binding._operation = OR_OPERATION;
-    return binding;
-  }
+  var mixin, tmp;
 
-});
+  if (this.properties) {
+    mixin = Mixin.create();
+    mixin.properties = this.properties;
+    delete this.properties;
+    this.mixins = [mixin];
+  }
 
-/**
-  @class
+  var len = arguments.length, mixins = this.mixins, idx;
 
-  A binding simply connects the properties of two objects so that whenever the
-  value of one property changes, the other property will be changed also. You
-  do not usually work with Binding objects directly but instead describe
-  bindings in your class definition using something like:
+  for(idx=0;idx<len;idx++) {
+    mixin = arguments[idx];
+    if (mixin instanceof Mixin) {
+      mixins.push(mixin);
+    } else {
+      tmp = Mixin.create();
+      tmp.properties = mixin;
+      mixins.push(tmp);
+    }
+  }
 
-        valueBinding: "MyApp.someController.title"
+  return this;
+};
 
-  This will create a binding from `MyApp.someController.title` to the `value`
-  property of your object instance automatically. Now the two values will be
-  kept in sync.
+var TMP_ARRAY = [];
+Mixin.prototype.apply = function(obj) {
+  TMP_ARRAY[0] = this;
+  var ret = applyMixin(obj, TMP_ARRAY, false);
+  TMP_ARRAY.length=0;
+  return ret;
+};
 
-  ## Customizing Your Bindings
+Mixin.prototype.applyPartial = function(obj) {
+  TMP_ARRAY[0] = this;
+  var ret = applyMixin(obj, TMP_ARRAY, true);
+  TMP_ARRAY.length=0;
+  return ret;
+};
 
-  In addition to synchronizing values, bindings can also perform some basic
-  transforms on values. These transforms can help to make sure the data fed
-  into one object always meets the expectations of that object regardless of
-  what the other object outputs.
+/** @private */
+function _detect(curMixin, targetMixin, seen) {
+  var guid = Ember.guidFor(curMixin);
 
-  To customize a binding, you can use one of the many helper methods defined
-  on Ember.Binding like so:
+  if (seen[guid]) return false;
+  seen[guid] = true;
 
-        valueBinding: Ember.Binding.single("MyApp.someController.title")
+  if (curMixin === targetMixin) return true;
+  var mixins = curMixin.mixins, loc = mixins ? mixins.length : 0;
+  while(--loc >= 0) {
+    if (_detect(mixins[loc], targetMixin, seen)) return true;
+  }
+  return false;
+}
 
-  This will create a binding just like the example above, except that now the
-  binding will convert the value of `MyApp.someController.title` to a single
-  object (removing any arrays) before applying it to the `value` property of
-  your object.
+Mixin.prototype.detect = function(obj) {
+  if (!obj) return false;
+  if (obj instanceof Mixin) return _detect(obj, this, {});
+  return !!meta(obj, false)[Ember.guidFor(this)];
+};
 
-  You can also chain helper methods to build custom bindings like so:
+Mixin.prototype.without = function() {
+  var ret = new Mixin(this);
+  ret._without = a_slice.call(arguments);
+  return ret;
+};
 
-        valueBinding: Ember.Binding.single("MyApp.someController.title").notEmpty("(EMPTY)")
+/** @private */
+function _keys(ret, mixin, seen) {
+  if (seen[Ember.guidFor(mixin)]) return;
+  seen[Ember.guidFor(mixin)] = true;
 
-  This will force the value of MyApp.someController.title to be a single value
-  and then check to see if the value is "empty" (null, undefined, empty array,
-  or an empty string). If it is empty, the value will be set to the string
-  "(EMPTY)".
+  if (mixin.properties) {
+    var props = mixin.properties;
+    for(var key in props) {
+      if (props.hasOwnProperty(key)) ret[key] = true;
+    }
+  } else if (mixin.mixins) {
+    a_forEach(mixin.mixins, function(x) { _keys(ret, x, seen); });
+  }
+}
 
-  ## One Way Bindings
+Mixin.prototype.keys = function() {
+  var keys = {}, seen = {}, ret = [];
+  _keys(keys, this, seen);
+  for(var key in keys) {
+    if (keys.hasOwnProperty(key)) ret.push(key);
+  }
+  return ret;
+};
 
-  One especially useful binding customization you can use is the `oneWay()`
-  helper. This helper tells Ember that you are only interested in
-  receiving changes on the object you are binding from. For example, if you
-  are binding to a preference and you want to be notified if the preference
-  has changed, but your object will not be changing the preference itself, you
-  could do:
+/** @private - make Mixin's have nice displayNames */
 
-        bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
+var NAME_KEY = Ember.GUID_KEY+'_name';
+var get = Ember.get;
 
-  This way if the value of MyApp.preferencesController.bigTitles changes the
-  "bigTitles" property of your object will change also. However, if you
-  change the value of your "bigTitles" property, it will not update the
-  preferencesController.
+/** @private */
+function processNames(paths, root, seen) {
+  var idx = paths.length;
+  for(var key in root) {
+    if (!root.hasOwnProperty || !root.hasOwnProperty(key)) continue;
+    var obj = root[key];
+    paths[idx] = key;
 
-  One way bindings are almost twice as fast to setup and twice as fast to
-  execute because the binding only has to worry about changes to one side.
+    if (obj && obj.toString === classToString) {
+      obj[NAME_KEY] = paths.join('.');
+    } else if (obj && get(obj, 'isNamespace')) {
+      if (seen[Ember.guidFor(obj)]) continue;
+      seen[Ember.guidFor(obj)] = true;
+      processNames(paths, obj, seen);
+    }
 
-  You should consider using one way bindings anytime you have an object that
-  may be created frequently and you do not intend to change a property; only
-  to monitor it for changes. (such as in the example above).
+  }
+  paths.length = idx; // cut out last item
+}
 
-  ## Adding Custom Transforms
+/** @private */
+function findNamespaces() {
+  var Namespace = Ember.Namespace, obj, isNamespace;
 
-  In addition to using the standard helpers provided by Ember, you can
-  also defined your own custom transform functions which will be used to
-  convert the value. To do this, just define your transform function and add
-  it to the binding with the transform() helper. The following example will
-  not allow Integers less than ten. Note that it checks the value of the
-  bindings and allows all other values to pass:
+  if (Namespace.PROCESSED) { return; }
 
-        valueBinding: Ember.Binding.transform(function(value, binding) {
-          return ((Ember.typeOf(value) === 'number') && (value < 10)) ? 10 : value;
-        }).from("MyApp.someController.value")
+  for (var prop in window) {
+    //  get(window.globalStorage, 'isNamespace') would try to read the storage for domain isNamespace and cause exception in Firefox.
+    // globalStorage is a storage obsoleted by the WhatWG storage specification. See https://developer.mozilla.org/en/DOM/Storage#globalStorage
+    if (prop === "globalStorage" && window.StorageList && window.globalStorage instanceof window.StorageList) { continue; }
+    // Unfortunately, some versions of IE don't support window.hasOwnProperty
+    if (window.hasOwnProperty && !window.hasOwnProperty(prop)) { continue; }
 
-  If you would like to instead use this transform on a number of bindings,
-  you can also optionally add your own helper method to Ember.Binding. This
-  method should simply return the value of `this.transform()`. The example
-  below adds a new helper called `notLessThan()` which will limit the value to
-  be not less than the passed minimum:
+    // At times we are not allowed to access certain properties for security reasons.
+    // There are also times where even if we can access them, we are not allowed to access their properties.
+    try {
+      obj = window[prop];
+      isNamespace = obj && get(obj, 'isNamespace');
+    } catch (e) {
+      continue;
+    }
 
-      Ember.Binding.reopen({
-        notLessThan: function(minValue) {
-          return this.transform(function(value, binding) {
-            return ((Ember.typeOf(value) === 'number') && (value < minValue)) ? minValue : value;
-          });
-        }
-      });
+    if (isNamespace) {
 
-  You could specify this in your core.js file, for example. Then anywhere in
-  your application you can use it to define bindings like so:
+      obj[NAME_KEY] = prop;
+    }
+  }
+}
 
-        valueBinding: Ember.Binding.from("MyApp.someController.value").notLessThan(10)
+Ember.identifyNamespaces = findNamespaces;
 
-  Also, remember that helpers are chained so you can use your helper along
-  with any other helpers. The example below will create a one way binding that
-  does not allow empty values or values less than 10:
+/** @private */
+superClassString = function(mixin) {
+  var superclass = mixin.superclass;
+  if (superclass) {
+    if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; }
+    else { return superClassString(superclass); }
+  } else {
+    return;
+  }
+};
 
-        valueBinding: Ember.Binding.oneWay("MyApp.someController.value").notEmpty().notLessThan(10)
+/** @private */
+classToString = function() {
+  var Namespace = Ember.Namespace, namespace;
 
-  Finally, it's also possible to specify bi-directional transforms. To do this,
-  you can pass a hash to `transform` with `to` and `from`. In the following
-  example, we are expecting a lowercase string that we want to transform to
-  uppercase.
+  // TODO: Namespace should really be in Metal
+  if (Namespace) {
+    if (!this[NAME_KEY] && !classToString.processed) {
+      if (!Namespace.PROCESSED) {
+        findNamespaces();
+        Namespace.PROCESSED = true;
+      }
 
-        valueBinding: Ember.Binding.transform({
-          to:   function(value, binding) { return value.toUpperCase(); },
-          from: function(value, binding) { return value.toLowerCase(); }
+      classToString.processed = true;
 
-  ## How to Manually Adding Binding
+      var namespaces = Namespace.NAMESPACES;
+      for (var i=0, l=namespaces.length; i<l; i++) {
+        namespace = namespaces[i];
+        processNames([namespace.toString()], namespace, {});
+      }
+    }
+  }
 
-  All of the examples above show you how to configure a custom binding, but
-  the result of these customizations will be a binding template, not a fully
-  active binding. The binding will actually become active only when you
-  instantiate the object the binding belongs to. It is useful however, to
-  understand what actually happens when the binding is activated.
+  if (this[NAME_KEY]) {
+    return this[NAME_KEY];
+  } else {
+    var str = superClassString(this);
+    if (str) {
+      return "(subclass of " + str + ")";
+    } else {
+      return "(unknown mixin)";
+    }
+  }
+};
 
-  For a binding to function it must have at least a "from" property and a "to"
-  property. The from property path points to the object/key that you want to
-  bind from while the to path points to the object/key you want to bind to.
+Mixin.prototype.toString = classToString;
 
-  When you define a custom binding, you are usually describing the property
-  you want to bind from (such as "MyApp.someController.value" in the examples
-  above). When your object is created, it will automatically assign the value
-  you want to bind "to" based on the name of your binding key. In the
-  examples above, during init, Ember objects will effectively call
-  something like this on your binding:
+// returns the mixins currently applied to the specified object
+// TODO: Make Ember.mixin
+Mixin.mixins = function(obj) {
+  var ret = [], mixins = meta(obj, false), key, mixin;
+  for(key in mixins) {
+    if (META_SKIP[key]) continue;
+    mixin = mixins[key];
 
-        binding = Ember.Binding.from(this.valueBinding).to("value");
+    // skip primitive mixins since these are always anonymous
+    if (!mixin.properties) ret.push(mixins[key]);
+  }
+  return ret;
+};
 
-  This creates a new binding instance based on the template you provide, and
-  sets the to path to the "value" property of the new object. Now that the
-  binding is fully configured with a "from" and a "to", it simply needs to be
-  connected to become active. This is done through the connect() method:
+REQUIRED = new Ember.Descriptor();
+REQUIRED.toString = function() { return '(Required Property)'; };
 
-        binding.connect(this);
+Ember.required = function() {
+  return REQUIRED;
+};
 
-  Note that when you connect a binding you pass the object you want it to be
-  connected to.  This object will be used as the root for both the from and
-  to side of the binding when inspecting relative paths.  This allows the
-  binding to be automatically inherited by subclassed objects as well.
+/** @private */
+Alias = function(methodName) {
+  this.methodName = methodName;
+};
+Alias.prototype = new Ember.Descriptor();
 
-  Now that the binding is connected, it will observe both the from and to side
-  and relay changes.
+Ember.alias = function(methodName) {
+  return new Alias(methodName);
+};
 
-  If you ever needed to do so (you almost never will, but it is useful to
-  understand this anyway), you could manually create an active binding by
-  using the Ember.bind() helper method. (This is the same method used by
-  to setup your bindings on objects):
+Ember.MixinDelegate = Mixin.create({
 
-        Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
+  willApplyProperty: Ember.required(),
+  didApplyProperty:  Ember.required()
 
-  Both of these code fragments have the same effect as doing the most friendly
-  form of binding creation like so:
+});
 
-        MyApp.anotherObject = Ember.Object.create({
-          valueBinding: "MyApp.someController.value",
+/** @private */
+MixinDelegate = Ember.MixinDelegate;
 
-          // OTHER CODE FOR THIS OBJECT...
 
-        });
+// ..........................................................
+// OBSERVER HELPER
+//
 
-  Ember's built in binding creation method makes it easy to automatically
-  create bindings for you. You should always use the highest-level APIs
-  available, even if you understand how to it works underneath.
+Ember.observer = function(func) {
+  var paths = a_slice.call(arguments, 1);
+  func.__ember_observes__ = paths;
+  return func;
+};
 
-  @since Ember 0.9
-*/
-Ember.Binding = Binding;
+Ember.beforeObserver = function(func) {
+  var paths = a_slice.call(arguments, 1);
+  func.__ember_observesBefore__ = paths;
+  return func;
+};
 
-/**
-  Global helper method to create a new binding.  Just pass the root object
-  along with a to and from path to create and connect the binding.  The new
-  binding object will be returned which you can further configure with
-  transforms and other conditions.
 
-  @param {Object} obj
-    The root object of the transform.
 
-  @param {String} to
-    The path to the 'to' side of the binding.  Must be relative to obj.
 
-  @param {String} from
-    The path to the 'from' side of the binding.  Must be relative to obj or
-    a global path.
 
-  @returns {Ember.Binding} binding instance
-*/
-Ember.bind = function(obj, to, from) {
-  return new Ember.Binding(to, from).connect(obj);
-};
 
-Ember.oneWay = function(obj, to, from) {
-  return new Ember.Binding(to, from).oneWay().connect(obj);
-};
 
 })();
 
@@ -5233,20 +5320,9 @@ Ember.oneWay = function(obj, to, from) {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals ENV ember_assert */
+/*globals ENV */
 var indexOf = Ember.ArrayUtils.indexOf;
 
-// ........................................
-// GLOBAL CONSTANTS
-//
-
-// ensure no undefined errors in browsers where console doesn't exist
-if (typeof console === 'undefined') {
-  window.console = {};
-  console.log = console.info = console.warn = console.error = function() {};
-}
-
-
 // ........................................
 // TYPING & ARRAY MESSAGING
 //
@@ -5935,7 +6011,10 @@ if (Ember.EXTEND_PROTOTYPES) {
         });
 
     Make sure you list these dependencies so Ember.js knows when to update
-    bindings that connect to a computed property.
+    bindings that connect to a computed property. Changing a dependency
+    will not immediately trigger an update of the computed property, but
+    will instead clear the cache so that it is updated when the next `get`
+    is called on the property.
 
     Note: you will usually want to use `property(...)` with `cacheable()`.
 
@@ -5996,44 +6075,6 @@ if (Ember.EXTEND_PROTOTYPES) {
 
 
 
-(function() {
-// ==========================================================================
-// Project:  Ember Runtime
-// Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2011 Apple Inc. All rights reserved.
-// License:   Licensed under MIT license (see license.js)
-// ==========================================================================
-var IS_BINDING = Ember.IS_BINDING = /^.+Binding$/;
-
-Ember._mixinBindings = function(obj, key, value, m) {
-  if (IS_BINDING.test(key)) {
-    if (!(value instanceof Ember.Binding)) {
-      value = new Ember.Binding(key.slice(0,-7), value); // make binding
-    } else {
-      value.to(key.slice(0, -7));
-    }
-    value.connect(obj);
-
-    // keep a set of bindings in the meta so that when we rewatch we can
-    // resync them...
-    var bindings = m.bindings;
-    if (!bindings) {
-      bindings = m.bindings = { __emberproto__: obj };
-    } else if (bindings.__emberproto__ !== obj) {
-      bindings = m.bindings = Ember.create(m.bindings);
-      bindings.__emberproto__ = obj;
-    }
-
-    bindings[key] = true;
-  }
-
-  return value;
-};
-
-})();
-
-
-
 (function() {
 // ==========================================================================
 // Project:  Ember Runtime
@@ -6187,14 +6228,13 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
   */
   firstObject: Ember.computed(function() {
     if (get(this, 'length')===0) return undefined ;
-    if (Ember.Array && Ember.Array.detect(this)) return this.objectAt(0);
 
     // handle generic enumerables
     var context = popCtx(), ret;
     ret = this.nextObject(0, null, context);
     pushCtx(context);
     return ret ;
-  }).property(),
+  }).property('[]').cacheable(),
 
   /**
     Helper method returns the last object from a collection. If your enumerable
@@ -6212,18 +6252,14 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
   lastObject: Ember.computed(function() {
     var len = get(this, 'length');
     if (len===0) return undefined ;
-    if (Ember.Array && Ember.Array.detect(this)) {
-      return this.objectAt(len-1);
-    } else {
-      var context = popCtx(), idx=0, cur, last = null;
-      do {
-        last = cur;
-        cur = this.nextObject(idx++, last, context);
-      } while (cur !== undefined);
-      pushCtx(context);
-      return last;
-    }
-  }).property(),
+    var context = popCtx(), idx=0, cur, last = null;
+    do {
+      last = cur;
+      cur = this.nextObject(idx++, last, context);
+    } while (cur !== undefined);
+    pushCtx(context);
+    return last;
+  }).property('[]').cacheable(),
 
   /**
     Returns true if the passed object can be found in the receiver.  The
@@ -6758,6 +6794,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     if (removing === -1) removing = null;
     if (adding   === -1) adding   = null;
 
+    Ember.propertyWillChange(this, '[]');
     if (hasDelta) Ember.propertyWillChange(this, 'length');
     Ember.sendEvent(this, '@enumerable:before', removing, adding);
 
@@ -6775,15 +6812,13 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
       optional start offset for the content change.  For unordered
       enumerables, you should always pass -1.
 
-    @param {Enumerable} added
-      optional enumerable containing items that were added to the set.  For
-      ordered enumerables, this should be an ordered array of items.  If no
-      items were added you can pass null.
+    @param {Ember.Enumerable|Number} removing
+      An enumerable of the objects to be removed or the number of items to
+      be removed.
 
-    @param {Enumerable} removes
-      optional enumerable containing items that were removed from the set.
-      For ordered enumerables, this should be an ordered array of items. If
-      no items were removed you can pass null.
+    @param {Ember.Enumerable|Numbe} adding
+      An enumerable of the objects to be added or the number of items to be
+      added.
 
     @returns {Object} receiver
   */
@@ -6805,6 +6840,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
 
     Ember.sendEvent(this, '@enumerable:change', removing, adding);
     if (hasDelta) Ember.propertyDidChange(this, 'length');
+    Ember.propertyDidChange(this, '[]');
 
     return this ;
   }
@@ -6828,7 +6864,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
 // HELPERS
 //
 
-var get = Ember.get, set = Ember.set, meta = Ember.meta, map = Ember.ArrayUtils.map;
+var get = Ember.get, set = Ember.set, meta = Ember.meta, map = Ember.ArrayUtils.map, cacheFor = Ember.cacheFor;
 
 /** @private */
 function none(obj) { return obj===null || obj===undefined; }
@@ -6931,6 +6967,14 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
     return this ;
   }).property().cacheable(),
 
+  firstObject: Ember.computed(function() {
+    return this.objectAt(0);
+  }).property().cacheable(),
+
+  lastObject: Ember.computed(function() {
+    return this.objectAt(get(this, 'length')-1);
+  }).property().cacheable(),
+
   /** @private (nodoc) - optimized version from Enumerable */
   contains: function(obj){
     return this.indexOf(obj) >= 0;
@@ -7121,8 +7165,8 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
       startIdx = 0;
       removeAmt = addAmt = -1;
     } else {
-      if (!removeAmt) removeAmt=0;
-      if (!addAmt) addAmt=0;
+      if (removeAmt === undefined) removeAmt=-1;
+      if (addAmt    === undefined) addAmt=-1;
     }
 
     Ember.sendEvent(this, '@array:before', startIdx, removeAmt, addAmt);
@@ -7140,6 +7184,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
 
     // Make sure the @each proxy is set up if anyone is observing @each
     if (Ember.isWatching(this, '@each')) { get(this, '@each'); }
+
     return this;
   },
 
@@ -7150,8 +7195,8 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
       startIdx = 0;
       removeAmt = addAmt = -1;
     } else {
-      if (!removeAmt) removeAmt=0;
-      if (!addAmt) addAmt=0;
+      if (removeAmt === undefined) removeAmt=-1;
+      if (addAmt    === undefined) addAmt=-1;
     }
 
     var adding, lim;
@@ -7165,6 +7210,19 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
 
     this.enumerableContentDidChange(removeAmt, adding);
     Ember.sendEvent(this, '@array:change', startIdx, removeAmt, addAmt);
+
+    var length      = get(this, 'length'),
+        cachedFirst = cacheFor(this, 'firstObject'),
+        cachedLast  = cacheFor(this, 'lastObject');
+    if (this.objectAt(0) !== cachedFirst) {
+      Ember.propertyWillChange(this, 'firstObject');
+      Ember.propertyDidChange(this, 'firstObject');
+    }
+    if (this.objectAt(length-1) !== cachedLast) {
+      Ember.propertyWillChange(this, 'lastObject');
+      Ember.propertyDidChange(this, 'lastObject');
+    }
+
     return this;
   },
 
@@ -7631,7 +7689,7 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,
         colors.removeAt(2, 2); => ["green", "blue"]
         colors.removeAt(4, 2); => Error: Index out of range
 
-    @param {Number|Ember.IndexSet} start index, start of range, or index set
+    @param {Number} start index, start of range
     @param {Number} len length of passing range
     @returns {Object} receiver
   */
@@ -7743,9 +7801,7 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,
     @returns {Ember.Array} receiver
   */
   unshiftObjects: function(objects) {
-    this.beginPropertyChanges();
-    forEach(objects, function(obj) { this.unshiftObject(obj); }, this);
-    this.endPropertyChanges();
+    this.replace(0, 0, objects);
     return this;
   },
 
@@ -7840,6 +7896,11 @@ var get = Ember.get, set = Ember.set;
   This will call the `targetAction` method on the `targetObject` to be called
   whenever the value of the `propertyKey` changes.
   
+  Note that if `propertyKey` is a computed property, the observer will be 
+  called when any of the property dependencies are changed, even if the 
+  resulting value of the computed property is unchanged. This is necessary
+  because computed properties are not computed until `get` is called.
+  
   @extends Ember.Mixin
 */
 Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
@@ -8292,8 +8353,7 @@ Ember.TargetActionSupport = Ember.Mixin.create({
     var target = get(this, 'target');
 
     if (Ember.typeOf(target) === "string") {
-      // TODO: Remove the false when deprecation is done
-      var value = getPath(this, target, false);
+      var value = getPath(this, target);
       if (value === undefined) { value = getPath(window, target); }
       return value;
     } else {
@@ -8409,6 +8469,7 @@ function makeCtor() {
       this.reopen.apply(this, initMixins);
       initMixins = null;
       rewatch(this); // always rewatch just in case
+      Ember.Mixin.finishPartial(this);
       this.init.apply(this, arguments);
     } else {
       if (hasChains) {
@@ -8420,6 +8481,7 @@ function makeCtor() {
       if (init===false) { init = this.init; } // cache for later instantiations
       Ember.GUID_DESC.value = undefined;
       o_defineProperty(this, '_super', Ember.GUID_DESC);
+      Ember.Mixin.finishPartial(this);
       init.apply(this, arguments);
     }
   };
@@ -8671,11 +8733,8 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none
   can also iterate through a set just like an array, even accessing objects
   by index, however there is no guarantee as to their order.
 
-  Starting with Ember 2.0 all Sets are now observable since there is no
-  added cost to providing this support.  Sets also do away with the more
-  specialized Set Observer API in favor of the more generic Enumerable
-  Observer API - which works on any enumerable object including both Sets and
-  Arrays.
+  All Sets are observable via the Enumerable Observer API - which works
+  on any enumerable object including both Sets and Arrays.
 
   ## Creating a Set
 
@@ -8789,16 +8848,28 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
   */
   clear: function() {
     if (this.isFrozen) { throw new Error(Ember.FROZEN_ERROR); }
+
     var len = get(this, 'length');
+    if (len === 0) { return this; }
+
     var guid;
+
     this.enumerableContentWillChange(len, 0);
+    Ember.propertyWillChange(this, 'firstObject');
+    Ember.propertyWillChange(this, 'lastObject');
+
     for (var i=0; i < len; i++){
       guid = guidFor(this[i]);
       delete this[guid];
       delete this[i];
     }
+
     set(this, 'length', 0);
+
+    Ember.propertyDidChange(this, 'firstObject');
+    Ember.propertyDidChange(this, 'lastObject');
     this.enumerableContentDidChange(len, 0);
+
     return this;
   },
 
@@ -8866,7 +8937,7 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
 
   /**
     Removes the last element from the set and returns it, or null if it's empty.
-    
+
         var colors = new Ember.Set(["green", "blue"]);
         colors.pop(); => "blue"
         colors.pop(); => "green"
@@ -8974,12 +9045,12 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
   /** @private - more optimized version */
   firstObject: Ember.computed(function() {
     return this.length > 0 ? this[0] : undefined;
-  }).property('[]').cacheable(),
+  }).property().cacheable(),
 
   /** @private - more optimized version */
   lastObject: Ember.computed(function() {
     return this.length > 0 ? this[this.length-1] : undefined;
-  }).property('[]').cacheable(),
+  }).property().cacheable(),
 
   /** @private (nodoc) - implements Ember.MutableEnumerable */
   addObject: function(obj) {
@@ -8994,11 +9065,16 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
     if (idx>=0 && idx<len && (this[idx] === obj)) return this; // added
 
     added = [obj];
+
     this.enumerableContentWillChange(null, added);
+    Ember.propertyWillChange(this, 'lastObject');
+
     len = get(this, 'length');
     this[guid] = len;
     this[len] = obj;
     set(this, 'length', len+1);
+
+    Ember.propertyDidChange(this, 'lastObject');
     this.enumerableContentDidChange(null, added);
 
     return this;
@@ -9012,6 +9088,8 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
     var guid = guidFor(obj),
         idx  = this[guid],
         len = get(this, 'length'),
+        isFirst = idx === 0,
+        isLast = idx === len-1,
         last, removed;
 
 
@@ -9019,6 +9097,8 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
       removed = [obj];
 
       this.enumerableContentWillChange(removed, null);
+      if (isFirst) { Ember.propertyWillChange(this, 'firstObject'); }
+      if (isLast)  { Ember.propertyWillChange(this, 'lastObject'); }
 
       // swap items - basically move the item to the end so it can be removed
       if (idx < len-1) {
@@ -9031,6 +9111,8 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
       delete this[len-1];
       set(this, 'length', len-1);
 
+      if (isFirst) { Ember.propertyDidChange(this, 'firstObject'); }
+      if (isLast)  { Ember.propertyDidChange(this, 'lastObject'); }
       this.enumerableContentDidChange(removed, null);
     }
 
@@ -9060,42 +9142,10 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
       array[idx] = this[idx];
     }
     return "Ember.Set<%@>".fmt(array.join(','));
-  },
-
-  // ..........................................................
-  // DEPRECATED
-  //
-
-  /** @deprecated
-
-    This property is often used to determine that a given object is a set.
-    Instead you should use instanceof:
-
-        #js:
-        // SproutCore 1.x:
-        isSet = myobject && myobject.isSet;
-
-        // Ember:
-        isSet = myobject instanceof Ember.Set
-
-    @type Boolean
-    @default true
-  */
-  isSet: true
+  }
 
 });
 
-// Support the older API
-var o_create = Ember.Set.create;
-Ember.Set.create = function(items) {
-  if (items && Ember.Enumerable.detect(items)) {
-
-    return new Ember.Set(items);
-  } else {
-    return o_create.apply(this, arguments);
-  }
-};
-
 })();
 
 
@@ -9226,7 +9276,7 @@ var get = Ember.get, set = Ember.set;
   A simple example of usage:
 
       var pets = ['dog', 'cat', 'fish'];
-      var arrayProxy = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+      var ap = Ember.ArrayProxy.create({ content: Ember.A(pets) });
       ap.get('firstObject'); // => 'dog'
       ap.set('content', ['amoeba', 'paramecium']);
       ap.get('firstObject'); // => 'amoeba'
@@ -9329,7 +9379,8 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,
   length: Ember.computed(function() {
     var content = get(this, 'content');
     return content ? get(content, 'length') : 0;
-  }).property('content.length').cacheable(),
+    // No dependencies since Enumerable notifies length of change
+  }).property().cacheable(),
 
   /** @private (nodoc) */
   replace: function(idx, amt, objects) {
@@ -9350,6 +9401,7 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,
   /** @private (nodoc) */
   init: function() {
     this._super();
+    this.contentWillChange();
     this.contentDidChange();
   }
 
@@ -9388,7 +9440,7 @@ var EachArray = Ember.Object.extend(Ember.Array, {
   length: Ember.computed(function() {
     var content = this._content;
     return content ? get(content, 'length') : 0;
-  }).property('[]').cacheable()
+  }).property().cacheable()
 
 });
 
@@ -9918,6 +9970,37 @@ Map.prototype = {
 
 
 
+(function() {
+var loadHooks = {};
+var loaded = {};
+
+Ember.onLoad = function(name, callback) {
+  var object;
+
+  loadHooks[name] = loadHooks[name] || Ember.A();
+  loadHooks[name].pushObject(callback);
+
+  if (object = loaded[name]) {
+    callback(object);
+  }
+};
+
+Ember.runLoadHooks = function(name, object) {
+  var hooks;
+
+  loaded[name] = object;
+
+  if (hooks = loadHooks[name]) {
+    loadHooks[name].forEach(function(callback) {
+      callback(object);
+    });
+  }
+};
+
+})();
+
+
+
 (function() {
 // ==========================================================================
 // Project:  Ember Runtime