diff --git a/Makefile b/Makefile
index 521b9dd..efeb6d5 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,8 @@
 compile:
-	coffee -c backbone.dualstorage.coffee spec/*.coffee
-	coffee -cbo spec backbone.dualstorage.coffee
-	cat amd.header.js spec/backbone.dualstorage.js amd.footer.js > backbone.dualstorage.amd.js
+	coffee -cj backbone.dualstorage.js backbone.dualstorage.adapters.coffee backbone.dualstorage.coffee
+	coffee -c spec/*.coffee
+	coffee -cbj spec/backbone.dualstorage.js backbone.dualstorage.adapters.coffee backbone.dualstorage.coffee
+	cat amd.header.js backbone.dualstorage.js amd.footer.js > backbone.dualstorage.amd.js
 
 infinite: compile
 	read # (press Enter to recompile)
diff --git a/SpecRunner.html b/SpecRunner.html
index f879d56..0a1398a 100644
--- a/SpecRunner.html
+++ b/SpecRunner.html
@@ -9,6 +9,7 @@
   <script type="text/javascript" src="lib/jquery-1.9.1.min.js"></script>
   <script type="text/javascript" src="lib/underscore.js"></script>
   <script type="text/javascript" src="lib/backbone-1.1.0.js"></script>
+  <script type="text/javascript" src="lib/sticky-2.9.js"></script>
   <script type="text/javascript" src="lib/jasmine-1.3.1/jasmine.js"></script>
   <script type="text/javascript" src="lib/jasmine-1.3.1/jasmine-html.js"></script>
   <script type="text/javascript" src="spec/spec_helper.js"></script>
@@ -23,6 +24,7 @@
   <script type="text/javascript" src="spec/backbone_extensions_spec.js"></script>
   <script type="text/javascript" src="spec/integration_spec.js"></script>
   <script type="text/javascript" src="spec/bugs_spec.js"></script>
+  <script type="text/javascript" src="spec/stickystorage_spec.js"></script>
 
   <script type="text/javascript">
     (function() {
diff --git a/backbone.dualstorage.adapters.coffee b/backbone.dualstorage.adapters.coffee
new file mode 100644
index 0000000..256464c
--- /dev/null
+++ b/backbone.dualstorage.adapters.coffee
@@ -0,0 +1,97 @@
+# Async storage adapters classes.
+
+class LocalStorageAdapter
+  # Reference implementation with LocalStorage.
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.LocalStorage'
+    @store = localStorage
+
+  initialize: ->
+    $.Deferred().resolve()
+
+  set: (key, value) ->
+    @store.setItem key, JSON.stringify value
+    $.Deferred().resolve value
+
+  get: (key) ->
+    $.Deferred().resolve JSON.parse @store.getItem key
+
+  remove: (key) ->
+    @store.removeItem key
+    $.Deferred().resolve()
+
+  clear: ->
+    @store.clear()
+    $.Deferred().resolve()
+
+
+class LawnchairStorageAdapter
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.Lawnchair'
+
+  initialize: ->
+    promise = $.Deferred()
+    @store = new Lawnchair
+      name: @name
+      adapter: ['indexed-db'], -> promise.resolve()
+    return promise
+
+  set: (key, value) ->
+    promise = $.Deferred()
+    @store.save {key: key, value: value}, (data) -> promise.resolve data.value
+    return promise
+
+  get: (key) ->
+    promise = $.Deferred()
+    @store.get key, (data) -> promise.resolve data?.value
+    return promise
+
+  remove: (key) ->
+    promise = $.Deferred()
+    @store.remove key, -> promise.resolve()
+    return promise
+
+  clear: ->
+    promise = $.Deferred()
+    @store.nuke -> promise.resolve()
+    return promise
+
+
+class StickyStorageAdapter
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.Sticky'
+
+  initialize: ->
+    promise = $.Deferred()
+    @store = new StickyStore
+      name: @name
+      adapters: ['indexedDB']
+      ready: -> promise.resolve()
+    return promise
+
+  set: (key, value) ->
+    promise = $.Deferred()
+    @store.set {key: key, value: value}, (data) -> promise.resolve data.value
+    return promise
+
+  get: (key) ->
+    promise = $.Deferred()
+    @store.get key, (data) -> promise.resolve data?.value
+    return promise
+
+  remove: (key) ->
+    promise = $.Deferred()
+    @store.remove key, -> promise.resolve()
+    return promise
+
+  clear: ->
+    promise = $.Deferred()
+    @store.removeAll -> promise.resolve()
+    return promise
+
+
+Backbone.storageAdapters =
+  LocalStorageAdapter: LocalStorageAdapter
+  LawnchairStorageAdapter: LawnchairStorageAdapter
+  # IndexedDB store is not working with Sticky.
+  # StickyStorageAdapter: StickyStorageAdapter
diff --git a/backbone.dualstorage.adapters.js b/backbone.dualstorage.adapters.js
new file mode 100644
index 0000000..69de598
--- /dev/null
+++ b/backbone.dualstorage.adapters.js
@@ -0,0 +1,161 @@
+// Generated by CoffeeScript 1.6.3
+var LawnchairStorageAdapter, LocalStorageAdapter, StickyStorageAdapter;
+
+LocalStorageAdapter = (function() {
+  function LocalStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.LocalStorage';
+    this.store = localStorage;
+  }
+
+  LocalStorageAdapter.prototype.initialize = function() {
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.set = function(key, value) {
+    this.store.setItem(key, JSON.stringify(value));
+    return $.Deferred().resolve(value);
+  };
+
+  LocalStorageAdapter.prototype.get = function(key) {
+    return $.Deferred().resolve(JSON.parse(this.store.getItem(key)));
+  };
+
+  LocalStorageAdapter.prototype.remove = function(key) {
+    this.store.removeItem(key);
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.clear = function() {
+    this.store.clear();
+    return $.Deferred().resolve();
+  };
+
+  return LocalStorageAdapter;
+
+})();
+
+LawnchairStorageAdapter = (function() {
+  function LawnchairStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Lawnchair';
+  }
+
+  LawnchairStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new Lawnchair({
+      name: this.name,
+      adapter: ['indexed-db']
+    }, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.save({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.nuke(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  return LawnchairStorageAdapter;
+
+})();
+
+StickyStorageAdapter = (function() {
+  function StickyStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Sticky';
+  }
+
+  StickyStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new StickyStore({
+      name: this.name,
+      adapters: ['indexedDB'],
+      ready: function() {
+        return promise.resolve();
+      }
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.set({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.removeAll(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  return StickyStorageAdapter;
+
+})();
+
+Backbone.storageAdapters = {
+  LocalStorageAdapter: LocalStorageAdapter,
+  LawnchairStorageAdapter: LawnchairStorageAdapter
+};
diff --git a/backbone.dualstorage.amd.js b/backbone.dualstorage.amd.js
index a2c85f0..97677a1 100644
--- a/backbone.dualstorage.amd.js
+++ b/backbone.dualstorage.amd.js
@@ -10,429 +10,678 @@
   }
 })(this, function(Backbone) {
 // Generated by CoffeeScript 1.6.3
-/*
-Backbone dualStorage Adapter v1.1.0
-
-A simple module to replace `Backbone.sync` with *localStorage*-based
-persistence. Models are given GUIDS, and saved into a JSON object. Simple
-as that.
-*/
-
-var S4, backboneSync, callbackTranslator, dualsync, localsync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse, result;
-
-Backbone.Collection.prototype.syncDirty = function() {
-  var id, ids, model, store, storeName, url, _i, _len, _results;
-  url = result(this, 'url');
-  storeName = result(this, 'storeName');
-  store = localStorage.getItem(("" + url + "_dirty") || localStorage.getItem("" + storeName + "_dirty"));
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    model = id.length === 36 ? this.findWhere({
-      id: id
-    }) : this.get(id);
-    _results.push(model != null ? model.save() : void 0);
-  }
-  return _results;
-};
-
-Backbone.Collection.prototype.syncDestroyed = function() {
-  var id, ids, model, store, storeName, url, _i, _len, _results;
-  url = result(this, 'url');
-  storeName = result(this, 'storeName');
-  store = localStorage.getItem(("" + url + "_destroyed") || (store = localStorage.getItem("" + storeName + "_destroyed")));
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    model = new this.model({
-      id: id
-    });
-    model.collection = this;
-    _results.push(model.destroy());
-  }
-  return _results;
-};
+(function() {
+  var LocalStorageAdapter, S4, StickyStorageAdapter, backboneSync, callbackTranslator, dualSync, localSync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse, result,
+    __slice = [].slice;
 
-Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
-  this.syncDirty();
-  return this.syncDestroyed();
-};
+  LocalStorageAdapter = (function() {
+    function LocalStorageAdapter() {}
 
-S4 = function() {
-  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
-};
+    LocalStorageAdapter.prototype.initialize = function() {
+      return $.Deferred().resolve;
+    };
 
-window.Store = (function() {
-  Store.prototype.sep = '';
+    LocalStorageAdapter.prototype.setItem = function(key, value) {
+      localStorage.setItem(key, value);
+      return $.Deferred().resolve(value);
+    };
 
-  function Store(name) {
-    this.name = name;
-    this.records = this.recordsOn(this.name);
-  }
+    LocalStorageAdapter.prototype.getItem = function(key) {
+      return $.Deferred().resolve(localStorage.getItem(key));
+    };
 
-  Store.prototype.generateId = function() {
-    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
-  };
+    LocalStorageAdapter.prototype.removeItem = function(key) {
+      localStorage.removeItem(key);
+      return $.Deferred().resolve();
+    };
 
-  Store.prototype.save = function() {
-    return localStorage.setItem(this.name, this.records.join(','));
-  };
+    LocalStorageAdapter.prototype.clear = function() {
+      localStorage.clear();
+      return $.Deferred().resolve();
+    };
 
-  Store.prototype.recordsOn = function(key) {
-    var store;
-    store = localStorage.getItem(key);
-    return (store && store.split(',')) || [];
-  };
+    return LocalStorageAdapter;
+
+  })();
 
-  Store.prototype.dirty = function(model) {
-    var dirtyRecords;
-    dirtyRecords = this.recordsOn(this.name + '_dirty');
-    if (!_.include(dirtyRecords, model.id.toString())) {
-      dirtyRecords.push(model.id);
-      localStorage.setItem(this.name + '_dirty', dirtyRecords.join(','));
+  StickyStorageAdapter = (function() {
+    function StickyStorageAdapter(name) {
+      this.name = name || 'Backbone.dualStorage';
     }
-    return model;
+
+    StickyStorageAdapter.prototype.initialize = function() {
+      var promise,
+        _this = this;
+      promise = $.Deferred();
+      this.store = new StickyStore({
+        name: this.name,
+        adapters: ['indexedDB', 'webSQL', 'localStorage'],
+        ready: function() {
+          console.log("Initialized " + _this.name);
+          return promise.resolve();
+        }
+      });
+      return promise;
+    };
+
+    StickyStorageAdapter.prototype.setItem = function(key, value) {
+      var promise,
+        _this = this;
+      promise = $.Deferred();
+      this.store.set(key, value, function(storedValue) {
+        console.log("setItem in " + _this.name + " > " + key + ":", value);
+        return promise.resolve(storedValue);
+      });
+      return promise;
+    };
+
+    StickyStorageAdapter.prototype.getItem = function(key) {
+      var promise,
+        _this = this;
+      promise = $.Deferred();
+      this.store.get(key, function(storedValue) {
+        console.log("getItem in " + _this.name + " > " + key + ":", storedValue);
+        return promise.resolve(storedValue);
+      });
+      return promise;
+    };
+
+    StickyStorageAdapter.prototype.removeItem = function(key) {
+      var promise,
+        _this = this;
+      promise = $.Deferred();
+      this.store.remove(key, function() {
+        console.log("removeItem in " + _this.name + " > " + key);
+        return promise.resolve();
+      });
+      return promise;
+    };
+
+    StickyStorageAdapter.prototype.clear = function() {
+      var promise,
+        _this = this;
+      promise = $.Deferred();
+      this.store.removeAll(function() {
+        console.log("clear " + _this.name);
+        return promise.resolve();
+      });
+      return promise;
+    };
+
+    return StickyStorageAdapter;
+
+  })();
+
+  Backbone.storageAdapters = {
+    LocalStorageAdapter: LocalStorageAdapter,
+    StickyStorageAdapter: StickyStorageAdapter
   };
 
-  Store.prototype.clean = function(model, from) {
-    var dirtyRecords, store;
-    store = "" + this.name + "_" + from;
-    dirtyRecords = this.recordsOn(store);
-    if (_.include(dirtyRecords, model.id.toString())) {
-      localStorage.setItem(store, _.without(dirtyRecords, model.id.toString()).join(','));
-    }
-    return model;
+  /*
+  Backbone dualStorage Adapter v1.1.0
+  
+  A simple module to replace `Backbone.sync` with *localStorage*-based
+  persistence. Models are given GUIDS, and saved into a JSON object. Simple
+  as that.
+  */
+
+
+  Backbone.storageAdapter = new Backbone.storageAdapters.LocalStorageAdapter;
+
+  Backbone.storageAdapter.initialize();
+
+  Backbone.Collection.prototype.syncDirty = function() {
+    var storeName,
+      _this = this;
+    storeName = result(this, 'storeName') || result(this, 'url');
+    return Backbone.storageAdapter.getItem("" + storeName + "_dirty").then(function(store) {
+      var id, ids, model, models;
+      ids = (store && store.split(',')) || [];
+      models = (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = ids.length; _i < _len; _i++) {
+          id = ids[_i];
+          _results.push(id.length === 36 ? this.findWhere({
+            id: id
+          }) : this.get(id));
+        }
+        return _results;
+      }).call(_this);
+      return $.when.apply($, (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = models.length; _i < _len; _i++) {
+          model = models[_i];
+          if (model) {
+            _results.push(model.save());
+          }
+        }
+        return _results;
+      })());
+    });
   };
 
-  Store.prototype.destroyed = function(model) {
-    var destroyedRecords;
-    destroyedRecords = this.recordsOn(this.name + '_destroyed');
-    if (!_.include(destroyedRecords, model.id.toString())) {
-      destroyedRecords.push(model.id);
-      localStorage.setItem(this.name + '_destroyed', destroyedRecords.join(','));
-    }
-    return model;
+  Backbone.Collection.prototype.syncDestroyed = function() {
+    var storeName,
+      _this = this;
+    storeName = result(this, 'storeName') || result(this, 'url');
+    return Backbone.storageAdapter.getItem("" + storeName + "_destroyed").then(function(store) {
+      var id, ids, model, models, _i, _len;
+      ids = (store && store.split(',')) || [];
+      models = (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = ids.length; _i < _len; _i++) {
+          id = ids[_i];
+          _results.push(new this.model({
+            id: id
+          }));
+        }
+        return _results;
+      }).call(_this);
+      for (_i = 0, _len = models.length; _i < _len; _i++) {
+        model = models[_i];
+        model.collection = _this;
+      }
+      return $.when.apply($, (function() {
+        var _j, _len1, _results;
+        _results = [];
+        for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+          model = models[_j];
+          _results.push(model.destroy());
+        }
+        return _results;
+      })());
+    });
   };
 
-  Store.prototype.create = function(model) {
-    if (!_.isObject(model)) {
-      return model;
-    }
-    if (!model.id) {
-      model.id = this.generateId();
-      model.set(model.idAttribute, model.id);
-    }
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    this.records.push(model.id.toString());
-    this.save();
-    return model;
+  Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
+    var _this = this;
+    return this.syncDirty().then(function() {
+      return _this.syncDestroyed();
+    });
   };
 
-  Store.prototype.update = function(model) {
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    if (!_.include(this.records, model.id.toString())) {
-      this.records.push(model.id.toString());
-    }
-    this.save();
-    return model;
+  S4 = function() {
+    return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
   };
 
-  Store.prototype.clear = function() {
-    var id, _i, _len, _ref;
-    _ref = this.records;
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      localStorage.removeItem(this.name + this.sep + id);
+  window.Store = (function() {
+    Store.prototype.sep = '';
+
+    function Store(name) {
+      this.name = name;
+      this.dirtyName = "" + name + "_dirty";
+      this.destroyedName = "" + name + "_destroyed";
+      this.records = [];
+    }
+
+    Store.prototype.initialize = function() {
+      var _this = this;
+      return this.recordsOn(this.name).done(function(result) {
+        return _this.records = result || [];
+      });
+    };
+
+    Store.prototype.generateId = function() {
+      return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+    };
+
+    Store.prototype.getStorageKey = function(model) {
+      if (_.isObject(model)) {
+        model = model.id;
+      }
+      return this.name + this.sep + model;
+    };
+
+    Store.prototype.save = function() {
+      return Backbone.storageAdapter.setItem(this.name, this.records.join(','));
+    };
+
+    Store.prototype.recordsOn = function(key) {
+      return Backbone.storageAdapter.getItem(key).then(function(store) {
+        return (store && store.split(',')) || [];
+      });
+    };
+
+    Store.prototype.dirty = function(model) {
+      var _this = this;
+      return this.recordsOn(this.dirtyName).then(function(dirtyRecords) {
+        if (!_.include(dirtyRecords, model.id.toString())) {
+          dirtyRecords.push(model.id.toString());
+          return Backbone.storageAdapter.setItem(_this.dirtyName, dirtyRecords.join(',')).then(function() {
+            return model;
+          });
+        }
+        return model;
+      });
+    };
+
+    Store.prototype.clean = function(model, from) {
+      var store,
+        _this = this;
+      store = "" + this.name + "_" + from;
+      return this.recordsOn(store).then(function(dirtyRecords) {
+        if (_.include(dirtyRecords, model.id.toString())) {
+          return Backbone.storageAdapter.setItem(store, _.without(dirtyRecords, model.id.toString()).join(',')).then(function() {
+            return model;
+          });
+        }
+        return model;
+      });
+    };
+
+    Store.prototype.destroyed = function(model) {
+      var _this = this;
+      return this.recordsOn(this.destroyedName).then(function(destroyedRecords) {
+        if (!_.include(destroyedRecords, model.id.toString())) {
+          destroyedRecords.push(model.id.toString());
+          Backbone.storageAdapter.setItem(_this.destroyedName, destroyedRecords.join(',')).then(function() {
+            return model;
+          });
+        }
+        return model;
+      });
+    };
+
+    Store.prototype.create = function(model) {
+      var _this = this;
+      if (!_.isObject(model)) {
+        return $.Deferred().resolve(model);
+      }
+      if (!model.id) {
+        model.id = this.generateId();
+        model.set(model.idAttribute, model.id);
+      }
+      return Backbone.storageAdapter.setItem(this.getStorageKey(model), JSON.stringify(model)).then(function() {
+        _this.records.push(model.id.toString());
+        return _this.save().then(function() {
+          return model;
+        });
+      });
+    };
+
+    Store.prototype.update = function(model) {
+      var _this = this;
+      return Backbone.storageAdapter.setItem(this.getStorageKey(model), JSON.stringify(model)).then(function() {
+        if (!_.include(_this.records, model.id.toString())) {
+          _this.records.push(model.id.toString());
+        }
+        return _this.save().then(function() {
+          return model;
+        });
+      });
+    };
+
+    Store.prototype.clear = function() {
+      var id,
+        _this = this;
+      return $.when.apply($, ((function() {
+        var _i, _len, _ref, _results;
+        _ref = this.records;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          id = _ref[_i];
+          _results.push(Backbone.storageAdapter.removeItem(this.getStorageKey(id)));
+        }
+        return _results;
+      }).call(this))).then(function() {
+        _this.records = [];
+        return _this.save();
+      });
+    };
+
+    Store.prototype.hasDirtyOrDestroyed = function() {
+      var _this = this;
+      return Backbone.storageAdapter.getItem(this.dirtyName).then(function(dirty) {
+        return Backbone.storageAdapter.getItem(_this.destroyedName).then(function(destroyed) {
+          return !_.isEmpty(dirty) || !_.isEmpty(destroyed);
+        });
+      });
+    };
+
+    Store.prototype.find = function(model) {
+      return Backbone.storageAdapter.getItem(this.getStorageKey(model)).then(function(modelAsJson) {
+        if (modelAsJson === null) {
+          return null;
+        }
+        return JSON.parse(modelAsJson);
+      });
+    };
+
+    Store.prototype.findAll = function() {
+      var id;
+      return $.when.apply($, ((function() {
+        var _i, _len, _ref, _results;
+        _ref = this.records;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          id = _ref[_i];
+          _results.push(Backbone.storageAdapter.getItem(this.getStorageKey(id)));
+        }
+        return _results;
+      }).call(this))).then(function() {
+        var model, models, _i, _len, _results;
+        models = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+        _results = [];
+        for (_i = 0, _len = models.length; _i < _len; _i++) {
+          model = models[_i];
+          _results.push(JSON.parse(model));
+        }
+        return _results;
+      });
+    };
+
+    Store.prototype.destroy = function(model) {
+      var _this = this;
+      return Backbone.storageAdapter.removeItem(this.getStorageKey(model)).then(function() {
+        _this.records = _.without(_this.records, model.id.toString());
+        return _this.save().then(function() {
+          return model;
+        });
+      });
+    };
+
+    return Store;
+
+  })();
+
+  callbackTranslator = {
+    needsTranslation: Backbone.VERSION === '0.9.10',
+    forBackboneCaller: function(callback) {
+      if (this.needsTranslation) {
+        return function(model, resp, options) {
+          return callback.call(null, resp);
+        };
+      } else {
+        return callback;
+      }
+    },
+    forDualstorageCaller: function(callback, model, options) {
+      if (this.needsTranslation) {
+        return function(resp) {
+          return callback.call(null, model, resp, options);
+        };
+      } else {
+        return callback;
+      }
     }
-    this.records = [];
-    return this.save();
   };
 
-  Store.prototype.hasDirtyOrDestroyed = function() {
-    return !_.isEmpty(localStorage.getItem(this.name + '_dirty')) || !_.isEmpty(localStorage.getItem(this.name + '_destroyed'));
+  localSync = function(method, model, options) {
+    var isValidModel, store,
+      _this = this;
+    isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
+    isValidModel || (isValidModel = model instanceof Backbone.Model);
+    isValidModel || (isValidModel = model instanceof Backbone.Collection);
+    if (!isValidModel) {
+      throw new Error('model parameter is required to be a backbone model or collection.');
+    }
+    store = new Store(options.storeName);
+    return store.initialize().then(function() {
+      var promise;
+      promise = (function() {
+        switch (method) {
+          case 'read':
+            if (model.id) {
+              return store.find(model);
+            } else {
+              return store.findAll();
+            }
+            break;
+          case 'hasDirtyOrDestroyed':
+            return store.hasDirtyOrDestroyed();
+          case 'clear':
+            return store.clear();
+          case 'create':
+            return store.find(model).then(function(preExisting) {
+              if (!(options.add && !options.merge && preExisting)) {
+                return store.create(model).then(function(model) {
+                  if (options.dirty) {
+                    return store.dirty(model).then(function() {
+                      return model;
+                    });
+                  }
+                  return model;
+                });
+              } else {
+                return preExisting;
+              }
+            });
+          case 'update':
+            return store.update(model).then(function(model) {
+              if (options.dirty) {
+                return store.dirty(model);
+              } else {
+                return store.clean(model, 'dirty');
+              }
+            });
+          case 'delete':
+            return store.destroy(model).then(function() {
+              if (options.dirty) {
+                return store.destroyed(model);
+              } else {
+                if (model.id.toString().length === 36) {
+                  return store.clean(model, 'dirty');
+                } else {
+                  return store.clean(model, 'destroyed');
+                }
+              }
+            });
+        }
+      })();
+      return promise.then(function(response) {
+        if (response != null ? response.attributes : void 0) {
+          response = response.attributes;
+        }
+        if (!options.ignoreCallbacks) {
+          if (response) {
+            options.success(response);
+          } else {
+            options.error('Record not found');
+          }
+        }
+        return response;
+      });
+    });
   };
 
-  Store.prototype.find = function(model) {
-    var modelAsJson;
-    modelAsJson = localStorage.getItem(this.name + this.sep + model.id);
-    if (modelAsJson === null) {
+  result = function(object, property) {
+    var value;
+    if (!object) {
       return null;
     }
-    return JSON.parse(modelAsJson);
+    value = object[property];
+    if (_.isFunction(value)) {
+      return value.call(object);
+    } else {
+      return value;
+    }
   };
 
-  Store.prototype.findAll = function() {
-    var id, _i, _len, _ref, _results;
-    _ref = this.records;
-    _results = [];
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      _results.push(JSON.parse(localStorage.getItem(this.name + this.sep + id)));
+  parseRemoteResponse = function(object, response) {
+    if (!(object && object.parseBeforeLocalSave)) {
+      return response;
+    }
+    if (_.isFunction(object.parseBeforeLocalSave)) {
+      return object.parseBeforeLocalSave(response);
     }
-    return _results;
   };
 
-  Store.prototype.destroy = function(model) {
-    localStorage.removeItem(this.name + this.sep + model.id);
-    this.records = _.reject(this.records, function(record_id) {
-      return record_id === model.id.toString();
-    });
-    this.save();
-    return model;
+  modelUpdatedWithResponse = function(model, response) {
+    var modelClone;
+    modelClone = new Backbone.Model;
+    modelClone.idAttribute = model.idAttribute;
+    modelClone.set(model.attributes);
+    modelClone.set(modelClone.parse(response));
+    return modelClone;
   };
 
-  return Store;
+  backboneSync = Backbone.sync;
 
-})();
+  onlineSync = function(method, model, options) {
+    options.success = callbackTranslator.forBackboneCaller(options.success);
+    options.error = callbackTranslator.forBackboneCaller(options.error);
+    return backboneSync(method, model, options);
+  };
 
-callbackTranslator = {
-  needsTranslation: Backbone.VERSION === '0.9.10',
-  forBackboneCaller: function(callback) {
-    if (this.needsTranslation) {
-      return function(model, resp, options) {
-        return callback.call(null, resp);
-      };
-    } else {
-      return callback;
+  dualSync = function(method, model, options) {
+    var error, local, success, temporaryId;
+    options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') || result(model.collection, 'url') || result(model, 'urlRoot') || result(model, 'url');
+    options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
+    options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
+    if (result(model, 'remote') || result(model.collection, 'remote')) {
+      return onlineSync(method, model, options);
     }
-  },
-  forDualstorageCaller: function(callback, model, options) {
-    if (this.needsTranslation) {
-      return function(resp) {
-        return callback.call(null, model, resp, options);
-      };
-    } else {
-      return callback;
+    local = result(model, 'local') || result(model.collection, 'local');
+    options.dirty = options.remote === false && !local;
+    if (options.remote === false || local) {
+      return localSync(method, model, options);
     }
-  }
-};
-
-localsync = function(method, model, options) {
-  var isValidModel, preExisting, response, store;
-  isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
-  isValidModel || (isValidModel = model instanceof Backbone.Model);
-  isValidModel || (isValidModel = model instanceof Backbone.Collection);
-  if (!isValidModel) {
-    throw new Error('model parameter is required to be a backbone model or collection.');
-  }
-  store = new Store(options.storeName);
-  response = (function() {
+    options.ignoreCallbacks = true;
+    success = options.success;
+    error = options.error;
     switch (method) {
       case 'read':
-        if (model.id) {
-          return store.find(model);
-        } else {
-          return store.findAll();
-        }
-        break;
-      case 'hasDirtyOrDestroyed':
-        return store.hasDirtyOrDestroyed();
-      case 'clear':
-        return store.clear();
-      case 'create':
-        if (!(options.add && !options.merge && (preExisting = store.find(model)))) {
-          model = store.create(model);
-          if (options.dirty) {
-            store.dirty(model);
-          }
-          return model;
-        } else {
-          return preExisting;
-        }
-        break;
-      case 'update':
-        store.update(model);
-        if (options.dirty) {
-          return store.dirty(model);
-        } else {
-          return store.clean(model, 'dirty');
-        }
-        break;
-      case 'delete':
-        store.destroy(model);
-        if (options.dirty) {
-          return store.destroyed(model);
-        } else {
-          if (model.id.toString().length === 36) {
-            return store.clean(model, 'dirty');
+        return localSync('hasDirtyOrDestroyed', model, options).then(function(hasDirtyOrDestroyed) {
+          if (hasDirtyOrDestroyed) {
+            return localSync(method, model, options).then(function(response) {
+              return success(response);
+            });
           } else {
-            return store.clean(model, 'destroyed');
-          }
-        }
-    }
-  })();
-  if (response != null ? response.attributes : void 0) {
-    response = response.attributes;
-  }
-  if (!options.ignoreCallbacks) {
-    if (response) {
-      options.success(response);
-    } else {
-      options.error('Record not found');
-    }
-  }
-  return response;
-};
-
-result = function(object, property) {
-  var value;
-  if (!object) {
-    return null;
-  }
-  value = object[property];
-  if (_.isFunction(value)) {
-    return value.call(object);
-  } else {
-    return value;
-  }
-};
-
-parseRemoteResponse = function(object, response) {
-  if (!(object && object.parseBeforeLocalSave)) {
-    return response;
-  }
-  if (_.isFunction(object.parseBeforeLocalSave)) {
-    return object.parseBeforeLocalSave(response);
-  }
-};
-
-modelUpdatedWithResponse = function(model, response) {
-  var modelClone;
-  modelClone = new Backbone.Model;
-  modelClone.idAttribute = model.idAttribute;
-  modelClone.set(model.attributes);
-  modelClone.set(modelClone.parse(response));
-  return modelClone;
-};
-
-backboneSync = Backbone.sync;
-
-onlineSync = function(method, model, options) {
-  options.success = callbackTranslator.forBackboneCaller(options.success);
-  options.error = callbackTranslator.forBackboneCaller(options.error);
-  return backboneSync(method, model, options);
-};
-
-dualsync = function(method, model, options) {
-  var error, local, success, temporaryId;
-  options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') || result(model.collection, 'url') || result(model, 'urlRoot') || result(model, 'url');
-  options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
-  options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
-  if (result(model, 'remote') || result(model.collection, 'remote')) {
-    return onlineSync(method, model, options);
-  }
-  local = result(model, 'local') || result(model.collection, 'local');
-  options.dirty = options.remote === false && !local;
-  if (options.remote === false || local) {
-    return localsync(method, model, options);
-  }
-  options.ignoreCallbacks = true;
-  success = options.success;
-  error = options.error;
-  switch (method) {
-    case 'read':
-      if (localsync('hasDirtyOrDestroyed', model, options)) {
-        return success(localsync(method, model, options));
-      } else {
-        options.success = function(resp, status, xhr) {
-          var collection, idAttribute, modelAttributes, responseModel, _i, _len;
-          resp = parseRemoteResponse(model, resp);
-          if (!options.add) {
-            localsync('clear', model, options);
-          }
-          if (_.isArray(resp)) {
-            collection = model;
-            idAttribute = collection.model.prototype.idAttribute;
-            for (_i = 0, _len = resp.length; _i < _len; _i++) {
-              modelAttributes = resp[_i];
-              model = collection.get(modelAttributes[idAttribute]);
-              if (model) {
-                responseModel = modelUpdatedWithResponse(model, modelAttributes);
+            options.success = function(resp, status, xhr) {
+              var go;
+              resp = parseRemoteResponse(model, resp);
+              go = function() {
+                var collection, idAttribute, m, modelAttributes, models, responseModel, _i, _len;
+                if (_.isArray(resp)) {
+                  collection = model;
+                  idAttribute = collection.model.prototype.idAttribute;
+                  models = [];
+                  for (_i = 0, _len = resp.length; _i < _len; _i++) {
+                    modelAttributes = resp[_i];
+                    model = collection.get(modelAttributes[idAttribute]);
+                    if (model) {
+                      responseModel = modelUpdatedWithResponse(model, modelAttributes);
+                    } else {
+                      responseModel = new collection.model(modelAttributes);
+                    }
+                    models.push(responseModel);
+                  }
+                  return $.when.apply($, ((function() {
+                    var _j, _len1, _results;
+                    _results = [];
+                    for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+                      m = models[_j];
+                      _results.push(localSync('create', m, options));
+                    }
+                    return _results;
+                  })())).then(function() {
+                    return success(resp, status, xhr);
+                  });
+                } else {
+                  responseModel = modelUpdatedWithResponse(model, resp);
+                  return localSync('create', responseModel, options).then(function() {
+                    return success(resp, status, xhr);
+                  });
+                }
+              };
+              if (!options.add) {
+                return localSync('clear', model, options).then(go);
               } else {
-                responseModel = new collection.model(modelAttributes);
+                return go();
               }
-              localsync('create', responseModel, options);
-            }
-          } else {
-            responseModel = modelUpdatedWithResponse(model, resp);
-            localsync('create', responseModel, options);
+            };
+            options.error = function(resp) {
+              return localSync(method, model, options).then(function(result) {
+                return success(result);
+              });
+            };
+            return onlineSync(method, model, options);
           }
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          return success(localsync(method, model, options));
-        };
-        return onlineSync(method, model, options);
-      }
-      break;
-    case 'create':
-      options.success = function(resp, status, xhr) {
-        var updatedModel;
-        updatedModel = modelUpdatedWithResponse(model, resp);
-        localsync(method, updatedModel, options);
-        return success(resp, status, xhr);
-      };
-      options.error = function(resp) {
-        options.dirty = true;
-        return success(localsync(method, model, options));
-      };
-      return onlineSync(method, model, options);
-    case 'update':
-      if (_.isString(model.id) && model.id.length === 36) {
-        temporaryId = model.id;
+        });
+      case 'create':
         options.success = function(resp, status, xhr) {
           var updatedModel;
           updatedModel = modelUpdatedWithResponse(model, resp);
-          model.set(model.idAttribute, temporaryId, {
-            silent: true
+          return localSync(method, updatedModel, options).then(function() {
+            return success(resp, status, xhr);
           });
-          localsync('delete', model, options);
-          localsync('create', updatedModel, options);
-          return success(resp, status, xhr);
         };
         options.error = function(resp) {
           options.dirty = true;
-          model.set(model.idAttribute, temporaryId, {
-            silent: true
+          return localSync(method, model, options).then(function(result) {
+            return success(result);
           });
-          return success(localsync(method, model, options));
-        };
-        model.set(model.idAttribute, null, {
-          silent: true
-        });
-        return onlineSync('create', model, options);
-      } else {
-        options.success = function(resp, status, xhr) {
-          var updatedModel;
-          updatedModel = modelUpdatedWithResponse(model, resp);
-          localsync(method, updatedModel, options);
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          options.dirty = true;
-          return success(localsync(method, model, options));
         };
         return onlineSync(method, model, options);
-      }
-      break;
-    case 'delete':
-      if (_.isString(model.id) && model.id.length === 36) {
-        return localsync(method, model, options);
-      } else {
-        options.success = function(resp, status, xhr) {
-          localsync(method, model, options);
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          options.dirty = true;
-          return success(localsync(method, model, options));
-        };
-        return onlineSync(method, model, options);
-      }
-  }
-};
+      case 'update':
+        if (_.isString(model.id) && model.id.length === 36) {
+          temporaryId = model.id;
+          options.success = function(resp, status, xhr) {
+            var updatedModel;
+            updatedModel = modelUpdatedWithResponse(model, resp);
+            model.set(model.idAttribute, temporaryId, {
+              silent: true
+            });
+            return localSync('delete', model, options).then(function() {
+              return localSync('create', updatedModel, options).then(function() {
+                return success(resp, status, xhr);
+              });
+            });
+          };
+          options.error = function(resp) {
+            options.dirty = true;
+            model.set(model.idAttribute, temporaryId, {
+              silent: true
+            });
+            return localSync(method, model, options).then(function(result) {
+              return success(result);
+            });
+          };
+          model.set(model.idAttribute, null, {
+            silent: true
+          });
+          return onlineSync('create', model, options);
+        } else {
+          options.success = function(resp, status, xhr) {
+            var updatedModel;
+            updatedModel = modelUpdatedWithResponse(model, resp);
+            return localSync(method, updatedModel, options).then(function() {
+              return success(resp, status, xhr);
+            });
+          };
+          options.error = function(resp) {
+            options.dirty = true;
+            return localSync(method, model, options).then(function(result) {
+              return success;
+            });
+          };
+          return onlineSync(method, model, options);
+        }
+        break;
+      case 'delete':
+        if (_.isString(model.id) && model.id.length === 36) {
+          return localSync(method, model, options);
+        } else {
+          options.success = function(resp, status, xhr) {
+            return localSync(method, model, options).then(function() {
+              return success(resp, status, xhr);
+            });
+          };
+          options.error = function(resp) {
+            options.dirty = true;
+            return localSync(method, model, options).then(function(result) {
+              return success(result);
+            });
+          };
+          return onlineSync(method, model, options);
+        }
+    }
+  };
+
+  Backbone.sync = dualSync;
 
-Backbone.sync = dualsync;
+}).call(this);
 });
\ No newline at end of file
diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index ab2e403..51f2084 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -6,32 +6,36 @@ persistence. Models are given GUIDS, and saved into a JSON object. Simple
 as that.
 ###
 
+# Use LocalStorageAdapter as default adapter.
+Backbone.storageAdapter = new Backbone.storageAdapters.LocalStorageAdapter
+
+# LocalStorage is not actually async, so we can call initialize here and
+# continue safely. But when using a real async StorageAdapter, you should
+# wait for initialize() to resolve before trying to do any sync operation.
+Backbone.storageAdapter.initialize()
+
+# Use default Store class provided by this library.
+# Backbone.Store = Store
+
 # Make it easy for collections to sync dirty and destroyed records
 # Simply call collection.syncDirtyAndDestroyed()
 Backbone.Collection.prototype.syncDirty = ->
-  url = result(@, 'url')
-  storeName = result(@, 'storeName')
-  store = localStorage.getItem "#{url}_dirty" || localStorage.getItem "#{storeName}_dirty"
-  ids = (store and store.split(',')) or []
-
-  for id in ids
-    model = if id.length == 36 then @findWhere(id: id) else @get(id)
-    model?.save()
+  storeName = result(@, 'storeName') || result(@, 'url')
+  Backbone.storageAdapter.getItem("#{storeName}_dirty").then (store) =>
+    ids = (store and store.split(',')) or []
+    models = ((if id.length == 36 then @findWhere(id: id) else @get(id)) for id in ids)
+    $.when (model.save() for model in models when model)...
 
 Backbone.Collection.prototype.syncDestroyed = ->
-  url = result(@, 'url')
-  storeName = result(@, 'storeName')
-  store = localStorage.getItem "#{url}_destroyed" || store = localStorage.getItem "#{storeName}_destroyed"
-  ids = (store and store.split(',')) or []
-
-  for id in ids
-    model = new @model(id: id)
-    model.collection = @
-    model.destroy()
+  storeName = result(@, 'storeName') || result(@, 'url')
+  Backbone.storageAdapter.getItem("#{storeName}_destroyed").then (store) =>
+    ids = (store and store.split(',')) or []
+    models = (new @model(id: id) for id in ids)
+    (model.collection = @ for model in models)
+    $.when (model.destroy() for model in models)...
 
 Backbone.Collection.prototype.syncDirtyAndDestroyed = ->
-  @syncDirty()
-  @syncDestroyed()
+  @syncDirty().then => @syncDestroyed()
 
 # Generate four random hex digits.
 S4 = ->
@@ -44,7 +48,13 @@ class window.Store
 
   constructor: (name) ->
     @name = name
-    @records = @recordsOn @name
+    @dirtyName = "#{name}_dirty"
+    @destroyedName = "#{name}_destroyed"
+    @records = []
+
+  initialize: ->
+    @recordsOn(@name).done (result) =>
+      @records = result || []
 
   # Generates an unique id to use when saving new instances into localstorage
   # by default generates a pseudo-GUID by concatenating random hexadecimal.
@@ -52,83 +62,83 @@ class window.Store
   generateId: ->
     S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4()
 
+  getStorageKey: (model) ->
+    if _.isObject model then model = model.id
+    @name + @sep + model
+
   # Save the current state of the **Store** to *localStorage*.
   save: ->
-    localStorage.setItem @name, @records.join(',')
+    Backbone.storageAdapter.setItem @name, @records.join(',')
 
   recordsOn: (key) ->
-    store = localStorage.getItem(key)
-    (store and store.split(',')) or []
+    Backbone.storageAdapter.getItem(key).then (store) ->
+      (store and store.split(',')) or []
 
   dirty: (model) ->
-    dirtyRecords = @recordsOn @name + '_dirty'
-    if not _.include(dirtyRecords, model.id.toString())
-      dirtyRecords.push model.id
-      localStorage.setItem @name + '_dirty', dirtyRecords.join(',')
-    model
+    @recordsOn(@dirtyName).then (dirtyRecords) =>
+      if not _.include(dirtyRecords, model.id.toString())
+        dirtyRecords.push model.id.toString()
+        return Backbone.storageAdapter.setItem(@dirtyName, dirtyRecords.join(',')).then -> model
+      model
 
   clean: (model, from) ->
     store = "#{@name}_#{from}"
-    dirtyRecords = @recordsOn store
-    if _.include dirtyRecords, model.id.toString()
-      localStorage.setItem store, _.without(dirtyRecords, model.id.toString()).join(',')
-    model
+    @recordsOn(store).then (dirtyRecords) =>
+      if _.include dirtyRecords, model.id.toString()
+        return Backbone.storageAdapter.setItem(store, _.without(dirtyRecords, model.id.toString()).join(',')).then -> model
+      model
 
   destroyed: (model) ->
-    destroyedRecords = @recordsOn @name + '_destroyed'
-    if not _.include destroyedRecords, model.id.toString()
-      destroyedRecords.push model.id
-      localStorage.setItem @name + '_destroyed', destroyedRecords.join(',')
-    model
+    @recordsOn(@destroyedName).then (destroyedRecords) =>
+      if not _.include destroyedRecords, model.id.toString()
+        destroyedRecords.push model.id.toString()
+        Backbone.storageAdapter.setItem(@destroyedName, destroyedRecords.join(',')).then -> model
+      model
 
   # Add a model, giving it a unique GUID, if it doesn't already
   # have an id of it's own.
   create: (model) ->
-    if not _.isObject(model) then return model
+    if not _.isObject(model) then return $.Deferred().resolve model
     if not model.id
       model.id = @generateId()
       model.set model.idAttribute, model.id
-    localStorage.setItem @name + @sep + model.id, JSON.stringify(model)
-    @records.push model.id.toString()
-    @save()
-    model
+    Backbone.storageAdapter.setItem(@getStorageKey(model), JSON.stringify(model)).then =>
+      @records.push model.id.toString()
+      @save().then => model
 
   # Update a model by replacing its copy in `this.data`.
   update: (model) ->
-    localStorage.setItem @name + @sep + model.id, JSON.stringify(model)
-    if not _.include(@records, model.id.toString())
-      @records.push model.id.toString()
-    @save()
-    model
+    Backbone.storageAdapter.setItem(@getStorageKey(model), JSON.stringify(model)).then =>
+      if not _.include(@records, model.id.toString())
+        @records.push model.id.toString()
+      @save().then => model
 
   clear: ->
-    for id in @records
-      localStorage.removeItem @name + @sep + id
-    @records = []
-    @save()
+    $.when((Backbone.storageAdapter.removeItem(@getStorageKey id) for id in @records)...).then =>
+      @records = []
+      @save()
 
   hasDirtyOrDestroyed: ->
-    not _.isEmpty(localStorage.getItem(@name + '_dirty')) or not _.isEmpty(localStorage.getItem(@name + '_destroyed'))
+    Backbone.storageAdapter.getItem(@dirtyName).then (dirty) =>
+      Backbone.storageAdapter.getItem(@destroyedName).then (destroyed) =>
+        not _.isEmpty(dirty) or not _.isEmpty(destroyed)
 
   # Retrieve a model from `this.data` by id.
   find: (model) ->
-    modelAsJson = localStorage.getItem(@name + @sep + model.id)
-    return null if modelAsJson == null
-    JSON.parse modelAsJson
+    Backbone.storageAdapter.getItem(@getStorageKey(model)).then (modelAsJson) ->
+      return null if modelAsJson == null
+      JSON.parse modelAsJson
 
   # Return the array of all models currently in storage.
   findAll: ->
-    for id in @records
-      JSON.parse localStorage.getItem(@name + @sep + id)
+    $.when((Backbone.storageAdapter.getItem(@getStorageKey id) for id in @records)...).then (models...) ->
+      (JSON.parse(model) for model in models)
 
   # Delete a model from `this.data`, returning it.
   destroy: (model) ->
-    localStorage.removeItem @name + @sep + model.id
-    @records = _.reject(@records, (record_id) ->
-      record_id is model.id.toString()
-    )
-    @save()
-    model
+    Backbone.storageAdapter.removeItem(@getStorageKey(model)).then =>
+      @records = _.without @records, model.id.toString()
+      @save().then -> model
 
 callbackTranslator =
   needsTranslation: Backbone.VERSION == '0.9.10'
@@ -147,7 +157,7 @@ callbackTranslator =
 
 # Override `Backbone.sync` to use delegate to the model or collection's
 # *localStorage* property, which should be an instance of `Store`.
-localsync = (method, model, options) ->
+localSync = (method, model, options) ->
   isValidModel = (method is 'clear') or (method is 'hasDirtyOrDestroyed')
   isValidModel ||= model instanceof Backbone.Model
   isValidModel ||= model instanceof Backbone.Collection
@@ -156,48 +166,54 @@ localsync = (method, model, options) ->
     throw new Error 'model parameter is required to be a backbone model or collection.'
 
   store = new Store options.storeName
+  store.initialize().then =>
 
-  response = switch method
-    when 'read'
-      if model.id
-        store.find(model)
-      else
-        store.findAll()
-    when 'hasDirtyOrDestroyed'
-      store.hasDirtyOrDestroyed()
-    when 'clear'
-      store.clear()
-    when 'create'
-      unless options.add and not options.merge and (preExisting = store.find(model))
-        model = store.create(model)
-        store.dirty(model) if options.dirty
-        model
-      else
-        preExisting
-    when 'update'
-      store.update(model)
-      if options.dirty
-        store.dirty(model)
-      else
-        store.clean(model, 'dirty')
-    when 'delete'
-      store.destroy(model)
-      if options.dirty
-        store.destroyed(model)
-      else
-        if model.id.toString().length == 36
-          store.clean(model, 'dirty')
+    promise = switch method
+      when 'read'
+        if model.id
+          store.find(model)
         else
-          store.clean(model, 'destroyed')
-  response = response.attributes if response?.attributes
+          store.findAll()
+      when 'hasDirtyOrDestroyed'
+        store.hasDirtyOrDestroyed()
+      when 'clear'
+        store.clear()
+      when 'create'
+        store.find(model).then (preExisting) ->
+          unless options.add and not options.merge and preExisting
+            store.create(model).then (model) ->
+              if options.dirty
+                return store.dirty(model).then ->
+                  model
+              model
+          else
+            preExisting
+      when 'update'
+        store.update(model).then (model) ->
+          if options.dirty
+            store.dirty(model)
+          else
+            store.clean(model, 'dirty')
+      when 'delete'
+        store.destroy(model).then ->
+          if options.dirty
+            store.destroyed(model)
+          else
+            if model.id.toString().length == 36
+              store.clean(model, 'dirty')
+            else
+              store.clean(model, 'destroyed')
 
-  unless options.ignoreCallbacks
-    if response
-      options.success response
-    else
-      options.error 'Record not found'
+    promise.then (response) ->
+      response = response.attributes if response?.attributes
+
+      unless options.ignoreCallbacks
+        if response
+          options.success response
+        else
+          options.error 'Record not found'
 
-  response
+      response
 
 # If the value of the named property is a function then invoke it;
 # otherwise, return it.
@@ -226,7 +242,7 @@ onlineSync = (method, model, options) ->
   options.error   = callbackTranslator.forBackboneCaller(options.error)
   backboneSync(method, model, options)
 
-dualsync = (method, model, options) ->
+dualSync = (method, model, options) ->
   options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') ||
                       result(model.collection, 'url')       || result(model, 'urlRoot')   || result(model, 'url')
   options.success = callbackTranslator.forDualstorageCaller(options.success, model, options)
@@ -238,7 +254,7 @@ dualsync = (method, model, options) ->
   # execute only local sync
   local = result(model, 'local') or result(model.collection, 'local')
   options.dirty = options.remote is false and not local
-  return localsync(method, model, options) if options.remote is false or local
+  return localSync(method, model, options) if options.remote is false or local
 
   # execute dual sync
   options.ignoreCallbacks = true
@@ -248,43 +264,53 @@ dualsync = (method, model, options) ->
 
   switch method
     when 'read'
-      if localsync('hasDirtyOrDestroyed', model, options)
-        success localsync(method, model, options)
-      else
-        options.success = (resp, status, xhr) ->
-          resp = parseRemoteResponse(model, resp)
-
-          localsync('clear', model, options) unless options.add
-
-          if _.isArray resp
-            collection = model
-            idAttribute = collection.model.prototype.idAttribute
-            for modelAttributes in resp
-              model = collection.get(modelAttributes[idAttribute])
-              if model
-                responseModel = modelUpdatedWithResponse(model, modelAttributes)
+      localSync('hasDirtyOrDestroyed', model, options).then (hasDirtyOrDestroyed) ->
+        if hasDirtyOrDestroyed
+          localSync(method, model, options).then (response) ->
+            success response
+        else
+          options.success = (resp, status, xhr) ->
+            resp = parseRemoteResponse(model, resp)
+
+            go = ->
+              if _.isArray resp
+                collection = model
+                idAttribute = collection.model.prototype.idAttribute
+                models = []
+                for modelAttributes in resp
+                  model = collection.get(modelAttributes[idAttribute])
+                  if model
+                    responseModel = modelUpdatedWithResponse(model, modelAttributes)
+                  else
+                    responseModel = new collection.model(modelAttributes)
+                  models.push responseModel
+                $.when((localSync('create', m, options) for m in models)...).then ->
+                  success(resp, status, xhr)
               else
-                responseModel = new collection.model(modelAttributes)
-              localsync('create', responseModel, options)
-          else
-            responseModel = modelUpdatedWithResponse(model, resp)
-            localsync('create', responseModel, options)
+                responseModel = modelUpdatedWithResponse(model, resp)
+                localSync('create', responseModel, options).then ->
+                  success(resp, status, xhr)
 
-          success(resp, status, xhr)
+            if not options.add
+              localSync('clear', model, options).then go
+            else
+              go()
 
-        options.error = (resp) ->
-          success localsync(method, model, options)
+          options.error = (resp) ->
+            localSync(method, model, options).then (result) ->
+              success result
 
-        onlineSync(method, model, options)
+          onlineSync(method, model, options)
 
     when 'create'
       options.success = (resp, status, xhr) ->
         updatedModel = modelUpdatedWithResponse model, resp
-        localsync(method, updatedModel, options)
-        success(resp, status, xhr)
+        localSync(method, updatedModel, options).then ->
+          success(resp, status, xhr)
       options.error = (resp) ->
         options.dirty = true
-        success localsync(method, model, options)
+        localSync(method, model, options).then (result) ->
+          success result
 
       onlineSync(method, model, options)
 
@@ -295,38 +321,41 @@ dualsync = (method, model, options) ->
         options.success = (resp, status, xhr) ->
           updatedModel = modelUpdatedWithResponse model, resp
           model.set model.idAttribute, temporaryId, silent: true
-          localsync('delete', model, options)
-          localsync('create', updatedModel, options)
-          success(resp, status, xhr)
+          localSync('delete', model, options).then ->
+            localSync('create', updatedModel, options).then ->
+              success(resp, status, xhr)
         options.error = (resp) ->
           options.dirty = true
           model.set model.idAttribute, temporaryId, silent: true
-          success localsync(method, model, options)
+          localSync(method, model, options).then (result) ->
+            success result
 
         model.set model.idAttribute, null, silent: true
         onlineSync('create', model, options)
       else
         options.success = (resp, status, xhr) ->
           updatedModel = modelUpdatedWithResponse model, resp
-          localsync(method, updatedModel, options)
-          success(resp, status, xhr)
+          localSync(method, updatedModel, options).then ->
+            success(resp, status, xhr)
         options.error = (resp) ->
           options.dirty = true
-          success localsync(method, model, options)
+          localSync(method, model, options).then (result) ->
+            success
 
         onlineSync(method, model, options)
 
     when 'delete'
       if _.isString(model.id) and model.id.length == 36
-        localsync(method, model, options)
+        localSync(method, model, options)
       else
         options.success = (resp, status, xhr) ->
-          localsync(method, model, options)
-          success(resp, status, xhr)
+          localSync(method, model, options).then ->
+            success(resp, status, xhr)
         options.error = (resp) ->
           options.dirty = true
-          success localsync(method, model, options)
+          localSync(method, model, options).then (result) ->
+            success result
 
         onlineSync(method, model, options)
 
-Backbone.sync = dualsync
+Backbone.sync = dualSync
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 1bbf50f..18fb7c3 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -7,209 +7,305 @@ persistence. Models are given GUIDS, and saved into a JSON object. Simple
 as that.
 */
 
+var S4, backboneSync, callbackTranslator, dualSync, localSync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse, result,
+  __slice = [].slice;
 
-(function() {
-  var S4, backboneSync, callbackTranslator, dualsync, localsync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse, result;
+Backbone.storageAdapter = new Backbone.storageAdapters.LocalStorageAdapter;
 
-  Backbone.Collection.prototype.syncDirty = function() {
-    var id, ids, model, store, storeName, url, _i, _len, _results;
-    url = result(this, 'url');
-    storeName = result(this, 'storeName');
-    store = localStorage.getItem(("" + url + "_dirty") || localStorage.getItem("" + storeName + "_dirty"));
-    ids = (store && store.split(',')) || [];
-    _results = [];
-    for (_i = 0, _len = ids.length; _i < _len; _i++) {
-      id = ids[_i];
-      model = id.length === 36 ? this.findWhere({
-        id: id
-      }) : this.get(id);
-      _results.push(model != null ? model.save() : void 0);
-    }
-    return _results;
-  };
+Backbone.storageAdapter.initialize();
 
-  Backbone.Collection.prototype.syncDestroyed = function() {
-    var id, ids, model, store, storeName, url, _i, _len, _results;
-    url = result(this, 'url');
-    storeName = result(this, 'storeName');
-    store = localStorage.getItem(("" + url + "_destroyed") || (store = localStorage.getItem("" + storeName + "_destroyed")));
+Backbone.Collection.prototype.syncDirty = function() {
+  var storeName,
+    _this = this;
+  storeName = result(this, 'storeName') || result(this, 'url');
+  return Backbone.storageAdapter.getItem("" + storeName + "_dirty").then(function(store) {
+    var id, ids, model, models;
     ids = (store && store.split(',')) || [];
-    _results = [];
-    for (_i = 0, _len = ids.length; _i < _len; _i++) {
-      id = ids[_i];
-      model = new this.model({
-        id: id
-      });
-      model.collection = this;
-      _results.push(model.destroy());
+    models = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = ids.length; _i < _len; _i++) {
+        id = ids[_i];
+        _results.push(id.length === 36 ? this.findWhere({
+          id: id
+        }) : this.get(id));
+      }
+      return _results;
+    }).call(_this);
+    return $.when.apply($, (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = models.length; _i < _len; _i++) {
+        model = models[_i];
+        if (model) {
+          _results.push(model.save());
+        }
+      }
+      return _results;
+    })());
+  });
+};
+
+Backbone.Collection.prototype.syncDestroyed = function() {
+  var storeName,
+    _this = this;
+  storeName = result(this, 'storeName') || result(this, 'url');
+  return Backbone.storageAdapter.getItem("" + storeName + "_destroyed").then(function(store) {
+    var id, ids, model, models, _i, _len;
+    ids = (store && store.split(',')) || [];
+    models = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = ids.length; _i < _len; _i++) {
+        id = ids[_i];
+        _results.push(new this.model({
+          id: id
+        }));
+      }
+      return _results;
+    }).call(_this);
+    for (_i = 0, _len = models.length; _i < _len; _i++) {
+      model = models[_i];
+      model.collection = _this;
     }
-    return _results;
-  };
-
-  Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
-    this.syncDirty();
-    return this.syncDestroyed();
+    return $.when.apply($, (function() {
+      var _j, _len1, _results;
+      _results = [];
+      for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+        model = models[_j];
+        _results.push(model.destroy());
+      }
+      return _results;
+    })());
+  });
+};
+
+Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
+  var _this = this;
+  return this.syncDirty().then(function() {
+    return _this.syncDestroyed();
+  });
+};
+
+S4 = function() {
+  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+};
+
+window.Store = (function() {
+  Store.prototype.sep = '';
+
+  function Store(name) {
+    this.name = name;
+    this.dirtyName = "" + name + "_dirty";
+    this.destroyedName = "" + name + "_destroyed";
+    this.records = [];
+  }
+
+  Store.prototype.initialize = function() {
+    var _this = this;
+    return this.recordsOn(this.name).done(function(result) {
+      return _this.records = result || [];
+    });
   };
 
-  S4 = function() {
-    return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+  Store.prototype.generateId = function() {
+    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
   };
 
-  window.Store = (function() {
-    Store.prototype.sep = '';
-
-    function Store(name) {
-      this.name = name;
-      this.records = this.recordsOn(this.name);
+  Store.prototype.getStorageKey = function(model) {
+    if (_.isObject(model)) {
+      model = model.id;
     }
+    return this.name + this.sep + model;
+  };
 
-    Store.prototype.generateId = function() {
-      return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
-    };
-
-    Store.prototype.save = function() {
-      return localStorage.setItem(this.name, this.records.join(','));
-    };
+  Store.prototype.save = function() {
+    return Backbone.storageAdapter.setItem(this.name, this.records.join(','));
+  };
 
-    Store.prototype.recordsOn = function(key) {
-      var store;
-      store = localStorage.getItem(key);
+  Store.prototype.recordsOn = function(key) {
+    return Backbone.storageAdapter.getItem(key).then(function(store) {
       return (store && store.split(',')) || [];
-    };
+    });
+  };
 
-    Store.prototype.dirty = function(model) {
-      var dirtyRecords;
-      dirtyRecords = this.recordsOn(this.name + '_dirty');
+  Store.prototype.dirty = function(model) {
+    var _this = this;
+    return this.recordsOn(this.dirtyName).then(function(dirtyRecords) {
       if (!_.include(dirtyRecords, model.id.toString())) {
-        dirtyRecords.push(model.id);
-        localStorage.setItem(this.name + '_dirty', dirtyRecords.join(','));
+        dirtyRecords.push(model.id.toString());
+        return Backbone.storageAdapter.setItem(_this.dirtyName, dirtyRecords.join(',')).then(function() {
+          return model;
+        });
       }
       return model;
-    };
+    });
+  };
 
-    Store.prototype.clean = function(model, from) {
-      var dirtyRecords, store;
-      store = "" + this.name + "_" + from;
-      dirtyRecords = this.recordsOn(store);
+  Store.prototype.clean = function(model, from) {
+    var store,
+      _this = this;
+    store = "" + this.name + "_" + from;
+    return this.recordsOn(store).then(function(dirtyRecords) {
       if (_.include(dirtyRecords, model.id.toString())) {
-        localStorage.setItem(store, _.without(dirtyRecords, model.id.toString()).join(','));
+        return Backbone.storageAdapter.setItem(store, _.without(dirtyRecords, model.id.toString()).join(',')).then(function() {
+          return model;
+        });
       }
       return model;
-    };
+    });
+  };
 
-    Store.prototype.destroyed = function(model) {
-      var destroyedRecords;
-      destroyedRecords = this.recordsOn(this.name + '_destroyed');
+  Store.prototype.destroyed = function(model) {
+    var _this = this;
+    return this.recordsOn(this.destroyedName).then(function(destroyedRecords) {
       if (!_.include(destroyedRecords, model.id.toString())) {
-        destroyedRecords.push(model.id);
-        localStorage.setItem(this.name + '_destroyed', destroyedRecords.join(','));
+        destroyedRecords.push(model.id.toString());
+        Backbone.storageAdapter.setItem(_this.destroyedName, destroyedRecords.join(',')).then(function() {
+          return model;
+        });
       }
       return model;
-    };
+    });
+  };
 
-    Store.prototype.create = function(model) {
-      if (!_.isObject(model)) {
+  Store.prototype.create = function(model) {
+    var _this = this;
+    if (!_.isObject(model)) {
+      return $.Deferred().resolve(model);
+    }
+    if (!model.id) {
+      model.id = this.generateId();
+      model.set(model.idAttribute, model.id);
+    }
+    return Backbone.storageAdapter.setItem(this.getStorageKey(model), JSON.stringify(model)).then(function() {
+      _this.records.push(model.id.toString());
+      return _this.save().then(function() {
         return model;
-      }
-      if (!model.id) {
-        model.id = this.generateId();
-        model.set(model.idAttribute, model.id);
-      }
-      localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-      this.records.push(model.id.toString());
-      this.save();
-      return model;
-    };
+      });
+    });
+  };
 
-    Store.prototype.update = function(model) {
-      localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-      if (!_.include(this.records, model.id.toString())) {
-        this.records.push(model.id.toString());
+  Store.prototype.update = function(model) {
+    var _this = this;
+    return Backbone.storageAdapter.setItem(this.getStorageKey(model), JSON.stringify(model)).then(function() {
+      if (!_.include(_this.records, model.id.toString())) {
+        _this.records.push(model.id.toString());
       }
-      this.save();
-      return model;
-    };
+      return _this.save().then(function() {
+        return model;
+      });
+    });
+  };
 
-    Store.prototype.clear = function() {
-      var id, _i, _len, _ref;
+  Store.prototype.clear = function() {
+    var id,
+      _this = this;
+    return $.when.apply($, ((function() {
+      var _i, _len, _ref, _results;
       _ref = this.records;
+      _results = [];
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         id = _ref[_i];
-        localStorage.removeItem(this.name + this.sep + id);
+        _results.push(Backbone.storageAdapter.removeItem(this.getStorageKey(id)));
       }
-      this.records = [];
-      return this.save();
-    };
+      return _results;
+    }).call(this))).then(function() {
+      _this.records = [];
+      return _this.save();
+    });
+  };
 
-    Store.prototype.hasDirtyOrDestroyed = function() {
-      return !_.isEmpty(localStorage.getItem(this.name + '_dirty')) || !_.isEmpty(localStorage.getItem(this.name + '_destroyed'));
-    };
+  Store.prototype.hasDirtyOrDestroyed = function() {
+    var _this = this;
+    return Backbone.storageAdapter.getItem(this.dirtyName).then(function(dirty) {
+      return Backbone.storageAdapter.getItem(_this.destroyedName).then(function(destroyed) {
+        return !_.isEmpty(dirty) || !_.isEmpty(destroyed);
+      });
+    });
+  };
 
-    Store.prototype.find = function(model) {
-      var modelAsJson;
-      modelAsJson = localStorage.getItem(this.name + this.sep + model.id);
+  Store.prototype.find = function(model) {
+    return Backbone.storageAdapter.getItem(this.getStorageKey(model)).then(function(modelAsJson) {
       if (modelAsJson === null) {
         return null;
       }
       return JSON.parse(modelAsJson);
-    };
+    });
+  };
 
-    Store.prototype.findAll = function() {
-      var id, _i, _len, _ref, _results;
+  Store.prototype.findAll = function() {
+    var id;
+    return $.when.apply($, ((function() {
+      var _i, _len, _ref, _results;
       _ref = this.records;
       _results = [];
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         id = _ref[_i];
-        _results.push(JSON.parse(localStorage.getItem(this.name + this.sep + id)));
+        _results.push(Backbone.storageAdapter.getItem(this.getStorageKey(id)));
+      }
+      return _results;
+    }).call(this))).then(function() {
+      var model, models, _i, _len, _results;
+      models = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      _results = [];
+      for (_i = 0, _len = models.length; _i < _len; _i++) {
+        model = models[_i];
+        _results.push(JSON.parse(model));
       }
       return _results;
-    };
+    });
+  };
 
-    Store.prototype.destroy = function(model) {
-      localStorage.removeItem(this.name + this.sep + model.id);
-      this.records = _.reject(this.records, function(record_id) {
-        return record_id === model.id.toString();
+  Store.prototype.destroy = function(model) {
+    var _this = this;
+    return Backbone.storageAdapter.removeItem(this.getStorageKey(model)).then(function() {
+      _this.records = _.without(_this.records, model.id.toString());
+      return _this.save().then(function() {
+        return model;
       });
-      this.save();
-      return model;
-    };
+    });
+  };
 
-    return Store;
+  return Store;
 
-  })();
+})();
 
-  callbackTranslator = {
-    needsTranslation: Backbone.VERSION === '0.9.10',
-    forBackboneCaller: function(callback) {
-      if (this.needsTranslation) {
-        return function(model, resp, options) {
-          return callback.call(null, resp);
-        };
-      } else {
-        return callback;
-      }
-    },
-    forDualstorageCaller: function(callback, model, options) {
-      if (this.needsTranslation) {
-        return function(resp) {
-          return callback.call(null, model, resp, options);
-        };
-      } else {
-        return callback;
-      }
+callbackTranslator = {
+  needsTranslation: Backbone.VERSION === '0.9.10',
+  forBackboneCaller: function(callback) {
+    if (this.needsTranslation) {
+      return function(model, resp, options) {
+        return callback.call(null, resp);
+      };
+    } else {
+      return callback;
     }
-  };
-
-  localsync = function(method, model, options) {
-    var isValidModel, preExisting, response, store;
-    isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
-    isValidModel || (isValidModel = model instanceof Backbone.Model);
-    isValidModel || (isValidModel = model instanceof Backbone.Collection);
-    if (!isValidModel) {
-      throw new Error('model parameter is required to be a backbone model or collection.');
+  },
+  forDualstorageCaller: function(callback, model, options) {
+    if (this.needsTranslation) {
+      return function(resp) {
+        return callback.call(null, model, resp, options);
+      };
+    } else {
+      return callback;
     }
-    store = new Store(options.storeName);
-    response = (function() {
+  }
+};
+
+localSync = function(method, model, options) {
+  var isValidModel, store,
+    _this = this;
+  isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
+  isValidModel || (isValidModel = model instanceof Backbone.Model);
+  isValidModel || (isValidModel = model instanceof Backbone.Collection);
+  if (!isValidModel) {
+    throw new Error('model parameter is required to be a backbone model or collection.');
+  }
+  store = new Store(options.storeName);
+  return store.initialize().then(function() {
+    var promise;
+    promise = (function() {
       switch (method) {
         case 'read':
           if (model.id) {
@@ -223,208 +319,250 @@ as that.
         case 'clear':
           return store.clear();
         case 'create':
-          if (!(options.add && !options.merge && (preExisting = store.find(model)))) {
-            model = store.create(model);
-            if (options.dirty) {
-              store.dirty(model);
+          return store.find(model).then(function(preExisting) {
+            if (!(options.add && !options.merge && preExisting)) {
+              return store.create(model).then(function(model) {
+                if (options.dirty) {
+                  return store.dirty(model).then(function() {
+                    return model;
+                  });
+                }
+                return model;
+              });
+            } else {
+              return preExisting;
             }
-            return model;
-          } else {
-            return preExisting;
-          }
-          break;
+          });
         case 'update':
-          store.update(model);
-          if (options.dirty) {
-            return store.dirty(model);
-          } else {
-            return store.clean(model, 'dirty');
-          }
-          break;
-        case 'delete':
-          store.destroy(model);
-          if (options.dirty) {
-            return store.destroyed(model);
-          } else {
-            if (model.id.toString().length === 36) {
+          return store.update(model).then(function(model) {
+            if (options.dirty) {
+              return store.dirty(model);
+            } else {
               return store.clean(model, 'dirty');
+            }
+          });
+        case 'delete':
+          return store.destroy(model).then(function() {
+            if (options.dirty) {
+              return store.destroyed(model);
             } else {
-              return store.clean(model, 'destroyed');
+              if (model.id.toString().length === 36) {
+                return store.clean(model, 'dirty');
+              } else {
+                return store.clean(model, 'destroyed');
+              }
             }
-          }
+          });
       }
     })();
-    if (response != null ? response.attributes : void 0) {
-      response = response.attributes;
-    }
-    if (!options.ignoreCallbacks) {
-      if (response) {
-        options.success(response);
-      } else {
-        options.error('Record not found');
+    return promise.then(function(response) {
+      if (response != null ? response.attributes : void 0) {
+        response = response.attributes;
+      }
+      if (!options.ignoreCallbacks) {
+        if (response) {
+          options.success(response);
+        } else {
+          options.error('Record not found');
+        }
       }
-    }
-    return response;
-  };
-
-  result = function(object, property) {
-    var value;
-    if (!object) {
-      return null;
-    }
-    value = object[property];
-    if (_.isFunction(value)) {
-      return value.call(object);
-    } else {
-      return value;
-    }
-  };
-
-  parseRemoteResponse = function(object, response) {
-    if (!(object && object.parseBeforeLocalSave)) {
       return response;
-    }
-    if (_.isFunction(object.parseBeforeLocalSave)) {
-      return object.parseBeforeLocalSave(response);
-    }
-  };
-
-  modelUpdatedWithResponse = function(model, response) {
-    var modelClone;
-    modelClone = new Backbone.Model;
-    modelClone.idAttribute = model.idAttribute;
-    modelClone.set(model.attributes);
-    modelClone.set(modelClone.parse(response));
-    return modelClone;
-  };
-
-  backboneSync = Backbone.sync;
-
-  onlineSync = function(method, model, options) {
-    options.success = callbackTranslator.forBackboneCaller(options.success);
-    options.error = callbackTranslator.forBackboneCaller(options.error);
-    return backboneSync(method, model, options);
-  };
-
-  dualsync = function(method, model, options) {
-    var error, local, success, temporaryId;
-    options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') || result(model.collection, 'url') || result(model, 'urlRoot') || result(model, 'url');
-    options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
-    options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
-    if (result(model, 'remote') || result(model.collection, 'remote')) {
-      return onlineSync(method, model, options);
-    }
-    local = result(model, 'local') || result(model.collection, 'local');
-    options.dirty = options.remote === false && !local;
-    if (options.remote === false || local) {
-      return localsync(method, model, options);
-    }
-    options.ignoreCallbacks = true;
-    success = options.success;
-    error = options.error;
-    switch (method) {
-      case 'read':
-        if (localsync('hasDirtyOrDestroyed', model, options)) {
-          return success(localsync(method, model, options));
+    });
+  });
+};
+
+result = function(object, property) {
+  var value;
+  if (!object) {
+    return null;
+  }
+  value = object[property];
+  if (_.isFunction(value)) {
+    return value.call(object);
+  } else {
+    return value;
+  }
+};
+
+parseRemoteResponse = function(object, response) {
+  if (!(object && object.parseBeforeLocalSave)) {
+    return response;
+  }
+  if (_.isFunction(object.parseBeforeLocalSave)) {
+    return object.parseBeforeLocalSave(response);
+  }
+};
+
+modelUpdatedWithResponse = function(model, response) {
+  var modelClone;
+  modelClone = new Backbone.Model;
+  modelClone.idAttribute = model.idAttribute;
+  modelClone.set(model.attributes);
+  modelClone.set(modelClone.parse(response));
+  return modelClone;
+};
+
+backboneSync = Backbone.sync;
+
+onlineSync = function(method, model, options) {
+  options.success = callbackTranslator.forBackboneCaller(options.success);
+  options.error = callbackTranslator.forBackboneCaller(options.error);
+  return backboneSync(method, model, options);
+};
+
+dualSync = function(method, model, options) {
+  var error, local, success, temporaryId;
+  options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') || result(model.collection, 'url') || result(model, 'urlRoot') || result(model, 'url');
+  options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
+  options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
+  if (result(model, 'remote') || result(model.collection, 'remote')) {
+    return onlineSync(method, model, options);
+  }
+  local = result(model, 'local') || result(model.collection, 'local');
+  options.dirty = options.remote === false && !local;
+  if (options.remote === false || local) {
+    return localSync(method, model, options);
+  }
+  options.ignoreCallbacks = true;
+  success = options.success;
+  error = options.error;
+  switch (method) {
+    case 'read':
+      return localSync('hasDirtyOrDestroyed', model, options).then(function(hasDirtyOrDestroyed) {
+        if (hasDirtyOrDestroyed) {
+          return localSync(method, model, options).then(function(response) {
+            return success(response);
+          });
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, _i, _len;
+            var go;
             resp = parseRemoteResponse(model, resp);
-            if (!options.add) {
-              localsync('clear', model, options);
-            }
-            if (_.isArray(resp)) {
-              collection = model;
-              idAttribute = collection.model.prototype.idAttribute;
-              for (_i = 0, _len = resp.length; _i < _len; _i++) {
-                modelAttributes = resp[_i];
-                model = collection.get(modelAttributes[idAttribute]);
-                if (model) {
-                  responseModel = modelUpdatedWithResponse(model, modelAttributes);
-                } else {
-                  responseModel = new collection.model(modelAttributes);
+            go = function() {
+              var collection, idAttribute, m, modelAttributes, models, responseModel, _i, _len;
+              if (_.isArray(resp)) {
+                collection = model;
+                idAttribute = collection.model.prototype.idAttribute;
+                models = [];
+                for (_i = 0, _len = resp.length; _i < _len; _i++) {
+                  modelAttributes = resp[_i];
+                  model = collection.get(modelAttributes[idAttribute]);
+                  if (model) {
+                    responseModel = modelUpdatedWithResponse(model, modelAttributes);
+                  } else {
+                    responseModel = new collection.model(modelAttributes);
+                  }
+                  models.push(responseModel);
                 }
-                localsync('create', responseModel, options);
+                return $.when.apply($, ((function() {
+                  var _j, _len1, _results;
+                  _results = [];
+                  for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+                    m = models[_j];
+                    _results.push(localSync('create', m, options));
+                  }
+                  return _results;
+                })())).then(function() {
+                  return success(resp, status, xhr);
+                });
+              } else {
+                responseModel = modelUpdatedWithResponse(model, resp);
+                return localSync('create', responseModel, options).then(function() {
+                  return success(resp, status, xhr);
+                });
               }
+            };
+            if (!options.add) {
+              return localSync('clear', model, options).then(go);
             } else {
-              responseModel = modelUpdatedWithResponse(model, resp);
-              localsync('create', responseModel, options);
+              return go();
             }
-            return success(resp, status, xhr);
           };
           options.error = function(resp) {
-            return success(localsync(method, model, options));
+            return localSync(method, model, options).then(function(result) {
+              return success(result);
+            });
           };
           return onlineSync(method, model, options);
         }
-        break;
-      case 'create':
+      });
+    case 'create':
+      options.success = function(resp, status, xhr) {
+        var updatedModel;
+        updatedModel = modelUpdatedWithResponse(model, resp);
+        return localSync(method, updatedModel, options).then(function() {
+          return success(resp, status, xhr);
+        });
+      };
+      options.error = function(resp) {
+        options.dirty = true;
+        return localSync(method, model, options).then(function(result) {
+          return success(result);
+        });
+      };
+      return onlineSync(method, model, options);
+    case 'update':
+      if (_.isString(model.id) && model.id.length === 36) {
+        temporaryId = model.id;
         options.success = function(resp, status, xhr) {
           var updatedModel;
           updatedModel = modelUpdatedWithResponse(model, resp);
-          localsync(method, updatedModel, options);
-          return success(resp, status, xhr);
+          model.set(model.idAttribute, temporaryId, {
+            silent: true
+          });
+          return localSync('delete', model, options).then(function() {
+            return localSync('create', updatedModel, options).then(function() {
+              return success(resp, status, xhr);
+            });
+          });
         };
         options.error = function(resp) {
           options.dirty = true;
-          return success(localsync(method, model, options));
-        };
-        return onlineSync(method, model, options);
-      case 'update':
-        if (_.isString(model.id) && model.id.length === 36) {
-          temporaryId = model.id;
-          options.success = function(resp, status, xhr) {
-            var updatedModel;
-            updatedModel = modelUpdatedWithResponse(model, resp);
-            model.set(model.idAttribute, temporaryId, {
-              silent: true
-            });
-            localsync('delete', model, options);
-            localsync('create', updatedModel, options);
-            return success(resp, status, xhr);
-          };
-          options.error = function(resp) {
-            options.dirty = true;
-            model.set(model.idAttribute, temporaryId, {
-              silent: true
-            });
-            return success(localsync(method, model, options));
-          };
-          model.set(model.idAttribute, null, {
+          model.set(model.idAttribute, temporaryId, {
             silent: true
           });
-          return onlineSync('create', model, options);
-        } else {
-          options.success = function(resp, status, xhr) {
-            var updatedModel;
-            updatedModel = modelUpdatedWithResponse(model, resp);
-            localsync(method, updatedModel, options);
+          return localSync(method, model, options).then(function(result) {
+            return success(result);
+          });
+        };
+        model.set(model.idAttribute, null, {
+          silent: true
+        });
+        return onlineSync('create', model, options);
+      } else {
+        options.success = function(resp, status, xhr) {
+          var updatedModel;
+          updatedModel = modelUpdatedWithResponse(model, resp);
+          return localSync(method, updatedModel, options).then(function() {
             return success(resp, status, xhr);
-          };
-          options.error = function(resp) {
-            options.dirty = true;
-            return success(localsync(method, model, options));
-          };
-          return onlineSync(method, model, options);
-        }
-        break;
-      case 'delete':
-        if (_.isString(model.id) && model.id.length === 36) {
-          return localsync(method, model, options);
-        } else {
-          options.success = function(resp, status, xhr) {
-            localsync(method, model, options);
+          });
+        };
+        options.error = function(resp) {
+          options.dirty = true;
+          return localSync(method, model, options).then(function(result) {
+            return success;
+          });
+        };
+        return onlineSync(method, model, options);
+      }
+      break;
+    case 'delete':
+      if (_.isString(model.id) && model.id.length === 36) {
+        return localSync(method, model, options);
+      } else {
+        options.success = function(resp, status, xhr) {
+          return localSync(method, model, options).then(function() {
             return success(resp, status, xhr);
-          };
-          options.error = function(resp) {
-            options.dirty = true;
-            return success(localsync(method, model, options));
-          };
-          return onlineSync(method, model, options);
-        }
-    }
-  };
-
-  Backbone.sync = dualsync;
+          });
+        };
+        options.error = function(resp) {
+          options.dirty = true;
+          return localSync(method, model, options).then(function(result) {
+            return success(result);
+          });
+        };
+        return onlineSync(method, model, options);
+      }
+  }
+};
 
-}).call(this);
+Backbone.sync = dualSync;
diff --git a/lib/chai b/lib/chai
new file mode 160000
index 0000000..4b51ea7
--- /dev/null
+++ b/lib/chai
@@ -0,0 +1 @@
+Subproject commit 4b51ea75484eae9225a4330d267f5e231f208ed0
diff --git a/lib/lawnchair b/lib/lawnchair
new file mode 160000
index 0000000..f9d2836
--- /dev/null
+++ b/lib/lawnchair
@@ -0,0 +1 @@
+Subproject commit f9d28360a923aa3c2d1e7a313721b34ebfd60d33
diff --git a/lib/mocha b/lib/mocha
new file mode 160000
index 0000000..ffaa38d
--- /dev/null
+++ b/lib/mocha
@@ -0,0 +1 @@
+Subproject commit ffaa38d49d10d4a5efd8e8b67db2960c4731cdc3
diff --git a/lib/sticky-2.9.js b/lib/sticky-2.9.js
new file mode 100644
index 0000000..ccc46aa
--- /dev/null
+++ b/lib/sticky-2.9.js
@@ -0,0 +1,1023 @@
+/**
+ * Sticky
+ *
+ * Version 2.9
+ * Copyright 2011 Alexander C. Mingoia
+ * MIT Licensed
+ *
+ * Sticky is a simple, key/value pair browser-storage cache leveraging the latest HTML5 storage API's.
+ * Sticky persists in your preferred order to one of indexedDB, webSQL, localStorage, globalStorage, or cookies.
+ *
+ * IndexedDB
+ *     IE 10+, FireFox 4+, and Chrome 11+
+ * WebSQL (SQLite)
+ *     Chrome 4+, Opera 10.5+, Safari 3.1+, and Android Browser 2.1+
+ *     5MB of data per DB, but can request more
+ * localStorage
+ *     Safari 4+, Mobile Safari (iPhone/iPad), Firefox 3.5+, Internet Explorer 8+ and Chrome 4+
+ *     5MB of data per domain
+ * globalStorage
+ *     FireFox 2-3
+ * Cookies
+ *     4KB+ depending on character encoding and implementation.
+ *
+ * For more compatibility information, see: http://caniuse.com/
+ */
+
+
+/**
+ * Constructor
+ *
+ * @param {Map} options Options:
+ *    var options = {
+ *      name: 'Sticky', // Store name. Used to keep multiple stores.
+ *      adapters: ['localStorage', 'indexedDB', 'webSQL', 'cookie'], // Storage adapters to use
+ *      expires: (24*60*60*1000), // Cookie expiration in milliseconds
+ *      ready: function() {}, // Fires after asynchronous connection to db is complete
+ *      size: 10 // WebSQL database size in megabytes
+ *    };
+ *
+ *  @return {StickyStore} Returns an instantiated store object.
+ */
+
+function StickyStore(options) {
+  var store = this;
+
+  // Default options
+  var defaults = {
+    name: 'Sticky',
+    adapters: ['localStorage', 'indexedDB', 'webSQL', 'cookie'],
+    expires: (24*60*60*1000),
+    size: 5
+  };
+
+  // Populate missing options with defaults
+  if (options) {
+    for (var key in defaults) {
+      if (!options[key]) {
+        options[key] = defaults[key];
+      }
+    }
+  }
+  else {
+    options = defaults;
+  }
+
+  store.options = options;
+
+  // Register ready callback
+  if (options.ready) {
+    if (typeof options.ready !== 'function') {
+      throw new Error('options.ready callback must be a function');
+    }
+    store.on('ready', options.ready);
+  }
+
+  // Sanitize name
+  if (options.name) {
+    var regexp = new RegExp('/\W/', 'i');
+    if (regexp.test(options.name)) {
+      throw new Error('options.name can only contain A-z, 0-9, and underscores.');
+    }
+  }
+
+  /**
+   * Callback for adapter initialization methods.
+   * Executes next preferred adapter's initialization method,
+   * adding successfully initialized adapters to the
+   * `StickyStore._adaptersReady` array.
+   *
+   * @param String adapter
+   */
+  var isReady = (function(adapter, ready) {
+    var adapterOptsIdx;
+    for (var i=0; i<this.options.adapters.length; i++) {
+      if (this.options.adapters[i] === adapter) {
+        adapterOptsIdx = i + 1;
+      }
+    }
+    if (ready) {
+      this.adapters[adapter].index = (this.connected.push(adapter) - 1);
+      if (this.connected.length === 1) {
+        this.trigger('ready', this);
+      }
+    }
+    if (adapterOptsIdx && this.adapters[this.options.adapters[adapterOptsIdx]]) {
+      this.adapters[this.options.adapters[adapterOptsIdx]].init.call(this, isReady);
+    }
+  });
+
+  // Initialize adapters
+  store.connected = [];
+  store.adapters[options.adapters[0]].init.call(store, isReady);
+};
+
+
+/**
+ * Subscribe to an event
+ *
+ * @param String event
+ * @param Function fn
+ */
+
+StickyStore.prototype.on = (function(event, fn) {
+  this.events = this.events || {};
+  if (this.events[event]) {
+    this.events[event].push(fn);
+  }
+  else {
+    this.events[event] = [fn];
+  }
+});
+
+
+/**
+ * Trigger an event
+ *
+ * Any arguments passed after `event` are
+ * passed to functions bound to the event.
+ *
+ * @param String event
+ * @param Mixed args
+ */
+
+StickyStore.prototype.trigger = (function(event, args) {
+  args = Array.prototype.slice.call(arguments, 1);
+  if (this.events && this.events[event]) {
+    for (var i=0; i<this.events[event].length; i++) {
+      this.events[event][i].apply(this, args);
+    }
+  }
+});
+
+
+/**
+ * Exec
+ *
+ * Executes an adapter operation (get/set/remove/removeAll).
+ *
+ * @param String op
+ * @param String key
+ * @param Mixed callback
+ * @param String adapter
+ *
+ * @return Mixed
+ */
+
+StickyStore.prototype.exec = (function(op, key, item, callback, adapter) {
+  var store = this;
+  var nextAdapter;
+  var asyncHandler;
+
+  if (typeof callback === 'string') {
+    adapter = callback;
+    callback = null;
+  }
+
+  if (typeof adapter === 'undefined') {
+    adapter = store.connected[0];
+  }
+
+  if (typeof store.adapters[adapter].index === 'number') {
+    nextAdapter = store.connected[store.adapters[adapter].index + 1];
+  }
+
+  var async = (adapter === 'indexedDB' || adapter === 'webSQL') ? true : false;
+  var args = (op === 'set') ? [key, item] : [key];
+
+  if (async === true) {
+    // This handles the callback for asynchronous
+    // adapters, and determines if trying the next
+    // preferred adapter is necessary.
+    asyncHandler = function(result) {
+      if (result === false && typeof nextAdapter === 'string') {
+        args.splice(-1, 1);
+        args.push(callback, nextAdapter);
+        return store[op].apply(store, args);
+      }
+      callback && callback.call(store, result);
+      store.trigger(op, key, result);
+    };
+    args.push(asyncHandler);
+  }
+
+  var result;
+  if (typeof store.adapters[adapter].io !== 'undefined') {
+    if (async) {
+      return store.adapters[adapter][op].apply(store, args);
+    }
+    result = store.adapters[adapter][op].apply(store, args);
+  }
+  if (result === false && typeof nextAdapter === 'string') {
+    args.push(callback, nextAdapter);
+    return store[op].apply(store, args);
+  }
+  store.trigger(op, key, result);
+  callback && callback.call(store, result);
+  return result;
+});
+
+
+/**
+ * Get
+ *
+ * @param String/Array key Key or array of keys for retrieval
+ * @param Function callback Optional. Called after async operations are completed
+ * with the stored item or false as the first argument.
+ * @param String adapter The adapter to use.
+ *
+ * @return Mixed Returns value stored or false.
+ */
+
+StickyStore.prototype.get = (function(key, callback, adapter) {
+  if (key.constructor === Array) {
+    var asyncHandler;
+    var keys = key;
+    if (callback) {
+      var store = this;
+      var asyncResults = [];
+      asyncHandler = function(result) {
+        asyncResults.push(result);
+        if (asyncResults.length === keys.length) {
+          callback.call(store, asyncResults);
+          store.trigger('get', keys);
+        }
+      };
+    }
+    var results = [];
+    for (var i=0; i<keys.length; i++) {
+      results.push(this.exec.call(this, 'get', keys[i], null, asyncHandler, adapter));
+    }
+    return results;
+  }
+  return this.exec.call(this, 'get', key, null, callback, adapter);
+});
+
+
+/**
+ * Set
+ *
+ * @param String/Array key Key or array of keys for retrieval
+ * @param Mixed/Array item Item or array of items to store
+ * @param Function callback Optional. Called after async operations are completed
+ * with the stored item or false as the first argument.
+ * @param String adapter The adapter to use.
+ *
+ * @return Mixed Returns value stored or false if attempt to store failed.
+ */
+
+StickyStore.prototype.set = (function(key, item, callback, adapter) {
+  if (item === undefined || item === null) return false;
+  if (key.constructor === Array && item.constructor === Array) {
+    var asyncHandler;
+    var keys = key;
+    var items = item;
+    if (callback) {
+      var store = this;
+      var asyncResults = [];
+      asyncHandler = function(result) {
+        asyncResults.push(result);
+        if (asyncResults.length === keys.length) {
+          callback.call(store, asyncResults);
+          store.trigger('set', keys, results);
+        }
+      };
+    }
+    var results = [];
+    for (var i=0; i<keys.length; i++) {
+      results.push(this.exec.call(this, 'set', keys[i], items[i], asyncHandler, adapter));
+    }
+    return results;
+  }
+  return this.exec.call(this, 'set', key, item, callback, adapter);
+});
+
+
+/**
+ * Remove
+ *
+ * @param String key
+ * @param Function callback Optional. Executed after async operations are complete
+ * Callback's first argument is a bolean of whether the operation was successful or not.
+ * @param String adapter The adapter to use.
+ *
+ * @param Bolean
+ */
+
+StickyStore.prototype.remove = (function(key, callback, adapter) {
+  var asyncHandler;
+  if (typeof callback === 'string') {
+    adapter = callback;
+    callback = null;
+  }
+  var adapters = (adapter) ? [adapter] : this.connected;
+  if (callback) {
+    var store = this;
+    var results = 0;
+    asyncHandler = function(result) {
+      results++;
+      if (results === adapters.length) {
+        callback.call(store, true);
+        store.trigger('remove', key);
+      }
+    };
+  }
+  if (adapters.length > 1) {
+    for (var i=0; i<adapters.length; i++) {
+      if (adapters[i] === adapter) {
+        asyncHandler.call(this, true);
+      }
+      else {
+        this.adapters[adapters[i]].remove.call(this, key, asyncHandler);
+      }
+    }
+    return this.exec.call(this, 'remove', key, null, null, adapter);
+  }
+  else {
+    return this.exec.call(this, 'remove', key, null, callback, adapter);
+  }
+});
+
+
+/**
+ * Remove All
+ *
+ * @param Function callback
+ * @param String adapter
+ *
+ * Removes all values in this store from all storage mechanisms
+ */
+
+StickyStore.prototype.removeAll = (function(callback, adapter) {
+  var asyncHandler;
+  if (typeof callback === 'string') {
+    adapter = callback;
+    callback = null;
+  }
+  var adapters = (adapter) ? [adapter] : this.connected;
+  if (callback) {
+    var store = this;
+    var results = 0;
+    asyncHandler = function(result) {
+      results++;
+      if (results === adapters.length) {
+        callback.call(store, true);
+        store.trigger('removeAll');
+      }
+    };
+  }
+  for (var i=0; i<adapters.length; i++) {
+    this.adapters[adapters[i]].removeAll.call(this, asyncHandler);
+  }
+});
+
+
+/**
+ * Adapters
+ */
+
+StickyStore.prototype.adapters = {'indexedDB':{}, 'webSQL':{}, 'localStorage':{}, 'cookie':{}};
+
+
+/**
+ * IndexedDB: Initialize
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.indexedDB.init = (function(callback) {
+  var store = this;
+
+  if (window) {
+      StickyStore.prototype.IndexedDB = window.indexedDB || window.webkitIndexedDB || window.mozIndexedDB || window.msIndexedDB;
+  }
+
+  // Method to create objectStore
+  var createObjectStore = function(event) {
+    // FF is event.target.result, Chrome is event.target.result.db
+    if (!store.adapters.indexedDB.io && event.target.result) {
+      store.adapters.indexedDB.io = (event.target.result.db) ? event.target.result.db : event.target.result
+    }
+    if (!store.adapters.indexedDB.io.objectStoreNames.contains(store.options.name)) {
+      store.adapters.indexedDB.io.createObjectStore(store.options.name, {keyPath: 'key'});
+    }
+  };
+
+  if (StickyStore.prototype.IndexedDB) {
+    // Request to open database
+    var request = StickyStore.prototype.IndexedDB.open(store.options.name, 20);
+
+    request.onsuccess = function(event) {
+      // FF is event.target.result, Chrome is event.target.result.db
+      if (!store.adapters.indexedDB.io && event.target.result) {
+        store.adapters.indexedDB.io = (event.target.result.db) ? event.target.result.db : event.target.result
+      }
+      // Backwards compatibility for older indexedDB implementations before
+      // IDBDatabase.setVersion() was removed.
+      if (event.target.result.setVersion && event.target.result.version !== '2.0') {
+        var request = store.adapters.indexedDB.io.setVersion('2.0');
+        request.onsuccess = createObjectStore;
+        request.onerror = function(event) {
+          callback && callback.call(store, 'indexedDB', false);
+          store.trigger('error', "Couldn't change indexedDB version (Code " + request.errorCode + ")");
+        };
+      }
+      else {
+        callback && callback.call(store, 'indexedDB', true);
+      }
+    };
+
+    request.onupgradeneeded = createObjectStore;
+
+    request.onerror = function(event) {
+      callback && callback.call(store, 'indexedDB', false);
+      store.trigger('error', "Couldn't open indexedDB (Code " + request.errorCode + ")");
+    };
+  }
+  else {
+    callback && callback.call(store, 'indexedDB', false);
+  }
+});
+
+
+/**
+ * IndexedDB: Get
+ *
+ * @param String key
+ * @param Mixed callback The callbacks first argument is the item or
+ * false depending on the operation's success.
+ */
+
+StickyStore.prototype.adapters.indexedDB.get = (function(key, callback) {
+  var store = this;
+  var tx = store.adapters.indexedDB.io.transaction([store.options.name], "readonly");
+  var objStore = tx.objectStore(store.options.name);
+  var request = objStore.get(key);
+  request.onsuccess = function(event) {
+    if (event.target.result) {
+      callback && callback.call(store, event.target.result.data);
+    }
+    else {
+      callback && callback.call(store, false);
+    }
+  };
+  request.onerror = function(event) {
+    store.trigger('error', "Couldn't get item from indexedDB objectStore (Code " + request.errorCode + ")");
+    callback && callback.call(store, false);
+  };
+});
+
+
+/**
+ * IndexedDB: Set
+ *
+ * @param String key
+ * @param Mixed value
+ * @param Function callback Optional. Called after async operations are completed
+ * with false as the first argument if operation failed or the item stored if successful.
+ *
+ * @return Mixed Returns item to be stored.
+ */
+
+StickyStore.prototype.adapters.indexedDB.set = (function(key, item, callback) {
+  var store = this;
+  var tx = store.adapters.indexedDB.io.transaction([store.options.name], "readwrite");
+  var objStore = tx.objectStore(store.options.name);
+  var request = objStore.put({'key': key, 'data': item});
+  request.onsuccess = function(e) {
+    callback && callback.call(store, item);
+  };
+  request.onerror = function(e) {
+    store.trigger('error', 'Failed to store item in indexedDB (Code: ' + e.target.errorCode + ')', item);
+    callback && callback.call(store, false);
+  };
+  return item;
+});
+
+
+/**
+ * IndexedDB: Remove
+ *
+ * @param String key
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.indexedDB.remove = (function(key, callback) {
+  var store = this;
+  var tx = store.adapters.indexedDB.io.transaction([store.options.name], "readwrite");
+  var request = tx.objectStore(store.options.name)['delete'](key);
+  request.onsuccess = function(e) {
+    callback && callback.call(store, true);
+  };
+  request.onerror = function(e) {
+    store.trigger('error', 'Error removing item from indexedDB', key);
+    callback && callback.call(store, false);
+  };
+});
+
+
+/**
+ * IndexedDB: Remove All
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.indexedDB.removeAll = (function(callback) {
+  var store = this;
+  var tx = store.adapters.indexedDB.io.transaction([store.options.name], "readwrite");
+  var request = tx.objectStore(store.options.name).clear();
+  request.onsuccess = function(e) {
+    callback && callback.call(store, true);
+  };
+  request.onerror = function(e) {
+    store.trigger('error', 'Error deleting indexedDB database', err);
+    callback && callback.call(store, false);
+  };
+});
+
+
+/**
+ * webSQL: Initialize
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.webSQL.init = (function(callback) {
+  var store = this;
+  try {
+    store.adapters.webSQL.io = window.openDatabase(
+      'Sticky',
+      '2.0',
+      'Sticky Offline Web Cache',
+      (store.options.size * 1024 * 1024)
+    );
+    if (store.adapters.webSQL.io) {
+      store.adapters.webSQL.io.transaction(function(tx) {
+        tx.executeSql('CREATE TABLE IF NOT EXISTS ' + store.options.name + ' (key TEXT, data TEXT)');
+        callback && callback.call(store, 'webSQL', true);
+      });
+    }
+  }
+  catch (err) {
+    callback && callback.call(store, 'webSQL', false);
+    store.trigger('error', err);
+  }
+});
+
+
+/**
+ * webSQL: Get
+ *
+ * @param String key
+ * @param Mixed callback The callbacks first argument is the item or
+ * false depending on the operation's success.
+ */
+
+StickyStore.prototype.adapters.webSQL.get = (function(key, callback) {
+  var store = this;
+  var item;
+  store.adapters.webSQL.io.transaction(function(tx) {
+    tx.executeSql(
+      'SELECT * FROM ' + store.options.name + ' WHERE key=?',
+      [key],
+      function(tx, results) {
+        if (results.rows.length === 1) {
+          var record = results.rows.item(0);
+          item = store.unserialize(record['data']);
+          callback && callback.call(store, item);
+        }
+        else {
+          callback && callback.call(store, false);
+        }
+      },
+      function(tx, error) {
+        store.trigger('error', "Couldn't get webSQL item with key: " + key, key);
+        callback && callback.call(store, false);
+      }
+    );
+  });
+});
+
+
+/**
+ * WebSQL: Set
+ *
+ * @param String key
+ * @param Mixed value
+ * @param Function callback Optional. Called after async operations are completed
+ * with false as the first argument if operation failed or the item stored if successful.
+ *
+ * @return Mixed Returns item to be stored.
+ */
+
+StickyStore.prototype.adapters.webSQL.set = (function(key, item, callback) {
+  var store = this;
+  var value = this.serialize(item);
+  var insert = function(tx, result) {
+    // If update failed then insert
+    if (result.rowsAffected === 0) {
+      tx.executeSql('INSERT INTO ' + store.options.name + ' (key, data) VALUES (?, ?)', [key, value], function(tx, result) {
+        if (result.rowsAffected === 0) {
+          store.trigger('error', 'Failed to insert webSQL item', item);
+          callback && callback.call(store, false);
+        }
+        else {
+          callback && callback.call(store, item);
+        }
+      });
+    }
+    else {
+      callback && callback.call(store, item);
+    }
+  }
+  // Update, and pass insert as callback
+  var update = function(tx) {
+    tx.executeSql('UPDATE ' + store.options.name + ' SET data=? WHERE key=?', [value, key], insert);
+  }
+  store.adapters.webSQL.io.transaction(update);
+  return item;
+});
+
+
+/**
+ * WebSQL: Remove
+ *
+ * @param String key
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.webSQL.remove = (function(key, callback) {
+  var store = this;
+  store.adapters.webSQL.io.transaction(function(tx) {
+    tx.executeSql(
+      'DELETE FROM ' + store.options.name + ' WHERE key=?',
+      [key],
+      function(tx, result) {;
+        if (result.rowsAffected === 0) {
+          callback && callback.call(store, false);
+        }
+        else {
+          callback && callback.call(store, true);
+        }
+      },
+      function(tx, error) {
+        callback && callback.call(store, false);
+        store.trigger('error', 'Failed to delete webSQL item', key);
+      }
+    );
+  });
+});
+
+
+/**
+ * WebSQL: Remove All
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.webSQL.removeAll = (function(callback) {
+  var store = this;
+  store.adapters.webSQL.io.transaction(function(tx) {
+    tx.executeSql(
+      'DELETE FROM ' + store.options.name, [],
+      function(tx, result) {;
+        if (result.rowsAffected === 0) {
+          callback && callback.call(store, false);
+        }
+        else {
+          callback && callback.call(store, true);
+        }
+      },
+      function(tx, error) {
+        callback && callback.call(store, false);
+        store.trigger('error', 'Failed to remove all webSQL items', error.message);
+      }
+    );
+  });
+});
+
+
+/**
+ * localStorage: Initialize
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.localStorage.init = (function(callback) {
+  if (window.localStorage) {
+    this.adapters.localStorage.io = localStorage;
+    callback && callback.call(this, 'localStorage', true);
+  }
+  else if (window.globalStorage) {
+    this.adapters.localStorage.io = globalStorage[this.options.domain];
+    callback && callback.call(this, 'localStorage', true);
+  }
+  else {
+    callback && callback.call(this, 'localStorage', false);
+  }
+});
+
+
+/**
+ * localStorage: Get
+ *
+ * @param String key
+ * @param Mixed callback The callbacks first argument is the item or
+ * false depending on the operation's success.
+ *
+ * @return Mixed Returns item stored or false.
+ */
+
+StickyStore.prototype.adapters.localStorage.get = (function(key, callback) {
+  var item;
+
+  try {
+    item = this.unserialize(this.adapters.localStorage.io.getItem(this.options.name + '_' + key));
+  }
+  catch (err) {
+    this.trigger('error', err);
+  }
+  if (item) {
+    callback && callback.call(this, item);
+    return item;
+  }
+  else {
+    callback && callback.call(this, false);
+    return false;
+  }
+});
+
+
+/**
+ * localStorage: Set
+ *
+ * @param String key
+ * @param Mixed value
+ * @param Function callback Optional. Called after async operations are completed
+ * with false as the first argument if operation failed or the item stored if successful.
+ *
+ * @return Mixed Returns item to be stored or false.
+ */
+
+StickyStore.prototype.adapters.localStorage.set = (function(key, item, callback) {
+  var value = this.serialize(item);
+  try {
+    this.adapters.localStorage.io.setItem(this.options.name + '_' + key, value);
+    callback && callback.call(this, item);
+    return item;
+  }
+  catch (err) {
+    this.trigger('error', err, item);
+    callback && callback.call(this, false);
+    return false;
+  }
+});
+
+
+/**
+ * localStorage: Remove
+ *
+ * @param String key
+ * @param Function callback
+ *
+ * @return Bolean
+ */
+
+StickyStore.prototype.adapters.localStorage.remove = (function(key, callback) {
+  try {
+    this.adapters.localStorage.io.removeItem(this.options.name + '_' + key);
+    callback && callback.call(this, true);
+    return true;
+  }
+  catch (err) {
+    this.trigger('error', err, key);
+    callback && callback.call(this, false);
+    return false;
+  }
+});
+
+
+/**
+ * localStorage: Remove All
+ *
+ * @param Function callback
+ *
+ * @return Bolean
+ */
+
+StickyStore.prototype.adapters.localStorage.removeAll = (function(callback) {
+  // Loop through each item in localStorage and remove ones that match
+  // this store.
+  var keys = [];
+  for (var i=0; i<this.adapters.localStorage.io.length; i++) {
+    var key = this.adapters.localStorage.io.key(i);
+    if (key.indexOf(this.options.name) === 0) {
+      keys.push(key);
+    }
+  }
+  for (var i=0; i<keys.length; i++) {
+    this.adapters.localStorage.io.removeItem(keys[i]);
+  }
+  callback && callback.call(this, true);
+  return true;
+});
+
+
+/**
+ * Cookie: Initialize
+ *
+ * @param Function callback
+ */
+
+StickyStore.prototype.adapters.cookie.init = (function(callback) {
+  if (typeof document.cookie === 'string') {
+    this.adapters.cookie.io = document.cookie;
+    callback && callback.call(this, 'cookie', true);
+  }
+  else {
+    callback && callback.call(this, 'cookie', false);
+  }
+});
+
+
+/**
+ * Cookie: Get
+ *
+ * @param String key
+ * @param Mixed callback The callbacks first argument is the item or
+ * false depending on the operation's success.
+ *
+ * @return Mixed Returns the item stored or false.
+ */
+
+StickyStore.prototype.adapters.cookie.get = (function(key, callback) {
+  var item;
+  key = this.options.name + '_' + key;
+  if (key.search(/\W/i) === -1) {
+    var match = document.cookie.match((new RegExp(key +'=[a-zA-Z0-9.()=|%/]+($|;)','g')));
+    if (match && match[0]) {
+      item = unescape(match[0].substring(key.length+1,match[0].length).replace(';','')) || null;
+    }
+  }
+  else {
+    this.trigger('error', 'Key cannot contain special characters when persisting to cookies. Only A-z, 0-9, and _ are allowed.', key);
+  }
+  if (item) {
+    item = this.unserialize(decodeURIComponent(item));
+    callback && callback.call(this, item);
+    return item;
+  }
+  else {
+    callback && callback.call(this, false);
+    return false;
+  }
+});
+
+
+/**
+ * Cookie: Set
+ *
+ * @param String key
+ * @param Mixed value
+ * @param Function callback Optional. Called after async operations are completed
+ * with false as the first argument if operation failed or the item stored if successful.
+ *
+ * @return Mixed Returns item to be stored or false.
+ */
+
+StickyStore.prototype.adapters.cookie.set = (function(key, item, callback) {
+  var value = encodeURIComponent(this.serialize(item));
+  if (((value.length + key.length) - 100) > 4000) {
+    this.trigger('error', 'Serialized value too large for cookie storage', key);
+  }
+  else if (key.search(/\W/i) !== -1) {
+    this.trigger('error', 'Key cannot contain special characters when persisting to cookies. Only A-z, 0-9, and _ are allowed.', key);
+  }
+  else if (value.search(/[;,=[ ]/i) !== -1) {
+    this.trigger('error', 'Value cannot contain spaces, semi-colons, equals, or commas when persisting to cookies.', key);
+  }
+  else {
+    key = this.options.name + '_' + key;
+    var date = new Date();
+    date.setTime(date.getTime()+this.options.expires);
+    var cookie = [
+      key+'='+value,
+      'path=/',
+      'expires='+date.toGMTString()
+    ];
+    document.cookie = cookie.join('; ');
+    callback && callback.call(this, item);
+    return item;
+  }
+  callback && callback.call(this, false);
+  return false;
+});
+
+
+/**
+ * Cookie: Remove
+ *
+ * @param String key
+ * @param Function callback
+ *
+ * @return Bolean
+ */
+
+StickyStore.prototype.adapters.cookie.remove = (function(key, callback) {
+  var cookieExists = this.adapters.cookie.get.call(this, key);
+  if (cookieExists) {
+    key = this.options.name + '_' + key;
+    var cookie = [
+      key+'=',
+      'path=/',
+      'expires=Thu, 01-Jan-70 00:00:01 GMT'
+    ];
+    document.cookie = cookie.join('; ');
+    callback && callback.call(this, true);
+    return true;
+  }
+  else {
+    callback && callback.call(this, false);
+    return false;
+  }
+});
+
+
+/**
+ * Cookie: Remove All
+ *
+ * @param Function callback
+ *
+ * @return Bolean
+ */
+
+StickyStore.prototype.adapters.cookie.removeAll = (function(callback) {
+  var cookies = document.cookie.split(';');
+  for (var i=0; i<cookies.length; i++) {
+    var key = cookies[i].split('=')[0];
+    if (key.indexOf(this.options.name) === 0) {
+      this.adapters.cookie.remove.call(this, key.replace(this.options.name + '_', ''));
+    }
+  }
+  callback && callback.call(this, true);
+  return true;
+});
+
+
+/**
+ * Serialize item for storage
+ *
+ * @param {Mixed} item
+ * @return {String} returns serialized item
+ */
+
+StickyStore.prototype.serialize = (function(item) {
+  var serialized;
+  // Objects and arrays are stringified
+  if (typeof item === 'string' && item.length > 0) {
+    serialized = item;
+  }
+  else {
+    if (typeof item === 'object' || item.constructor === Array) {
+      try {
+        serialized = 'J::O' + JSON.stringify(item);
+      }
+      catch (err) {
+        store.trigger('error', err, item);
+      }
+    }
+    else {
+        serialized = item.toString();
+    }
+  }
+  return serialized;
+});
+
+
+/**
+ * Unserialize item for storage
+ *
+ * @param {String} serialized serialized item
+ * @return {Mixed} returns item
+ */
+
+StickyStore.prototype.unserialize = (function(serialized) {
+  var item;
+  if (serialized) {
+    if (serialized.substr(0, 4) === 'J::O') {
+      try {
+        item = JSON.parse(serialized.substr(4));
+      }
+      catch (err) {
+        this.trigger('error', err, serialized);
+      }
+    }
+    else if (isNaN(serialized) === false) {
+      item = Number(serialized);
+    }
+    else {
+      item = serialized;
+    }
+  }
+  return item;
+});
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index 6a72885..9ba05fc 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -1,293 +1,382 @@
 // Generated by CoffeeScript 1.6.3
-/*
-Backbone dualStorage Adapter v1.1.0
-
-A simple module to replace `Backbone.sync` with *localStorage*-based
-persistence. Models are given GUIDS, and saved into a JSON object. Simple
-as that.
-*/
-
-var S4, backboneSync, callbackTranslator, dualsync, localsync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse, result;
-
-Backbone.Collection.prototype.syncDirty = function() {
-  var id, ids, model, store, storeName, url, _i, _len, _results;
-  url = result(this, 'url');
-  storeName = result(this, 'storeName');
-  store = localStorage.getItem(("" + url + "_dirty") || localStorage.getItem("" + storeName + "_dirty"));
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    model = id.length === 36 ? this.findWhere({
-      id: id
-    }) : this.get(id);
-    _results.push(model != null ? model.save() : void 0);
+var S4, dualSync, localSync, onlineSync, updateModelWithResponse,
+  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+Backbone.storageAdapters = {};
+
+Backbone.storageAdapters.LocalStorageAdapter = (function() {
+  function LocalStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.LocalStorage';
+    this.store = localStorage;
+  }
+
+  LocalStorageAdapter.prototype.initialize = function() {
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.set = function(key, value) {
+    this.store.setItem(key, JSON.stringify(value));
+    return $.Deferred().resolve(value);
+  };
+
+  LocalStorageAdapter.prototype.get = function(key) {
+    return $.Deferred().resolve(JSON.parse(this.store.getItem(key)));
+  };
+
+  LocalStorageAdapter.prototype.remove = function(key) {
+    this.store.removeItem(key);
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.clear = function() {
+    this.store.clear();
+    return $.Deferred().resolve();
+  };
+
+  return LocalStorageAdapter;
+
+})();
+
+Backbone.storageAdapters.LawnchairStorageAdapter = (function() {
+  function LawnchairStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Lawnchair';
   }
-  return _results;
-};
 
-Backbone.Collection.prototype.syncDestroyed = function() {
-  var id, ids, model, store, storeName, url, _i, _len, _results;
-  url = result(this, 'url');
-  storeName = result(this, 'storeName');
-  store = localStorage.getItem(("" + url + "_destroyed") || (store = localStorage.getItem("" + storeName + "_destroyed")));
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    model = new this.model({
-      id: id
+  LawnchairStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new Lawnchair({
+      name: this.name,
+      adapter: ['indexed-db']
+    }, function() {
+      return promise.resolve();
     });
-    model.collection = this;
-    _results.push(model.destroy());
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.save({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.nuke(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  return LawnchairStorageAdapter;
+
+})();
+
+Backbone.storageAdapters.StickyStorageAdapter = (function() {
+  function StickyStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Sticky';
   }
-  return _results;
-};
 
-Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
-  this.syncDirty();
-  return this.syncDestroyed();
-};
+  StickyStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new StickyStore({
+      name: this.name,
+      adapters: ['indexedDB'],
+      ready: function() {
+        return promise.resolve();
+      }
+    });
+    return promise;
+  };
 
-S4 = function() {
-  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
-};
+  StickyStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.set({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.removeAll(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
 
-window.Store = (function() {
-  Store.prototype.sep = '';
+  return StickyStorageAdapter;
 
-  function Store(name) {
+})();
+
+Backbone.Store = (function() {
+  function Store(name, storage) {
     this.name = name;
-    this.records = this.recordsOn(this.name);
+    this.storage = storage;
+    this.data = {};
   }
 
   Store.prototype.generateId = function() {
     return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
   };
 
-  Store.prototype.save = function() {
-    return localStorage.setItem(this.name, this.records.join(','));
+  Store.prototype.initialize = function() {
+    var _this = this;
+    return this.storage.get(this.name).then(function(savedData) {
+      _this.data.records = (savedData != null ? savedData.records : void 0) || [];
+      _this.data.dirty = (savedData != null ? savedData.dirty : void 0) || [];
+      _this.data.destroyed = (savedData != null ? savedData.destroyed : void 0) || [];
+      _this.data.local = (savedData != null ? savedData.local : void 0) || [];
+      return _this.data.recordsById = (savedData != null ? savedData.recordsById : void 0) || {};
+    });
   };
 
-  Store.prototype.recordsOn = function(key) {
-    var store;
-    store = localStorage.getItem(key);
-    return (store && store.split(',')) || [];
+  Store.prototype.save = function() {
+    return this.storage.set(this.name, this.data);
   };
 
-  Store.prototype.dirty = function(model) {
-    var dirtyRecords;
-    dirtyRecords = this.recordsOn(this.name + '_dirty');
-    if (!_.include(dirtyRecords, model.id.toString())) {
-      dirtyRecords.push(model.id);
-      localStorage.setItem(this.name + '_dirty', dirtyRecords.join(','));
+  Store.prototype.toggleModel = function(target, model, status) {
+    var _ref, _ref1;
+    if (status && (_ref = model.id, __indexOf.call(this.data[target], _ref) < 0)) {
+      this.data[target].push(model.id);
+    } else if (!status && (_ref1 = model.id, __indexOf.call(this.data[target], _ref1) >= 0)) {
+      this.data[target] = _.without(this.data[target], model.id);
     }
-    return model;
+    return this.save().then(function() {
+      return model;
+    });
   };
 
-  Store.prototype.clean = function(model, from) {
-    var dirtyRecords, store;
-    store = "" + this.name + "_" + from;
-    dirtyRecords = this.recordsOn(store);
-    if (_.include(dirtyRecords, model.id.toString())) {
-      localStorage.setItem(store, _.without(dirtyRecords, model.id.toString()).join(','));
+  Store.prototype.isDirty = function(model, status) {
+    var _ref, _ref1;
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) < 0) {
+      throw new Error("model with id " + model.id + " is not in the store.");
     }
-    return model;
+    if (_ref1 = model.id, __indexOf.call(this.data.destroyed, _ref1) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as dirty because it is marked as destroyed.");
+    }
+    return this.toggleModel('dirty', model, status);
   };
 
-  Store.prototype.destroyed = function(model) {
-    var destroyedRecords;
-    destroyedRecords = this.recordsOn(this.name + '_destroyed');
-    if (!_.include(destroyedRecords, model.id.toString())) {
-      destroyedRecords.push(model.id);
-      localStorage.setItem(this.name + '_destroyed', destroyedRecords.join(','));
+  Store.prototype.isDestroyed = function(model, status) {
+    var _ref, _ref1;
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as destroyed because it is still in the store.");
+    }
+    if (_ref1 = model.id, __indexOf.call(this.data.dirty, _ref1) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as destroyed because it is marked as dirty.");
     }
-    return model;
+    return this.toggleModel('destroyed', model, status);
   };
 
-  Store.prototype.create = function(model) {
-    if (!_.isObject(model)) {
-      return model;
+  Store.prototype.add = function(models) {
+    var model, _i, _len, _ref;
+    if (!_.isArray(models)) {
+      models = [models];
     }
-    if (!model.id) {
-      model.id = this.generateId();
-      model.set(model.idAttribute, model.id);
+    for (_i = 0, _len = models.length; _i < _len; _i++) {
+      model = models[_i];
+      if (_ref = model.id, __indexOf.call(this.data.records, _ref) >= 0) {
+        throw new Error("model with id " + model.id + " is already in the store.");
+      }
+      if (!model.id) {
+        model.id = this.generateId();
+        model.set(model.idAttribute, model.id);
+        this.data.local.push(model.id);
+      }
+      this.data.records.push(model.id);
+      this.data.recordsById[model.id] = model.toJSON();
     }
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    this.records.push(model.id.toString());
-    this.save();
-    return model;
+    return this.save().then(function() {
+      if (models.length === 1) {
+        return models[0];
+      } else {
+        return models;
+      }
+    });
   };
 
   Store.prototype.update = function(model) {
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    if (!_.include(this.records, model.id.toString())) {
-      this.records.push(model.id.toString());
+    var _ref;
+    if (!model.id) {
+      throw new Error("model does not have an id.");
+    }
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) < 0) {
+      throw new Error("model with id " + model.id + " is not in the store, try adding instead of updating.");
     }
-    this.save();
-    return model;
+    this.data.recordsById[model.id] = model.toJSON();
+    return this.save().then(function() {
+      return model;
+    });
+  };
+
+  Store.prototype.remove = function(model) {
+    delete this.data.recordsById[model.id];
+    this.data.dirty = _.without(this.data.dirty, model.id);
+    this.data.local = _.without(this.data.local, model.id);
+    this.data.records = _.without(this.data.records, model.id);
+    return this.save().then(function() {
+      return model;
+    });
   };
 
   Store.prototype.clear = function() {
-    var id, _i, _len, _ref;
-    _ref = this.records;
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      localStorage.removeItem(this.name + this.sep + id);
-    }
-    this.records = [];
+    this.data = {};
     return this.save();
   };
 
-  Store.prototype.hasDirtyOrDestroyed = function() {
-    return !_.isEmpty(localStorage.getItem(this.name + '_dirty')) || !_.isEmpty(localStorage.getItem(this.name + '_destroyed'));
+  Store.prototype.find = function(id) {
+    var model, _ref, _results;
+    if (id) {
+      return this.data.recordsById[id];
+    } else {
+      _ref = this.data.recordsById;
+      _results = [];
+      for (id in _ref) {
+        model = _ref[id];
+        _results.push(model);
+      }
+      return _results;
+    }
   };
 
-  Store.prototype.find = function(model) {
-    var modelAsJson;
-    modelAsJson = localStorage.getItem(this.name + this.sep + model.id);
-    if (modelAsJson === null) {
-      return null;
+  Store.prototype.findDirty = function(id) {
+    var _i, _len, _ref, _results;
+    if (id) {
+      if (__indexOf.call(this.data.dirty, id) >= 0) {
+        return this.data.recordsById[id];
+      }
+    } else {
+      _ref = this.data.dirty;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        id = _ref[_i];
+        _results.push(this.data.recordsById[id]);
+      }
+      return _results;
     }
-    return JSON.parse(modelAsJson);
   };
 
-  Store.prototype.findAll = function() {
-    var id, _i, _len, _ref, _results;
-    _ref = this.records;
-    _results = [];
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      _results.push(JSON.parse(localStorage.getItem(this.name + this.sep + id)));
+  Store.prototype.findDestroyed = function(id) {
+    if (id) {
+      return __indexOf.call(this.data.destroyed, id) >= 0;
+    } else {
+      return this.data.destroyed;
     }
-    return _results;
   };
 
-  Store.prototype.destroy = function(model) {
-    localStorage.removeItem(this.name + this.sep + model.id);
-    this.records = _.reject(this.records, function(record_id) {
-      return record_id === model.id.toString();
-    });
-    this.save();
-    return model;
+  Store.prototype.hasDirtyOrDestroyed = function() {
+    return !_.isEmpty(this.data.dirty) || !_.isEmpty(this.data.destroyed);
   };
 
   return Store;
 
 })();
 
-callbackTranslator = {
-  needsTranslation: Backbone.VERSION === '0.9.10',
-  forBackboneCaller: function(callback) {
-    if (this.needsTranslation) {
-      return function(model, resp, options) {
-        return callback.call(null, resp);
-      };
-    } else {
-      return callback;
-    }
-  },
-  forDualstorageCaller: function(callback, model, options) {
-    if (this.needsTranslation) {
-      return function(resp) {
-        return callback.call(null, model, resp, options);
-      };
-    } else {
-      return callback;
-    }
-  }
+S4 = function() {
+  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
 };
 
-localsync = function(method, model, options) {
-  var isValidModel, preExisting, response, store;
-  isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
+localSync = function(method, model, options) {
+  var isValidModel, returnAsync, store;
+  isValidModel = method === 'clear' || method === 'hasDirtyOrDestroyed';
   isValidModel || (isValidModel = model instanceof Backbone.Model);
   isValidModel || (isValidModel = model instanceof Backbone.Collection);
   if (!isValidModel) {
-    throw new Error('model parameter is required to be a backbone model or collection.');
-  }
-  store = new Store(options.storeName);
-  response = (function() {
-    switch (method) {
-      case 'read':
-        if (model.id) {
-          return store.find(model);
-        } else {
-          return store.findAll();
-        }
-        break;
-      case 'hasDirtyOrDestroyed':
-        return store.hasDirtyOrDestroyed();
-      case 'clear':
-        return store.clear();
-      case 'create':
-        if (!(options.add && !options.merge && (preExisting = store.find(model)))) {
-          model = store.create(model);
-          if (options.dirty) {
-            store.dirty(model);
-          }
-          return model;
-        } else {
-          return preExisting;
-        }
-        break;
-      case 'update':
-        store.update(model);
-        if (options.dirty) {
-          return store.dirty(model);
-        } else {
-          return store.clean(model, 'dirty');
-        }
-        break;
-      case 'delete':
-        store.destroy(model);
-        if (options.dirty) {
-          return store.destroyed(model);
-        } else {
-          if (model.id.toString().length === 36) {
-            return store.clean(model, 'dirty');
-          } else {
-            return store.clean(model, 'destroyed');
-          }
-        }
-    }
-  })();
-  if (response != null ? response.attributes : void 0) {
-    response = response.attributes;
+    throw new Error('model parameter is required to be a Backbone model or collection.');
   }
-  if (!options.ignoreCallbacks) {
-    if (response) {
-      options.success(response);
-    } else {
-      options.error('Record not found');
-    }
-  }
-  return response;
-};
-
-result = function(object, property) {
-  var value;
-  if (!object) {
-    return null;
-  }
-  value = object[property];
-  if (_.isFunction(value)) {
-    return value.call(object);
-  } else {
-    return value;
-  }
-};
-
-parseRemoteResponse = function(object, response) {
-  if (!(object && object.parseBeforeLocalSave)) {
-    return response;
+  if (!options.storeName) {
+    throw new Error('storeName parameter is required.');
   }
-  if (_.isFunction(object.parseBeforeLocalSave)) {
-    return object.parseBeforeLocalSave(response);
+  if (!options.storage) {
+    throw new Error('storage parameter is required.');
   }
+  returnAsync = function() {
+    return $.Deferred().resolve;
+  };
+  store = new Backbone.Store(options.storeName, options.storage);
+  return store.initialize().then(function() {
+    var promise;
+    promise = (function() {
+      switch (method) {
+        case 'read':
+          return returnAsync(store.find(model != null ? model.id : void 0));
+        case 'create':
+          return store.add(model).then(function(model) {
+            return store.isDirty(model, options.offline);
+          });
+        case 'update':
+          return store.update(model).then(function(model) {
+            return store.isDirty(model, options.offline);
+          });
+        case 'remove':
+          return store.remove(model).then(function(model) {
+            return store.isDestroyed(model, options.offline);
+          });
+        case 'clear':
+          return store.clear();
+        case 'hasDirtyOrDestroyed':
+          return returnAsync(store.hasDirtyOrDestroyed());
+      }
+    })();
+    if (options.useCallbacks) {
+      return promise.done(function(response) {
+        return options.success((response != null ? response.attributes : void 0) || response);
+      });
+    }
+  });
 };
 
-modelUpdatedWithResponse = function(model, response) {
+updateModelWithResponse = function(model, response) {
   var modelClone;
   modelClone = new Backbone.Model;
   modelClone.idAttribute = model.idAttribute;
@@ -296,131 +385,160 @@ modelUpdatedWithResponse = function(model, response) {
   return modelClone;
 };
 
-backboneSync = Backbone.sync;
-
-onlineSync = function(method, model, options) {
-  options.success = callbackTranslator.forBackboneCaller(options.success);
-  options.error = callbackTranslator.forBackboneCaller(options.error);
-  return backboneSync(method, model, options);
-};
+onlineSync = Backbone.sync;
 
-dualsync = function(method, model, options) {
-  var error, local, success, temporaryId;
-  options.storeName = result(model.collection, 'storeName') || result(model, 'storeName') || result(model.collection, 'url') || result(model, 'urlRoot') || result(model, 'url');
-  options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
-  options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
-  if (result(model, 'remote') || result(model.collection, 'remote')) {
+dualSync = function(method, model, options) {
+  var error, onlyLocal, success, temporaryId;
+  options.storeName = _.result(model.collection, 'storeName') || _.result(model, 'storeName') || _.result(model.collection, 'url') || _.result(model, 'urlRoot') || _.result(model, 'url');
+  if (_.result(model, 'onlyRemote') || _.result(model.collection, 'onlyRemote')) {
     return onlineSync(method, model, options);
   }
-  local = result(model, 'local') || result(model.collection, 'local');
-  options.dirty = options.remote === false && !local;
-  if (options.remote === false || local) {
-    return localsync(method, model, options);
+  onlyLocal = _.result(model, 'onlyLocal') || _.result(model.collection, 'onlyLocal');
+  options.offline = !onlyLocal && options.remote === false;
+  if (onlyLocal || options.remote === false) {
+    return localSync(method, model, options).done(function(response) {
+      return options != null ? options.success(model, response, options) : void 0;
+    });
   }
-  options.ignoreCallbacks = true;
   success = options.success;
   error = options.error;
   switch (method) {
     case 'read':
-      if (localsync('hasDirtyOrDestroyed', model, options)) {
-        return success(localsync(method, model, options));
-      } else {
-        options.success = function(resp, status, xhr) {
-          var collection, idAttribute, modelAttributes, responseModel, _i, _len;
-          resp = parseRemoteResponse(model, resp);
-          if (!options.add) {
-            localsync('clear', model, options);
-          }
-          if (_.isArray(resp)) {
-            collection = model;
-            idAttribute = collection.model.prototype.idAttribute;
-            for (_i = 0, _len = resp.length; _i < _len; _i++) {
-              modelAttributes = resp[_i];
-              model = collection.get(modelAttributes[idAttribute]);
-              if (model) {
-                responseModel = modelUpdatedWithResponse(model, modelAttributes);
-              } else {
-                responseModel = new collection.model(modelAttributes);
+      return localSync('hasDirtyOrDestroyed', model, options).then(function(hasDirtyOrDestroyed) {
+        var returnModel;
+        if (hasDirtyOrDestroyed) {
+          return localSync('read', model, options).done(function(response) {
+            return options != null ? options.success(model, response, options) : void 0;
+          });
+        } else {
+          returnModel = model;
+          options.success = function(model, response, options) {
+            var collection, idAttribute, modelAttributes, models, promise, _i, _len;
+            models = [];
+            if (_.isArray(response)) {
+              collection = model;
+              idAttribute = collection.model.prototype.idAttribute;
+              for (_i = 0, _len = response.length; _i < _len; _i++) {
+                modelAttributes = response[_i];
+                model = collection.get(modelAttributes[idAttribute]);
+                model && (model = updateModelWithResponse(model, modelAttributes));
+                if (!model) {
+                  model = new collection.model(modelAttributes);
+                }
+                models.push(model);
               }
-              localsync('create', responseModel, options);
+            } else {
+              models = [updateModelWithResponse(model, response)];
             }
-          } else {
-            responseModel = modelUpdatedWithResponse(model, resp);
-            localsync('create', responseModel, options);
-          }
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          return success(localsync(method, model, options));
-        };
-        return onlineSync(method, model, options);
-      }
-      break;
+            if (!options.add) {
+              promise = localSync('clear', model, options);
+            } else {
+              promise = $.Deferred().resolve();
+            }
+            return promise.done = function() {
+              var promises;
+              promises = (function() {
+                var _j, _len1, _results;
+                _results = [];
+                for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+                  model = models[_j];
+                  _results.push(localSync('create', model, options));
+                }
+                return _results;
+              })();
+              return $.when.apply($, promises).then(function() {
+                return typeof success === "function" ? success(returnModel, response, options) : void 0;
+              });
+            };
+          };
+          options.error = function(model, response, options) {
+            return localSync('read', model, options).then(function(response) {
+              return typeof success === "function" ? success(model, response, options) : void 0;
+            });
+          };
+          return onlineSync('read', model, options);
+        }
+      });
     case 'create':
-      options.success = function(resp, status, xhr) {
+      options.success = function(model, response, options) {
         var updatedModel;
-        updatedModel = modelUpdatedWithResponse(model, resp);
-        localsync(method, updatedModel, options);
-        return success(resp, status, xhr);
+        updatedModel = updateModelWithResponse(model, response);
+        return localSync('create', updatedModel, options).then(function(savedModel) {
+          return typeof success === "function" ? success(model, savedModel.attributes, options) : void 0;
+        });
       };
-      options.error = function(resp) {
-        options.dirty = true;
-        return success(localsync(method, model, options));
+      options.error = function(model, response, options) {
+        options.offline = true;
+        return localSync('create', model, options).then(function(savedModel) {
+          return typeof success === "function" ? success(model, savedModel.attributes, options) : void 0;
+        });
       };
-      return onlineSync(method, model, options);
+      return onlineSync('create', model, options);
     case 'update':
-      if (_.isString(model.id) && model.id.length === 36) {
+      if ((model != null ? model.id.length : void 0) === 36) {
         temporaryId = model.id;
-        options.success = function(resp, status, xhr) {
+        options.success = function(model, response, options) {
           var updatedModel;
-          updatedModel = modelUpdatedWithResponse(model, resp);
+          updatedModel = updateModelWithResponse(model, response);
           model.set(model.idAttribute, temporaryId, {
             silent: true
           });
-          localsync('delete', model, options);
-          localsync('create', updatedModel, options);
-          return success(resp, status, xhr);
+          return localSync('remove', model, options).then(function() {
+            return localSync('create', updatedModel, options).then(function(savedModel) {
+              return typeof success === "function" ? success(savedModel, savedModel.attributes, options) : void 0;
+            });
+          });
         };
-        options.error = function(resp) {
-          options.dirty = true;
+        options.error = function(model, response, options) {
+          options.offline = true;
           model.set(model.idAttribute, temporaryId, {
             silent: true
           });
-          return success(localsync(method, model, options));
+          return localSync('update', model, options).then(function(savedModel) {
+            return typeof success === "function" ? success(savedModel, savedModel.attributes, options) : void 0;
+          });
         };
         model.set(model.idAttribute, null, {
           silent: true
         });
         return onlineSync('create', model, options);
       } else {
-        options.success = function(resp, status, xhr) {
+        options.success = function(model, response, options) {
           var updatedModel;
-          updatedModel = modelUpdatedWithResponse(model, resp);
-          localsync(method, updatedModel, options);
-          return success(resp, status, xhr);
+          updatedModel = updateModelWithResponse(model, response);
+          return localSync('update', updatedModel, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
         };
-        options.error = function(resp) {
-          options.dirty = true;
-          return success(localsync(method, model, options));
+        options.error = function(model, response, options) {
+          options.offline = true;
+          return localSync('update', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
         };
-        return onlineSync(method, model, options);
+        return onlineSync('update', model, options);
       }
       break;
-    case 'delete':
-      if (_.isString(model.id) && model.id.length === 36) {
-        return localsync(method, model, options);
+    case 'remove':
+      if ((model != null ? model.id.length : void 0) === 36) {
+        return localSync('remove', model, options);
       } else {
-        options.success = function(resp, status, xhr) {
-          localsync(method, model, options);
-          return success(resp, status, xhr);
+        options.success = function(model, response, options) {
+          return localSync('remove', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
         };
-        options.error = function(resp) {
-          options.dirty = true;
-          return success(localsync(method, model, options));
+        options.error = function(model, response, options) {
+          options.offline = true;
+          return localSync('remove', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
         };
-        return onlineSync(method, model, options);
+        return onlineSync('remove', model, options);
       }
   }
 };
 
-Backbone.sync = dualsync;
+Backbone.onlineSync = onlineSync;
+
+Backbone.dualSync = dualSync;
diff --git a/spec/backbone_extensions_spec.coffee b/spec/backbone_extensions_spec.coffee
index 47558a7..c770305 100644
--- a/spec/backbone_extensions_spec.coffee
+++ b/spec/backbone_extensions_spec.coffee
@@ -1,21 +1,17 @@
-{Backbone, localStorage} = window
+{Backbone} = window
 
 describe 'monkey patching', ->
   it 'aliases Backbone.sync to backboneSync', ->
     expect(window.backboneSync).toBeDefined()
     expect(window.backboneSync.identity).toEqual('sync')
 
-describe 'offline localStorage sync', ->
+describe 'offline storage sync', ->
   {collection} = {}
+
   beforeEach ->
-    localStorage.clear()
-    localStorage.setItem 'cats', '2,3,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff'
-    localStorage.setItem 'cats_dirty', '2,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff'
-    localStorage.setItem 'cats_destroyed', '3'
-    localStorage.setItem 'cats2', '{"id": "2", "color": "auburn"}'
-    localStorage.setItem 'cats3', '{"id": "3", "color": "burgundy"}'
-    localStorage.setItem 'catsa', '{"id": "a", "color": "scarlet"}'
-    localStorage.setItem 'catsnew', '{"id": "deadbeef-c03d-f00d-aced-dec0ded4b1ff", "color": "pearl"}'
+    console.log 'beforeEach'
+    done = false
+
     collection = new Backbone.Collection [
       {id: 2, color: 'auburn'},
       {id: 3, color: 'burgundy'},
@@ -24,33 +20,56 @@ describe 'offline localStorage sync', ->
     ]
     collection.url = -> 'cats'
 
+    runs ->
+      console.log 'runs'
+      Backbone.storageAdapter = new Backbone.storageAdapters.StickyStorageAdapter
+      Backbone.storageAdapter.initialize().done ->
+        console.log 'initialized'
+        Backbone.storageAdapter.clear().done ->
+          console.log 'cleared'
+          items =
+            cats: '2,3,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff'
+            cats_dirty: '2,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff'
+            cats_destroyed: '3'
+            cats2: '{"id": "2", "color": "auburn"}'
+            cats3: '{"id": "3", "color": "burgundy"}'
+            catsa: '{"id": "a", "color": "scarlet"}'
+            catsnew: '{"id": "deadbeef-c03d-f00d-aced-dec0ded4b1ff", "color": "pearl"}'
+          $.when((Backbone.storageAdapter.setItem(key, value) for key, value of items)...).done ->
+            console.log 'done'
+            done = true
+
+    waitsFor -> done
+
   describe 'syncDirtyAndDestroyed', ->
     it 'calls syncDirty and syncDestroyed', ->
-      syncDirty = spyOn Backbone.Collection.prototype, 'syncDirty'
-      syncDestroyed = spyOn Backbone.Collection.prototype, 'syncDestroyed'
-      collection.syncDirtyAndDestroyed()
-      expect(syncDirty).toHaveBeenCalled()
-      expect(syncDestroyed).toHaveBeenCalled()
+      syncDirty = spyOn(Backbone.Collection.prototype, 'syncDirty').andCallThrough()
+      syncDestroyed = spyOn(Backbone.Collection.prototype, 'syncDestroyed').andCallThrough()
+      collection.syncDirtyAndDestroyed().then ->
+        expect(syncDirty).toHaveBeenCalled()
+        expect(syncDestroyed).toHaveBeenCalled()
 
   describe 'syncDirty', ->
     it 'finds and saves all dirty models', ->
       saveInteger = spyOn(collection.get(2), 'save').andCallThrough()
       saveString = spyOn(collection.get('a'), 'save').andCallThrough()
-      collection.syncDirty()
-      expect(saveInteger).toHaveBeenCalled()
-      expect(saveString).toHaveBeenCalled()
-      expect(localStorage.getItem 'cats_dirty').toBeFalsy()
+      collection.syncDirty().then ->
+        expect(saveInteger).toHaveBeenCalled()
+        expect(saveString).toHaveBeenCalled()
+        Backbone.storageAdapter.getItem('cats_dirty').then (item) ->
+          expect(item).toBeFalsy()
 
     it 'works when there are no dirty records', ->
-      localStorage.removeItem 'cats_dirty'
-      collection.syncDirty()
+      Backbone.storageAdapter.removeItem('cats_dirty').then ->
+        collection.syncDirty()
 
   describe 'syncDestroyed', ->
     it 'finds all models marked as destroyed and destroys them', ->
       destroy = spyOn collection.get(3), 'destroy'
-      collection.syncDestroyed()
-      expect(localStorage.getItem 'cats_destroyed').toBeFalsy()
+      collection.syncDestroyed().then ->
+        Backbone.storageAdapter.getItem('cats_destroyed').then (item) ->
+          expect(item).toBeFalsy()
 
     it 'works when there are no destroyed records', ->
-      localStorage.setItem 'cats_destroyed', ''
-      collection.syncDestroyed()
+      Backbone.storageAdapter.setItem('cats_destroyed', '').then ->
+        collection.syncDestroyed()
diff --git a/spec/backbone_extensions_spec.js b/spec/backbone_extensions_spec.js
index 213426f..2d953a4 100644
--- a/spec/backbone_extensions_spec.js
+++ b/spec/backbone_extensions_spec.js
@@ -1,8 +1,8 @@
 // Generated by CoffeeScript 1.6.3
 (function() {
-  var Backbone, localStorage;
+  var Backbone;
 
-  Backbone = window.Backbone, localStorage = window.localStorage;
+  Backbone = window.Backbone;
 
   describe('monkey patching', function() {
     return it('aliases Backbone.sync to backboneSync', function() {
@@ -11,18 +11,13 @@
     });
   });
 
-  describe('offline localStorage sync', function() {
+  describe('offline storage sync', function() {
     var collection;
     collection = {}.collection;
     beforeEach(function() {
-      localStorage.clear();
-      localStorage.setItem('cats', '2,3,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff');
-      localStorage.setItem('cats_dirty', '2,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff');
-      localStorage.setItem('cats_destroyed', '3');
-      localStorage.setItem('cats2', '{"id": "2", "color": "auburn"}');
-      localStorage.setItem('cats3', '{"id": "3", "color": "burgundy"}');
-      localStorage.setItem('catsa', '{"id": "a", "color": "scarlet"}');
-      localStorage.setItem('catsnew', '{"id": "deadbeef-c03d-f00d-aced-dec0ded4b1ff", "color": "pearl"}');
+      var done;
+      console.log('beforeEach');
+      done = false;
       collection = new Backbone.Collection([
         {
           id: 2,
@@ -38,18 +33,54 @@
           color: 'pearl'
         }
       ]);
-      return collection.url = function() {
+      collection.url = function() {
         return 'cats';
       };
+      runs(function() {
+        console.log('runs');
+        Backbone.storageAdapter = new Backbone.storageAdapters.StickyStorageAdapter;
+        return Backbone.storageAdapter.initialize().done(function() {
+          console.log('initialized');
+          return Backbone.storageAdapter.clear().done(function() {
+            var items, key, value;
+            console.log('cleared');
+            items = {
+              cats: '2,3,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff',
+              cats_dirty: '2,a,deadbeef-c03d-f00d-aced-dec0ded4b1ff',
+              cats_destroyed: '3',
+              cats2: '{"id": "2", "color": "auburn"}',
+              cats3: '{"id": "3", "color": "burgundy"}',
+              catsa: '{"id": "a", "color": "scarlet"}',
+              catsnew: '{"id": "deadbeef-c03d-f00d-aced-dec0ded4b1ff", "color": "pearl"}'
+            };
+            return $.when.apply($, ((function() {
+              var _results;
+              _results = [];
+              for (key in items) {
+                value = items[key];
+                _results.push(Backbone.storageAdapter.setItem(key, value));
+              }
+              return _results;
+            })())).done(function() {
+              console.log('done');
+              return done = true;
+            });
+          });
+        });
+      });
+      return waitsFor(function() {
+        return done;
+      });
     });
     describe('syncDirtyAndDestroyed', function() {
       return it('calls syncDirty and syncDestroyed', function() {
         var syncDestroyed, syncDirty;
-        syncDirty = spyOn(Backbone.Collection.prototype, 'syncDirty');
-        syncDestroyed = spyOn(Backbone.Collection.prototype, 'syncDestroyed');
-        collection.syncDirtyAndDestroyed();
-        expect(syncDirty).toHaveBeenCalled();
-        return expect(syncDestroyed).toHaveBeenCalled();
+        syncDirty = spyOn(Backbone.Collection.prototype, 'syncDirty').andCallThrough();
+        syncDestroyed = spyOn(Backbone.Collection.prototype, 'syncDestroyed').andCallThrough();
+        return collection.syncDirtyAndDestroyed().then(function() {
+          expect(syncDirty).toHaveBeenCalled();
+          return expect(syncDestroyed).toHaveBeenCalled();
+        });
       });
     });
     describe('syncDirty', function() {
@@ -57,26 +88,34 @@
         var saveInteger, saveString;
         saveInteger = spyOn(collection.get(2), 'save').andCallThrough();
         saveString = spyOn(collection.get('a'), 'save').andCallThrough();
-        collection.syncDirty();
-        expect(saveInteger).toHaveBeenCalled();
-        expect(saveString).toHaveBeenCalled();
-        return expect(localStorage.getItem('cats_dirty')).toBeFalsy();
+        return collection.syncDirty().then(function() {
+          expect(saveInteger).toHaveBeenCalled();
+          expect(saveString).toHaveBeenCalled();
+          return Backbone.storageAdapter.getItem('cats_dirty').then(function(item) {
+            return expect(item).toBeFalsy();
+          });
+        });
       });
       return it('works when there are no dirty records', function() {
-        localStorage.removeItem('cats_dirty');
-        return collection.syncDirty();
+        return Backbone.storageAdapter.removeItem('cats_dirty').then(function() {
+          return collection.syncDirty();
+        });
       });
     });
     return describe('syncDestroyed', function() {
       it('finds all models marked as destroyed and destroys them', function() {
         var destroy;
         destroy = spyOn(collection.get(3), 'destroy');
-        collection.syncDestroyed();
-        return expect(localStorage.getItem('cats_destroyed')).toBeFalsy();
+        return collection.syncDestroyed().then(function() {
+          return Backbone.storageAdapter.getItem('cats_destroyed').then(function(item) {
+            return expect(item).toBeFalsy();
+          });
+        });
       });
       return it('works when there are no destroyed records', function() {
-        localStorage.setItem('cats_destroyed', '');
-        return collection.syncDestroyed();
+        return Backbone.storageAdapter.setItem('cats_destroyed', '').then(function() {
+          return collection.syncDestroyed();
+        });
       });
     });
   });
diff --git a/spec/bugs_spec.coffee b/spec/bugs_spec.coffee
index 933e207..ab95fbe 100644
--- a/spec/bugs_spec.coffee
+++ b/spec/bugs_spec.coffee
@@ -1,4 +1,4 @@
-{Store, backboneSync, localsync} = window
+{Store, backboneSync, localSync} = window
 
 describe 'bugs, that once fixed, should be moved to the proper spec file and modified to test their inverse', ->
   it 'fails to throw an error when no storeName is provided to the Store constructor,
@@ -12,7 +12,7 @@ describe 'bugs, that once fixed, should be moved to the proper spec file and mod
 
     beforeEach ->
       backboneSync.calls = []
-      localsync 'clear', {}, success: (->), error: (->)
+      localSync 'clear', {}, success: (->), error: (->)
       collection = new Backbone.Collection
       collection.url = 'eyes/'
       model = new Backbone.Model
diff --git a/spec/bugs_spec.js b/spec/bugs_spec.js
index d75bac2..6c70333 100644
--- a/spec/bugs_spec.js
+++ b/spec/bugs_spec.js
@@ -1,8 +1,8 @@
 // Generated by CoffeeScript 1.6.3
 (function() {
-  var Store, backboneSync, localsync;
+  var Store, backboneSync, localSync;
 
-  Store = window.Store, backboneSync = window.backboneSync, localsync = window.localsync;
+  Store = window.Store, backboneSync = window.backboneSync, localSync = window.localSync;
 
   describe('bugs, that once fixed, should be moved to the proper spec file and modified to test their inverse', function() {
     it('fails to throw an error when no storeName is provided to the Store constructor,\
@@ -19,7 +19,7 @@
       _ref = {}, Role = _ref.Role, RoleCollection = _ref.RoleCollection, collection = _ref.collection, model = _ref.model;
       beforeEach(function() {
         backboneSync.calls = [];
-        localsync('clear', {}, {
+        localSync('clear', {}, {
           success: (function() {}),
           error: (function() {})
         });
diff --git a/spec/dualsync_spec.coffee b/spec/dualsync_spec.coffee
index 1f5381a..8b4df56 100644
--- a/spec/dualsync_spec.coffee
+++ b/spec/dualsync_spec.coffee
@@ -1,4 +1,4 @@
-{Backbone, backboneSync, localsync, localStorage} = window
+{Backbone, backboneSync, localSync, localStorage} = window
 {collection, model, ModelWithAlternateIdAttribute} = {}
 
 beforeEach ->
@@ -16,12 +16,13 @@ beforeEach ->
   delete model.remote
 
 spyOnLocalsync = ->
-  spyOn(window, 'localsync')
+  spyOn(window, 'localSync')
     .andCallFake (method, model, options) ->
       options.success?() unless options.ignoreCallbacks
-  localsync = window.localsync
+      $.Deferred().resolve();
+  localSync = window.localSync
 
-describe 'delegating to localsync and backboneSync, and calling the model callbacks', ->
+describe 'delegating to localSync and backboneSync, and calling the model callbacks', ->
   describe 'dual tier storage', ->
     checkMergedAttributesFor = (method, modelToUpdate = model) ->
       spyOnLocalsync()
@@ -31,62 +32,62 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
         modelToUpdate.set updatedAttribute: 'original value'
         originalAttributes = _.clone(modelToUpdate.attributes)
         serverResponse = _.extend(model.toJSON(), updatedAttribute: 'updated value', newAttribute: 'new value')
-        dualsync(method, modelToUpdate, success: (-> ready = true), serverResponse: serverResponse)
+        dualSync(method, modelToUpdate, success: (-> ready = true), serverResponse: serverResponse)
       waitsFor (-> ready), "The success callback should have been called", 100
       runs ->
         expect(modelToUpdate.attributes).toEqual originalAttributes
-        localsyncedAttributes = _(localsync.calls).map((call) -> call.args[1].attributes)
+        localSyncedAttributes = _(localSync.calls).map((call) -> call.args[1].attributes)
         updatedAttributes =
           _id: 12
           position: 'arm'
           updatedAttribute: 'updated value'
           newAttribute: 'new value'
-        expect(localsyncedAttributes).toContain updatedAttributes
+        expect(localSyncedAttributes).toContain updatedAttributes
 
     describe 'create', ->
-      it 'delegates to both localsync and backboneSync', ->
+      it 'delegates to both localSync and backboneSync', ->
         spyOnLocalsync()
         ready = false
         runs ->
-          dualsync('create', model, success: (-> ready = true))
+          dualSync('create', model, success: (-> ready = true))
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
           expect(backboneSync).toHaveBeenCalled()
           expect(backboneSync.calls[0].args[0]).toEqual 'create'
-          expect(localsync).toHaveBeenCalled()
-          expect(localsync.calls[0].args[0]).toEqual 'create'
-          expect(_(localsync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
+          expect(localSync).toHaveBeenCalled()
+          expect(localSync.calls[0].args[0]).toEqual 'create'
+          expect(_(localSync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
 
       it 'merges the response attributes into the model attributes', ->
         checkMergedAttributesFor 'create'
 
     describe 'read', ->
-      it 'delegates to both localsync and backboneSync', ->
+      it 'delegates to both localSync and backboneSync', ->
         spyOnLocalsync()
         ready = false
         runs ->
-          dualsync('read', model, success: (-> ready = true))
+          dualSync('read', model, success: (-> ready = true))
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
           expect(backboneSync).toHaveBeenCalled()
           expect(_(backboneSync.calls).any((call) -> call.args[0] == 'read')).toBeTruthy()
-          expect(localsync).toHaveBeenCalled()
-          expect(_(localsync.calls).any((call) -> call.args[0] == 'create')).toBeTruthy()
-          expect(_(localsync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
+          expect(localSync).toHaveBeenCalled()
+          expect(_(localSync.calls).any((call) -> call.args[0] == 'create')).toBeTruthy()
+          expect(_(localSync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
 
       describe 'for collections', ->
-        it 'calls localsync create once for each model', ->
+        it 'calls localSync create once for each model', ->
           spyOnLocalsync()
           ready = false
           collectionResponse = [{_id: 12, position: 'arm'}, {_id: 13, position: 'a new model'}]
           runs ->
-            dualsync('read', collection, success: (-> ready = true), serverResponse: collectionResponse)
+            dualSync('read', collection, success: (-> ready = true), serverResponse: collectionResponse)
           waitsFor (-> ready), "The success callback should have been called", 100
           runs ->
             expect(backboneSync).toHaveBeenCalled()
             expect(_(backboneSync.calls).any((call) -> call.args[0] == 'read')).toBeTruthy()
-            expect(localsync).toHaveBeenCalled()
-            createCalls = _(localsync.calls).select((call) -> call.args[0] == 'create')
+            expect(localSync).toHaveBeenCalled()
+            createCalls = _(localSync.calls).select((call) -> call.args[0] == 'create')
             expect(createCalls.length).toEqual 2
             expect(_(createCalls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
             createdModelAttributes = _(createCalls).map((call) -> call.args[1].attributes)
@@ -94,42 +95,42 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
             expect(createdModelAttributes[1]).toEqual _id: 13, position: 'a new model'
 
     describe 'update', ->
-      it 'delegates to both localsync and backboneSync', ->
+      it 'delegates to both localSync and backboneSync', ->
         spyOnLocalsync()
         ready = false
         runs ->
-          dualsync('update', model, success: (-> ready = true))
+          dualSync('update', model, success: (-> ready = true))
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
           expect(backboneSync).toHaveBeenCalled()
           expect(_(backboneSync.calls).any((call) -> call.args[0] == 'update')).toBeTruthy()
-          expect(localsync).toHaveBeenCalled()
-          expect(_(localsync.calls).any((call) -> call.args[0] == 'update')).toBeTruthy()
-          expect(_(localsync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
+          expect(localSync).toHaveBeenCalled()
+          expect(_(localSync.calls).any((call) -> call.args[0] == 'update')).toBeTruthy()
+          expect(_(localSync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
 
       it 'merges the response attributes into the model attributes', ->
         checkMergedAttributesFor 'update'
 
     describe 'delete', ->
-      it 'delegates to both localsync and backboneSync', ->
+      it 'delegates to both localSync and backboneSync', ->
         spyOnLocalsync()
         ready = false
         runs ->
-          dualsync('delete', model, success: (-> ready = true))
+          dualSync('delete', model, success: (-> ready = true))
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
           expect(backboneSync).toHaveBeenCalled()
           expect(_(backboneSync.calls).any((call) -> call.args[0] == 'delete')).toBeTruthy()
-          expect(localsync).toHaveBeenCalled()
-          expect(_(localsync.calls).any((call) -> call.args[0] == 'delete')).toBeTruthy()
-          expect(_(localsync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
+          expect(localSync).toHaveBeenCalled()
+          expect(_(localSync.calls).any((call) -> call.args[0] == 'delete')).toBeTruthy()
+          expect(_(localSync.calls).every((call) -> call.args[1] instanceof Backbone.Model)).toBeTruthy()
 
   describe 'respects the remote only attribute on models', ->
     it 'delegates for remote models', ->
       ready = false
       runs ->
         model.remote = true
-        dualsync('create', model, success: (-> ready = true))
+        dualSync('create', model, success: (-> ready = true))
       waitsFor (-> ready), "The success callback should have been called", 100
       runs ->
         expect(backboneSync).toHaveBeenCalled()
@@ -139,7 +140,7 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
       ready = false
       runs ->
         collection.remote = true
-        dualsync('read', model, success: (-> ready = true))
+        dualSync('read', model, success: (-> ready = true))
       waitsFor (-> ready), "The success callback should have been called", 100
       runs ->
         expect(backboneSync).toHaveBeenCalled()
@@ -152,18 +153,18 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
       runs ->
         model.local = true
         backboneSync.reset()
-        dualsync('update', model, success: (-> ready = true))
+        dualSync('update', model, success: (-> ready = true))
       waitsFor (-> ready), "The success callback should have been called", 100
       runs ->
-        expect(localsync).toHaveBeenCalled()
-        expect(localsync.calls[0].args[0]).toEqual 'update'
+        expect(localSync).toHaveBeenCalled()
+        expect(localSync.calls[0].args[0]).toEqual 'update'
 
     it 'delegates for local collections', ->
       ready = false
       runs ->
         collection.local = true
         backboneSync.reset()
-        dualsync('delete', model, success: (-> ready = true))
+        dualSync('delete', model, success: (-> ready = true))
       waitsFor (-> ready), "The success callback should have been called", 100
       runs ->
         expect(backboneSync).not.toHaveBeenCalled()
@@ -172,7 +173,7 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
     ready = false
     runs ->
       backboneSync.reset()
-      dualsync('create', model, success: (-> ready = true), remote: false)
+      dualSync('create', model, success: (-> ready = true), remote: false)
     waitsFor (-> ready), "The success callback should have been called", 100
     runs ->
       expect(backboneSync).not.toHaveBeenCalled()
@@ -182,50 +183,51 @@ describe 'delegating to localsync and backboneSync, and calling the model callba
       describe 'for models', ->
         it 'gets merged with existing attributes on a model', ->
           spyOnLocalsync()
-          localsync.reset()
+          localSync.reset()
           ready = false
           runs ->
-            dualsync('read', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
+            dualSync('read', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
           waitsFor (-> ready), "The success callback should have been called", 100
           runs ->
-            expect(localsync.calls[2].args[0]).toEqual 'create'
-            expect(localsync.calls[2].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
+            window.x = localSync
+            expect(localSync.calls[2].args[0]).toEqual 'create'
+            expect(localSync.calls[2].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
 
       describe 'for collections', ->
         it 'gets merged with existing attributes on the model with the same id', ->
           spyOnLocalsync()
-          localsync.reset()
+          localSync.reset()
           ready = false
           runs ->
-            dualsync('read', collection, success: (-> ready = true), serverResponse: [{side: 'left', _id: 12}])
+            dualSync('read', collection, success: (-> ready = true), serverResponse: [{side: 'left', _id: 12}])
           waitsFor (-> ready), "The success callback should have been called", 100
           runs ->
-            expect(localsync.calls[2].args[0]).toEqual 'create'
-            expect(localsync.calls[2].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 12
+            expect(localSync.calls[2].args[0]).toEqual 'create'
+            expect(localSync.calls[2].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 12
 
     describe 'on create', ->
       it 'gets merged with existing attributes on a model', ->
         spyOnLocalsync()
-        localsync.reset()
+        localSync.reset()
         ready = false
         runs ->
-          dualsync('create', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
+          dualSync('create', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
-          expect(localsync.calls[0].args[0]).toEqual 'create'
-          expect(localsync.calls[0].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
+          expect(localSync.calls[0].args[0]).toEqual 'create'
+          expect(localSync.calls[0].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
 
     describe 'on update', ->
       it 'gets merged with existing attributes on a model', ->
         spyOnLocalsync()
-        localsync.reset()
+        localSync.reset()
         ready = false
         runs ->
-          dualsync('update', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
+          dualSync('update', model, success: (-> ready = true), serverResponse: {side: 'left', _id: 13})
         waitsFor (-> ready), "The success callback should have been called", 100
         runs ->
-          expect(localsync.calls[0].args[0]).toEqual 'update'
-          expect(localsync.calls[0].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
+          expect(localSync.calls[0].args[0]).toEqual 'update'
+          expect(localSync.calls[0].args[1].attributes).toEqual position: 'arm', side: 'left', _id: 13
 
 describe 'offline storage', ->
   it 'marks records dirty when options.remote is false, except if the model/collection is marked as local', ->
@@ -234,22 +236,22 @@ describe 'offline storage', ->
     runs ->
       ready = false
       collection.local = true
-      dualsync('update', model, success: (-> ready = true), remote: false)
+      dualSync('update', model, success: (-> ready = true), remote: false)
     waitsFor (-> ready), "The success callback should have been called", 100
     runs ->
-      expect(localsync).toHaveBeenCalled()
-      expect(localsync.calls.length).toEqual 1
-      expect(localsync.calls[0].args[2].dirty).toBeFalsy()
+      expect(localSync).toHaveBeenCalled()
+      expect(localSync.calls.length).toEqual 1
+      expect(localSync.calls[0].args[2].dirty).toBeFalsy()
     runs ->
-      localsync.reset()
+      localSync.reset()
       ready = false
       collection.local = false
-      dualsync('update', model, success: (-> ready = true), remote: false)
+      dualSync('update', model, success: (-> ready = true), remote: false)
     waitsFor (-> ready), "The success callback should have been called", 100
     runs ->
-      expect(localsync).toHaveBeenCalled()
-      expect(localsync.calls.length).toEqual 1
-      expect(localsync.calls[0].args[2].dirty).toBeTruthy()
+      expect(localSync).toHaveBeenCalled()
+      expect(localSync.calls.length).toEqual 1
+      expect(localSync.calls[0].args[2].dirty).toBeTruthy()
 
 describe 'dualStorage hooks', ->
   beforeEach ->
@@ -257,13 +259,13 @@ describe 'dualStorage hooks', ->
       new ModelWithAlternateIdAttribute(parsedRemote: true)
     ready = false
     runs ->
-      dualsync 'create', model, success: (-> ready = true)
+      dualSync 'create', model, success: (-> ready = true)
     waitsFor (-> ready), "The success callback should have been called", 100
 
   it 'filters read responses through parseBeforeLocalSave when defined on the model or collection', ->
     response = null
     runs ->
-      dualsync 'read', model, success: (callback_args...) ->
+      dualSync 'read', model, success: (callback_args...) ->
         response = callback_args
     waitsFor (-> response), "The success callback should have been called", 100
     runs ->
@@ -275,8 +277,8 @@ describe 'storeName selection', ->
     model.local = true
     model.url = '/bacon/bits'
     spyOnLocalsync()
-    dualsync(null, model, {})
-    expect(localsync.calls[0].args[2].storeName).toEqual model.url
+    dualSync(null, model, {})
+    expect(localSync.calls[0].args[2].storeName).toEqual model.url
 
   it 'prefers the model urlRoot over the url as a store name', ->
     model = new ModelWithAlternateIdAttribute()
@@ -284,8 +286,8 @@ describe 'storeName selection', ->
     model.url = '/bacon/bits'
     model.urlRoot = '/bacon'
     spyOnLocalsync()
-    dualsync(null, model, {})
-    expect(localsync.calls[0].args[2].storeName).toEqual model.urlRoot
+    dualSync(null, model, {})
+    expect(localSync.calls[0].args[2].storeName).toEqual model.urlRoot
 
   it 'prefers the collection url over the model urlRoot as a store name', ->
     model = new ModelWithAlternateIdAttribute()
@@ -295,8 +297,8 @@ describe 'storeName selection', ->
     model.collection = new Backbone.Collection()
     model.collection.url = '/ranch'
     spyOnLocalsync()
-    dualsync(null, model, {})
-    expect(localsync.calls[0].args[2].storeName).toEqual model.collection.url
+    dualSync(null, model, {})
+    expect(localSync.calls[0].args[2].storeName).toEqual model.collection.url
 
   it 'prefers the model storeName over the collection url as a store name', ->
     model = new ModelWithAlternateIdAttribute()
@@ -307,8 +309,8 @@ describe 'storeName selection', ->
     model.collection.url = '/ranch'
     model.storeName = 'melted cheddar'
     spyOnLocalsync()
-    dualsync(null, model, {})
-    expect(localsync.calls[0].args[2].storeName).toEqual model.storeName
+    dualSync(null, model, {})
+    expect(localSync.calls[0].args[2].storeName).toEqual model.storeName
 
   it 'prefers the collection storeName over the model storeName as a store name', ->
     model = new ModelWithAlternateIdAttribute()
@@ -320,5 +322,5 @@ describe 'storeName selection', ->
     model.storeName = 'melted cheddar'
     model.collection.storeName = 'ketchup'
     spyOnLocalsync()
-    dualsync(null, model, {})
-    expect(localsync.calls[0].args[2].storeName).toEqual model.collection.storeName
+    dualSync(null, model, {})
+    expect(localSync.calls[0].args[2].storeName).toEqual model.collection.storeName
diff --git a/spec/dualsync_spec.js b/spec/dualsync_spec.js
index d06d81f..cce59cf 100644
--- a/spec/dualsync_spec.js
+++ b/spec/dualsync_spec.js
@@ -1,9 +1,9 @@
 // Generated by CoffeeScript 1.6.3
 (function() {
-  var Backbone, ModelWithAlternateIdAttribute, backboneSync, collection, localStorage, localsync, model, spyOnLocalsync, _ref,
+  var Backbone, ModelWithAlternateIdAttribute, backboneSync, collection, localStorage, localSync, model, spyOnLocalsync, _ref,
     __slice = [].slice;
 
-  Backbone = window.Backbone, backboneSync = window.backboneSync, localsync = window.localsync, localStorage = window.localStorage;
+  Backbone = window.Backbone, backboneSync = Backbone.onlineSync, localSync = window.localSync, localStorage = window.localStorage;
 
   _ref = {}, collection = _ref.collection, model = _ref.model, ModelWithAlternateIdAttribute = _ref.ModelWithAlternateIdAttribute;
 
@@ -26,15 +26,18 @@
   });
 
   spyOnLocalsync = function() {
-    spyOn(window, 'localsync').andCallFake(function(method, model, options) {
+    spyOn(window, 'localSync').andCallFake(function(method, model, options) {
       if (!options.ignoreCallbacks) {
-        return typeof options.success === "function" ? options.success() : void 0;
+        if (typeof options.success === "function") {
+          options.success();
+        }
       }
+      return $.Deferred().resolve();
     });
-    return localsync = window.localsync;
+    return localSync = window.localSync;
   };
 
-  describe('delegating to localsync and backboneSync, and calling the model callbacks', function() {
+  describe('delegating to localSync and backboneSync, and calling the model callbacks', function() {
     describe('dual tier storage', function() {
       var checkMergedAttributesFor;
       checkMergedAttributesFor = function(method, modelToUpdate) {
@@ -55,7 +58,7 @@
             updatedAttribute: 'updated value',
             newAttribute: 'new value'
           });
-          return dualsync(method, modelToUpdate, {
+          return dualSync(method, modelToUpdate, {
             success: (function() {
               return ready = true;
             }),
@@ -66,9 +69,9 @@
           return ready;
         }), "The success callback should have been called", 100);
         return runs(function() {
-          var localsyncedAttributes, updatedAttributes;
+          var localSyncedAttributes, updatedAttributes;
           expect(modelToUpdate.attributes).toEqual(originalAttributes);
-          localsyncedAttributes = _(localsync.calls).map(function(call) {
+          localSyncedAttributes = _(localSync.calls).map(function(call) {
             return call.args[1].attributes;
           });
           updatedAttributes = {
@@ -77,16 +80,16 @@
             updatedAttribute: 'updated value',
             newAttribute: 'new value'
           };
-          return expect(localsyncedAttributes).toContain(updatedAttributes);
+          return expect(localSyncedAttributes).toContain(updatedAttributes);
         });
       };
       describe('create', function() {
-        it('delegates to both localsync and backboneSync', function() {
+        it('delegates to both localSync and backboneSync', function() {
           var ready;
           spyOnLocalsync();
           ready = false;
           runs(function() {
-            return dualsync('create', model, {
+            return dualSync('create', model, {
               success: (function() {
                 return ready = true;
               })
@@ -98,9 +101,9 @@
           return runs(function() {
             expect(backboneSync).toHaveBeenCalled();
             expect(backboneSync.calls[0].args[0]).toEqual('create');
-            expect(localsync).toHaveBeenCalled();
-            expect(localsync.calls[0].args[0]).toEqual('create');
-            return expect(_(localsync.calls).every(function(call) {
+            expect(localSync).toHaveBeenCalled();
+            expect(localSync.calls[0].args[0]).toEqual('create');
+            return expect(_(localSync.calls).every(function(call) {
               return call.args[1] instanceof Backbone.Model;
             })).toBeTruthy();
           });
@@ -110,12 +113,12 @@
         });
       });
       describe('read', function() {
-        it('delegates to both localsync and backboneSync', function() {
+        it('delegates to both localSync and backboneSync', function() {
           var ready;
           spyOnLocalsync();
           ready = false;
           runs(function() {
-            return dualsync('read', model, {
+            return dualSync('read', model, {
               success: (function() {
                 return ready = true;
               })
@@ -129,17 +132,17 @@
             expect(_(backboneSync.calls).any(function(call) {
               return call.args[0] === 'read';
             })).toBeTruthy();
-            expect(localsync).toHaveBeenCalled();
-            expect(_(localsync.calls).any(function(call) {
+            expect(localSync).toHaveBeenCalled();
+            expect(_(localSync.calls).any(function(call) {
               return call.args[0] === 'create';
             })).toBeTruthy();
-            return expect(_(localsync.calls).every(function(call) {
+            return expect(_(localSync.calls).every(function(call) {
               return call.args[1] instanceof Backbone.Model;
             })).toBeTruthy();
           });
         });
         return describe('for collections', function() {
-          return it('calls localsync create once for each model', function() {
+          return it('calls localSync create once for each model', function() {
             var collectionResponse, ready;
             spyOnLocalsync();
             ready = false;
@@ -153,7 +156,7 @@
               }
             ];
             runs(function() {
-              return dualsync('read', collection, {
+              return dualSync('read', collection, {
                 success: (function() {
                   return ready = true;
                 }),
@@ -169,8 +172,8 @@
               expect(_(backboneSync.calls).any(function(call) {
                 return call.args[0] === 'read';
               })).toBeTruthy();
-              expect(localsync).toHaveBeenCalled();
-              createCalls = _(localsync.calls).select(function(call) {
+              expect(localSync).toHaveBeenCalled();
+              createCalls = _(localSync.calls).select(function(call) {
                 return call.args[0] === 'create';
               });
               expect(createCalls.length).toEqual(2);
@@ -193,12 +196,12 @@
         });
       });
       describe('update', function() {
-        it('delegates to both localsync and backboneSync', function() {
+        it('delegates to both localSync and backboneSync', function() {
           var ready;
           spyOnLocalsync();
           ready = false;
           runs(function() {
-            return dualsync('update', model, {
+            return dualSync('update', model, {
               success: (function() {
                 return ready = true;
               })
@@ -212,11 +215,11 @@
             expect(_(backboneSync.calls).any(function(call) {
               return call.args[0] === 'update';
             })).toBeTruthy();
-            expect(localsync).toHaveBeenCalled();
-            expect(_(localsync.calls).any(function(call) {
+            expect(localSync).toHaveBeenCalled();
+            expect(_(localSync.calls).any(function(call) {
               return call.args[0] === 'update';
             })).toBeTruthy();
-            return expect(_(localsync.calls).every(function(call) {
+            return expect(_(localSync.calls).every(function(call) {
               return call.args[1] instanceof Backbone.Model;
             })).toBeTruthy();
           });
@@ -226,12 +229,12 @@
         });
       });
       return describe('delete', function() {
-        return it('delegates to both localsync and backboneSync', function() {
+        return it('delegates to both localSync and backboneSync', function() {
           var ready;
           spyOnLocalsync();
           ready = false;
           runs(function() {
-            return dualsync('delete', model, {
+            return dualSync('delete', model, {
               success: (function() {
                 return ready = true;
               })
@@ -245,11 +248,11 @@
             expect(_(backboneSync.calls).any(function(call) {
               return call.args[0] === 'delete';
             })).toBeTruthy();
-            expect(localsync).toHaveBeenCalled();
-            expect(_(localsync.calls).any(function(call) {
+            expect(localSync).toHaveBeenCalled();
+            expect(_(localSync.calls).any(function(call) {
               return call.args[0] === 'delete';
             })).toBeTruthy();
-            return expect(_(localsync.calls).every(function(call) {
+            return expect(_(localSync.calls).every(function(call) {
               return call.args[1] instanceof Backbone.Model;
             })).toBeTruthy();
           });
@@ -262,7 +265,7 @@
         ready = false;
         runs(function() {
           model.remote = true;
-          return dualsync('create', model, {
+          return dualSync('create', model, {
             success: (function() {
               return ready = true;
             })
@@ -281,7 +284,7 @@
         ready = false;
         runs(function() {
           collection.remote = true;
-          return dualsync('read', model, {
+          return dualSync('read', model, {
             success: (function() {
               return ready = true;
             })
@@ -304,7 +307,7 @@
         runs(function() {
           model.local = true;
           backboneSync.reset();
-          return dualsync('update', model, {
+          return dualSync('update', model, {
             success: (function() {
               return ready = true;
             })
@@ -314,8 +317,8 @@
           return ready;
         }), "The success callback should have been called", 100);
         return runs(function() {
-          expect(localsync).toHaveBeenCalled();
-          return expect(localsync.calls[0].args[0]).toEqual('update');
+          expect(localSync).toHaveBeenCalled();
+          return expect(localSync.calls[0].args[0]).toEqual('update');
         });
       });
       return it('delegates for local collections', function() {
@@ -324,7 +327,7 @@
         runs(function() {
           collection.local = true;
           backboneSync.reset();
-          return dualsync('delete', model, {
+          return dualSync('delete', model, {
             success: (function() {
               return ready = true;
             })
@@ -343,7 +346,7 @@
       ready = false;
       runs(function() {
         backboneSync.reset();
-        return dualsync('create', model, {
+        return dualSync('create', model, {
           success: (function() {
             return ready = true;
           }),
@@ -363,10 +366,10 @@
           return it('gets merged with existing attributes on a model', function() {
             var ready;
             spyOnLocalsync();
-            localsync.reset();
+            localSync.reset();
             ready = false;
             runs(function() {
-              return dualsync('read', model, {
+              return dualSync('read', model, {
                 success: (function() {
                   return ready = true;
                 }),
@@ -380,8 +383,9 @@
               return ready;
             }), "The success callback should have been called", 100);
             return runs(function() {
-              expect(localsync.calls[2].args[0]).toEqual('create');
-              return expect(localsync.calls[2].args[1].attributes).toEqual({
+              window.x = localSync;
+              expect(localSync.calls[2].args[0]).toEqual('create');
+              return expect(localSync.calls[2].args[1].attributes).toEqual({
                 position: 'arm',
                 side: 'left',
                 _id: 13
@@ -393,10 +397,10 @@
           return it('gets merged with existing attributes on the model with the same id', function() {
             var ready;
             spyOnLocalsync();
-            localsync.reset();
+            localSync.reset();
             ready = false;
             runs(function() {
-              return dualsync('read', collection, {
+              return dualSync('read', collection, {
                 success: (function() {
                   return ready = true;
                 }),
@@ -412,8 +416,8 @@
               return ready;
             }), "The success callback should have been called", 100);
             return runs(function() {
-              expect(localsync.calls[2].args[0]).toEqual('create');
-              return expect(localsync.calls[2].args[1].attributes).toEqual({
+              expect(localSync.calls[2].args[0]).toEqual('create');
+              return expect(localSync.calls[2].args[1].attributes).toEqual({
                 position: 'arm',
                 side: 'left',
                 _id: 12
@@ -426,10 +430,10 @@
         return it('gets merged with existing attributes on a model', function() {
           var ready;
           spyOnLocalsync();
-          localsync.reset();
+          localSync.reset();
           ready = false;
           runs(function() {
-            return dualsync('create', model, {
+            return dualSync('create', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -443,8 +447,8 @@
             return ready;
           }), "The success callback should have been called", 100);
           return runs(function() {
-            expect(localsync.calls[0].args[0]).toEqual('create');
-            return expect(localsync.calls[0].args[1].attributes).toEqual({
+            expect(localSync.calls[0].args[0]).toEqual('create');
+            return expect(localSync.calls[0].args[1].attributes).toEqual({
               position: 'arm',
               side: 'left',
               _id: 13
@@ -456,10 +460,10 @@
         return it('gets merged with existing attributes on a model', function() {
           var ready;
           spyOnLocalsync();
-          localsync.reset();
+          localSync.reset();
           ready = false;
           runs(function() {
-            return dualsync('update', model, {
+            return dualSync('update', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -473,8 +477,8 @@
             return ready;
           }), "The success callback should have been called", 100);
           return runs(function() {
-            expect(localsync.calls[0].args[0]).toEqual('update');
-            return expect(localsync.calls[0].args[1].attributes).toEqual({
+            expect(localSync.calls[0].args[0]).toEqual('update');
+            return expect(localSync.calls[0].args[1].attributes).toEqual({
               position: 'arm',
               side: 'left',
               _id: 13
@@ -493,7 +497,7 @@
       runs(function() {
         ready = false;
         collection.local = true;
-        return dualsync('update', model, {
+        return dualSync('update', model, {
           success: (function() {
             return ready = true;
           }),
@@ -504,15 +508,15 @@
         return ready;
       }), "The success callback should have been called", 100);
       runs(function() {
-        expect(localsync).toHaveBeenCalled();
-        expect(localsync.calls.length).toEqual(1);
-        return expect(localsync.calls[0].args[2].dirty).toBeFalsy();
+        expect(localSync).toHaveBeenCalled();
+        expect(localSync.calls.length).toEqual(1);
+        return expect(localSync.calls[0].args[2].dirty).toBeFalsy();
       });
       runs(function() {
-        localsync.reset();
+        localSync.reset();
         ready = false;
         collection.local = false;
-        return dualsync('update', model, {
+        return dualSync('update', model, {
           success: (function() {
             return ready = true;
           }),
@@ -523,9 +527,9 @@
         return ready;
       }), "The success callback should have been called", 100);
       return runs(function() {
-        expect(localsync).toHaveBeenCalled();
-        expect(localsync.calls.length).toEqual(1);
-        return expect(localsync.calls[0].args[2].dirty).toBeTruthy();
+        expect(localSync).toHaveBeenCalled();
+        expect(localSync.calls.length).toEqual(1);
+        return expect(localSync.calls[0].args[2].dirty).toBeTruthy();
       });
     });
   });
@@ -540,7 +544,7 @@
       };
       ready = false;
       runs(function() {
-        return dualsync('create', model, {
+        return dualSync('create', model, {
           success: (function() {
             return ready = true;
           })
@@ -554,7 +558,7 @@
       var response;
       response = null;
       runs(function() {
-        return dualsync('read', model, {
+        return dualSync('read', model, {
           success: function() {
             var callback_args;
             callback_args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
@@ -577,8 +581,8 @@
       model.local = true;
       model.url = '/bacon/bits';
       spyOnLocalsync();
-      dualsync(null, model, {});
-      return expect(localsync.calls[0].args[2].storeName).toEqual(model.url);
+      dualSync(null, model, {});
+      return expect(localSync.calls[0].args[2].storeName).toEqual(model.url);
     });
     it('prefers the model urlRoot over the url as a store name', function() {
       model = new ModelWithAlternateIdAttribute();
@@ -586,8 +590,8 @@
       model.url = '/bacon/bits';
       model.urlRoot = '/bacon';
       spyOnLocalsync();
-      dualsync(null, model, {});
-      return expect(localsync.calls[0].args[2].storeName).toEqual(model.urlRoot);
+      dualSync(null, model, {});
+      return expect(localSync.calls[0].args[2].storeName).toEqual(model.urlRoot);
     });
     it('prefers the collection url over the model urlRoot as a store name', function() {
       model = new ModelWithAlternateIdAttribute();
@@ -597,8 +601,8 @@
       model.collection = new Backbone.Collection();
       model.collection.url = '/ranch';
       spyOnLocalsync();
-      dualsync(null, model, {});
-      return expect(localsync.calls[0].args[2].storeName).toEqual(model.collection.url);
+      dualSync(null, model, {});
+      return expect(localSync.calls[0].args[2].storeName).toEqual(model.collection.url);
     });
     it('prefers the model storeName over the collection url as a store name', function() {
       model = new ModelWithAlternateIdAttribute();
@@ -609,8 +613,8 @@
       model.collection.url = '/ranch';
       model.storeName = 'melted cheddar';
       spyOnLocalsync();
-      dualsync(null, model, {});
-      return expect(localsync.calls[0].args[2].storeName).toEqual(model.storeName);
+      dualSync(null, model, {});
+      return expect(localSync.calls[0].args[2].storeName).toEqual(model.storeName);
     });
     return it('prefers the collection storeName over the model storeName as a store name', function() {
       model = new ModelWithAlternateIdAttribute();
@@ -622,8 +626,8 @@
       model.storeName = 'melted cheddar';
       model.collection.storeName = 'ketchup';
       spyOnLocalsync();
-      dualsync(null, model, {});
-      return expect(localsync.calls[0].args[2].storeName).toEqual(model.collection.storeName);
+      dualSync(null, model, {});
+      return expect(localSync.calls[0].args[2].storeName).toEqual(model.collection.storeName);
     });
   });
 
diff --git a/spec/integration_spec.coffee b/spec/integration_spec.coffee
index 54c74dc..21c64d3 100644
--- a/spec/integration_spec.coffee
+++ b/spec/integration_spec.coffee
@@ -1,9 +1,9 @@
-{backboneSync, localsync, dualSync, localStorage} = window
+{backboneSync, localSync, dualSync, localStorage} = window
 {collection, model} = {}
 
 beforeEach ->
   backboneSync.calls = []
-  localsync 'clear', {}, ignoreCallbacks: true, storeName: 'eyes/'
+  localSync 'clear', {}, ignoreCallbacks: true, storeName: 'eyes/'
   collection = new Backbone.Collection
     id: 123
     vision: 'crystal'
@@ -18,7 +18,7 @@ describe 'using Backbone.sync directly', ->
       localStorage.clear()
       successCallback = jasmine.createSpy('success').andCallFake -> saved = true
       errorCallback = jasmine.createSpy('error')
-      dualsync 'create', model, success: successCallback, error: errorCallback
+      dualSync 'create', model, success: successCallback, error: errorCallback
     waitsFor (-> saved), "The success callback for 'create' should have been called", 100
     runs ->
       expect(backboneSync.calls.length).toEqual(1)
@@ -32,7 +32,7 @@ describe 'using Backbone.sync directly', ->
         fetched = true
         expect(resp.vision).toEqual('crystal')
       errorCallback = jasmine.createSpy('error')
-      dualsync 'read', model, success: successCallback, error: errorCallback
+      dualSync 'read', model, success: successCallback, error: errorCallback
     waitsFor (-> fetched), "The success callback for 'read' should have been called", 100
     runs ->
       expect(backboneSync.calls.length).toEqual(2)
diff --git a/spec/integration_spec.js b/spec/integration_spec.js
index f1cde22..96b8dab 100644
--- a/spec/integration_spec.js
+++ b/spec/integration_spec.js
@@ -1,17 +1,17 @@
 // Generated by CoffeeScript 1.6.3
 (function() {
-  var backboneSync, collection, dualSync, localStorage, localsync, model, _ref,
+  var backboneSync, collection, dualSync, localStorage, localSync, model, _ref,
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
     __slice = [].slice;
 
-  backboneSync = window.backboneSync, localsync = window.localsync, dualSync = window.dualSync, localStorage = window.localStorage;
+  backboneSync = window.backboneSync, localSync = window.localSync, dualSync = window.dualSync, localStorage = window.localStorage;
 
   _ref = {}, collection = _ref.collection, model = _ref.model;
 
   beforeEach(function() {
     backboneSync.calls = [];
-    localsync('clear', {}, {
+    localSync('clear', {}, {
       ignoreCallbacks: true,
       storeName: 'eyes/'
     });
@@ -34,7 +34,7 @@
           return saved = true;
         });
         errorCallback = jasmine.createSpy('error');
-        return dualsync('create', model, {
+        return dualSync('create', model, {
           success: successCallback,
           error: errorCallback
         });
@@ -55,7 +55,7 @@
           return expect(resp.vision).toEqual('crystal');
         }));
         errorCallback = jasmine.createSpy('error');
-        return dualsync('read', model, {
+        return dualSync('read', model, {
           success: successCallback,
           error: errorCallback
         });
diff --git a/spec/localstorage_store_spec.coffee b/spec/localstorage_store_spec.coffee
index 5aeec5a..d332e9e 100644
--- a/spec/localstorage_store_spec.coffee
+++ b/spec/localstorage_store_spec.coffee
@@ -7,6 +7,8 @@ describe 'window.Store', ->
     localStorage.setItem 'cats', '3'
     localStorage.setItem 'cats3', '{"id": "3", "color": "burgundy"}'
     store = new Store 'cats'
+    store.initialize()
+    return store
 
   describe 'creation', ->
     it 'takes a name in its constructor', ->
@@ -16,78 +18,87 @@ describe 'window.Store', ->
   describe 'persistence', ->
     describe 'find', ->
       it 'fetches records by id', ->
-        expect(store.find(id: 3)).toEqual id: '3', color: 'burgundy'
+        store.find(id: 3).done (result) ->
+          expect(result).toEqual id: '3', color: 'burgundy'
 
       # JSON.parse(null) causes error on Android 2.x devices, so it should be avoided
       it 'does not try to JSON.parse null values', ->
         spyOn JSON, 'parse'
-        store.find id: 'unpersistedId'
-        expect(JSON.parse).not.toHaveBeenCalledWith(null)
+        store.find(id: 'unpersistedId').done ->
+          expect(JSON.parse).not.toHaveBeenCalledWith(null)
 
       it 'returns null when not found', ->
-        result = store.find(id: 'unpersistedId')
-        expect(result).toBeNull()
+        store.find(id: 'unpersistedId').done (result) ->
+          expect(result).toBeNull()
 
     it 'fetches all records with findAll', ->
-      expect(store.findAll()).toEqual [id: '3', color: 'burgundy']
+      store.findAll().done (result) ->
+        expect(result).toEqual [id: '3', color: 'burgundy']
 
     it 'clears out its records', ->
-      store.clear()
-      expect(localStorage.getItem 'cats').toBe ''
-      expect(localStorage.getItem 'cats3').toBeNull()
+      store.clear().done ->
+        expect(localStorage.getItem 'cats').toBe ''
+        expect(localStorage.getItem 'cats3').toBeNull()
 
     it 'creates records', ->
       model = id: 2, color: 'blue'
-      store.create model
-      expect(localStorage.getItem 'cats').toBe '3,2'
-      expect(JSON.parse(localStorage.getItem 'cats2')).toEqual id: 2, color: 'blue'
+      store.create(model).done ->
+        expect(localStorage.getItem 'cats').toBe '3,2'
+        expect(JSON.parse(localStorage.getItem 'cats2')).toEqual id: 2, color: 'blue'
 
     it 'overwrites existing records with the same id on create', ->
       model = id: 3, color: 'lavender'
-      store.create model
-      expect(JSON.parse(localStorage.getItem 'cats3')).toEqual id: 3, color: 'lavender'
+      store.create(model).done ->
+        expect(JSON.parse(localStorage.getItem 'cats3')).toEqual id: 3, color: 'lavender'
 
     it 'generates an id when creating records with no id', ->
       localStorage.clear()
       store = new Store 'cats'
       model = color: 'calico', idAttribute: 'id', set: (attribute, value) -> this[attribute] = value
-      store.create model
-      expect(model.id).not.toBeNull()
-      expect(localStorage.getItem('cats')).toBe model.id
+      store.create(model).done ->
+        expect(model.id).not.toBeNull()
+        expect(localStorage.getItem('cats')).toBe model.id
 
     it 'updates records', ->
-      store.update id: 3, color: 'green'
-      expect(JSON.parse(localStorage.getItem 'cats3')).toEqual id: 3, color: 'green'
+      store.update(id: 3, color: 'green').done ->
+        expect(JSON.parse(localStorage.getItem 'cats3')).toEqual id: 3, color: 'green'
 
     it 'destroys records', ->
-      store.destroy id: 3
-      expect(localStorage.getItem 'cats').toBe ''
-      expect(localStorage.getItem 'cats3').toBeNull()
+      store.destroy(id: 3).done ->
+        expect(localStorage.getItem 'cats').toBe ''
+        expect(localStorage.getItem 'cats3').toBeNull()
 
   describe 'offline', ->
     it 'on a clean slate, hasDirtyOrDestroyed returns false', ->
-      expect(store.hasDirtyOrDestroyed()).toBeFalsy()
+      store.hasDirtyOrDestroyed().done (result) ->
+        expect(result).toBeFalsy()
 
     it 'marks records dirty and clean, and reports if it hasDirtyOrDestroyed records', ->
-      store.dirty id: 3
-      expect(store.hasDirtyOrDestroyed()).toBeTruthy()
-      store.clean id: 3, 'dirty'
-      expect(store.hasDirtyOrDestroyed()).toBeFalsy()
+      store.dirty(id: 3).done ->
+        store.hasDirtyOrDestroyed().done (result) ->
+          expect(result).toBeTruthy()
+          store.clean(id: 3, 'dirty').done ->
+            store.hasDirtyOrDestroyed().done (result) ->
+              expect(result).toBeFalsy()
 
     it 'marks records destroyed and clean from destruction, and reports if it hasDirtyOrDestroyed records', ->
-      store.destroyed id: 3
-      expect(store.hasDirtyOrDestroyed()).toBeTruthy()
-      store.clean id: 3, 'destroyed'
-      expect(store.hasDirtyOrDestroyed()).toBeFalsy()
+      store.destroyed(id: 3).done ->
+        store.hasDirtyOrDestroyed().done (result) ->
+          expect(result).toBeTruthy()
+          store.clean(id: 3, 'destroyed').done ->
+            store.hasDirtyOrDestroyed().done (result) ->
+              expect(result).toBeFalsy()
 
     it 'cleans the list of dirty or destroyed models out of localStorage after saving or destroying', ->
       collection = new Backbone.Collection [{id: 2, color: 'auburn'}, {id: 3, color: 'burgundy'}]
       collection.url = 'cats'
-      store.dirty id: 2
-      store.destroyed id: 3
-      expect(store.hasDirtyOrDestroyed()).toBeTruthy()
-      collection.get(2).save()
-      collection.get(3).destroy()
-      expect(store.hasDirtyOrDestroyed()).toBeFalsy()
-      expect(localStorage.getItem('cats_dirty').length).toBe 0
-      expect(localStorage.getItem('cats_destroyed').length).toBe 0
+      store.dirty(id: 2).done ->
+        store.destroyed(id: 3).done ->
+          store.hasDirtyOrDestroyed().done (result) ->
+            expect(result).toBeTruthy()
+            collection.get(2).save().done ->
+              collection.get(3).destroy().done ->
+                store.hasDirtyOrDestroyed().done (result) ->
+                  expect(result).toBeFalsy()
+                  expect(localStorage.getItem('cats_dirty').length).toBe 0
+                  expect(localStorage.getItem('cats_destroyed').length).toBe 0
diff --git a/spec/localstorage_store_spec.js b/spec/localstorage_store_spec.js
index e1d512c..2e13490 100644
--- a/spec/localstorage_store_spec.js
+++ b/spec/localstorage_store_spec.js
@@ -11,7 +11,9 @@
       localStorage.clear();
       localStorage.setItem('cats', '3');
       localStorage.setItem('cats3', '{"id": "3", "color": "burgundy"}');
-      return store = new Store('cats');
+      store = new Store('cats');
+      store.initialize();
+      return store;
     });
     describe('creation', function() {
       return it('takes a name in its constructor', function() {
@@ -22,51 +24,58 @@
     describe('persistence', function() {
       describe('find', function() {
         it('fetches records by id', function() {
-          return expect(store.find({
+          return store.find({
             id: 3
-          })).toEqual({
-            id: '3',
-            color: 'burgundy'
+          }).done(function(result) {
+            return expect(result).toEqual({
+              id: '3',
+              color: 'burgundy'
+            });
           });
         });
         it('does not try to JSON.parse null values', function() {
           spyOn(JSON, 'parse');
-          store.find({
+          return store.find({
             id: 'unpersistedId'
+          }).done(function() {
+            return expect(JSON.parse).not.toHaveBeenCalledWith(null);
           });
-          return expect(JSON.parse).not.toHaveBeenCalledWith(null);
         });
         return it('returns null when not found', function() {
-          var result;
-          result = store.find({
+          return store.find({
             id: 'unpersistedId'
+          }).done(function(result) {
+            return expect(result).toBeNull();
           });
-          return expect(result).toBeNull();
         });
       });
       it('fetches all records with findAll', function() {
-        return expect(store.findAll()).toEqual([
-          {
-            id: '3',
-            color: 'burgundy'
-          }
-        ]);
+        return store.findAll().done(function(result) {
+          return expect(result).toEqual([
+            {
+              id: '3',
+              color: 'burgundy'
+            }
+          ]);
+        });
       });
       it('clears out its records', function() {
-        store.clear();
-        expect(localStorage.getItem('cats')).toBe('');
-        return expect(localStorage.getItem('cats3')).toBeNull();
+        return store.clear().done(function() {
+          expect(localStorage.getItem('cats')).toBe('');
+          return expect(localStorage.getItem('cats3')).toBeNull();
+        });
       });
       it('creates records', function() {
         model = {
           id: 2,
           color: 'blue'
         };
-        store.create(model);
-        expect(localStorage.getItem('cats')).toBe('3,2');
-        return expect(JSON.parse(localStorage.getItem('cats2'))).toEqual({
-          id: 2,
-          color: 'blue'
+        return store.create(model).done(function() {
+          expect(localStorage.getItem('cats')).toBe('3,2');
+          return expect(JSON.parse(localStorage.getItem('cats2'))).toEqual({
+            id: 2,
+            color: 'blue'
+          });
         });
       });
       it('overwrites existing records with the same id on create', function() {
@@ -74,10 +83,11 @@
           id: 3,
           color: 'lavender'
         };
-        store.create(model);
-        return expect(JSON.parse(localStorage.getItem('cats3'))).toEqual({
-          id: 3,
-          color: 'lavender'
+        return store.create(model).done(function() {
+          return expect(JSON.parse(localStorage.getItem('cats3'))).toEqual({
+            id: 3,
+            color: 'lavender'
+          });
         });
       });
       it('generates an id when creating records with no id', function() {
@@ -90,51 +100,68 @@
             return this[attribute] = value;
           }
         };
-        store.create(model);
-        expect(model.id).not.toBeNull();
-        return expect(localStorage.getItem('cats')).toBe(model.id);
+        return store.create(model).done(function() {
+          expect(model.id).not.toBeNull();
+          return expect(localStorage.getItem('cats')).toBe(model.id);
+        });
       });
       it('updates records', function() {
-        store.update({
-          id: 3,
-          color: 'green'
-        });
-        return expect(JSON.parse(localStorage.getItem('cats3'))).toEqual({
+        return store.update({
           id: 3,
           color: 'green'
+        }).done(function() {
+          return expect(JSON.parse(localStorage.getItem('cats3'))).toEqual({
+            id: 3,
+            color: 'green'
+          });
         });
       });
       return it('destroys records', function() {
-        store.destroy({
+        return store.destroy({
           id: 3
+        }).done(function() {
+          expect(localStorage.getItem('cats')).toBe('');
+          return expect(localStorage.getItem('cats3')).toBeNull();
         });
-        expect(localStorage.getItem('cats')).toBe('');
-        return expect(localStorage.getItem('cats3')).toBeNull();
       });
     });
     return describe('offline', function() {
       it('on a clean slate, hasDirtyOrDestroyed returns false', function() {
-        return expect(store.hasDirtyOrDestroyed()).toBeFalsy();
+        return store.hasDirtyOrDestroyed().done(function(result) {
+          return expect(result).toBeFalsy();
+        });
       });
       it('marks records dirty and clean, and reports if it hasDirtyOrDestroyed records', function() {
-        store.dirty({
+        return store.dirty({
           id: 3
+        }).done(function() {
+          return store.hasDirtyOrDestroyed().done(function(result) {
+            expect(result).toBeTruthy();
+            return store.clean({
+              id: 3
+            }, 'dirty').done(function() {
+              return store.hasDirtyOrDestroyed().done(function(result) {
+                return expect(result).toBeFalsy();
+              });
+            });
+          });
         });
-        expect(store.hasDirtyOrDestroyed()).toBeTruthy();
-        store.clean({
-          id: 3
-        }, 'dirty');
-        return expect(store.hasDirtyOrDestroyed()).toBeFalsy();
       });
       it('marks records destroyed and clean from destruction, and reports if it hasDirtyOrDestroyed records', function() {
-        store.destroyed({
+        return store.destroyed({
           id: 3
+        }).done(function() {
+          return store.hasDirtyOrDestroyed().done(function(result) {
+            expect(result).toBeTruthy();
+            return store.clean({
+              id: 3
+            }, 'destroyed').done(function() {
+              return store.hasDirtyOrDestroyed().done(function(result) {
+                return expect(result).toBeFalsy();
+              });
+            });
+          });
         });
-        expect(store.hasDirtyOrDestroyed()).toBeTruthy();
-        store.clean({
-          id: 3
-        }, 'destroyed');
-        return expect(store.hasDirtyOrDestroyed()).toBeFalsy();
       });
       return it('cleans the list of dirty or destroyed models out of localStorage after saving or destroying', function() {
         var collection;
@@ -148,18 +175,26 @@
           }
         ]);
         collection.url = 'cats';
-        store.dirty({
+        return store.dirty({
           id: 2
+        }).done(function() {
+          return store.destroyed({
+            id: 3
+          }).done(function() {
+            return store.hasDirtyOrDestroyed().done(function(result) {
+              expect(result).toBeTruthy();
+              return collection.get(2).save().done(function() {
+                return collection.get(3).destroy().done(function() {
+                  return store.hasDirtyOrDestroyed().done(function(result) {
+                    expect(result).toBeFalsy();
+                    expect(localStorage.getItem('cats_dirty').length).toBe(0);
+                    return expect(localStorage.getItem('cats_destroyed').length).toBe(0);
+                  });
+                });
+              });
+            });
+          });
         });
-        store.destroyed({
-          id: 3
-        });
-        expect(store.hasDirtyOrDestroyed()).toBeTruthy();
-        collection.get(2).save();
-        collection.get(3).destroy();
-        expect(store.hasDirtyOrDestroyed()).toBeFalsy();
-        expect(localStorage.getItem('cats_dirty').length).toBe(0);
-        return expect(localStorage.getItem('cats_destroyed').length).toBe(0);
       });
     });
   });
diff --git a/spec/localsync_spec.coffee b/spec/localsync_spec.coffee
index aaad3bf..882c2cc 100644
--- a/spec/localsync_spec.coffee
+++ b/spec/localsync_spec.coffee
@@ -1,14 +1,14 @@
-{Store, Backbone, localsync} = window
+{Store, Backbone, localSync} = window
 
-describe 'localsync', ->
+describe 'localSync', ->
   describe 'standard Backbone.sync methods', ->
     describe 'creating records', ->
       it 'creates records', ->
         {ready, create, model} = {}
         runs ->
-          create = spyOn(Store.prototype, 'create')
           model = new Backbone.Model id: 1
-          localsync 'create', model, {success: (-> ready = true), error: (-> ready = true)}
+          create = spyOn(Store.prototype, 'create').andReturn $.Deferred().resolve(model)
+          localSync 'create', model, {success: (-> ready = true), error: (-> ready = true)}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(create).toHaveBeenCalledWith model
@@ -17,16 +17,16 @@ describe 'localsync', ->
         {ready, create} = {}
         runs ->
           ready = false
-          create = spyOn(Store.prototype, 'find').andReturn id: 1
-          create = spyOn(Store.prototype, 'create')
+          create = spyOn(Store.prototype, 'find').andReturn $.Deferred().resolve(id: 1)
+          create = spyOn(Store.prototype, 'create').andReturn $.Deferred().resolve()
           model = new Backbone.Model id: 1
-          localsync 'create', model, {success: (-> ready = true), error: (-> ready = true), add: true}
+          localSync 'create', model, {success: (-> ready = true), error: (-> ready = true), add: true}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           ready = false
           expect(create).not.toHaveBeenCalled()
           model = new Backbone.Model id: 1
-          localsync 'create', model, {success: (-> ready = true), error: (-> ready = true), add: true, merge: true}
+          localSync 'create', model, {success: (-> ready = true), error: (-> ready = true), add: true, merge: true}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(create).toHaveBeenCalled()
@@ -35,9 +35,9 @@ describe 'localsync', ->
         {ready, create, model, dirty} = {}
         runs ->
           model = new Backbone.Model id: 1
-          create = spyOn(Store.prototype, 'create').andReturn model
-          dirty = spyOn(Store.prototype, 'dirty')
-          localsync 'create', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
+          create = spyOn(Store.prototype, 'create').andReturn $.Deferred().resolve(model)
+          dirty = spyOn(Store.prototype, 'dirty').andReturn $.Deferred().resolve(model)
+          localSync 'create', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(create).toHaveBeenCalledWith model
@@ -47,9 +47,9 @@ describe 'localsync', ->
       it 'reads models', ->
         {ready, find, model} = {}
         runs ->
-          find = spyOn(Store.prototype, 'find')
           model = new Backbone.Model id: 1
-          localsync 'read', model, {success: (-> ready = true), error: (-> ready = true)}
+          find = spyOn(Store.prototype, 'find').andReturn $.Deferred().resolve(model)
+          localSync 'read', model, {success: (-> ready = true), error: (-> ready = true)}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(find).toHaveBeenCalledWith model
@@ -57,8 +57,8 @@ describe 'localsync', ->
       it 'reads collections', ->
         {ready, findAll} = {}
         runs ->
-          findAll = spyOn(Store.prototype, 'findAll')
-          localsync 'read', new Backbone.Collection, {success: (-> ready = true), error: (-> ready = true)}
+          findAll = spyOn(Store.prototype, 'findAll').andReturn $.Deferred().resolve()
+          localSync 'read', new Backbone.Collection, {success: (-> ready = true), error: (-> ready = true)}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(findAll).toHaveBeenCalled()
@@ -67,9 +67,9 @@ describe 'localsync', ->
       it 'updates records', ->
         {ready, update, model} = {}
         runs ->
-          update = spyOn(Store.prototype, 'update')
           model = new Backbone.Model id: 1
-          localsync 'update', model, {success: (-> ready = true), error: (-> ready = true)}
+          update = spyOn(Store.prototype, 'update').andReturn $.Deferred().resolve(model)
+          localSync 'update', model, {success: (-> ready = true), error: (-> ready = true)}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(update).toHaveBeenCalledWith model
@@ -78,9 +78,9 @@ describe 'localsync', ->
         {ready, update, model, dirty} = {}
         runs ->
           model = new Backbone.Model id: 1
-          update = spyOn(Store.prototype, 'update')
-          dirty = spyOn(Store.prototype, 'dirty')
-          localsync 'update', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
+          update = spyOn(Store.prototype, 'update').andReturn $.Deferred().resolve(model)
+          dirty = spyOn(Store.prototype, 'dirty').andReturn $.Deferred().resolve(model)
+          localSync 'update', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(update).toHaveBeenCalledWith model
@@ -90,9 +90,9 @@ describe 'localsync', ->
       it 'deletes records', ->
         {ready, destroy, model} = {}
         runs ->
-          destroy = spyOn(Store.prototype, 'destroy')
           model = new Backbone.Model id: 1
-          localsync 'delete', model, {success: (-> ready = true), error: (-> ready = true)}
+          destroy = spyOn(Store.prototype, 'destroy').andReturn $.Deferred().resolve(model)
+          localSync 'delete', model, {success: (-> ready = true), error: (-> ready = true)}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(destroy).toHaveBeenCalledWith model
@@ -101,9 +101,9 @@ describe 'localsync', ->
         {ready, destroy, destroyed, model} = {}
         runs ->
           model = new Backbone.Model id: 1
-          destroy = spyOn(Store.prototype, 'destroy')
-          destroyed = spyOn(Store.prototype, 'destroyed')
-          localsync 'delete', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
+          destroy = spyOn(Store.prototype, 'destroy').andReturn $.Deferred().resolve(model)
+          destroyed = spyOn(Store.prototype, 'destroyed').andReturn $.Deferred().resolve(model)
+          localSync 'delete', model, {success: (-> ready = true), error: (-> ready = true), dirty: true}
         waitsFor (-> ready), "A callback should have been called", 100
         runs ->
           expect(destroy).toHaveBeenCalledWith model
@@ -112,20 +112,20 @@ describe 'localsync', ->
   describe 'extra methods', ->
     it 'clears out all records from the store', ->
       runs ->
-        clear = spyOn(Store.prototype, 'clear')
-        localsync 'clear', {}, {success: (-> ready = true), error: (-> ready = true)}
+        clear = spyOn(Store.prototype, 'clear').andReturn $.Deferred().resolve()
+        localSync 'clear', {}, {success: (-> ready = true), error: (-> ready = true)}
 
     it 'reports whether or not it hasDirtyOrDestroyed', ->
       runs ->
-        clear = spyOn(Store.prototype, 'hasDirtyOrDestroyed')
-        localsync 'hasDirtyOrDestroyed', {}, {success: (-> ready = true), error: (-> ready = true)}
+        clear = spyOn(Store.prototype, 'hasDirtyOrDestroyed').andReturn $.Deferred().resolve()
+        localSync 'hasDirtyOrDestroyed', {}, {success: (-> ready = true), error: (-> ready = true)}
 
   describe 'callbacks', ->
     it "sends the models's attributes as the callback response", ->
       {model, response} = {}
       runs ->
         model = new Backbone.Model id: 1
-        localsync 'create', model, {success: ((resp) -> response = resp)}
+        localSync 'create', model, {success: ((resp) -> response = resp)}
       waitsFor (-> response), "A callback should have been called with a response", 100
       runs ->
         expect(response).toBe model.attributes
@@ -135,36 +135,36 @@ describe 'localsync', ->
       runs ->
         callback = jasmine.createSpy 'callback'
         model = new Backbone.Model id: 1
-        localsync 'create', model, {success: callback, error: callback, ignoreCallbacks: true}
+        localSync 'create', model, {success: callback, error: callback, ignoreCallbacks: true}
       waitsFor (-> new Date().getTime() - start > 5), 'Wait 5 ms to give the callback a chance to execute', 100
       runs ->
         start = false
         expect(callback).not.toHaveBeenCalled()
         model = new Backbone.Model id: 1
-        localsync 'create', model, {success: callback, error: callback}
+        localSync 'create', model, {success: callback, error: callback}
       waitsFor (-> callback.wasCalled), 'The callback should have been called', 100
 
   describe 'model parameter', ->
     beforeEach ->
-      spyOn(Store.prototype, 'create')
+      spyOn(Store.prototype, 'create').andReturn $.Deferred().resolve()
 
     it 'should not accept objects / attributes as model', ->
       attributes = {}
-      call = -> localsync 'create', attributes, {ignoreCallbacks: true}
+      call = -> localSync 'create', attributes, {ignoreCallbacks: true}
       expect(call).toThrow()
 
     it 'should accept a backbone model as model', ->
-      call = -> localsync 'create', new Backbone.Model, {ignoreCallbacks: true}
+      call = -> localSync 'create', new Backbone.Model, {ignoreCallbacks: true}
       expect(call).not.toThrow()
 
     it 'should accept a backbone collection as model', ->
-      call = -> localsync 'create', new Backbone.Collection, {ignoreCallbacks: true}
+      call = -> localSync 'create', new Backbone.Collection, {ignoreCallbacks: true}
       expect(call).not.toThrow()
 
     it 'should accept any object as model on extra method "clear"', ->
-      call = -> localsync 'clear', {}, {ignoreCallbacks: true}
+      call = -> localSync 'clear', {}, {ignoreCallbacks: true}
       expect(call).not.toThrow()
 
     it 'should accept any object as model on extra method "hasDirtyOrDestroyed"', ->
-      call = -> localsync 'hasDirtyOrDestroyed', {}, {ignoreCallbacks: true}
+      call = -> localSync 'hasDirtyOrDestroyed', {}, {ignoreCallbacks: true}
       expect(call).not.toThrow()
diff --git a/spec/localsync_spec.js b/spec/localsync_spec.js
index 25bcf17..e58588e 100644
--- a/spec/localsync_spec.js
+++ b/spec/localsync_spec.js
@@ -1,21 +1,21 @@
 // Generated by CoffeeScript 1.6.3
 (function() {
-  var Backbone, Store, localsync;
+  var Backbone, Store, localSync;
 
-  Store = window.Store, Backbone = window.Backbone, localsync = window.localsync;
+  Store = window.Store, Backbone = window.Backbone, localSync = window.localSync;
 
-  describe('localsync', function() {
+  describe('localSync', function() {
     describe('standard Backbone.sync methods', function() {
       describe('creating records', function() {
         it('creates records', function() {
           var create, model, ready, _ref;
           _ref = {}, ready = _ref.ready, create = _ref.create, model = _ref.model;
           runs(function() {
-            create = spyOn(Store.prototype, 'create');
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('create', model, {
+            create = spyOn(Store.prototype, 'create').andReturn($.Deferred().resolve(model));
+            return localSync('create', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -37,14 +37,14 @@
           runs(function() {
             var model;
             ready = false;
-            create = spyOn(Store.prototype, 'find').andReturn({
+            create = spyOn(Store.prototype, 'find').andReturn($.Deferred().resolve({
               id: 1
-            });
-            create = spyOn(Store.prototype, 'create');
+            }));
+            create = spyOn(Store.prototype, 'create').andReturn($.Deferred().resolve());
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('create', model, {
+            return localSync('create', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -64,7 +64,7 @@
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('create', model, {
+            return localSync('create', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -89,9 +89,9 @@
             model = new Backbone.Model({
               id: 1
             });
-            create = spyOn(Store.prototype, 'create').andReturn(model);
-            dirty = spyOn(Store.prototype, 'dirty');
-            return localsync('create', model, {
+            create = spyOn(Store.prototype, 'create').andReturn($.Deferred().resolve(model));
+            dirty = spyOn(Store.prototype, 'dirty').andReturn($.Deferred().resolve(model));
+            return localSync('create', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -115,11 +115,11 @@
           var find, model, ready, _ref;
           _ref = {}, ready = _ref.ready, find = _ref.find, model = _ref.model;
           runs(function() {
-            find = spyOn(Store.prototype, 'find');
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('read', model, {
+            find = spyOn(Store.prototype, 'find').andReturn($.Deferred().resolve(model));
+            return localSync('read', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -139,8 +139,8 @@
           var findAll, ready, _ref;
           _ref = {}, ready = _ref.ready, findAll = _ref.findAll;
           runs(function() {
-            findAll = spyOn(Store.prototype, 'findAll');
-            return localsync('read', new Backbone.Collection, {
+            findAll = spyOn(Store.prototype, 'findAll').andReturn($.Deferred().resolve());
+            return localSync('read', new Backbone.Collection, {
               success: (function() {
                 return ready = true;
               }),
@@ -162,11 +162,11 @@
           var model, ready, update, _ref;
           _ref = {}, ready = _ref.ready, update = _ref.update, model = _ref.model;
           runs(function() {
-            update = spyOn(Store.prototype, 'update');
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('update', model, {
+            update = spyOn(Store.prototype, 'update').andReturn($.Deferred().resolve(model));
+            return localSync('update', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -189,9 +189,9 @@
             model = new Backbone.Model({
               id: 1
             });
-            update = spyOn(Store.prototype, 'update');
-            dirty = spyOn(Store.prototype, 'dirty');
-            return localsync('update', model, {
+            update = spyOn(Store.prototype, 'update').andReturn($.Deferred().resolve(model));
+            dirty = spyOn(Store.prototype, 'dirty').andReturn($.Deferred().resolve(model));
+            return localSync('update', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -215,11 +215,11 @@
           var destroy, model, ready, _ref;
           _ref = {}, ready = _ref.ready, destroy = _ref.destroy, model = _ref.model;
           runs(function() {
-            destroy = spyOn(Store.prototype, 'destroy');
             model = new Backbone.Model({
               id: 1
             });
-            return localsync('delete', model, {
+            destroy = spyOn(Store.prototype, 'destroy').andReturn($.Deferred().resolve(model));
+            return localSync('delete', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -242,9 +242,9 @@
             model = new Backbone.Model({
               id: 1
             });
-            destroy = spyOn(Store.prototype, 'destroy');
-            destroyed = spyOn(Store.prototype, 'destroyed');
-            return localsync('delete', model, {
+            destroy = spyOn(Store.prototype, 'destroy').andReturn($.Deferred().resolve(model));
+            destroyed = spyOn(Store.prototype, 'destroyed').andReturn($.Deferred().resolve(model));
+            return localSync('delete', model, {
               success: (function() {
                 return ready = true;
               }),
@@ -268,8 +268,8 @@
       it('clears out all records from the store', function() {
         return runs(function() {
           var clear;
-          clear = spyOn(Store.prototype, 'clear');
-          return localsync('clear', {}, {
+          clear = spyOn(Store.prototype, 'clear').andReturn($.Deferred().resolve());
+          return localSync('clear', {}, {
             success: (function() {
               var ready;
               return ready = true;
@@ -284,8 +284,8 @@
       return it('reports whether or not it hasDirtyOrDestroyed', function() {
         return runs(function() {
           var clear;
-          clear = spyOn(Store.prototype, 'hasDirtyOrDestroyed');
-          return localsync('hasDirtyOrDestroyed', {}, {
+          clear = spyOn(Store.prototype, 'hasDirtyOrDestroyed').andReturn($.Deferred().resolve());
+          return localSync('hasDirtyOrDestroyed', {}, {
             success: (function() {
               var ready;
               return ready = true;
@@ -306,7 +306,7 @@
           model = new Backbone.Model({
             id: 1
           });
-          return localsync('create', model, {
+          return localSync('create', model, {
             success: (function(resp) {
               return response = resp;
             })
@@ -330,7 +330,7 @@
           model = new Backbone.Model({
             id: 1
           });
-          return localsync('create', model, {
+          return localSync('create', model, {
             success: callback,
             error: callback,
             ignoreCallbacks: true
@@ -346,7 +346,7 @@
           model = new Backbone.Model({
             id: 1
           });
-          return localsync('create', model, {
+          return localSync('create', model, {
             success: callback,
             error: callback
           });
@@ -358,13 +358,13 @@
     });
     return describe('model parameter', function() {
       beforeEach(function() {
-        return spyOn(Store.prototype, 'create');
+        return spyOn(Store.prototype, 'create').andReturn($.Deferred().resolve());
       });
       it('should not accept objects / attributes as model', function() {
         var attributes, call;
         attributes = {};
         call = function() {
-          return localsync('create', attributes, {
+          return localSync('create', attributes, {
             ignoreCallbacks: true
           });
         };
@@ -373,7 +373,7 @@
       it('should accept a backbone model as model', function() {
         var call;
         call = function() {
-          return localsync('create', new Backbone.Model, {
+          return localSync('create', new Backbone.Model, {
             ignoreCallbacks: true
           });
         };
@@ -382,7 +382,7 @@
       it('should accept a backbone collection as model', function() {
         var call;
         call = function() {
-          return localsync('create', new Backbone.Collection, {
+          return localSync('create', new Backbone.Collection, {
             ignoreCallbacks: true
           });
         };
@@ -391,7 +391,7 @@
       it('should accept any object as model on extra method "clear"', function() {
         var call;
         call = function() {
-          return localsync('clear', {}, {
+          return localSync('clear', {}, {
             ignoreCallbacks: true
           });
         };
@@ -400,7 +400,7 @@
       return it('should accept any object as model on extra method "hasDirtyOrDestroyed"', function() {
         var call;
         call = function() {
-          return localsync('hasDirtyOrDestroyed', {}, {
+          return localSync('hasDirtyOrDestroyed', {}, {
             ignoreCallbacks: true
           });
         };
diff --git a/spec/stickystorage_spec.coffee b/spec/stickystorage_spec.coffee
new file mode 100644
index 0000000..ca0ee78
--- /dev/null
+++ b/spec/stickystorage_spec.coffee
@@ -0,0 +1,47 @@
+{StickyStorageAdapter} = window.Backbone.storageAdapters;
+
+describe 'StickyStorageAdapter', ->
+  beforeEach ->
+    done = false
+    runs ->
+      storage = new StickyStorageAdapter
+      storage.initialize().done ->
+        storage.clear().done ->
+          done = true
+    waitsFor -> done
+
+  describe 'creation', ->
+    it 'takes a name in its constructor', ->
+      # This should actually test that the created storage (IndexedDB, WebSQL, etc) uses this name.
+      # But we trust Sticky to do its job :)
+      storage = new StickyStorageAdapter 'SuperSizedStorage'
+      expect(storage.name).toBe 'SuperSizedStorage'
+
+    it 'initializes', ->
+      storage = new StickyStorageAdapter
+      storage.initialize().done ->
+        expect(storage.store instanceof StickyStore).toBe true
+
+  describe 'methods', ->
+    it 'sets and gets a record', ->
+      {result} = {}
+      runs ->
+        storage = new StickyStorageAdapter
+        storage.initialize().done ->
+          storage.setItem('test', foo: 'bar').done ->
+            storage.getItem('test').done (item) ->
+              result = item
+      waitsFor -> result?
+      runs -> expect(result).toEqual foo: 'bar'
+
+    it 'deletes a record', ->
+      {result} = {}
+      runs ->
+        storage = new StickyStorageAdapter
+        storage.initialize().done ->
+          storage.setItem('test', foo: 'bar').done ->
+            storage.removeItem('test').done ->
+              storage.getItem('test').done (item) ->
+                result = item
+      waitsFor -> result?
+      runs -> expect(result).toBeNull()
diff --git a/spec/stickystorage_spec.js b/spec/stickystorage_spec.js
new file mode 100644
index 0000000..6a20779
--- /dev/null
+++ b/spec/stickystorage_spec.js
@@ -0,0 +1,92 @@
+// Generated by CoffeeScript 1.6.3
+(function() {
+  var StickyStorageAdapter;
+
+  StickyStorageAdapter = window.Backbone.storageAdapters.StickyStorageAdapter;
+
+  describe('StickyStorageAdapter', function() {
+    beforeEach(function() {
+      var done;
+      done = false;
+      runs(function() {
+        var storage;
+        storage = new StickyStorageAdapter;
+        return storage.initialize().done(function() {
+          return storage.clear().done(function() {
+            return done = true;
+          });
+        });
+      });
+      return waitsFor(function() {
+        return done;
+      });
+    });
+    describe('creation', function() {
+      it('takes a name in its constructor', function() {
+        var storage;
+        storage = new StickyStorageAdapter('SuperSizedStorage');
+        return expect(storage.name).toBe('SuperSizedStorage');
+      });
+      return it('initializes', function() {
+        var storage;
+        storage = new StickyStorageAdapter;
+        return storage.initialize().done(function() {
+          return expect(storage.store instanceof StickyStore).toBe(true);
+        });
+      });
+    });
+    return describe('methods', function() {
+      it('sets and gets a record', function() {
+        var result;
+        result = {}.result;
+        runs(function() {
+          var storage;
+          storage = new StickyStorageAdapter;
+          return storage.initialize().done(function() {
+            return storage.setItem('test', {
+              foo: 'bar'
+            }).done(function() {
+              return storage.getItem('test').done(function(item) {
+                return result = item;
+              });
+            });
+          });
+        });
+        waitsFor(function() {
+          return result != null;
+        });
+        return runs(function() {
+          return expect(result).toEqual({
+            foo: 'bar'
+          });
+        });
+      });
+      return it('deletes a record', function() {
+        var result;
+        result = {}.result;
+        runs(function() {
+          var storage;
+          storage = new StickyStorageAdapter;
+          return storage.initialize().done(function() {
+            return storage.setItem('test', {
+              foo: 'bar'
+            }).done(function() {
+              return storage.removeItem('test').done(function() {
+                return storage.getItem('test').done(function(item) {
+                  return result = item;
+                });
+              });
+            });
+          });
+        });
+        waitsFor(function() {
+          return result != null;
+        });
+        return runs(function() {
+          return expect(result).toBeNull();
+        });
+      });
+    });
+  });
+
+}).call(this);
diff --git a/src/adapters.coffee b/src/adapters.coffee
new file mode 100644
index 0000000..3161570
--- /dev/null
+++ b/src/adapters.coffee
@@ -0,0 +1,92 @@
+# Async storage adapter classes.
+Backbone.storageAdapters = {}
+
+class Backbone.storageAdapters.LocalStorageAdapter
+  # Reference implementation with LocalStorage.
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.LocalStorage'
+    @store = localStorage
+
+  initialize: ->
+    $.Deferred().resolve()
+
+  set: (key, value) ->
+    @store.setItem key, JSON.stringify value
+    $.Deferred().resolve value
+
+  get: (key) ->
+    $.Deferred().resolve JSON.parse @store.getItem key
+
+  remove: (key) ->
+    @store.removeItem key
+    $.Deferred().resolve()
+
+  clear: ->
+    @store.clear()
+    $.Deferred().resolve()
+
+
+class Backbone.storageAdapters.LawnchairStorageAdapter
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.Lawnchair'
+
+  initialize: ->
+    promise = $.Deferred()
+    @store = new Lawnchair
+      name: @name
+      adapter: ['indexed-db'], -> promise.resolve()
+    return promise
+
+  set: (key, value) ->
+    promise = $.Deferred()
+    @store.save {key: key, value: value}, (data) -> promise.resolve data.value
+    return promise
+
+  get: (key) ->
+    promise = $.Deferred()
+    @store.get key, (data) -> promise.resolve data?.value
+    return promise
+
+  remove: (key) ->
+    promise = $.Deferred()
+    @store.remove key, -> promise.resolve()
+    return promise
+
+  clear: ->
+    promise = $.Deferred()
+    @store.nuke -> promise.resolve()
+    return promise
+
+
+# IndexedDB store is currently not working with Sticky.
+class Backbone.storageAdapters.StickyStorageAdapter
+  constructor: (name) ->
+    @name = name || 'Backbone.dualStorage.Sticky'
+
+  initialize: ->
+    promise = $.Deferred()
+    @store = new StickyStore
+      name: @name
+      adapters: ['indexedDB']
+      ready: -> promise.resolve()
+    return promise
+
+  set: (key, value) ->
+    promise = $.Deferred()
+    @store.set {key: key, value: value}, (data) -> promise.resolve data.value
+    return promise
+
+  get: (key) ->
+    promise = $.Deferred()
+    @store.get key, (data) -> promise.resolve data?.value
+    return promise
+
+  remove: (key) ->
+    promise = $.Deferred()
+    @store.remove key, -> promise.resolve()
+    return promise
+
+  clear: ->
+    promise = $.Deferred()
+    @store.removeAll -> promise.resolve()
+    return promise
diff --git a/src/adapters.js b/src/adapters.js
new file mode 100644
index 0000000..5c3a8cc
--- /dev/null
+++ b/src/adapters.js
@@ -0,0 +1,156 @@
+// Generated by CoffeeScript 1.6.3
+Backbone.storageAdapters = {};
+
+Backbone.storageAdapters.LocalStorageAdapter = (function() {
+  function LocalStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.LocalStorage';
+    this.store = localStorage;
+  }
+
+  LocalStorageAdapter.prototype.initialize = function() {
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.set = function(key, value) {
+    this.store.setItem(key, JSON.stringify(value));
+    return $.Deferred().resolve(value);
+  };
+
+  LocalStorageAdapter.prototype.get = function(key) {
+    return $.Deferred().resolve(JSON.parse(this.store.getItem(key)));
+  };
+
+  LocalStorageAdapter.prototype.remove = function(key) {
+    this.store.removeItem(key);
+    return $.Deferred().resolve();
+  };
+
+  LocalStorageAdapter.prototype.clear = function() {
+    this.store.clear();
+    return $.Deferred().resolve();
+  };
+
+  return LocalStorageAdapter;
+
+})();
+
+Backbone.storageAdapters.LawnchairStorageAdapter = (function() {
+  function LawnchairStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Lawnchair';
+  }
+
+  LawnchairStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new Lawnchair({
+      name: this.name,
+      adapter: ['indexed-db']
+    }, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.save({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  LawnchairStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.nuke(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  return LawnchairStorageAdapter;
+
+})();
+
+Backbone.storageAdapters.StickyStorageAdapter = (function() {
+  function StickyStorageAdapter(name) {
+    this.name = name || 'Backbone.dualStorage.Sticky';
+  }
+
+  StickyStorageAdapter.prototype.initialize = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store = new StickyStore({
+      name: this.name,
+      adapters: ['indexedDB'],
+      ready: function() {
+        return promise.resolve();
+      }
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.set = function(key, value) {
+    var promise;
+    promise = $.Deferred();
+    this.store.set({
+      key: key,
+      value: value
+    }, function(data) {
+      return promise.resolve(data.value);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.get = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.get(key, function(data) {
+      return promise.resolve(data != null ? data.value : void 0);
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.remove = function(key) {
+    var promise;
+    promise = $.Deferred();
+    this.store.remove(key, function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  StickyStorageAdapter.prototype.clear = function() {
+    var promise;
+    promise = $.Deferred();
+    this.store.removeAll(function() {
+      return promise.resolve();
+    });
+    return promise;
+  };
+
+  return StickyStorageAdapter;
+
+})();
diff --git a/src/dualSync.coffee b/src/dualSync.coffee
new file mode 100644
index 0000000..815782f
--- /dev/null
+++ b/src/dualSync.coffee
@@ -0,0 +1,139 @@
+# Backbone.sync replacement for dual data persistance
+
+updateModelWithResponse = (model, response) ->
+  modelClone = new Backbone.Model
+  modelClone.idAttribute = model.idAttribute
+  modelClone.set model.attributes
+  modelClone.set modelClone.parse response
+  modelClone
+
+onlineSync = Backbone.sync
+
+dualSync = (method, model, options) ->
+  options.storeName = _.result(model.collection, 'storeName') or
+                      _.result(model, 'storeName') or
+                      _.result(model.collection, 'url') or
+                      _.result(model, 'urlRoot') or
+                      _.result(model, 'url')
+
+  if _.result(model, 'onlyRemote') or _.result(model.collection, 'onlyRemote')
+    return onlineSync(method, model, options)
+
+  onlyLocal = _.result(model, 'onlyLocal') or _.result(model.collection, 'onlyLocal')
+  options.offline = not onlyLocal and options.remote == false
+  if onlyLocal or options.remote == false
+    return localSync(method, model, options).done (response) ->
+      options?.success model, response, options
+
+  # TODO: implement parseBeforeLocalSave
+  success = options.success
+  error = options.error
+
+  switch method
+    when 'read'
+      localSync('hasDirtyOrDestroyed', model, options).then (hasDirtyOrDestroyed) ->
+        if hasDirtyOrDestroyed
+          # The store has dirty or destroyed models, return local data only.
+          return localSync('read', model, options).done (response) ->
+            options?.success model, response, options
+        else
+          # Run onlineSync and then save models locally.
+          returnModel = model
+          options.success = (model, response, options) ->
+            models = []
+            if _.isArray response
+              collection = model
+              idAttribute = collection.model.prototype.idAttribute
+              for modelAttributes in response
+                model = collection.get(modelAttributes[idAttribute])
+                model and model = updateModelWithResponse(model, modelAttributes)
+                if not model
+                  model = new collection.model(modelAttributes)
+                models.push model
+            else
+              models = [updateModelWithResponse(model, response)]
+
+            if not options.add
+              promise = localSync('clear', model, options)
+            else
+              promise = $.Deferred().resolve()
+
+            promise.done = ->
+              promises = (localSync('create', model, options) for model in models)
+              $.when(promises...).then ->
+                success? returnModel, response, options
+
+          # On read error, return local models
+          options.error = (model, response, options) ->
+            localSync('read', model, options).then (response) ->
+              success? model, response, options
+
+          onlineSync 'read', model, options
+
+    when 'create'
+      options.success = (model, response, options) ->
+        updatedModel = updateModelWithResponse model, response
+        localSync('create', updatedModel, options).then (savedModel) ->
+          success? model, savedModel.attributes, options
+
+      options.error = (model, response, options) ->
+        options.offline = true
+        localSync('create', model, options).then (savedModel) ->
+          success? model, savedModel.attributes, options
+
+      onlineSync 'create', model, options
+
+    when 'update'
+      # TODO: use localSync and check if model is in local list
+      # instead of checking id length.
+
+      if model?.id.length == 36
+        temporaryId = model.id
+
+        options.success = (model, response, options) ->
+          updatedModel = updateModelWithResponse model, response
+          model.set model.idAttribute, temporaryId, silent: true
+          localSync('remove', model, options).then ->
+            localSync('create', updatedModel, options).then (savedModel)->
+              success? savedModel, savedModel.attributes, options
+
+        options.error = (model, response, options) ->
+          options.offline = true
+          model.set model.idAttribute, temporaryId, silent: true
+          localSync('update', model, options).then (savedModel) ->
+            success? savedModel, savedModel.attributes, options
+
+        model.set model.idAttribute, null, silent: true
+        onlineSync 'create', model, options
+
+      else
+        options.success = (model, response, options) ->
+          updatedModel = updateModelWithResponse model, response
+          localSync('update', updatedModel, options).then ->
+            success? model, response, options
+
+        options.error = (model, response, options) ->
+          options.offline = true
+          localSync('update', model, options).then ->
+            success? model, response, options
+
+        onlineSync 'update', model, options
+
+    when 'remove'
+      if model?.id.length == 36
+        localSync 'remove', model, options
+      else
+        options.success = (model, response, options) ->
+          localSync('remove', model, options).then ->
+            success? model, response, options
+
+        options.error = (model, response, options) ->
+          options.offline = true
+          localSync('remove', model, options).then ->
+            success? model, response, options
+
+        onlineSync 'remove', model, options
+
+
+Backbone.onlineSync = onlineSync
+Backbone.dualSync = dualSync
diff --git a/src/dualSync.js b/src/dualSync.js
new file mode 100644
index 0000000..1106263
--- /dev/null
+++ b/src/dualSync.js
@@ -0,0 +1,169 @@
+// Generated by CoffeeScript 1.6.3
+var dualSync, onlineSync, updateModelWithResponse;
+
+updateModelWithResponse = function(model, response) {
+  var modelClone;
+  modelClone = new Backbone.Model;
+  modelClone.idAttribute = model.idAttribute;
+  modelClone.set(model.attributes);
+  modelClone.set(modelClone.parse(response));
+  return modelClone;
+};
+
+onlineSync = Backbone.sync;
+
+dualSync = function(method, model, options) {
+  var error, onlyLocal, success, temporaryId;
+  options.storeName = _.result(model.collection, 'storeName') || _.result(model, 'storeName') || _.result(model.collection, 'url') || _.result(model, 'urlRoot') || _.result(model, 'url');
+  if (_.result(model, 'onlyRemote') || _.result(model.collection, 'onlyRemote')) {
+    return onlineSync(method, model, options);
+  }
+  onlyLocal = _.result(model, 'onlyLocal') || _.result(model.collection, 'onlyLocal');
+  options.offline = !onlyLocal && options.remote === false;
+  if (onlyLocal || options.remote === false) {
+    return localSync(method, model, options).done(function(response) {
+      return options != null ? options.success(model, response, options) : void 0;
+    });
+  }
+  success = options.success;
+  error = options.error;
+  switch (method) {
+    case 'read':
+      return localSync('hasDirtyOrDestroyed', model, options).then(function(hasDirtyOrDestroyed) {
+        var returnModel;
+        if (hasDirtyOrDestroyed) {
+          return localSync('read', model, options).done(function(response) {
+            return options != null ? options.success(model, response, options) : void 0;
+          });
+        } else {
+          returnModel = model;
+          options.success = function(model, response, options) {
+            var collection, idAttribute, modelAttributes, models, promise, _i, _len;
+            models = [];
+            if (_.isArray(response)) {
+              collection = model;
+              idAttribute = collection.model.prototype.idAttribute;
+              for (_i = 0, _len = response.length; _i < _len; _i++) {
+                modelAttributes = response[_i];
+                model = collection.get(modelAttributes[idAttribute]);
+                model && (model = updateModelWithResponse(model, modelAttributes));
+                if (!model) {
+                  model = new collection.model(modelAttributes);
+                }
+                models.push(model);
+              }
+            } else {
+              models = [updateModelWithResponse(model, response)];
+            }
+            if (!options.add) {
+              promise = localSync('clear', model, options);
+            } else {
+              promise = $.Deferred().resolve();
+            }
+            return promise.done = function() {
+              var promises;
+              promises = (function() {
+                var _j, _len1, _results;
+                _results = [];
+                for (_j = 0, _len1 = models.length; _j < _len1; _j++) {
+                  model = models[_j];
+                  _results.push(localSync('create', model, options));
+                }
+                return _results;
+              })();
+              return $.when.apply($, promises).then(function() {
+                return typeof success === "function" ? success(returnModel, response, options) : void 0;
+              });
+            };
+          };
+          options.error = function(model, response, options) {
+            return localSync('read', model, options).then(function(response) {
+              return typeof success === "function" ? success(model, response, options) : void 0;
+            });
+          };
+          return onlineSync('read', model, options);
+        }
+      });
+    case 'create':
+      options.success = function(model, response, options) {
+        var updatedModel;
+        updatedModel = updateModelWithResponse(model, response);
+        return localSync('create', updatedModel, options).then(function(savedModel) {
+          return typeof success === "function" ? success(model, savedModel.attributes, options) : void 0;
+        });
+      };
+      options.error = function(model, response, options) {
+        options.offline = true;
+        return localSync('create', model, options).then(function(savedModel) {
+          return typeof success === "function" ? success(model, savedModel.attributes, options) : void 0;
+        });
+      };
+      return onlineSync('create', model, options);
+    case 'update':
+      if ((model != null ? model.id.length : void 0) === 36) {
+        temporaryId = model.id;
+        options.success = function(model, response, options) {
+          var updatedModel;
+          updatedModel = updateModelWithResponse(model, response);
+          model.set(model.idAttribute, temporaryId, {
+            silent: true
+          });
+          return localSync('remove', model, options).then(function() {
+            return localSync('create', updatedModel, options).then(function(savedModel) {
+              return typeof success === "function" ? success(savedModel, savedModel.attributes, options) : void 0;
+            });
+          });
+        };
+        options.error = function(model, response, options) {
+          options.offline = true;
+          model.set(model.idAttribute, temporaryId, {
+            silent: true
+          });
+          return localSync('update', model, options).then(function(savedModel) {
+            return typeof success === "function" ? success(savedModel, savedModel.attributes, options) : void 0;
+          });
+        };
+        model.set(model.idAttribute, null, {
+          silent: true
+        });
+        return onlineSync('create', model, options);
+      } else {
+        options.success = function(model, response, options) {
+          var updatedModel;
+          updatedModel = updateModelWithResponse(model, response);
+          return localSync('update', updatedModel, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
+        };
+        options.error = function(model, response, options) {
+          options.offline = true;
+          return localSync('update', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
+        };
+        return onlineSync('update', model, options);
+      }
+      break;
+    case 'remove':
+      if ((model != null ? model.id.length : void 0) === 36) {
+        return localSync('remove', model, options);
+      } else {
+        options.success = function(model, response, options) {
+          return localSync('remove', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
+        };
+        options.error = function(model, response, options) {
+          options.offline = true;
+          return localSync('remove', model, options).then(function() {
+            return typeof success === "function" ? success(model, response, options) : void 0;
+          });
+        };
+        return onlineSync('remove', model, options);
+      }
+  }
+};
+
+Backbone.onlineSync = onlineSync;
+
+Backbone.dualSync = dualSync;
diff --git a/src/localSync.coffee b/src/localSync.coffee
new file mode 100644
index 0000000..58927f4
--- /dev/null
+++ b/src/localSync.coffee
@@ -0,0 +1,48 @@
+# Wrapper function with Backbone.sync API for persisting data in a *storage*
+# (through a Backbone.Store instance)
+
+localSync = (method, model, options) ->
+  isValidModel = method in ['clear', 'hasDirtyOrDestroyed']
+  isValidModel ||= model instanceof Backbone.Model
+  isValidModel ||= model instanceof Backbone.Collection
+
+  if not isValidModel
+    throw new Error 'model parameter is required to be a Backbone model or collection.'
+
+  if not options.storeName
+    throw new Error 'storeName parameter is required.'
+
+  if not options.storage
+    throw new Error 'storage parameter is required.'
+
+  # Helpers method to return sync methods as async promises
+  returnAsync = -> $.Deferred().resolve
+
+  store = new Backbone.Store options.storeName, options.storage
+
+  store.initialize().then ->
+    promise = switch method
+      when 'read'
+        returnAsync store.find model?.id
+
+      when 'create'
+        store.add(model).then (model) ->
+          store.isDirty(model, options.offline)
+
+      when 'update'
+        store.update(model).then (model) ->
+          store.isDirty(model, options.offline)
+
+      when 'remove'
+        store.remove(model).then (model) ->
+          store.isDestroyed(model, options.offline)
+
+      when 'clear'
+        store.clear()
+
+      when 'hasDirtyOrDestroyed'
+        returnAsync store.hasDirtyOrDestroyed()
+
+    if options.useCallbacks
+      promise.done (response) ->
+        options.success response?.attributes or response
diff --git a/src/localSync.js b/src/localSync.js
new file mode 100644
index 0000000..0d66704
--- /dev/null
+++ b/src/localSync.js
@@ -0,0 +1,52 @@
+// Generated by CoffeeScript 1.6.3
+var localSync;
+
+localSync = function(method, model, options) {
+  var isValidModel, returnAsync, store;
+  isValidModel = method === 'clear' || method === 'hasDirtyOrDestroyed';
+  isValidModel || (isValidModel = model instanceof Backbone.Model);
+  isValidModel || (isValidModel = model instanceof Backbone.Collection);
+  if (!isValidModel) {
+    throw new Error('model parameter is required to be a Backbone model or collection.');
+  }
+  if (!options.storeName) {
+    throw new Error('storeName parameter is required.');
+  }
+  if (!options.storage) {
+    throw new Error('storage parameter is required.');
+  }
+  returnAsync = function() {
+    return $.Deferred().resolve;
+  };
+  store = new Backbone.Store(options.storeName, options.storage);
+  return store.initialize().then(function() {
+    var promise;
+    promise = (function() {
+      switch (method) {
+        case 'read':
+          return returnAsync(store.find(model != null ? model.id : void 0));
+        case 'create':
+          return store.add(model).then(function(model) {
+            return store.isDirty(model, options.offline);
+          });
+        case 'update':
+          return store.update(model).then(function(model) {
+            return store.isDirty(model, options.offline);
+          });
+        case 'remove':
+          return store.remove(model).then(function(model) {
+            return store.isDestroyed(model, options.offline);
+          });
+        case 'clear':
+          return store.clear();
+        case 'hasDirtyOrDestroyed':
+          return returnAsync(store.hasDirtyOrDestroyed());
+      }
+    })();
+    if (options.useCallbacks) {
+      return promise.done(function(response) {
+        return options.success((response != null ? response.attributes : void 0) || response);
+      });
+    }
+  });
+};
diff --git a/src/store.coffee b/src/store.coffee
new file mode 100644
index 0000000..eb6b2c0
--- /dev/null
+++ b/src/store.coffee
@@ -0,0 +1,139 @@
+# Async store class for saving a collection of models in a *storage*.
+# It also handles saving dirty and destroyed metadata.
+
+# Store only provides an API for saving models and dirty/destroyed metadata,
+# without actually knowing when it should save the model as dirty/destroyed or
+# when to remove it from those lists.
+# That is handled at a higher level (in localSync/dualSync).
+
+class Backbone.Store
+  constructor: (name, storage) ->
+    @name = name
+    @storage = storage
+    @data = {}
+
+  # Generates a unique id to use when saving new instances while offline.
+  # By default generates a pseudo-GUID by concatenating random hexadecimal.
+  # You can overwrite this function to use another strategy.
+  generateId: ->
+    S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4()
+
+  # Load the current state of the Store from storage.
+  initialize: ->
+    @storage.get(@name).then (savedData) =>
+      # All models currently available in this store.
+      @data.records = savedData?.records || []
+      # Models that have been modified and need to sync online.
+      @data.dirty = savedData?.dirty || []
+      # Models that have been destroyed and need to sync online.
+      @data.destroyed = savedData?.destroyed || []
+      # Models that are only saved locally.
+      # If the model is not in the dirty list, then it is a local only model.
+      @data.local = savedData?.local || []
+      # Map ids to model attributes.
+      @data.recordsById = savedData?.recordsById || {}
+
+  # Save the current state of the Store in storage.
+  save: ->
+    @storage.set @name, @data
+
+  # Add or remove a model from dirty or destroyed arrays.
+  # TODO: find a better name for this method?
+  toggleModel: (target, model, status) ->
+    if status and model.id not in @data[target]
+      @data[target].push model.id
+    else if not status and model.id in @data[target]
+      @data[target] = _.without @data[target], model.id
+
+    @save().then -> model
+
+  # Mark a model as dirty / not dirty.
+  isDirty: (model, status) ->
+    if model.id not in @data.records
+      throw new Error "model with id #{model.id} is not in the store."
+
+    if model.id in @data.destroyed
+      throw new Error "can't mark model with id #{model.id} as dirty because it is marked as destroyed."
+
+    @toggleModel 'dirty', model, status
+
+  # Mark a model as destroyed / not destroyed.
+  isDestroyed: (model, status) ->
+    if model.id in @data.records
+      throw new Error "can't mark model with id #{model.id} as destroyed because it is still in the store."
+
+    if model.id in @data.dirty
+      throw new Error "can't mark model with id #{model.id} as destroyed because it is marked as dirty."
+
+    @toggleModel 'destroyed', model, status
+
+  # Add a model to the store.
+  add: (models) ->
+    models = [models] if not _.isArray models
+    for model in models
+      if model.id in @data.records
+        throw new Error "model with id #{model.id} is already in the store."
+
+      # If id is missing, then we add it as a local model.
+      # This could be because the client if offline, server responded with error,
+      # or the model is configured to save only locally.
+      if not model.id
+        model.id = @generateId()
+        model.set model.idAttribute, model.id
+        @data.local.push model.id
+
+      @data.records.push model.id
+      @data.recordsById[model.id] = model.toJSON()
+
+    @save().then -> if models.length == 1 then models[0] else models
+
+  # Update a model in the store.
+  update: (model) ->
+    if not model.id
+      throw new Error "model does not have an id."
+
+    if model.id not in @data.records
+      throw new Error "model with id #{model.id} is not in the store, try adding instead of updating."
+
+    @data.recordsById[model.id] = model.toJSON()
+    @save().then -> model
+
+  # Remove a model from the store.
+  remove: (model) ->
+    delete @data.recordsById[model.id]
+    @data.dirty = _.without @data.dirty, model.id
+    @data.local = _.without @data.local, model.id
+    @data.records = _.without @data.records, model.id
+    @save().then -> model
+
+  # Clear all models in the store.
+  clear: ->
+    @data = {}
+    @save()
+
+  # Retrieve a model from the store by id.
+  # Or return all models if id is falsy.
+  find: (id) ->
+    if id then @data.recordsById[id]
+    else (model for id, model of @data.recordsById)
+
+  # Retrieve all dirty models.
+  findDirty: (id) ->
+    if id
+      @data.recordsById[id] if id in @data.dirty
+    else
+      (@data.recordsById[id] for id in @data.dirty)
+
+  # Retrieve all destroyed model ids.
+  findDestroyed: (id) ->
+    if id then id in @data.destroyed
+    else @data.destroyed
+
+  # Returns true if there are dirty or destroyed models in the store.
+  hasDirtyOrDestroyed: ->
+    not _.isEmpty(@data.dirty) or not _.isEmpty(@data.destroyed)
+
+
+# Generate four random hex digits.
+S4 = ->
+  (((1 + Math.random()) * 0x10000) | 0).toString(16).substring 1
diff --git a/src/store.js b/src/store.js
new file mode 100644
index 0000000..cd5f357
--- /dev/null
+++ b/src/store.js
@@ -0,0 +1,171 @@
+// Generated by CoffeeScript 1.6.3
+var S4,
+  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+Backbone.Store = (function() {
+  function Store(name, storage) {
+    this.name = name;
+    this.storage = storage;
+    this.data = {};
+  }
+
+  Store.prototype.generateId = function() {
+    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+  };
+
+  Store.prototype.initialize = function() {
+    var _this = this;
+    return this.storage.get(this.name).then(function(savedData) {
+      _this.data.records = (savedData != null ? savedData.records : void 0) || [];
+      _this.data.dirty = (savedData != null ? savedData.dirty : void 0) || [];
+      _this.data.destroyed = (savedData != null ? savedData.destroyed : void 0) || [];
+      _this.data.local = (savedData != null ? savedData.local : void 0) || [];
+      return _this.data.recordsById = (savedData != null ? savedData.recordsById : void 0) || {};
+    });
+  };
+
+  Store.prototype.save = function() {
+    return this.storage.set(this.name, this.data);
+  };
+
+  Store.prototype.toggleModel = function(target, model, status) {
+    var _ref, _ref1;
+    if (status && (_ref = model.id, __indexOf.call(this.data[target], _ref) < 0)) {
+      this.data[target].push(model.id);
+    } else if (!status && (_ref1 = model.id, __indexOf.call(this.data[target], _ref1) >= 0)) {
+      this.data[target] = _.without(this.data[target], model.id);
+    }
+    return this.save().then(function() {
+      return model;
+    });
+  };
+
+  Store.prototype.isDirty = function(model, status) {
+    var _ref, _ref1;
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) < 0) {
+      throw new Error("model with id " + model.id + " is not in the store.");
+    }
+    if (_ref1 = model.id, __indexOf.call(this.data.destroyed, _ref1) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as dirty because it is marked as destroyed.");
+    }
+    return this.toggleModel('dirty', model, status);
+  };
+
+  Store.prototype.isDestroyed = function(model, status) {
+    var _ref, _ref1;
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as destroyed because it is still in the store.");
+    }
+    if (_ref1 = model.id, __indexOf.call(this.data.dirty, _ref1) >= 0) {
+      throw new Error("can't mark model with id " + model.id + " as destroyed because it is marked as dirty.");
+    }
+    return this.toggleModel('destroyed', model, status);
+  };
+
+  Store.prototype.add = function(models) {
+    var model, _i, _len, _ref;
+    if (!_.isArray(models)) {
+      models = [models];
+    }
+    for (_i = 0, _len = models.length; _i < _len; _i++) {
+      model = models[_i];
+      if (_ref = model.id, __indexOf.call(this.data.records, _ref) >= 0) {
+        throw new Error("model with id " + model.id + " is already in the store.");
+      }
+      if (!model.id) {
+        model.id = this.generateId();
+        model.set(model.idAttribute, model.id);
+        this.data.local.push(model.id);
+      }
+      this.data.records.push(model.id);
+      this.data.recordsById[model.id] = model.toJSON();
+    }
+    return this.save().then(function() {
+      if (models.length === 1) {
+        return models[0];
+      } else {
+        return models;
+      }
+    });
+  };
+
+  Store.prototype.update = function(model) {
+    var _ref;
+    if (!model.id) {
+      throw new Error("model does not have an id.");
+    }
+    if (_ref = model.id, __indexOf.call(this.data.records, _ref) < 0) {
+      throw new Error("model with id " + model.id + " is not in the store, try adding instead of updating.");
+    }
+    this.data.recordsById[model.id] = model.toJSON();
+    return this.save().then(function() {
+      return model;
+    });
+  };
+
+  Store.prototype.remove = function(model) {
+    delete this.data.recordsById[model.id];
+    this.data.dirty = _.without(this.data.dirty, model.id);
+    this.data.local = _.without(this.data.local, model.id);
+    this.data.records = _.without(this.data.records, model.id);
+    return this.save().then(function() {
+      return model;
+    });
+  };
+
+  Store.prototype.clear = function() {
+    this.data = {};
+    return this.save();
+  };
+
+  Store.prototype.find = function(id) {
+    var model, _ref, _results;
+    if (id) {
+      return this.data.recordsById[id];
+    } else {
+      _ref = this.data.recordsById;
+      _results = [];
+      for (id in _ref) {
+        model = _ref[id];
+        _results.push(model);
+      }
+      return _results;
+    }
+  };
+
+  Store.prototype.findDirty = function(id) {
+    var _i, _len, _ref, _results;
+    if (id) {
+      if (__indexOf.call(this.data.dirty, id) >= 0) {
+        return this.data.recordsById[id];
+      }
+    } else {
+      _ref = this.data.dirty;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        id = _ref[_i];
+        _results.push(this.data.recordsById[id]);
+      }
+      return _results;
+    }
+  };
+
+  Store.prototype.findDestroyed = function(id) {
+    if (id) {
+      return __indexOf.call(this.data.destroyed, id) >= 0;
+    } else {
+      return this.data.destroyed;
+    }
+  };
+
+  Store.prototype.hasDirtyOrDestroyed = function() {
+    return !_.isEmpty(this.data.dirty) || !_.isEmpty(this.data.destroyed);
+  };
+
+  return Store;
+
+})();
+
+S4 = function() {
+  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+};
diff --git a/test/index.html b/test/index.html
new file mode 100644
index 0000000..5a95561
--- /dev/null
+++ b/test/index.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Backbone.dualStorage Tests</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="../lib/mocha/mocha.css" />
+  </head>
+  <body>
+    <div id="mocha"></div>
+    <script src="../lib/mocha/mocha.js"></script>
+    <script src="../lib/chai/chai.js"></script>
+    <script src="../lib/jquery-1.9.1.min.js"></script>
+    <script src="../lib/sticky-2.9.js"></script>
+    <script src="../lib/lawnchair/src/Lawnchair.js"></script>
+    <script src="../lib/lawnchair/src/adapters/dom.js"></script>
+    <script src="../lib/lawnchair/src/adapters/indexed-db.js"></script>
+    <script src="../lib/underscore.js"></script>
+    <script src="../lib/backbone-1.1.0.js"></script>
+    <script src="../src/adapters.js"></script>
+    <script src="../src/store.js"></script>
+    <script>mocha.setup('bdd')</script>
+    <script src="test.adapters.js"></script>
+    <script src="test.store.js"></script>
+    <script>
+      var expect = chai.expect;
+      mocha.checkLeaks();
+      mocha.globals(['jQuery', 'Backbone']);
+      mocha.run();
+    </script>
+  </body>
+</html>
\ No newline at end of file
diff --git a/test/test.adapters.coffee b/test/test.adapters.coffee
new file mode 100644
index 0000000..21e4467
--- /dev/null
+++ b/test/test.adapters.coffee
@@ -0,0 +1,50 @@
+StickyStorage = Backbone.storageAdapters.StickyStorageAdapter
+
+describe 'StorageAdapters', ->
+  for storageName, storageClass of Backbone.storageAdapters
+    do (storageName, storageClass) ->
+      _describe = if storageClass is StickyStorage then describe.skip else describe
+      _describe storageName, ->
+
+        it 'takes a name in its constructor and initializes', (done) ->
+          storage = new storageClass 'SuperSizedStorage'
+          storage.initialize().done ->
+            expect(storage.name).to.equal 'SuperSizedStorage'
+            expect(storage.store).to.exist
+            storage.clear().done ->
+              done()
+
+        _describe 'methods', ->
+          {storage} = {}
+
+          beforeEach (done) ->
+            storage = new storageClass
+            storage.initialize().done ->
+              done()
+
+          afterEach (done) ->
+            storage.clear().done ->
+              done()
+
+          it 'sets and gets a record', (done) ->
+            storage.set('item', foo: 'bar').done ->
+              storage.get('item').done (item) ->
+                expect(item).to.eql foo: 'bar'
+                done()
+
+          it 'deletes a record', (done) ->
+            storage.set('item', foo: 'bar').done ->
+              storage.remove('item').done ->
+                storage.get('item').done (item) ->
+                  expect(item).to.not.ok
+                  done()
+
+          it 'clears all records', (done) ->
+            storage.set('item1', 1).done ->
+              storage.set('item2', 2).done ->
+                storage.clear().done ->
+                  storage.get('item1').done (item1) ->
+                    expect(item1).to.not.ok
+                    storage.get('item2').done (item2) ->
+                      expect(item2).to.not.ok
+                      done()
diff --git a/test/test.adapters.js b/test/test.adapters.js
new file mode 100644
index 0000000..619f771
--- /dev/null
+++ b/test/test.adapters.js
@@ -0,0 +1,85 @@
+// Generated by CoffeeScript 1.6.3
+var StickyStorage;
+
+StickyStorage = Backbone.storageAdapters.StickyStorageAdapter;
+
+describe('StorageAdapters', function() {
+  var storageClass, storageName, _ref, _results;
+  _ref = Backbone.storageAdapters;
+  _results = [];
+  for (storageName in _ref) {
+    storageClass = _ref[storageName];
+    _results.push((function(storageName, storageClass) {
+      var _describe;
+      _describe = storageClass === StickyStorage ? describe.skip : describe;
+      return _describe(storageName, function() {
+        it('takes a name in its constructor and initializes', function(done) {
+          var storage;
+          storage = new storageClass('SuperSizedStorage');
+          return storage.initialize().done(function() {
+            expect(storage.name).to.equal('SuperSizedStorage');
+            expect(storage.store).to.exist;
+            return storage.clear().done(function() {
+              return done();
+            });
+          });
+        });
+        return _describe('methods', function() {
+          var storage;
+          storage = {}.storage;
+          beforeEach(function(done) {
+            storage = new storageClass;
+            return storage.initialize().done(function() {
+              return done();
+            });
+          });
+          afterEach(function(done) {
+            return storage.clear().done(function() {
+              return done();
+            });
+          });
+          it('sets and gets a record', function(done) {
+            return storage.set('item', {
+              foo: 'bar'
+            }).done(function() {
+              return storage.get('item').done(function(item) {
+                expect(item).to.eql({
+                  foo: 'bar'
+                });
+                return done();
+              });
+            });
+          });
+          it('deletes a record', function(done) {
+            return storage.set('item', {
+              foo: 'bar'
+            }).done(function() {
+              return storage.remove('item').done(function() {
+                return storage.get('item').done(function(item) {
+                  expect(item).to.not.ok;
+                  return done();
+                });
+              });
+            });
+          });
+          return it('clears all records', function(done) {
+            return storage.set('item1', 1).done(function() {
+              return storage.set('item2', 2).done(function() {
+                return storage.clear().done(function() {
+                  return storage.get('item1').done(function(item1) {
+                    expect(item1).to.not.ok;
+                    return storage.get('item2').done(function(item2) {
+                      expect(item2).to.not.ok;
+                      return done();
+                    });
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+    })(storageName, storageClass));
+  }
+  return _results;
+});
diff --git a/test/test.localSync.coffee b/test/test.localSync.coffee
new file mode 100644
index 0000000..d1d02aa
--- /dev/null
+++ b/test/test.localSync.coffee
@@ -0,0 +1,25 @@
+describe 'localSync', ->
+  for storageName, storageClass of Backbone.storageAdapters
+    do (storageName, storageClass) ->
+
+      _describe = if storageClass is StickyStorage then describe.skip else describe
+      _describe "with #{storageName}", ->
+        {storage, store, model} = {}
+
+        beforeEach (done) ->
+          storage = new storageClass
+          store = new Backbone.Store 'Store', storage
+          model = new Backbone.Model
+            id: 1
+            abc: 123
+          storage.initialize().done ->
+            store.initialize().done -> done()
+
+        afterEach (done) ->
+          store.clear().done ->
+            storage.clear().done ->
+              done()
+
+        it 'works correctly when merge == false', (done) ->
+
+          Backbone.
\ No newline at end of file
diff --git a/test/test.localSync.js b/test/test.localSync.js
new file mode 100644
index 0000000..357240d
--- /dev/null
+++ b/test/test.localSync.js
@@ -0,0 +1,39 @@
+// Generated by CoffeeScript 1.6.3
+describe('localSync', function() {
+  var storageClass, storageName, _ref, _results;
+  _ref = Backbone.storageAdapters;
+  _results = [];
+  for (storageName in _ref) {
+    storageClass = _ref[storageName];
+    _results.push((function(storageName, storageClass) {
+      var _describe;
+      _describe = storageClass === StickyStorage ? describe.skip : describe;
+      return _describe("with " + storageName, function() {
+        var model, storage, store, _ref1;
+        _ref1 = {}, storage = _ref1.storage, store = _ref1.store, model = _ref1.model;
+        beforeEach(function(done) {
+          storage = new storageClass;
+          store = new Backbone.Store('Store', storage);
+          model = new Backbone.Model({
+            id: 1,
+            abc: 123
+          });
+          return storage.initialize().done(function() {
+            return store.initialize().done(function() {
+              return done();
+            });
+          });
+        });
+        afterEach(function(done) {
+          return store.clear().done(function() {
+            return storage.clear().done(function() {
+              return done();
+            });
+          });
+        });
+        return it('works correctly when merge == false', function(done) {});
+      });
+    })(storageName, storageClass));
+  }
+  return _results;
+});
diff --git a/test/test.store.coffee b/test/test.store.coffee
new file mode 100644
index 0000000..41627d7
--- /dev/null
+++ b/test/test.store.coffee
@@ -0,0 +1,301 @@
+describe 'Store', ->
+  for storageName, storageClass of Backbone.storageAdapters
+    do (storageName, storageClass) ->
+
+      _describe = if storageClass is StickyStorage then describe.skip else describe
+      _describe "with #{storageName}", ->
+        {storage} = {}
+
+        beforeEach (done) ->
+          storage = new storageClass
+          storage.initialize().done ->
+            done()
+
+        afterEach (done) ->
+          storage.clear().done ->
+            done()
+
+        it 'takes a name and a storage adapter in its constructor', ->
+          store = new Backbone.Store 'Store', storage
+
+        it 'initializes correctly', (done) ->
+          store = new Backbone.Store 'Store', storage
+          expect(store.data).to.deep.eql {}
+          store.initialize().done ->
+            expect(store.data.dirty).to.eql []
+            expect(store.data.destroyed).to.eql []
+            expect(store.data.local).to.eql []
+            expect(store.data.records).to.eql []
+            expect(store.data.recordsById).to.eql {}
+            done()
+
+        {model, otherModel, store} = {}
+        storeSetup = (done) ->
+          model = new Backbone.Model
+            id: 1
+            abc: 123
+          otherModel = new Backbone.Model
+            id: 2
+            xxx: 666
+          store = new Backbone.Store 'Store', storage
+          store.initialize().done -> done()
+
+        storeClear = (done) ->
+          store.clear().done -> done()
+
+        describe 'when adding', ->
+          beforeEach storeSetup
+          afterEach storeClear
+
+          it 'adds one model to the store', (done) ->
+            store.add(model).done (saved) ->
+              storage.get('Store').done (storeData) ->
+                expect(storeData).to.deep.eql store.data
+                expect(saved.attributes).to.deep.eql model.attributes
+                expect(saved.attributes).to.deep.eql storeData.recordsById[1]
+                expect(store.data).to.deep.eql
+                    records: [1]
+                    recordsById: 1: model.attributes
+                    local: []
+                    dirty: []
+                    destroyed: []
+                done()
+
+          it 'adds many models to the store', (done) ->
+            models = [model, otherModel]
+            store.add(models).done (saved) ->
+              storage.get('Store').done (storeData) ->
+                expect(storeData).to.deep.eql store.data
+                expect(saved[0].attributes).to.deep.eql model.attributes
+                expect(saved[0].attributes).to.deep.eql storeData.recordsById[1]
+                expect(saved[1].attributes).to.deep.eql otherModel.attributes
+                expect(saved[1].attributes).to.deep.eql storeData.recordsById[2]
+                expect(store.data).to.deep.eql
+                    records: [1, 2]
+                    recordsById:
+                      1: model.attributes
+                      2: otherModel.attributes
+                    local: []
+                    dirty: []
+                    destroyed: []
+                done()
+
+          it 'adds the model creating a unique id using idAttribute', (done) ->
+            model = new Backbone.Model
+              abc: 123
+            model.idAttribute = '_id'
+            store.add(model).done (saved) ->
+              storage.get('Store').done (storeData) ->
+                expectedAttr = abc: 123, _id: model.id
+                expect(storeData).to.deep.eql store.data
+                expect(saved.attributes).to.deep.eql expectedAttr
+                expect(saved.attributes).to.deep.eql storeData.recordsById[model.id]
+                expect(saved.id).to.equal model.id
+                recordsById = {}
+                recordsById[model.id] = model.attributes
+                expect(store.data).to.deep.eql
+                    records: [model.id]
+                    recordsById: recordsById
+                    local: [model.id]
+                    dirty: []
+                    destroyed: []
+                done()
+
+          it 'throws an error if the model is already in the store', (done) ->
+            store.add(model).done (saved) ->
+              expect(-> store.add(model)).to.throw(/already in the store/)
+              done()
+
+        describe 'when updating', ->
+          beforeEach storeSetup
+          afterEach storeClear
+
+          it 'updates the model in the store', (done) ->
+            store.add(model).done ->
+              model.set abc: 666
+              store.update(model).done (updated) ->
+                storage.get('Store').done (storeData) ->
+                  expect(storeData).to.deep.eql store.data
+                  expect(updated.attributes).to.deep.eql model.attributes
+                  expect(updated.attributes).to.deep.eql storeData.recordsById[1]
+                  expect(store.data).to.deep.eql
+                    records: [1]
+                    recordsById: {1: model.attributes}
+                    local: []
+                    dirty: []
+                    destroyed: []
+                  done()
+
+          it 'throws an error if the model does not have an id', ->
+            model = new Backbone.Model
+            expect(-> store.update(model)).to.throw(/model does not have an id/)
+
+          it 'throws an error if the model is not in the store', ->
+            expect(-> store.update(model)).to.throw(/is not in the store/)
+
+        describe 'when removing', ->
+          beforeEach storeSetup
+          afterEach storeClear
+
+          it 'removes the model from the store', (done) ->
+            store.add(model).done ->
+              store.remove(model).done (removed) ->
+                storage.get('Store').done (storeData) ->
+                  expect(storeData).to.deep.eql store.data
+                  expect(removed.attributes).to.deep.eql model.attributes
+                  expect(store.data).to.deep.eql
+                    records: []
+                    recordsById: {}
+                    local: []
+                    dirty: []
+                    destroyed: []
+                  done()
+
+          it 'removes a local model from the store', (done) ->
+            model = new Backbone.Model
+            store.add(model).done ->
+              store.remove(model).done () ->
+                storage.get('Store').done (storeData) ->
+                  expect(storeData).to.deep.eql store.data
+                  expect(store.data).to.deep.eql
+                    records: []
+                    recordsById: {}
+                    local: []
+                    dirty: []
+                    destroyed: []
+                  done()
+
+          it 'removes the model from the dirty list', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done ->
+                store.remove(model).done () ->
+                  storage.get('Store').done (storeData) ->
+                    expect(storeData).to.deep.eql store.data
+                    expect(store.data).to.deep.eql
+                      records: []
+                      recordsById: {}
+                      local: []
+                      dirty: []
+                      destroyed: []
+                    done()
+
+          it 'clears the store removing all saved data', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done ->
+                store.isDestroyed(otherModel, true).done ->
+                  store.clear().done ->
+                    storage.get('Store').done (storeData) ->
+                      expect(storeData).to.deep.eql {}
+                      expect(store.data).to.deep.eql {}
+                      done()
+
+        describe 'when searching', ->
+          beforeEach storeSetup
+          afterEach storeClear
+
+          it 'finds a model', (done) ->
+            store.add(model).done ->
+              expect(store.find 1).to.deep.eql model.attributes
+              done()
+
+          it 'finds all models', (done) ->
+            store.add(model).done ->
+              store.add(otherModel).done ->
+                models = [model.attributes, otherModel.attributes]
+                expect(store.find()).to.deep.eql models
+                done()
+
+          it 'finds all dirty models', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done ->
+                expect(store.findDirty()).to.deep.eql [model.attributes]
+                done()
+
+          it 'finds all destroyed models', (done) ->
+            store.isDestroyed(model, true).done ->
+              expect(store.findDestroyed()).to.deep.eql [model.id]
+              done()
+
+          it 'returns correct values when model is not found', ->
+            expect(store.find 1).to.be.undefined
+            expect(store.findDirty 1).to.be.undefined
+            expect(store.findDestroyed 1).to.be.false
+
+        describe 'dirty / destroyed flags', (done) ->
+          beforeEach storeSetup
+          afterEach storeClear
+
+          it 'marks a model as dirty', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done (dirtyModel) ->
+                storage.get('Store').done (storeData) ->
+                  expect(storeData).to.deep.eql store.data
+                  expect(dirtyModel.attributes).to.deep.eql model.attributes
+                  expect(store.data).to.deep.eql
+                    records: [1]
+                    recordsById: {1: model.attributes}
+                    local: []
+                    dirty: [1]
+                    destroyed: []
+                  done()
+
+          it 'marks a model as destroyed', (done) ->
+            store.isDestroyed(model, true).done (destroyedModel) ->
+              storage.get('Store').done (storeData) ->
+                expect(storeData).to.deep.eql store.data
+                expect(destroyedModel.attributes).to.deep.eql model.attributes
+                expect(store.data).to.deep.eql
+                  records: []
+                  recordsById: {}
+                  local: []
+                  dirty: []
+                  destroyed: [1]
+                done()
+
+          it 'unmarks a model as dirty', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done () ->
+                store.isDirty(model, false).done (dirtyModel) ->
+                  storage.get('Store').done (storeData) ->
+                    expect(storeData).to.deep.eql store.data
+                    expect(dirtyModel.attributes).to.deep.eql model.attributes
+                    expect(store.data).to.deep.eql
+                      records: [1]
+                      recordsById: {1: model.attributes}
+                      local: []
+                      dirty: []
+                      destroyed: []
+                    done()
+
+          it 'unmarks a model as destroyed', (done) ->
+            store.isDestroyed(model, true).done () ->
+              store.isDestroyed(model, false).done (dirtyModel) ->
+                storage.get('Store').done (storeData) ->
+                  expect(storeData).to.deep.eql store.data
+                  expect(dirtyModel.attributes).to.deep.eql model.attributes
+                  expect(store.data).to.deep.eql
+                    records: []
+                    recordsById: {}
+                    local: []
+                    dirty: []
+                    destroyed: []
+                  done()
+
+          it 'reports correctly if there are dirty models', (done) ->
+            store.add(model).done ->
+              store.isDirty(model, true).done ->
+                expect(store.hasDirtyOrDestroyed).to.be.ok
+                done()
+
+          it 'reports correctly if there are destroyed models', (done) ->
+            store.isDestroyed(model, true).done ->
+              expect(store.hasDirtyOrDestroyed).to.be.ok
+              done()
+
+          it 'throws an error if the model is not in the store', ->
+            expect(-> store.isDirty(model, true)).to.throw(/is not in the store/)
+
+          it 'throws an error if trying to mark a stored model as destroyed', (done) ->
+            store.add(model).done ->
+              expect(-> store.isDestroyed(model, true)).to.throw(/is still in the store/)
+              done()
diff --git a/test/test.store.js b/test/test.store.js
new file mode 100644
index 0000000..9b95724
--- /dev/null
+++ b/test/test.store.js
@@ -0,0 +1,409 @@
+// Generated by CoffeeScript 1.6.3
+describe('Store', function() {
+  var storageClass, storageName, _ref, _results;
+  _ref = Backbone.storageAdapters;
+  _results = [];
+  for (storageName in _ref) {
+    storageClass = _ref[storageName];
+    _results.push((function(storageName, storageClass) {
+      var _describe;
+      _describe = storageClass === StickyStorage ? describe.skip : describe;
+      return _describe("with " + storageName, function() {
+        var model, otherModel, storage, store, storeClear, storeSetup, _ref1;
+        storage = {}.storage;
+        beforeEach(function(done) {
+          storage = new storageClass;
+          return storage.initialize().done(function() {
+            return done();
+          });
+        });
+        afterEach(function(done) {
+          return storage.clear().done(function() {
+            return done();
+          });
+        });
+        it('takes a name and a storage adapter in its constructor', function() {
+          var store;
+          return store = new Backbone.Store('Store', storage);
+        });
+        it('initializes correctly', function(done) {
+          var store;
+          store = new Backbone.Store('Store', storage);
+          expect(store.data).to.deep.eql({});
+          return store.initialize().done(function() {
+            expect(store.data.dirty).to.eql([]);
+            expect(store.data.destroyed).to.eql([]);
+            expect(store.data.local).to.eql([]);
+            expect(store.data.records).to.eql([]);
+            expect(store.data.recordsById).to.eql({});
+            return done();
+          });
+        });
+        _ref1 = {}, model = _ref1.model, otherModel = _ref1.otherModel, store = _ref1.store;
+        storeSetup = function(done) {
+          model = new Backbone.Model({
+            id: 1,
+            abc: 123
+          });
+          otherModel = new Backbone.Model({
+            id: 2,
+            xxx: 666
+          });
+          store = new Backbone.Store('Store', storage);
+          return store.initialize().done(function() {
+            return done();
+          });
+        };
+        storeClear = function(done) {
+          return store.clear().done(function() {
+            return done();
+          });
+        };
+        describe('when adding', function() {
+          beforeEach(storeSetup);
+          afterEach(storeClear);
+          it('adds one model to the store', function(done) {
+            return store.add(model).done(function(saved) {
+              return storage.get('Store').done(function(storeData) {
+                expect(storeData).to.deep.eql(store.data);
+                expect(saved.attributes).to.deep.eql(model.attributes);
+                expect(saved.attributes).to.deep.eql(storeData.recordsById[1]);
+                expect(store.data).to.deep.eql({
+                  records: [1],
+                  recordsById: {
+                    1: model.attributes
+                  },
+                  local: [],
+                  dirty: [],
+                  destroyed: []
+                });
+                return done();
+              });
+            });
+          });
+          it('adds many models to the store', function(done) {
+            var models;
+            models = [model, otherModel];
+            return store.add(models).done(function(saved) {
+              return storage.get('Store').done(function(storeData) {
+                expect(storeData).to.deep.eql(store.data);
+                expect(saved[0].attributes).to.deep.eql(model.attributes);
+                expect(saved[0].attributes).to.deep.eql(storeData.recordsById[1]);
+                expect(saved[1].attributes).to.deep.eql(otherModel.attributes);
+                expect(saved[1].attributes).to.deep.eql(storeData.recordsById[2]);
+                expect(store.data).to.deep.eql({
+                  records: [1, 2],
+                  recordsById: {
+                    1: model.attributes,
+                    2: otherModel.attributes
+                  },
+                  local: [],
+                  dirty: [],
+                  destroyed: []
+                });
+                return done();
+              });
+            });
+          });
+          it('adds the model creating a unique id using idAttribute', function(done) {
+            model = new Backbone.Model({
+              abc: 123
+            });
+            model.idAttribute = '_id';
+            return store.add(model).done(function(saved) {
+              return storage.get('Store').done(function(storeData) {
+                var expectedAttr, recordsById;
+                expectedAttr = {
+                  abc: 123,
+                  _id: model.id
+                };
+                expect(storeData).to.deep.eql(store.data);
+                expect(saved.attributes).to.deep.eql(expectedAttr);
+                expect(saved.attributes).to.deep.eql(storeData.recordsById[model.id]);
+                expect(saved.id).to.equal(model.id);
+                recordsById = {};
+                recordsById[model.id] = model.attributes;
+                expect(store.data).to.deep.eql({
+                  records: [model.id],
+                  recordsById: recordsById,
+                  local: [model.id],
+                  dirty: [],
+                  destroyed: []
+                });
+                return done();
+              });
+            });
+          });
+          return it('throws an error if the model is already in the store', function(done) {
+            return store.add(model).done(function(saved) {
+              expect(function() {
+                return store.add(model);
+              }).to["throw"](/already in the store/);
+              return done();
+            });
+          });
+        });
+        describe('when updating', function() {
+          beforeEach(storeSetup);
+          afterEach(storeClear);
+          it('updates the model in the store', function(done) {
+            return store.add(model).done(function() {
+              model.set({
+                abc: 666
+              });
+              return store.update(model).done(function(updated) {
+                return storage.get('Store').done(function(storeData) {
+                  expect(storeData).to.deep.eql(store.data);
+                  expect(updated.attributes).to.deep.eql(model.attributes);
+                  expect(updated.attributes).to.deep.eql(storeData.recordsById[1]);
+                  expect(store.data).to.deep.eql({
+                    records: [1],
+                    recordsById: {
+                      1: model.attributes
+                    },
+                    local: [],
+                    dirty: [],
+                    destroyed: []
+                  });
+                  return done();
+                });
+              });
+            });
+          });
+          it('throws an error if the model does not have an id', function() {
+            model = new Backbone.Model;
+            return expect(function() {
+              return store.update(model);
+            }).to["throw"](/model does not have an id/);
+          });
+          return it('throws an error if the model is not in the store', function() {
+            return expect(function() {
+              return store.update(model);
+            }).to["throw"](/is not in the store/);
+          });
+        });
+        describe('when removing', function() {
+          beforeEach(storeSetup);
+          afterEach(storeClear);
+          it('removes the model from the store', function(done) {
+            return store.add(model).done(function() {
+              return store.remove(model).done(function(removed) {
+                return storage.get('Store').done(function(storeData) {
+                  expect(storeData).to.deep.eql(store.data);
+                  expect(removed.attributes).to.deep.eql(model.attributes);
+                  expect(store.data).to.deep.eql({
+                    records: [],
+                    recordsById: {},
+                    local: [],
+                    dirty: [],
+                    destroyed: []
+                  });
+                  return done();
+                });
+              });
+            });
+          });
+          it('removes a local model from the store', function(done) {
+            model = new Backbone.Model;
+            return store.add(model).done(function() {
+              return store.remove(model).done(function() {
+                return storage.get('Store').done(function(storeData) {
+                  expect(storeData).to.deep.eql(store.data);
+                  expect(store.data).to.deep.eql({
+                    records: [],
+                    recordsById: {},
+                    local: [],
+                    dirty: [],
+                    destroyed: []
+                  });
+                  return done();
+                });
+              });
+            });
+          });
+          it('removes the model from the dirty list', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function() {
+                return store.remove(model).done(function() {
+                  return storage.get('Store').done(function(storeData) {
+                    expect(storeData).to.deep.eql(store.data);
+                    expect(store.data).to.deep.eql({
+                      records: [],
+                      recordsById: {},
+                      local: [],
+                      dirty: [],
+                      destroyed: []
+                    });
+                    return done();
+                  });
+                });
+              });
+            });
+          });
+          return it('clears the store removing all saved data', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function() {
+                return store.isDestroyed(otherModel, true).done(function() {
+                  return store.clear().done(function() {
+                    return storage.get('Store').done(function(storeData) {
+                      expect(storeData).to.deep.eql({});
+                      expect(store.data).to.deep.eql({});
+                      return done();
+                    });
+                  });
+                });
+              });
+            });
+          });
+        });
+        describe('when searching', function() {
+          beforeEach(storeSetup);
+          afterEach(storeClear);
+          it('finds a model', function(done) {
+            return store.add(model).done(function() {
+              expect(store.find(1)).to.deep.eql(model.attributes);
+              return done();
+            });
+          });
+          it('finds all models', function(done) {
+            return store.add(model).done(function() {
+              return store.add(otherModel).done(function() {
+                var models;
+                models = [model.attributes, otherModel.attributes];
+                expect(store.find()).to.deep.eql(models);
+                return done();
+              });
+            });
+          });
+          it('finds all dirty models', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function() {
+                expect(store.findDirty()).to.deep.eql([model.attributes]);
+                return done();
+              });
+            });
+          });
+          it('finds all destroyed models', function(done) {
+            return store.isDestroyed(model, true).done(function() {
+              expect(store.findDestroyed()).to.deep.eql([model.id]);
+              return done();
+            });
+          });
+          return it('returns correct values when model is not found', function() {
+            expect(store.find(1)).to.be.undefined;
+            expect(store.findDirty(1)).to.be.undefined;
+            return expect(store.findDestroyed(1)).to.be["false"];
+          });
+        });
+        return describe('dirty / destroyed flags', function(done) {
+          beforeEach(storeSetup);
+          afterEach(storeClear);
+          it('marks a model as dirty', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function(dirtyModel) {
+                return storage.get('Store').done(function(storeData) {
+                  expect(storeData).to.deep.eql(store.data);
+                  expect(dirtyModel.attributes).to.deep.eql(model.attributes);
+                  expect(store.data).to.deep.eql({
+                    records: [1],
+                    recordsById: {
+                      1: model.attributes
+                    },
+                    local: [],
+                    dirty: [1],
+                    destroyed: []
+                  });
+                  return done();
+                });
+              });
+            });
+          });
+          it('marks a model as destroyed', function(done) {
+            return store.isDestroyed(model, true).done(function(destroyedModel) {
+              return storage.get('Store').done(function(storeData) {
+                expect(storeData).to.deep.eql(store.data);
+                expect(destroyedModel.attributes).to.deep.eql(model.attributes);
+                expect(store.data).to.deep.eql({
+                  records: [],
+                  recordsById: {},
+                  local: [],
+                  dirty: [],
+                  destroyed: [1]
+                });
+                return done();
+              });
+            });
+          });
+          it('unmarks a model as dirty', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function() {
+                return store.isDirty(model, false).done(function(dirtyModel) {
+                  return storage.get('Store').done(function(storeData) {
+                    expect(storeData).to.deep.eql(store.data);
+                    expect(dirtyModel.attributes).to.deep.eql(model.attributes);
+                    expect(store.data).to.deep.eql({
+                      records: [1],
+                      recordsById: {
+                        1: model.attributes
+                      },
+                      local: [],
+                      dirty: [],
+                      destroyed: []
+                    });
+                    return done();
+                  });
+                });
+              });
+            });
+          });
+          it('unmarks a model as destroyed', function(done) {
+            return store.isDestroyed(model, true).done(function() {
+              return store.isDestroyed(model, false).done(function(dirtyModel) {
+                return storage.get('Store').done(function(storeData) {
+                  expect(storeData).to.deep.eql(store.data);
+                  expect(dirtyModel.attributes).to.deep.eql(model.attributes);
+                  expect(store.data).to.deep.eql({
+                    records: [],
+                    recordsById: {},
+                    local: [],
+                    dirty: [],
+                    destroyed: []
+                  });
+                  return done();
+                });
+              });
+            });
+          });
+          it('reports correctly if there are dirty models', function(done) {
+            return store.add(model).done(function() {
+              return store.isDirty(model, true).done(function() {
+                expect(store.hasDirtyOrDestroyed).to.be.ok;
+                return done();
+              });
+            });
+          });
+          it('reports correctly if there are destroyed models', function(done) {
+            return store.isDestroyed(model, true).done(function() {
+              expect(store.hasDirtyOrDestroyed).to.be.ok;
+              return done();
+            });
+          });
+          it('throws an error if the model is not in the store', function() {
+            return expect(function() {
+              return store.isDirty(model, true);
+            }).to["throw"](/is not in the store/);
+          });
+          return it('throws an error if trying to mark a stored model as destroyed', function(done) {
+            return store.add(model).done(function() {
+              expect(function() {
+                return store.isDestroyed(model, true);
+              }).to["throw"](/is still in the store/);
+              return done();
+            });
+          });
+        });
+      });
+    })(storageName, storageClass));
+  }
+  return _results;
+});