diff --git a/packages/ember-data/lib/adapters/rest_adapter.js b/packages/ember-data/lib/adapters/rest_adapter.js
index 1fafe8f2128..45dc2f7117d 100644
--- a/packages/ember-data/lib/adapters/rest_adapter.js
+++ b/packages/ember-data/lib/adapters/rest_adapter.js
@@ -3,17 +3,58 @@ require('ember-data/system/adapter');
 require('ember-data/serializers/rest_serializer');
 /*global jQuery*/
 
-var get = Ember.get, set = Ember.set;
+var get = Ember.get, set = Ember.set, merge = Ember.merge;
+
+function loaderFor(store, record, id) {
+  return {
+    acknowledge: function() {
+      store.didSaveRecord(record);
+    },
+
+    loadMain: function(type, data, prematerialized) {
+      if (record) {
+        store.didSaveRecord(record, data, prematerialized);
+      } else {
+        if (id) {
+          prematerialized = prematerialized || {};
+          prematerialized.id = id;
+        }
+
+        return store.load(type, data, prematerialized);
+      }
+    },
+
+    load: function() {
+      return store.load.apply(store, arguments);
+    },
+
+    loadMany: function(type, array) {
+      for (var i=0, l=array.length; i<l; i++) {
+        store.load(type, array[i]);
+      }
+    },
+
+    sinceForType: function(type, since) {
+      store.sinceForType(type, since);
+    }
+  };
+}
 
 DS.RESTAdapter = DS.Adapter.extend({
   bulkCommit: false,
+  since: 'since',
 
   serializer: DS.RESTSerializer,
 
   init: function() {
     this._super.apply(this, arguments);
 
-    get(this, 'serializer').plurals = this.plurals;
+    get(this, 'serializer').plurals = this.plurals || {};
+  },
+
+  load: function(store, type, payload) {
+    var loader = loaderFor(store, null, this.extractId(type, payload));
+    get(this, 'serializer').extractSingle(loader, type, payload);
   },
 
   createRecord: function(store, type, record) {
@@ -27,7 +68,7 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didCreateRecord(store, type, record, json);
+          this.didSaveRecord(store, type, record, json);
         });
       },
       error: function(xhr) {
@@ -38,36 +79,32 @@ DS.RESTAdapter = DS.Adapter.extend({
 
   dirtyRecordsForHasManyChange: Ember.K,
 
-  didSaveRecord: function(store, record, hash) {
-    record.eachAssociation(function(name, meta) {
-      if (meta.kind === 'belongsTo') {
-        store.didUpdateRelationship(record, name);
-      }
-    });
+  didSaveRecord: function(store, type, record, json) {
+    var loader = loaderFor(store, record);
 
-    store.didSaveRecord(record, hash);
+    get(this, 'serializer').extract(loader, json, {
+      type: type
+    });
   },
 
-  didSaveRecords: function(store, records, array) {
-    var i = 0;
+  didSaveRecords: function(store, type, records, json) {
+    var self = this;
 
-    records.forEach(function(record) {
-      this.didSaveRecord(store, record, array && array[i++]);
-    }, this);
-  },
+    var loader = loaderFor(store);
+    loader.loadMainArray = function(type, array) {
+      var i = 0;
 
-  didCreateRecord: function(store, type, record, json) {
-    var loader = {
-      loadMain: function(type, data, prematerialized) {
-        store.didSaveRecord(record, data, prematerialized);
-      },
+      records.forEach(function(record) {
+        store.didSaveRecord(record, array && array[i++]);
+      });
+    };
 
-      load: function() {
-        store.load.apply(store, arguments);
-      }
+    loader.acknowledge = function() {
+      records.forEach(store.didSaveRecord, store);
     };
 
     get(this, 'serializer').extract(loader, json, {
+      multiple: true,
       type: type
     });
   },
@@ -91,19 +128,12 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didCreateRecords(store, type, records, json);
+          this.didSaveRecords(store, type, records, json);
         });
       }
     });
   },
 
-  didCreateRecords: function(store, type, records, json) {
-    var root = this.pluralize(this.rootForType(type));
-
-    this.sideload(store, type, json, root);
-    this.didSaveRecords(store, records, json[root]);
-  },
-
   updateRecord: function(store, type, record) {
     var id = get(record, 'id');
     var root = this.rootForType(type);
@@ -116,7 +146,7 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didUpdateRecord(store, type, record, json);
+          this.didSaveRecord(store, type, record, json);
         });
       },
       error: function(xhr) {
@@ -125,13 +155,6 @@ DS.RESTAdapter = DS.Adapter.extend({
     });
   },
 
-  didUpdateRecord: function(store, type, record, json) {
-    var root = this.rootForType(type);
-
-    this.sideload(store, type, json, root);
-    this.didSaveRecord(store, record, json && json[root]);
-  },
-
   updateRecords: function(store, type, records) {
     if (get(this, 'bulkCommit') === false) {
       return this._super(store, type, records);
@@ -151,19 +174,12 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didUpdateRecords(store, type, records, json);
+          this.didSaveRecords(store, type, records, json);
         });
       }
     });
   },
 
-  didUpdateRecords: function(store, type, records, json) {
-    var root = this.pluralize(this.rootForType(type));
-
-    this.sideload(store, type, json, root);
-    this.didSaveRecords(store, records, json[root]);
-  },
-
   deleteRecord: function(store, type, record) {
     var id = get(record, 'id');
     var root = this.rootForType(type);
@@ -172,17 +188,12 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didDeleteRecord(store, type, record, json);
+          this.didSaveRecord(store, type, record, json);
         });
       }
     });
   },
 
-  didDeleteRecord: function(store, type, record, json) {
-    if (json) { this.sideload(store, type, json); }
-    this.didSaveRecord(store, record);
-  },
-
   deleteRecords: function(store, type, records) {
     if (get(this, 'bulkCommit') === false) {
       return this._super(store, type, records);
@@ -203,17 +214,12 @@ DS.RESTAdapter = DS.Adapter.extend({
       context: this,
       success: function(json) {
         Ember.run(this, function(){
-          this.didDeleteRecords(store, type, records, json);
+          this.didSaveRecords(store, type, records, json);
         });
       }
     });
   },
 
-  didDeleteRecords: function(store, type, records, json) {
-    if (json) { this.sideload(store, type, json); }
-    this.didSaveRecords(store, records);
-  },
-
   find: function(store, type, id) {
     var root = this.rootForType(type);
 
@@ -227,19 +233,10 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   didFindRecord: function(store, type, json, id) {
-    var loader = {
-      loadMain: function() {
-        store.load.apply(store, arguments);
-      },
+    var loader = loaderFor(store, null, id);
 
-      load: function() {
-        store.load.apply(store, arguments);
-      }
-    };
-
-    this.extract(loader, json, {
-      type: type,
-      id: id
+    get(this, 'serializer').extract(loader, json, {
+      type: type
     });
   },
 
@@ -257,11 +254,16 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   didFindAll: function(store, type, json) {
-    var root = this.pluralize(this.rootForType(type)),
-        since = this.extractSince(json);
+    var loader = loaderFor(store),
+        serializer = get(this, 'serializer');
+
+    loader.loadMainArray = function(type, data) {
+      loader.loadMany(type, data);
+    };
+
+    serializer.extract(loader, json, { type: type, multiple: true });
 
-    this.sideload(store, type, json, root);
-    store.loadMany(type, json[root]);
+    var since = this.extractSince(json);
 
     // this registers the id with the store, so it will be passed
     // into the next call to `findAll`
@@ -284,10 +286,15 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   didFindQuery: function(store, type, json, recordArray) {
-    var root = this.pluralize(this.rootForType(type));
+    var loader = loaderFor(store);
+    loader.loadMainArray = function(type, data) {
+      recordArray.load(data);
+    };
 
-    this.sideload(store, type, json, root);
-    recordArray.load(json[root]);
+    get(this, 'serializer').extract(loader, json, {
+      multiple: true,
+      type: type
+    });
   },
 
   findMany: function(store, type, ids) {
@@ -320,10 +327,15 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   didFindMany: function(store, type, json) {
-    var root = this.pluralize(this.rootForType(type));
+    var loader = loaderFor(store);
+    loader.loadMainArray = function(type, data) {
+      loader.loadMany(type, data);
+    };
 
-    this.sideload(store, type, json, root);
-    store.loadMany(type, json[root]);
+    get(this, 'serializer').extract(loader, json, {
+      multiple: true,
+      type: type
+    });
   },
 
   didError: function(store, type, record, xhr) {
@@ -380,9 +392,6 @@ DS.RESTAdapter = DS.Adapter.extend({
     return url.join("/");
   },
 
-  meta: 'meta',
-  since: 'since',
-
   sinceQuery: function(since) {
     var query = {};
     query[get(this, 'since')] = since;
diff --git a/packages/ember-data/lib/serializers/rest_serializer.js b/packages/ember-data/lib/serializers/rest_serializer.js
index 6323af46a9e..0e4fa782f9e 100644
--- a/packages/ember-data/lib/serializers/rest_serializer.js
+++ b/packages/ember-data/lib/serializers/rest_serializer.js
@@ -1,14 +1,90 @@
-var get = Ember.get;
+var get = Ember.get, map = Ember.ArrayPolyfills.map;
 
 DS.RESTSerializer = DS.JSONSerializer.extend({
+  meta: 'meta',
+  since: 'since',
+
+  init: function() {
+    this._super();
+    this.sideloadMapping = Ember.Map.create();
+  },
+
+  configure: function(type, configuration) {
+    var sideloadAs = configuration.sideloadAs;
+
+    if (sideloadAs) {
+      this.sideloadMapping.set(sideloadAs, type);
+      delete configuration.sideloadAs;
+    }
+
+    this._super.apply(this, arguments);
+  },
+
   extract: function(loader, json, options) {
+    if (!json) { loader.acknowledge(); return; }
+
     var type = options.type,
         root = this.rootForType(type),
+        multiple = options.multiple,
         id = options.id;
 
-    loader.loadMain(type, json[root], { id: id });
+    if (multiple) {
+      root = this.pluralize(root);
+    }
 
     this.sideload(loader, type, json, root);
+    this.extractMeta(loader, type, json);
+
+    if (multiple) {
+      loader.loadMainArray(type, json[root]);
+    } else {
+      this.extractSingle(loader, type, json[root]);
+    }
+  },
+
+  extractSingle: function(loader, type, json) {
+    var mapping = this.mappingForType(type);
+    var embeddedData, prematerialized = {};
+
+    var associations = type.eachAssociation(function(name, association) {
+      if (!mapping || !mapping[name]) { return; }
+
+      if (mapping[name].embedded) {
+        embeddedData = json[this.keyFor(association)];
+
+        if (embeddedData) {
+          if (association.kind === 'belongsTo') {
+            this.extractEmbeddedBelongsTo(loader, association, embeddedData, prematerialized);
+          } else if (association.kind === 'hasMany') {
+            this.extractEmbeddedHasMany(loader, association, embeddedData, prematerialized);
+          }
+        }
+      }
+    }, this);
+
+    loader.loadMain(type, json, prematerialized);
+  },
+
+  extractEmbeddedHasMany: function(loader, association, array, prematerialized) {
+    var references = map.call(array, function(item) {
+      return loader.load(association.type, item);
+    });
+
+    prematerialized[association.key] = references;
+  },
+
+  extractEmbeddedBelongsTo: function(loader, association, data, prematerialized) {
+    var recordReference = loader.load(association.type, data);
+    prematerialized[association.key] = recordReference;
+  },
+
+  extractMeta: function(loader, type, json) {
+    var meta = json[get(this, 'meta')], since;
+    if (!meta) { return; }
+
+    if (since = meta[get(this, 'since')]) {
+      loader.sinceForType(type, since);
+    }
   },
 
   sideload: function(loader, type, json, root) {
@@ -24,10 +100,7 @@ DS.RESTSerializer = DS.JSONSerializer.extend({
       sideloadedType = type.typeForAssociation(prop);
 
       if (!sideloadedType) {
-        mappings = get(this, 'mappings');
-        Ember.assert("Your server returned a hash with the key " + prop + " but you have no mappings", !!mappings);
-
-        sideloadedType = get(mappings, prop);
+        sideloadedType = this.sideloadMapping.get(prop);
 
         if (typeof sideloadedType === 'string') {
           sideloadedType = get(window, sideloadedType);
@@ -68,8 +141,6 @@ DS.RESTSerializer = DS.JSONSerializer.extend({
 
   // HELPERS
 
-  plurals: {},
-
   // define a plurals hash in your subclass to define
   // special-case pluralization
   pluralize: function(name) {
@@ -84,7 +155,15 @@ DS.RESTSerializer = DS.JSONSerializer.extend({
   },
 
   keyForBelongsTo: function(type, name) {
-    return this.keyForAttributeName(type, name) + "_id";
+    var mapping = this.mappingForType(type);
+
+    var key = this.keyForAttributeName(type, name);
+
+    if (mapping && mapping[name] && mapping[name].embedded) {
+      return key;
+    }
+
+    return key + "_id";
   },
 
   keyForAttributeName: function(type, name) {
@@ -94,6 +173,6 @@ DS.RESTSerializer = DS.JSONSerializer.extend({
   addBelongsTo: function(hash, record, key, relationship) {
     var id = get(record, relationship.key+'.id');
 
-    if (!Ember.none(id)) { hash[key] = id; }
+    if (!Ember.isNone(id)) { hash[key] = id; }
   }
 });
diff --git a/packages/ember-data/lib/system/adapter.js b/packages/ember-data/lib/system/adapter.js
index 7f77c2e4f20..60100fe0128 100644
--- a/packages/ember-data/lib/system/adapter.js
+++ b/packages/ember-data/lib/system/adapter.js
@@ -55,6 +55,7 @@ DS.Adapter = Ember.Object.extend(DS._Mappable, {
     }
 
     this._attributesMap = this.createInstanceMapFor('attributes');
+    this._configurationsMap = this.createInstanceMapFor('configurations');
 
     this._outstandingOperations = new Ember.MapWithDefault({
       defaultValue: function() { return 0; }
@@ -127,11 +128,11 @@ DS.Adapter = Ember.Object.extend(DS._Mappable, {
       mappings onto
   */
   registerSerializerMappings: function(serializer) {
-    var mappings = this._attributesMap;
+    var mappings = this._attributesMap,
+        configurations = this._configurationsMap;
 
-    mappings.forEach(function(type, mapping) {
-      serializer.map(type, mapping);
-    }, this);
+    mappings.forEach(serializer.map, serializer);
+    configurations.forEach(serializer.configure, serializer);
   },
 
   /**
diff --git a/packages/ember-data/lib/system/associations/belongs_to.js b/packages/ember-data/lib/system/associations/belongs_to.js
index 6f6b82d605a..1f04337e075 100644
--- a/packages/ember-data/lib/system/associations/belongs_to.js
+++ b/packages/ember-data/lib/system/associations/belongs_to.js
@@ -1,5 +1,5 @@
 var get = Ember.get, set = Ember.set,
-    none = Ember.none;
+    none = Ember.isNone;
 
 DS.belongsTo = function(type, options) {
   Ember.assert("The first argument DS.belongsTo must be a model type or string, like DS.belongsTo(App.Person)", !!type && (typeof type === 'string' || DS.Model.detect(type)));
@@ -21,7 +21,12 @@ DS.belongsTo = function(type, options) {
     }
 
     id = data[key];
-    return id ? store.find(type, id) : null;
+
+    if (typeof id === 'object') {
+      return store.findByClientId(type, id.clientId);
+    } else {
+      return id ? store.find(type, id) : null;
+    }
   }).property('data').meta(meta);
 };
 
diff --git a/packages/ember-data/lib/system/associations/ext.js b/packages/ember-data/lib/system/associations/ext.js
index 8f9c3587608..f9b5075f261 100644
--- a/packages/ember-data/lib/system/associations/ext.js
+++ b/packages/ember-data/lib/system/associations/ext.js
@@ -38,6 +38,8 @@ DS.Model.reopen({
         Ember.addObserver(proto, key, null, 'belongsToDidChange');
         Ember.addBeforeObserver(proto, key, null, 'belongsToWillChange');
       }
+
+      meta.parentType = proto.constructor;
     }
   }
 });
diff --git a/packages/ember-data/lib/system/model/model.js b/packages/ember-data/lib/system/model/model.js
index 1311bef1e30..d71d14ab063 100644
--- a/packages/ember-data/lib/system/model/model.js
+++ b/packages/ember-data/lib/system/model/model.js
@@ -1,6 +1,6 @@
 require("ember-data/system/model/states");
 
-var get = Ember.get, set = Ember.set, none = Ember.none;
+var get = Ember.get, set = Ember.set, none = Ember.isNone, map = Ember.EnumerableUtils.map;
 
 var retrieveFromCurrentState = Ember.computed(function(key) {
   return get(get(this, 'stateManager.currentState'), key);
@@ -16,6 +16,7 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
   isValid: retrieveFromCurrentState,
 
   clientId: null,
+  id: null,
   transaction: null,
   stateManager: null,
   errors: null,
@@ -149,32 +150,32 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
   },
 
   dataDidChange: Ember.observer(function() {
-    var associations = get(this.constructor, 'associationsByName'),
-        hasMany = get(this, 'data').hasMany, store = get(this, 'store'),
-        idToClientId = store.idToClientId,
-        cachedValue;
+    var associations = get(this.constructor, 'associationsByName');
 
     this.updateRecordArraysLater();
 
     associations.forEach(function(name, association) {
       if (association.kind === 'hasMany') {
-        cachedValue = this.cacheFor(name);
+        this.hasManyDidChange(association.key);
+      }
+    }, this);
+  }, 'data'),
 
-        if (cachedValue) {
-          var key = name,
-              ids = hasMany[key] || [];
+  hasManyDidChange: function(key) {
+    var cachedValue = this.cacheFor(key);
 
-          var clientIds;
+    if (cachedValue) {
+      var type = get(this.constructor, 'associationsByName').get(key).type;
+      var store = get(this, 'store');
+      var ids = this._data.hasMany[key] || [];
 
-          clientIds = Ember.EnumerableUtils.map(ids, function(id) {
-            return store.clientIdForId(association.type, id);
-          });
+      var references = map(ids, function(id) {
+        return store.referenceForId(type, id);
+      });
 
-          set(cachedValue, 'content', Ember.A(clientIds));
-        }
-      }
-    }, this);
-  }, 'data'),
+      set(cachedValue, 'content', Ember.A(references));
+    }
+  },
 
   updateRecordArraysLater: function() {
     Ember.run.once(this, this.updateRecordArrays);
@@ -187,6 +188,8 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
       hasMany: {},
       id: null
     };
+
+    this.notifyPropertyChange('data');
   },
 
   materializeId: function(id) {
@@ -275,31 +278,9 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
     this.updateRecordArraysLater();
   },
 
-  adapterDidUpdateHasMany: function(name) {
-    var cachedValue = this.cacheFor(name),
-        hasMany = get(this, 'data').hasMany,
-        store = get(this, 'store');
-
-    var associations = get(this.constructor, 'associationsByName'),
-        association = associations.get(name),
-        idToClientId = store.idToClientId;
-
-    if (cachedValue) {
-      var key = name,
-          ids = hasMany[key] || [];
-
-      var clientIds;
-
-      clientIds = Ember.EnumerableUtils.map(ids, function(id) {
-        return store.clientIdForId(association.type, id);
-      });
-
-      set(cachedValue, 'content', Ember.A(clientIds));
-      set(cachedValue, 'isLoaded', true);
-    }
-
-    this.updateRecordArraysLater();
-  },
+  reference: Ember.computed(function() {
+    return get(this, 'store').referenceForClientId(get(this, 'clientId'));
+  }),
 
   adapterDidInvalidate: function(errors) {
     this.send('becameInvalid', errors);
diff --git a/packages/ember-data/lib/system/record_arrays/adapter_populated_record_array.js b/packages/ember-data/lib/system/record_arrays/adapter_populated_record_array.js
index d443536fd64..ee0264a453c 100644
--- a/packages/ember-data/lib/system/record_arrays/adapter_populated_record_array.js
+++ b/packages/ember-data/lib/system/record_arrays/adapter_populated_record_array.js
@@ -13,10 +13,10 @@ DS.AdapterPopulatedRecordArray = DS.RecordArray.extend({
   load: function(array) {
     var store = get(this, 'store'), type = get(this, 'type');
 
-    var clientIds = store.loadMany(type, array).clientIds;
+    var references = store.loadMany(type, array);
 
     this.beginPropertyChanges();
-    set(this, 'content', Ember.A(clientIds));
+    set(this, 'content', Ember.A(references));
     set(this, 'isLoaded', true);
     this.endPropertyChanges();
 
diff --git a/packages/ember-data/lib/system/record_arrays/many_array.js b/packages/ember-data/lib/system/record_arrays/many_array.js
index 909c7ef6709..d055305f9a0 100644
--- a/packages/ember-data/lib/system/record_arrays/many_array.js
+++ b/packages/ember-data/lib/system/record_arrays/many_array.js
@@ -1,5 +1,4 @@
 require("ember-data/system/record_arrays/record_array");
-require("ember-data/system/record_arrays/many_array_states");
 
 var get = Ember.get, set = Ember.set;
 
@@ -65,11 +64,11 @@ DS.ManyArray = DS.RecordArray.extend({
   },
 
   fetch: function() {
-    var clientIds = get(this, 'content'),
+    var references = get(this, 'content'),
         store = get(this, 'store'),
         type = get(this, 'type');
 
-    store.fetchUnloadedClientIds(type, clientIds);
+    store.fetchUnloadedReferences(type, references);
   },
 
   // Overrides Ember.Array's replace method to implement
@@ -77,7 +76,7 @@ DS.ManyArray = DS.RecordArray.extend({
     // Map the array of record objects into an array of  client ids.
     added = added.map(function(record) {
       Ember.assert("You can only add records of " + (get(this, 'type') && get(this, 'type').toString()) + " to this association.", !get(this, 'type') || (get(this, 'type') === record.constructor));
-      return record.get('clientId');
+      return get(record, 'reference');
     }, this);
 
     this._super(index, removed, added);
@@ -102,11 +101,11 @@ DS.ManyArray = DS.RecordArray.extend({
       // the `arrayContentDidChange` will set `newParent` on
       // the change.
       for (var i=index; i<index+removed; i++) {
-        var clientId = get(this, 'content').objectAt(i);
+        var reference = get(this, 'content').objectAt(i);
         //var record = this.objectAt(i);
         //if (!record) { continue; }
 
-        var change = DS.OneToManyChange.forChildAndParent(clientId, get(this, 'store'), {
+        var change = DS.OneToManyChange.forChildAndParent(reference.clientId, get(this, 'store'), {
           parentType: owner.constructor,
           hasManyName: name
         });
@@ -133,9 +132,9 @@ DS.ManyArray = DS.RecordArray.extend({
       // from the child object, and adds the current owner as
       // the new parent.
       for (var i=index; i<index+added; i++) {
-        var clientId = get(this, 'content').objectAt(i);
+        var reference = get(this, 'content').objectAt(i);
 
-        var change = DS.OneToManyChange.forChildAndParent(clientId, get(this, 'store'), {
+        var change = DS.OneToManyChange.forChildAndParent(reference.clientId, get(this, 'store'), {
           parentType: owner.constructor,
           hasManyName: name
         });
@@ -197,13 +196,11 @@ DS.ManyArray = DS.RecordArray.extend({
 
   /** @private */
   removeFromContent: function(record) {
-    var clientId = get(record, 'clientId');
-    get(this, 'content').removeObject(clientId);
+    get(this, 'content').removeObject(get(record, 'reference'));
   },
 
   /** @private */
   addToContent: function(record) {
-    var clientId = get(record, 'clientId');
-    get(this, 'content').addObject(clientId);
+    get(this, 'content').addObject(get(record, 'reference'));
   }
 });
diff --git a/packages/ember-data/lib/system/record_arrays/record_array.js b/packages/ember-data/lib/system/record_arrays/record_array.js
index e3110e34ebd..0c5cac2f8dc 100644
--- a/packages/ember-data/lib/system/record_arrays/record_array.js
+++ b/packages/ember-data/lib/system/record_arrays/record_array.js
@@ -30,19 +30,19 @@ DS.RecordArray = Ember.ArrayProxy.extend(Ember.Evented, {
 
   objectAtContent: function(index) {
     var content = get(this, 'content'),
-        clientId = content.objectAt(index),
+        reference = content.objectAt(index),
         store = get(this, 'store');
 
-    if (clientId !== undefined) {
-      return store.findByClientId(get(this, 'type'), clientId);
+    if (reference) {
+      return store.findByClientId(get(this, 'type'), reference.clientId);
     }
   },
 
   materializedObjectAt: function(index) {
-    var clientId = get(this, 'content').objectAt(index);
-    if (!clientId) { return; }
+    var reference = get(this, 'content').objectAt(index);
+    if (!reference) { return; }
 
-    if (get(this, 'store').recordIsMaterialized(clientId)) {
+    if (get(this, 'store').recordIsMaterialized(reference.clientId)) {
       return this.objectAt(index);
     }
   },
@@ -54,5 +54,13 @@ DS.RecordArray = Ember.ArrayProxy.extend(Ember.Evented, {
         type = get(this, 'type');
 
     store.fetchAll(type, this);
+  },
+
+  addReference: function(reference) {
+    get(this, 'content').addObject(reference);
+  },
+
+  removeReference: function(reference) {
+    get(this, 'content').removeObject(reference);
   }
 });
diff --git a/packages/ember-data/lib/system/serializer.js b/packages/ember-data/lib/system/serializer.js
index e4cc7d8c08e..0e15109af71 100644
--- a/packages/ember-data/lib/system/serializer.js
+++ b/packages/ember-data/lib/system/serializer.js
@@ -559,7 +559,7 @@ DS.Serializer = Ember.Object.extend({
 
   materialize: function(record, serialized, prematerialized) {
     var id;
-    if (Ember.none(get(record, 'id'))) {
+    if (Ember.isNone(get(record, 'id'))) {
       if (prematerialized && prematerialized.hasOwnProperty('id')) {
         id = prematerialized.id;
       } else {
@@ -756,6 +756,18 @@ DS.Serializer = Ember.Object.extend({
     return this._keyFromMappingOrHook('keyForBelongsTo', type, name);
   },
 
+  keyFor: function(description) {
+    var type = description.parentType,
+        name = description.key;
+
+    switch (description.kind) {
+      case 'belongsTo':
+        return this._keyForBelongsTo(type, name);
+      case 'hasMany':
+        return this._keyForHasMany(type, name);
+    }
+  },
+
   /**
     @private
 
@@ -849,8 +861,8 @@ DS.Serializer = Ember.Object.extend({
     this.mappings.set(type, mappings);
   },
 
-  configure: function(type, configurations) {
-    this.configurations.set(type, configurations);
+  configure: function(type, configuration) {
+    this.configurations.set(type, configuration);
   },
 
   mappingForType: function(type) {
@@ -859,6 +871,7 @@ DS.Serializer = Ember.Object.extend({
   },
 
   configurationForType: function(type) {
+    this._reifyConfigurations();
     return this.configurations.get(type);
   },
 
@@ -882,6 +895,28 @@ DS.Serializer = Ember.Object.extend({
     this.mappings = reifiedMappings;
 
     this._didReifyMappings = true;
+  },
+
+  _reifyConfigurations: function() {
+    if (this._didReifyConfigurations) { return; }
+
+    var configurations = this.configurations,
+        reifiedConfigurations = Ember.Map.create();
+
+    configurations.forEach(function(key, mapping) {
+      if (typeof key === 'string') {
+        var type = Ember.get(Ember.lookup, key);
+        Ember.assert("Could not find model at path" + key, type);
+
+        reifiedConfigurations.set(type, mapping);
+      } else {
+        reifiedConfigurations.set(key, mapping);
+      }
+    });
+
+    this.configurations = reifiedConfigurations;
+
+    this._didReifyConfigurations = true;
   }
 });
 
diff --git a/packages/ember-data/lib/system/store.js b/packages/ember-data/lib/system/store.js
index 2dbbca16aa2..e68fd3bbbb2 100644
--- a/packages/ember-data/lib/system/store.js
+++ b/packages/ember-data/lib/system/store.js
@@ -1,4 +1,5 @@
 /*globals Ember*/
+/*jshint eqnull:true*/
 
 require("ember-data/system/record_arrays");
 require("ember-data/system/transaction");
@@ -33,7 +34,7 @@ var CREATED = { created: true };
 // ID into the URL, and if we later try to deserialize that URL and find the
 // corresponding record, we will not know if it is a string or a number.
 var coerceId = function(id) {
-  return id+'';
+  return id == null ? null : id+'';
 };
 
 var map = Ember.EnumerableUtils.map;
@@ -94,6 +95,7 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     this.clientIdToPrematerializedData = {};
     this.recordArraysByClientId = {};
     this.relationshipChanges = {};
+    this.recordReferences = {};
 
     // Internally, we maintain a map of all unloaded IDs requested by
     // a ManyArray. As the adapter loads data into the store, the
@@ -300,7 +302,7 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     // client-side ID generators will use something like uuid.js
     // to avoid conflicts.
     var adapter;
-    if (Ember.none(id)) {
+    if (Ember.isNone(id)) {
       adapter = get(this, 'adapter');
       if (adapter && adapter.generateIdForRecord) {
         id = coerceId(adapter.generateIdForRecord(this, record));
@@ -517,20 +519,21 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     In preparation for loading, this method also marks any unloaded
     `clientId`s as loading.
   */
-  neededClientIds: function(type, clientIds) {
-    var neededClientIds = [],
+  neededReferences: function(type, references) {
+    var neededReferences = [],
         cidToData = this.clientIdToData,
-        clientId;
+        reference;
 
-    for (var i=0, l=clientIds.length; i<l; i++) {
-      clientId = clientIds[i];
-      if (cidToData[clientId] === UNLOADED) {
-        neededClientIds.push(clientId);
-        cidToData[clientId] = LOADING;
+    for (var i=0, l=references.length; i<l; i++) {
+      reference = references[i];
+
+      if (cidToData[reference.clientId] === UNLOADED) {
+        neededReferences.push(reference);
+        cidToData[reference.clientId] = LOADING;
       }
     }
 
-    return neededClientIds;
+    return neededReferences;
   },
 
   /**
@@ -543,9 +546,9 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     then converts the needed `clientId`s to IDs and invokes `findMany`
     on the adapter.
   */
-  fetchUnloadedClientIds: function(type, clientIds) {
-    var neededClientIds = this.neededClientIds(type, clientIds);
-    this.fetchMany(type, neededClientIds);
+  fetchUnloadedReferences: function(type, references) {
+    var neededReferences = this.neededReferences(type, references);
+    this.fetchMany(type, neededReferences);
   },
 
   /**
@@ -557,22 +560,38 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
 
     It is used both by a brand new association (via the `findMany`
     method) or when the data underlying an existing association
-    changes (via the `fetchUnloadedClientIds` method).
+    changes (via the `fetchUnloadedReferences` method).
   */
-  fetchMany: function(type, clientIds) {
-    var clientIdToId = this.clientIdToId;
+  fetchMany: function(type, references) {
+    if (!references.length) { return; }
 
-    var neededIds = map(clientIds, function(clientId) {
-      return clientIdToId[clientId];
+    var ids = map(references, function(reference) {
+      return reference.id;
     });
 
-    if (!neededIds.length) { return; }
-
     var adapter = this.adapterForType(type);
-    if (adapter && adapter.findMany) { adapter.findMany(this, type, neededIds); }
+    if (adapter && adapter.findMany) { adapter.findMany(this, type, ids); }
     else { throw "Adapter is either null or does not implement `findMany` method"; }
   },
 
+  referenceForId: function(type, id) {
+    var clientId = this.clientIdForId(type, id);
+    return this.referenceForClientId(clientId);
+  },
+
+  referenceForClientId: function(clientId) {
+    var references = this.recordReferences;
+
+    if (references[clientId]) {
+      return references[clientId];
+    }
+
+    return references[clientId] = {
+      id: this.idForClientId(clientId),
+      clientId: clientId
+    };
+  },
+
   /**
     @private
 
@@ -605,27 +624,34 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
 
     if (!Ember.isArray(ids)) {
       var adapter = this.adapterForType(type);
-      if (adapter && adapter.findAssociation) { adapter.findAssociation(this, record, relationship, ids); }
+      if (adapter && adapter.findHasMany) { adapter.findHasMany(this, record, relationship, ids); }
       else { throw fmt("Adapter is either null or does not implement `findMany` method", this); }
 
       return this.createManyArray(type, Ember.A());
     }
 
-    ids = map(ids, function(id) { return coerceId(id); });
-    var clientIds = this.clientIdsForIds(type, ids);
+    // Coerce server IDs into Record Reference
+    var references = map(ids, function(reference) {
+      if (typeof reference !== 'object' && reference !== null) {
+        return this.referenceForId(type, reference);
+      }
+
+      return reference;
+    }, this);
 
-    var neededClientIds = this.neededClientIds(type, clientIds),
-        manyArray = this.createManyArray(type, Ember.A(clientIds)),
+    var neededReferences = this.neededReferences(type, references),
+        manyArray = this.createManyArray(type, Ember.A(references)),
         loadingRecordArrays = this.loadingRecordArrays,
-        clientId, i, l;
+        reference, clientId, i, l;
 
     // Start the decrementing counter on the ManyArray at the number of
     // records we need to load from the adapter
-    manyArray.loadingRecordsCount(neededClientIds.length);
+    manyArray.loadingRecordsCount(neededReferences.length);
 
-    if (neededClientIds.length) {
-      for (i=0, l=neededClientIds.length; i<l; i++) {
-        clientId = neededClientIds[i];
+    if (neededReferences.length) {
+      for (i=0, l=neededReferences.length; i<l; i++) {
+        reference = neededReferences[i];
+        clientId = reference.clientId;
 
         // keep track of the record arrays that a given loading record
         // is part of. This way, if the same record is in multiple
@@ -638,10 +664,14 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
         }
       }
 
-      this.fetchMany(type, neededClientIds);
+      this.fetchMany(type, neededReferences);
     } else {
       // all requested records are available
       manyArray.set('isLoaded', true);
+
+      Ember.run.once(function() {
+        manyArray.trigger('didLoad');
+      });
     }
 
     return manyArray;
@@ -791,7 +821,7 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     @return {boolean}
   */
   recordIsLoaded: function(type, id) {
-    return !Ember.none(this.typeMapFor(type).idToCid[id]);
+    return !Ember.isNone(this.typeMapFor(type).idToCid[id]);
   },
 
   // ............
@@ -1064,11 +1094,6 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     if (relationship) { relationship.adapterDidUpdate(); }
   },
 
-  materializeHasMany: function(record, name, ids) {
-    record.materializeHasMany(name, ids);
-    record.adapterDidUpdateHasMany(name);
-  },
-
   /**
     This allows an adapter to acknowledge all relationship changes
     for a given record.
@@ -1154,10 +1179,11 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
         type = record.constructor,
         id = this.preprocessData(type, data);
 
-    Ember.assert("An adapter cannot assign a new id to a record that already has an id. " + record + " had id: " + oldId + " and you tried to update it with " + id + ". This likely happened because your server returned data in response to a find or update that had a different id than the one you sent.", oldId === undefined || id === oldId);
+    Ember.assert("An adapter cannot assign a new id to a record that already has an id. " + record + " had id: " + oldId + " and you tried to update it with " + id + ". This likely happened because your server returned data in response to a find or update that had a different id than the one you sent.", oldId === null || id === oldId);
 
     typeMap.idToCid[id] = clientId;
     this.clientIdToId[clientId] = id;
+    this.referenceForClientId(clientId).id = id;
   },
 
   /**
@@ -1174,7 +1200,6 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     @return {String} id the id represented by the data
   */
   preprocessData: function(type, data) {
-    this.adapterForType(type).extractEmbeddedData(this, type, data);
     return this.adapterForType(type).extractId(type, data);
   },
 
@@ -1321,13 +1346,14 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     var alreadyInArray = content.indexOf(clientId) !== -1;
 
     var recordArrays = this.recordArraysForClientId(clientId);
+    var reference = this.referenceForClientId(clientId);
 
-    if (shouldBeInArray && !alreadyInArray) {
+    if (shouldBeInArray) {
       recordArrays.add(array);
-      content.pushObject(clientId);
-    } else if (!shouldBeInArray && alreadyInArray) {
+      array.addReference(reference);
+    } else if (!shouldBeInArray) {
       recordArrays.remove(array);
-      content.removeObject(clientId);
+      array.removeReference(reference);
     }
   },
 
@@ -1340,12 +1366,11 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
     @param {DS.Model} record
   */
   removeFromRecordArrays: function(record) {
-    var clientId = get(record, 'clientId');
-    var recordArrays = this.recordArraysForClientId(clientId);
+    var reference = get(record, 'reference');
+    var recordArrays = this.recordArraysForClientId(reference.clientId);
 
     recordArrays.forEach(function(array) {
-      var content = get(array, 'content');
-      content.removeObject(clientId);
+      array.removeReference(reference);
     });
   },
 
@@ -1489,12 +1514,10 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
 
     this.updateRecordArrays(type, clientId);
 
-    return { id: id, clientId: clientId };
+    return this.referenceForClientId(clientId);
   },
 
   loadMany: function(type, ids, dataList) {
-    var clientIds = Ember.A([]);
-
     if (dataList === undefined) {
       dataList = ids;
       ids = map(dataList, function(data) {
@@ -1502,12 +1525,23 @@ DS.Store = Ember.Object.extend(DS._Mappable, {
       }, this);
     }
 
-    for (var i=0, l=get(ids, 'length'); i<l; i++) {
-      var loaded = this.load(type, ids[i], dataList[i]);
-      clientIds.pushObject(loaded.clientId);
-    }
+    return map(ids, function(id, i) {
+      return this.load(type, id, dataList[i]);
+    }, this);
+  },
+
+  loadHasMany: function(record, key, ids) {
+    record.materializeHasMany(key, ids);
+
+    // Update any existing many arrays that use the previous IDs,
+    // if necessary.
+    record.hasManyDidChange(key);
+
+    var association = record.cacheFor(key);
 
-    return { clientIds: clientIds, ids: ids };
+    // TODO (tomdale) this assumes that loadHasMany *always* means
+    // that the records for the provided IDs are loaded.
+    if (association) { set(association, 'isLoaded', true); }
   },
 
   /** @private
diff --git a/packages/ember-data/lib/transforms/json_transforms.js b/packages/ember-data/lib/transforms/json_transforms.js
index 2a2000e9476..74327e7d771 100644
--- a/packages/ember-data/lib/transforms/json_transforms.js
+++ b/packages/ember-data/lib/transforms/json_transforms.js
@@ -1,24 +1,26 @@
+var none = Ember.isNone;
+
 /**
   DS.Transforms is a hash of transforms used by DS.Serializer.
 */
 DS.JSONTransforms = {
   string: {
     deserialize: function(serialized) {
-      return Ember.none(serialized) ? null : String(serialized);
+      return none(serialized) ? null : String(serialized);
     },
 
     serialize: function(deserialized) {
-      return Ember.none(deserialized) ? null : String(deserialized);
+      return none(deserialized) ? null : String(deserialized);
     }
   },
 
   number: {
     deserialize: function(serialized) {
-      return Ember.none(serialized) ? null : Number(serialized);
+      return none(serialized) ? null : Number(serialized);
     },
 
     serialize: function(deserialized) {
-      return Ember.none(deserialized) ? null : Number(deserialized);
+      return none(deserialized) ? null : Number(deserialized);
     }
   },
 
diff --git a/packages/ember-data/tests/integration/associations_test.js b/packages/ember-data/tests/integration/associations_test.js
index bce31a2f130..9f67c1e1c71 100644
--- a/packages/ember-data/tests/integration/associations_test.js
+++ b/packages/ember-data/tests/integration/associations_test.js
@@ -106,7 +106,7 @@ test("When a hasMany association is accessed, the adapter's findMany method shou
   store.load(Person, { id: 1, comments: [ 1 ] });
 });
 
-test("An adapter can materialize a hash and get it back later in a findAssociation hook", function() {
+test("An adapter can materialize a hash and get it back later in a findHasMany hook", function() {
   expect(8);
 
   stop();
@@ -147,7 +147,7 @@ test("An adapter can materialize a hash and get it back later in a findAssociati
     throw new Error("Should not get here");
   };
 
-  adapter.findAssociation = function(store, record, relationship, details) {
+  adapter.findHasMany = function(store, record, relationship, details) {
     equal(relationship.type, Comment);
     equal(relationship.key, 'comments');
     equal(details.url, "/posts/1/comments");
@@ -158,7 +158,7 @@ test("An adapter can materialize a hash and get it back later in a findAssociati
         { id: 2, body: "Second" }
       ]);
 
-      store.materializeHasMany(record, relationship.key, [ 1, 2 ]);
+      store.loadHasMany(record, relationship.key, [ 1, 2 ]);
 
       setTimeout(function() {
         done();
diff --git a/packages/ember-data/tests/integration/embedded_load_test.js b/packages/ember-data/tests/integration/embedded_load_test.js
index 3e910c5628f..9d79a2d8ff5 100644
--- a/packages/ember-data/tests/integration/embedded_load_test.js
+++ b/packages/ember-data/tests/integration/embedded_load_test.js
@@ -1,6 +1,6 @@
 var originalLookup = Ember.lookup, lookup;
 
-var Adapter, store;
+var Adapter, store, adapter;
 
 var Person = DS.Model.extend();
 
@@ -20,12 +20,11 @@ module("Embedded Load", {
     lookup.Person = Person;
     lookup.Comment = Comment;
 
-    Adapter = DS.Adapter.extend();
+    Adapter = DS.RESTAdapter.extend();
 
-    store = DS.Store.create({
-      adapter: Adapter
-    });
+    store = DS.Store.create();
   },
+
   teardown: function() {
     Ember.lookup = originalLookup;
   }
@@ -38,7 +37,10 @@ Ember.ArrayPolyfills.forEach.call([[Comment, "as a type"], ["Comment", "as a str
       user: { embedded: 'load' }
     });
 
-    store.load(Comment, {
+    adapter = Adapter.create();
+    store.set('adapter', adapter);
+
+    adapter.load(store, Comment, {
       id: 1,
       user: {
         id: 2,
@@ -46,7 +48,7 @@ Ember.ArrayPolyfills.forEach.call([[Comment, "as a type"], ["Comment", "as a str
       }
     });
 
-    store.load(Comment, {
+    adapter.load(store, Comment, {
       id: 2,
       user: {
         id: 2,
@@ -71,13 +73,16 @@ Ember.ArrayPolyfills.forEach.call([Person, "Person"], function(mapping) {
       comments: { embedded: 'load' }
     });
 
-    store.load(Person, {
+    adapter = Adapter.create();
+    store.set('adapter', adapter);
+
+    adapter.load(store, Person, {
       id: 1,
       name: "Erik Brynroflsson",
       comments: [{ id: 1 }, { id: 2 }]
     });
 
-    store.load(Person, {
+    adapter.load(store, Person, {
       id: 2,
       name: "Patrick Gibson",
       comments: [{ id: 1 }, { id: 2 }]
diff --git a/packages/ember-data/tests/integration/embedded_test.js b/packages/ember-data/tests/integration/embedded_test.js
index 39841d8d628..aba29b191c9 100644
--- a/packages/ember-data/tests/integration/embedded_test.js
+++ b/packages/ember-data/tests/integration/embedded_test.js
@@ -5,19 +5,27 @@ module("Embedded Records without IDs", {
   setup: function() {
     var attr = DS.attr;
 
-    Post = DS.Model.extend({
+    var App = Ember.Namespace.create({
+      toString: function() { return "App"; }
+    });
+
+    Post = App.Post = DS.Model.extend({
       title: attr('string')
     });
 
-    Comment = DS.Model.extend({
+    Comment = App.Comment = DS.Model.extend({
       title: attr('string'),
 
       post: DS.belongsTo(Post)
     });
 
-    serializer = DS.JSONSerializer.create();
+    Post.reopen({
+      comments: DS.hasMany(Comment)
+    });
 
-    Adapter = DS.Adapter.extend({
+    serializer = DS.RESTSerializer.create();
+
+    Adapter = DS.RESTAdapter.extend({
       serializer: serializer
     });
 
@@ -25,15 +33,20 @@ module("Embedded Records without IDs", {
       post: { embedded: 'always' }
     });
 
-    store = DS.Store.create({
-      adapter: Adapter.create()
+    Adapter.map(Post, {
+      comments: { embedded: 'always' }
     });
 
+    adapter = Adapter.create();
+
+    store = DS.Store.create({
+      adapter: adapter
+    });
   }
 });
 
 test("An embedded record can be accessed via a belongsTo relationship but does not have an ID", function() {
-  store.load(Comment, {
+  adapter.load(store, Comment, {
     id: 1,
     title: "Why not use a more lightweight solution?",
 
@@ -42,7 +55,7 @@ test("An embedded record can be accessed via a belongsTo relationship but does n
     }
   });
 
-  store.load(Comment, {
+  adapter.load(store, Comment, {
     id: 2,
     title: "I do not trust it",
 
@@ -63,3 +76,26 @@ test("An embedded record can be accessed via a belongsTo relationship but does n
   equal(post2.get('title'), "Katz's Recent Foray into JavaScript", "the embedded record is found and its attributed are materialized");
   equal(post2.get('id'), null, "the embedded record does not have an id");
 });
+
+test("Embedded records can be accessed via a hasMany relationship without having IDs", function() {
+  adapter.load(store, Post, {
+    id: 1,
+    title: "A New MVC Framework in Under 100 Lines of Code",
+
+    comments: [{
+      title: "Why not use a more lightweight solution?"
+    }, {
+      title: "This does not seem to reflect the Unix philosophy haha"
+    }]
+  });
+
+  var post = store.find(Post, 1);
+
+  var comments = post.get('comments');
+
+  var comment1 = comments.objectAt(0);
+  var comment2 = comments.objectAt(1);
+
+  equal(comment1.get('title'), "Why not use a more lightweight solution?");
+  equal(comment2.get('title'), "This does not seem to reflect the Unix philosophy haha");
+});
diff --git a/packages/ember-data/tests/integration/store_adapter_test.js b/packages/ember-data/tests/integration/store_adapter_test.js
index 166fde88519..75b5b4baf59 100644
--- a/packages/ember-data/tests/integration/store_adapter_test.js
+++ b/packages/ember-data/tests/integration/store_adapter_test.js
@@ -400,7 +400,7 @@ test("can rollback after sucessives updates", function() {
 test("mappings registered on an adapter class are applied to the serializer of adapter instances", function() {
   var MyAdapter = DS.Adapter.extend();
 
-  MyAdapter.map(Person, {
+  MyAdapter.configure(Person, {
     primaryKey: 'id!'
   });
 
diff --git a/packages/ember-data/tests/unit/associations_test.js b/packages/ember-data/tests/unit/associations_test.js
index 35288ac674e..16be795ca74 100644
--- a/packages/ember-data/tests/unit/associations_test.js
+++ b/packages/ember-data/tests/unit/associations_test.js
@@ -356,16 +356,14 @@ test("updating the content of a RecordArray updates its content", function() {
   });
 
   var store = DS.Store.create();
-  var loaded = store.loadMany(Tag, [5, 2, 12], [{ id: 5, name: "friendly" }, { id: 2, name: "smarmy" }, { id: 12, name: "oohlala" }]);
+  var references = store.loadMany(Tag, [5, 2, 12], [{ id: 5, name: "friendly" }, { id: 2, name: "smarmy" }, { id: 12, name: "oohlala" }]);
 
-  var clientIds = loaded.clientIds;
-
-  var tags = DS.RecordArray.create({ content: Ember.A([clientIds[0], clientIds[1]]), store: store, type: Tag });
+  var tags = DS.RecordArray.create({ content: Ember.A(references.slice(0, 2)), store: store, type: Tag });
 
   var tag = tags.objectAt(0);
   equal(get(tag, 'name'), "friendly", "precond - we're working with the right tags");
 
-  set(tags, 'content', Ember.A([clientIds[1], clientIds[2]]));
+  set(tags, 'content', Ember.A(references.slice(1, 3)));
   tag = tags.objectAt(0);
   equal(get(tag, 'name'), "smarmy", "the lookup was updated");
 });
diff --git a/packages/ember-data/tests/unit/json_serializer_test.js b/packages/ember-data/tests/unit/json_serializer_test.js
index 16a0ed723cd..a2a95a0cdab 100644
--- a/packages/ember-data/tests/unit/json_serializer_test.js
+++ b/packages/ember-data/tests/unit/json_serializer_test.js
@@ -184,11 +184,11 @@ test("mapped relationships are respected when materializing a record from JSON",
 });
 
 test("mapped primary keys are respected when serializing a record to JSON", function() {
-  serializer.map(Person, {
+  serializer.configure(Person, {
     primaryKey: '__id__'
   });
 
-  serializer.map('Address', {
+  serializer.configure('Address', {
     primaryKey: 'ID'
   });
 
@@ -203,11 +203,11 @@ test("mapped primary keys are respected when serializing a record to JSON", func
 });
 
 test("mapped primary keys are respected when materializing a record from JSON", function() {
-  serializer.map(Person, {
+  serializer.configure(Person, {
     primaryKey: '__id__'
   });
 
-  serializer.map('Address', {
+  serializer.configure('Address', {
     primaryKey: 'ID'
   });
 
diff --git a/packages/ember-data/tests/unit/record_array_test.js b/packages/ember-data/tests/unit/record_array_test.js
index 106f3c2cb98..3e5d6235633 100644
--- a/packages/ember-data/tests/unit/record_array_test.js
+++ b/packages/ember-data/tests/unit/record_array_test.js
@@ -154,11 +154,10 @@ test("a record array that backs a collection view functions properly", function(
 
   function compareArrays() {
     var recordArray = container.content;
-    var recordCache = store.get('recordCache');
     var content = recordArray.get('content');
     for(var i = 0; i < content.length; i++) {
-      var clientId = content.objectAt(i);
-      var record = recordCache[clientId];
+      var clientId = content.objectAt(i).clientId;
+      var record = store.findByClientId(get(recordArray, 'type'), clientId);
       equal(record && record.clientId, clientId, "The entries in the record cache should have matching client ids.");
     }
   }
diff --git a/packages/ember-data/tests/unit/rest_adapter_test.js b/packages/ember-data/tests/unit/rest_adapter_test.js
index 31704b50844..59295f5c284 100644
--- a/packages/ember-data/tests/unit/rest_adapter_test.js
+++ b/packages/ember-data/tests/unit/rest_adapter_test.js
@@ -24,15 +24,15 @@ module("the REST adapter", {
             success.call(self, json);
           };
         }
-      },
-
-      plurals: {
-        person: 'people'
       }
     });
 
     serializer = get(adapter, 'serializer');
 
+    serializer.plurals = {
+      person: 'people'
+    };
+
     store = DS.Store.create({
       adapter: adapter
     });
@@ -45,6 +45,10 @@ module("the REST adapter", {
       return "App.Person";
     };
 
+    serializer.configure(Person, {
+      sideloadAs: "people"
+    });
+
     Group = DS.Model.extend({
       name: DS.attr('string'),
       people: DS.hasMany(Person)
@@ -123,9 +127,9 @@ test("creating a person makes a POST to /people, with the data hash", function()
 });
 
 test("singular creations can sideload data", function() {
-  serializer.mappings = {
-    groups: Group
-  };
+  serializer.configure(Group, {
+    sideloadAs: 'groups'
+  });
 
   person = store.createRecord(Person, { name: "Tom Dale" });
 
@@ -201,9 +205,7 @@ test("updates are not required to return data", function() {
 });
 
 test("singular updates can sideload data", function() {
-  adapter.mappings = {
-    groups: Group
-  };
+  serializer.configure(Group, { sideloadAs: 'groups' });
 
   store.load(Person, { id: 1, name: "Yehuda Katz" });
 
@@ -235,20 +237,6 @@ test("singular updates can sideload data", function() {
   equal(get(group, 'name'), "Group 1", "the data sideloaded successfully");
 });
 
-/*
-test("updating a record with custom primaryKey", function() {
-  store.load(Role, { _id: 1, name: "Developer" });
-
-  role = store.find(Role, 1);
-
-  set(role, 'name', "Manager");
-  store.commit();
-
-  expectUrl("/roles/1", "the plural of the model name with its ID");
-  ajaxHash.success({ role: { _id: 1, name: "Manager" } });
-});
-*/
-
 test("deleting a person makes a DELETE to /people/:id", function() {
   store.load(Person, { id: 1, name: "Tom Dale" });
 
@@ -273,9 +261,7 @@ test("deleting a person makes a DELETE to /people/:id", function() {
 });
 
 test("singular deletes can sideload data", function() {
-  adapter.mappings = {
-    groups: Group
-  };
+  serializer.configure(Group, { sideloadAs: 'groups' });
 
   store.load(Person, { id: 1, name: "Tom Dale" });
 
@@ -391,8 +377,9 @@ test("finding all people with since makes a GET to /people", function() {
 });
 
 test("meta and since are configurable", function() {
-  store.set('_adapter.meta', 'metaObject');
-  store.set('_adapter.since', 'sinceToken');
+  set(serializer, 'meta', 'metaObject');
+  set(serializer, 'since', 'sinceToken');
+  set(adapter, 'since', 'lastToken');
 
   people = store.find(Person);
 
@@ -405,7 +392,7 @@ test("meta and since are configurable", function() {
 
   expectUrl("/people", "the plural of the model name");
   expectType("GET");
-  expectData({sinceToken: '123'});
+  expectData({lastToken: '123'});
 
   ajaxHash.success({ metaObject: {sinceToken: '1234'}, people: [{ id: 2, name: "Paul Chavard" }] });
 
@@ -690,7 +677,7 @@ test("bulk commits can sideload data", function() {
   var tom = store.createRecord(Person, { name: "Tom Dale" });
   var yehuda = store.createRecord(Person, { name: "Yehuda Katz" });
 
-  adapter.mappings = { groups: Group };
+  serializer.configure(Group, { sideloadAs: 'groups' });
 
   people = [ tom, yehuda ];
 
@@ -758,9 +745,7 @@ test("updating several people (with bulkCommit) makes a PUT to /people/bulk with
 test("bulk updates can sideload data", function() {
   set(adapter, 'bulkCommit', true);
 
-  adapter.mappings = {
-    groups: Group
-  };
+  serializer.configure(Group, { sideloadAs: 'groups' });
 
   store.loadMany(Person, [
     { id: 1, name: "Yehuda Katz" },
@@ -843,9 +828,7 @@ test("deleting several people (with bulkCommit) makes a PUT to /people/bulk", fu
 test("bulk deletes can sideload data", function() {
   set(adapter, 'bulkCommit', true);
 
-  adapter.mappings = {
-    groups: Group
-  };
+  serializer.configure(Group, { sideloadAs: 'groups' });
 
   store.loadMany(Person, [
     { id: 1, name: "Yehuda Katz" },
@@ -922,7 +905,7 @@ test("additional data can be sideloaded with associations in correct order", fun
     person: DS.belongsTo(Person)
   });
 
-  store.adapter.mappings = {'comments': Comment};
+  serializer.configure(Comment, { sideloadAs: 'comments' });
 
   var comments = store.filter(Comment, function(data) {
     equal(store.find(Comment, data.get('id')).get('person.id'), 1);
diff --git a/packages/ember-data/tests/unit/serializers/rest_serializer_test.js b/packages/ember-data/tests/unit/serializers/rest_serializer_test.js
index de73c7ca042..eff016b4b46 100644
--- a/packages/ember-data/tests/unit/serializers/rest_serializer_test.js
+++ b/packages/ember-data/tests/unit/serializers/rest_serializer_test.js
@@ -35,9 +35,9 @@ test("Calling extract on a JSON payload with multiple records will tear them apa
     groups: DS.hasMany(App.Group)
   });
 
-  serializer.mappings = {
-    groups: App.Group
-  };
+  serializer.configure(App.Group, {
+    sideloadAs: 'groups'
+  });
 
   var payload = {
     post: {
@@ -49,10 +49,16 @@ test("Calling extract on a JSON payload with multiple records will tear them apa
     groups: [{ id: 1, name: "Trolls" }]
   };
 
-  var callCount = 0;
+  var loadCallCount = 0,
+      loadMainCallCount = 0;
+
   var loader = {
     load: function(type, data, prematerialized) {
-      callCount++;
+      loadCallCount++;
+    },
+
+    loadMain: function(type, data, prematerialized) {
+      loadMainCallCount++;
     }
   };
 
@@ -60,7 +66,8 @@ test("Calling extract on a JSON payload with multiple records will tear them apa
     type: App.Post
   });
 
-  equal(callCount, 2, "two records were loaded from single payload");
+  equal(loadMainCallCount, 1, "one main record was loaded from a single payload");
+  equal(loadCallCount, 1, "one secondary record was loaded from a single payload");
 
   //this.extractRecord(type, structure, loader)
 
diff --git a/packages/ember-data/tests/unit/store_test.js b/packages/ember-data/tests/unit/store_test.js
index 7b98d228cb5..6616f8e5ce9 100644
--- a/packages/ember-data/tests/unit/store_test.js
+++ b/packages/ember-data/tests/unit/store_test.js
@@ -336,22 +336,6 @@ test("loadMany extracts ids from an Array of hashes if no ids are specified", fu
   equal(get(store.find(Person, 1), 'name'), "Scumbag Dale", "correctly extracted id for loaded data");
 });
 
-/*
-test("loadMany uses a model's primaryKey if one is provided to extract ids", function() {
-  var store = DS.Store.create();
-
-  var array = [{ key: 1, name: "Scumbag Dale" }, { key: 2, name: "Scumbag Katz" }, { key: 3, name: "Scumbag Bryn" }];
-
-  var Person = DS.Model.extend({
-    name: DS.attr('string'),
-    primaryKey: "key"
-  });
-
-  store.loadMany(Person, array);
-  equal(get(store.find(Person, 1), 'name'), "Scumbag Dale", "correctly extracted id for loaded data");
-});
-*/
-
 test("loadMany takes an optional Object and passes it on to the Adapter", function() {
   var passedQuery = { page: 1 };