From a253722a3658589d99d2f722b02381dd29e65de7 Mon Sep 17 00:00:00 2001
From: Richard Littauer <richard.littauer@gmail.com>
Date: Wed, 8 Jul 2015 13:12:35 -0400
Subject: [PATCH] Checking in build. #208 #210

---
 build/main.min.js | 18702 ++++++++++++++++++++++----------------------
 1 file changed, 9479 insertions(+), 9223 deletions(-)

diff --git a/build/main.min.js b/build/main.min.js
index 55c7d85..df77181 100644
--- a/build/main.min.js
+++ b/build/main.min.js
@@ -208,7 +208,7 @@ function buildView (options) {
 
         var displayHighlights = function () {
           if (highlightsExist !== false) {
-            db.get(fingerprint, function (err, response) {
+            db.allDocs({include_docs: true, keys: [fingerprint]}, function (err, response) {
               if (err) {
                 highlightsExist = false
                 return console.log('Fingerprint not found in db', err)
@@ -217,7 +217,7 @@ function buildView (options) {
                 // console.log('Fingerprint found in db', fingerprint, response)
 
                 if (!window.beagle.highlights) {
-                  window.beagle.highlights = response.selections
+                  window.beagle.highlights = response.rows[0].doc.selections
                 }
 
                 _.forEach(window.beagle.highlights, function (selection, i) {
@@ -242,15 +242,21 @@ function buildView (options) {
           displayHighlights()
         })
       }
+
+      React.render(
+        App(options),
+        parent.getElementById('react')
+      )
     })
+  } else {
+    // If not a PDF or if PDF broken, no fingerprint will be added.
+    // Deal with any issues in data in the React app.
+    React.render(
+      App(options),
+      parent.getElementById('react')
+    )
   }
 
-  // If not a PDF or if PDF broken, no fingerprint will be added.
-  // Deal with any issues in data in the React app.
-  React.render(
-    App(options),
-    parent.getElementById('react')
-  )
 
   linkHandler()
 
@@ -755,27 +761,35 @@ var Highlight = React.createClass({
     }
 
     function saveSelection (selection) {
-      db.get(documentId, function (err, value) {
+      db.allDocs({include_docs: true, key: documentId}, function (err, value) {
         if (err && err.name !== 'not_found') {
           return console.log('Failed to get ' + documentId + 'from db', err)
+        } else if (err) {
+          return console.log(err)
         }
+
+        var row = value.rows[0]
+
         /* Instantiate the object if it doesn't exist yet */
-        value = value || {}
-        value._id = documentId
+        var doc = row.doc || {}
+        doc._id = documentId
+        if (row.value && row.value.rev) {
+          doc._rev = row.value.rev
+        }
 
         /* Add in the selection to the selections array */
-        value.selections = value.selections || []
-        value.selections.push(selection)
+        doc.selections = doc.selections || []
+        doc.selections.push(selection)
 
         /* Get rid of prototypes so we can put this to the database */
-        value = JSON.parse(JSON.stringify(value))
-
-        db.put(value, function (err, response) {
-          if (err) { console.log('Failed to save selection', err) }
-          console.log('Stored ' + response.id + ' away...', response)
-
-          // PouchDB.sync('test', PouchDBUrl)
+        doc = JSON.parse(JSON.stringify(doc))
 
+        db.put(doc, function (err, response) {
+          if (err) {
+            console.log('Failed to save selection', err)
+          } else {
+            console.log('Stored ' + response.id + ' away...', response)
+          }
         })
       })
     }
@@ -919,7 +933,7 @@ var Login = React.createClass({
       // OAauth Code goes here.
       OAuth.initialize('IHLK6uDxpnuH1S71dCwbf30bjBM')
       // Using popup
-      OAuth.popup('google').done(function (result) {
+      OAuth.popup('google', {cache: true}).done(function (result) {
         console.log(result)
         result.me().done(function (me) {
           console.log('Console me: ', me)
@@ -1332,7 +1346,7 @@ module.exports.ContactForm = exports.ContactForm = ContactForm
 module.exports.SendSlack = exports.SendSlack = SendSlack
 
 },{"../utilities/classNames.js":"/Users/richard/src/beagle/js/utilities/classNames.js","browser-node-slack":"/Users/richard/src/beagle/node_modules/browser-node-slack/slack.js","react":"/Users/richard/src/beagle/node_modules/react/react.js","react-bootstrap":"/Users/richard/src/beagle/node_modules/react-bootstrap/lib/index.js"}],"/Users/richard/src/beagle/js/data/schema.js":[function(require,module,exports){
-/*globals emit */
+/*globals emit, localStorage */
 
 var crypto = require('crypto')
 var validator = require('validator')
@@ -1347,7 +1361,7 @@ var PouchDB = require('pouchdb')
 PouchDB.plugin(require('pouchdb-authentication'))
 var db = new PouchDB(PouchDBUrl)
 
-var request = require('request')
+var request = require('request').defaults({jar: true})
 
 // // Create a local DB for testing and usage offline, but use the other DB as much as possible
 // // TODO Check what happens on connection loss.
@@ -1700,155 +1714,112 @@ module.exports.LinkObject = exports.LinkObject = LinkObject
 
 // Both the signup and the login functions
 module.exports.logIn = exports.logIn = function logIn (oauthInfo, cb) {
+  // Get current session using getSession currently does not work. See issue:
+  // db.getSession(function (err, response) {
 
-  // Get current session
-  db.getSession(function (err, response) {
-    if (err) {
-      // network error
-      console.log('err', err)
-    } else if (!response.userCtx.name) {
-      // Nobody's logged in.
-      console.log('No one is logged in')
-      // Bug: Naming the anonymous function as `function  map ()` will break CouchDB.
-      db.query({map: function (doc) {
-        if (doc.type === 'LINK') {
-          emit(doc)
-        }
-      }}).then(function (result) {
-        // If there are no results, create a user object with an id and oauth arr
-        if (result.total_rows === 0) {
-          request({
-            uri: BeagleProxyAPI + '/signUp',
-            method: 'POST',
-            form: {
-              userId: oauthInfo.email,
-              oauthInfo: oauthInfo
-            }
-          }, function (err, res, body) {
-            if (err) {
-              console.log('Err with getting user info', err, res)
-            } else if (res.statusCode !== 200) {
-              console.log(res.statusCode, body)
-            } else {
-              console.log('Result of signing up:', body)
-
-              var user = new LinkObject(oauthInfo)
-
-              // Create the link document
-              db.put(user).then(function (response) {
-                console.log('Created link object', response)
-              }).then(function (response) {
-                db.getSession(function (err, response) {
-                  if (err) {
-                    console.log('Err', err)
-                  } else if (!response.userCtx.name) {
-                    console.log('Nobody is logged in, still', err, response)
-                  } else {
-                    console.log('User', response.userCtx)
-                  }
-                })
-              }).catch(function (err) {
-                console.log(err)
-              })
-            }
-          })
-        // If there are results, sign in with given ID as beagleUsername
-        } else {
-          console.log('Log the user in', result)
-          result.rows.some(function (link) {
-            console.log('Hello', link)
-            if (oauthInfo.email === link.key.email) {
-              request({
-                uri: BeagleProxyAPI + '/login',
-                method: 'POST',
-                form: {
-                  userId: oauthInfo.email,
-                  oauthInfo: oauthInfo
-                }
-              }, function (err, res, body) {
-                if (err) {
-                  console.log('Error logging in', err)
-                } else {
-                  console.log('Result of logging in', err, res, body)
-
-                  db.getSession(function (err, response) {
-                    if (err) {
-                      console.log('Err', err)
-                    } else if (!response.userCtx.name) {
-                      console.log('Nobody is logged in, still,', err, response)
-                    } else {
-                      console.log('User', response.userCtx)
-                    }
-                  })
-
-                  // Add the Oauth token to the link object
-                  // db.get(oauth.email).
-                }
-                return true
-              })
-            }
-            return false
-          })
-        }
-      }).catch(function (err) {
-        // Catch errors
-        console.log('Err', err)
-      })
-    } else {
-      console.log('User', response.userCtx)
-      // response.userCtx.name is the current user
-    }
-  })
-  // If not logged in, log in
-  // If not exist, create
-  // If exists, authenticate and log in
-}
-
-// var user = new LinkObject({
-//   provider: 'google',
-//   account: '117598722553782441947',
-//   email: 'richard.littauer@gmail.com',
-//   token: 'ya29.owF9ALI87lYi6LBeUmVnPI5vGqrWX970Q0STGzBFccvSnZQk9svCQJc3DJkVrYXDTuPcynBGd_XyFg'
-// })
-
-// // Create the link document
-// db.put(user).then(function (response) {
-//   console.log('Created link object', response)
-// }).catch(function (err) {
-//   console.log(err)
-// })
-
-// db.get('599c8ebd244182506db8687de3b4ae6de81b1756').then(function (response) {
-//   console.log('response', response)
-// })
-
-// db.getUser('richard.littauer@gmail.com').then(function(response) {
-//   console.log(response)
-// }).catch(function(err){
-//   console.log(err)
-// })
-
-// exports.logIn({
-//   provider: 'google',
-//   account: '117598722553782441947',
-//   email: 'richard.littauer@gmail.com',
-//   token: 'ya29.owF9ALI87lYi6LBeUmVnPI5vGqrWX970Q0STGzBFccvSnZQk9svCQJc3DJkVrYXDTuPcynBGd_XyFg'
-// }, function (err, res, body) {
-//   if (err) {
-//     console.log('Err with getting user info', err)
-//   } else if (res.statusCode !== 200) {
-//     console.log(res.statusCode, body)
-//   } else {
-//     console.log('Result of signing up:', body)
-
-//     // Create the link document
-//     // db.put(user).then(function (response) {
-//     //   console.log('Created link object')
-//     // }).catch(function (err) {
-//     //   console.log(err)
-//     // })
-//   }
-// })
+  if (localStorage.userId !== 'undefined') {
+    console.log(localStorage.userId)
+    return localStorage.userId
+  } else {
+    // Bug: Naming the anonymous function as `function  map ()` will break CouchDB.
+    db.query({map: function (doc) {
+      if (doc.type === 'LINK') {
+        emit(doc)
+      }
+    }}).then(function (result) {
+      // If there is a link object, sign in with given ID as beagleUsername
+      if (result.total_rows !== 0) {
+        // console.log('Log the user in', result)
+        result.rows.some(function (link) {
+          // console.log('Hello', link)
+          if (oauthInfo.email === link.key.email) {
+            request({
+              uri: BeagleProxyAPI + '/login',
+              method: 'POST',
+              form: {
+                userId: oauthInfo.email,
+                oauthInfo: oauthInfo
+              }
+            }, function (err, res, body) {
+              if (err) {
+                console.log('Error logging in', err)
+              } else if (res.statusCode !== 200) {
+                console.log('Invalid status code from server', res)
+              } else {
+                console.log('Result of logging in', body)
+
+                console.log('body.name', oauthInfo.email)
+
+                // TODO Cache this instead of just popping it on window
+                localStorage.userId = oauthInfo.email
+                return localStorage.userId
+
+                // Again, db.getSession is not working right now.
+                // db.getSession(function (err, response) {
+                //   if (err) {
+                //     console.log('Err', err)
+                //   } else if (!response.userCtx.name) {
+                //     console.log('Nobody is logged in, still,', err, response)
+                //   } else {
+                //     console.log('User', response.userCtx)
+                //   }
+                // })
+
+                // Add the Oauth token to the link object
+                // TODO Do this - right now, the OAuth tokens aren't even being used.
+                // db.get(oauth.email).
+              }
+              return true
+            })
+          }
+          return false
+        })
+      // If there are no results, create a user object with an id and oauth arr
+      } else {
+        request({
+          uri: BeagleProxyAPI + '/signUp',
+          method: 'POST',
+          form: {
+            userId: oauthInfo.email,
+            oauthInfo: oauthInfo
+          }
+        }, function (err, res, body) {
+          if (err) {
+            console.log('Err with getting user info', err, res)
+          } else if (res.statusCode !== 200) {
+            console.log(res.statusCode, body)
+          } else {
+            console.log('Result of signing up:', body)
+
+            var user = new LinkObject(oauthInfo)
+
+            // Create the link document
+            db.put(user).then(function (response) {
+              console.log('Created link object', response)
+
+              localStorage.userId = oauthInfo.email
+              return localStorage.userId
+              // db.getSession(function (err, response) {
+              //   if (err) {
+              //     console.log('Err', err)
+              //   } else if (!response.userCtx.name) {
+              //     console.log('Nobody is logged in, still', err, response)
+              //   } else {
+              //     console.log('User', response.userCtx)
+              //   }
+              // })
+            }).catch(function (err) {
+              console.log(err)
+            })
+          }
+        })
+      }
+    }).catch(function (err) {
+      // Catch errors
+      console.log('Err', err)
+    })
+  }
+}
 
 module.exports.login = module.exports.logIn
 
@@ -2098,7 +2069,7 @@ module.exports.permissionMatch = exports.permissionMatch = function permissionMa
 },{"../env.js":"/Users/richard/src/beagle/js/env.js","../utilities/galapagos.js":"/Users/richard/src/beagle/js/utilities/galapagos.js","crypto":"/Users/richard/src/beagle/node_modules/browserify/node_modules/crypto-browserify/index.js","lodash":"/Users/richard/src/beagle/node_modules/lodash/index.js","pouchdb":"/Users/richard/src/beagle/node_modules/pouchdb/lib/index.js","pouchdb-authentication":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/index.js","request":"/Users/richard/src/beagle/node_modules/request/index.js","validator":"/Users/richard/src/beagle/node_modules/validator/validator.js"}],"/Users/richard/src/beagle/js/env.js":[function(require,module,exports){
 // For all intents and purposes, these are global vars
 // TODO: Find a better way to do this
-var PouchDBUrl = 'http://54.164.111.240:5984/test'
+var PouchDBUrl = 'http://54.164.111.240:5984/dev'
 module.exports.PouchDBUrl = PouchDBUrl
 
 },{}],"/Users/richard/src/beagle/js/lib/url-checks.js":[function(require,module,exports){
@@ -5368,7 +5339,7 @@ var showHighlight = function (selected, cb) {
         'left:' + Math.min(bounds[0], bounds[2]) + 'px; top:' + Math.min(bounds[1], bounds[3]) + 'px;' +
         'width:' + Math.abs(bounds[0] - bounds[2]) + 'px; height:' + Math.abs(bounds[1] - bounds[3]) + 'px;')
       pageElement.appendChild(el)
-      return cb()
+      return cb && cb()
     })
   }
   return
@@ -187242,11 +187213,15 @@ function getBaseUrl(db) {
 }
 exports.getUsersUrl = function (db) {
   var url = getBaseUrl(db) + '/_users';
-  return url.replace('\/\/\/', '/');
+  url = url.replace('\/\/\/', '/')
+  console.log('User URL: ', url)
+  return url;
 };
 exports.getSessionUrl = function (db) {
   var url = getBaseUrl(db) + '/_session';
-  return url.replace('\/\/\/', '/');
+  // url = url.replace('\/\/\/', '/')
+  console.log('Session URL: ', url)
+  return url;
 };
 exports.once = function (fun) {
   var called = false;
@@ -187327,7 +187302,7 @@ exports.uuid = require('./uuid');
 exports.Promise = Promise;
 
 }).call(this,require('_process'))
-},{"./uuid":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","inherits":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/inherits/inherits_browser.js","pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js","pouchdb/extras/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/extras/ajax.js","pouchdb/extras/promise":"/Users/richard/src/beagle/node_modules/pouchdb/extras/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js":[function(require,module,exports){
+},{"./uuid":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","inherits":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/inherits/inherits_browser.js","pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js","pouchdb/extras/ajax":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/extras/ajax.js","pouchdb/extras/promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/extras/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js":[function(require,module,exports){
 "use strict";
 
 // BEGIN Math.uuid.js
@@ -187414,6 +187389,477 @@ module.exports = uuid;
 
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/inherits/inherits_browser.js":[function(require,module,exports){
 arguments[4]["/Users/richard/src/beagle/node_modules/beagle-altmetrics/node_modules/accum-transform/node_modules/through2/node_modules/readable-stream/node_modules/inherits/inherits_browser.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js":[function(require,module,exports){
+'use strict';
+
+module.exports = INTERNAL;
+
+function INTERNAL() {}
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/all.js":[function(require,module,exports){
+'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = all;
+function all(iterable) {
+  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+    return reject(new TypeError('must be an array'));
+  }
+
+  var len = iterable.length;
+  var called = false;
+  if (!len) {
+    return resolve([]);
+  }
+
+  var values = new Array(len);
+  var resolved = 0;
+  var i = -1;
+  var promise = new Promise(INTERNAL);
+  
+  while (++i < len) {
+    allResolver(iterable[i], i);
+  }
+  return promise;
+  function allResolver(value, i) {
+    resolve(value).then(resolveFromAll, function (error) {
+      if (!called) {
+        called = true;
+        handlers.reject(promise, error);
+      }
+    });
+    function resolveFromAll(outValue) {
+      values[i] = outValue;
+      if (++resolved === len & !called) {
+        called = true;
+        handlers.resolve(promise, values);
+      }
+    }
+  }
+}
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js":[function(require,module,exports){
+'use strict';
+var tryCatch = require('./tryCatch');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+
+exports.resolve = function (self, value) {
+  var result = tryCatch(getThen, value);
+  if (result.status === 'error') {
+    return exports.reject(self, result.value);
+  }
+  var thenable = result.value;
+
+  if (thenable) {
+    resolveThenable.safely(self, thenable);
+  } else {
+    self.state = states.FULFILLED;
+    self.outcome = value;
+    var i = -1;
+    var len = self.queue.length;
+    while (++i < len) {
+      self.queue[i].callFulfilled(value);
+    }
+  }
+  return self;
+};
+exports.reject = function (self, error) {
+  self.state = states.REJECTED;
+  self.outcome = error;
+  var i = -1;
+  var len = self.queue.length;
+  while (++i < len) {
+    self.queue[i].callRejected(error);
+  }
+  return self;
+};
+
+function getThen(obj) {
+  // Make sure we only access the accessor once as required by the spec
+  var then = obj && obj.then;
+  if (obj && typeof obj === 'object' && typeof then === 'function') {
+    return function appyThen() {
+      then.apply(obj, arguments);
+    };
+  }
+}
+
+},{"./resolveThenable":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolveThenable.js","./states":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/states.js","./tryCatch":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/tryCatch.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/index.js":[function(require,module,exports){
+module.exports = exports = require('./promise');
+
+exports.resolve = require('./resolve');
+exports.reject = require('./reject');
+exports.all = require('./all');
+exports.race = require('./race');
+
+},{"./all":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/all.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js","./race":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/race.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js":[function(require,module,exports){
+'use strict';
+
+var unwrap = require('./unwrap');
+var INTERNAL = require('./INTERNAL');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+var QueueItem = require('./queueItem');
+
+module.exports = Promise;
+function Promise(resolver) {
+  if (!(this instanceof Promise)) {
+    return new Promise(resolver);
+  }
+  if (typeof resolver !== 'function') {
+    throw new TypeError('resolver must be a function');
+  }
+  this.state = states.PENDING;
+  this.queue = [];
+  this.outcome = void 0;
+  if (resolver !== INTERNAL) {
+    resolveThenable.safely(this, resolver);
+  }
+}
+
+Promise.prototype['catch'] = function (onRejected) {
+  return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+  if (typeof onFulfilled !== 'function' && this.state === states.FULFILLED ||
+    typeof onRejected !== 'function' && this.state === states.REJECTED) {
+    return this;
+  }
+  var promise = new Promise(INTERNAL);
+  if (this.state !== states.PENDING) {
+    var resolver = this.state === states.FULFILLED ? onFulfilled : onRejected;
+    unwrap(promise, resolver, this.outcome);
+  } else {
+    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+  }
+
+  return promise;
+};
+
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js","./queueItem":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/queueItem.js","./resolveThenable":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolveThenable.js","./states":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/states.js","./unwrap":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/unwrap.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/queueItem.js":[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var unwrap = require('./unwrap');
+
+module.exports = QueueItem;
+function QueueItem(promise, onFulfilled, onRejected) {
+  this.promise = promise;
+  if (typeof onFulfilled === 'function') {
+    this.onFulfilled = onFulfilled;
+    this.callFulfilled = this.otherCallFulfilled;
+  }
+  if (typeof onRejected === 'function') {
+    this.onRejected = onRejected;
+    this.callRejected = this.otherCallRejected;
+  }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+  handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+  unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+  handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+  unwrap(this.promise, this.onRejected, value);
+};
+
+},{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./unwrap":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/unwrap.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/race.js":[function(require,module,exports){
+'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = race;
+function race(iterable) {
+  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+    return reject(new TypeError('must be an array'));
+  }
+
+  var len = iterable.length;
+  var called = false;
+  if (!len) {
+    return resolve([]);
+  }
+
+  var i = -1;
+  var promise = new Promise(INTERNAL);
+
+  while (++i < len) {
+    resolver(iterable[i]);
+  }
+  return promise;
+  function resolver(value) {
+    resolve(value).then(function (response) {
+      if (!called) {
+        called = true;
+        handlers.resolve(promise, response);
+      }
+    }, function (error) {
+      if (!called) {
+        called = true;
+        handlers.reject(promise, error);
+      }
+    });
+  }
+}
+
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/reject.js":[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = reject;
+
+function reject(reason) {
+	var promise = new Promise(INTERNAL);
+	return handlers.reject(promise, reason);
+}
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolve.js":[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = resolve;
+
+var FALSE = handlers.resolve(new Promise(INTERNAL), false);
+var NULL = handlers.resolve(new Promise(INTERNAL), null);
+var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
+var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
+var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
+
+function resolve(value) {
+  if (value) {
+    if (value instanceof Promise) {
+      return value;
+    }
+    return handlers.resolve(new Promise(INTERNAL), value);
+  }
+  var valueType = typeof value;
+  switch (valueType) {
+    case 'boolean':
+      return FALSE;
+    case 'undefined':
+      return UNDEFINED;
+    case 'object':
+      return NULL;
+    case 'number':
+      return ZERO;
+    case 'string':
+      return EMPTYSTRING;
+  }
+}
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolveThenable.js":[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var tryCatch = require('./tryCatch');
+function safelyResolveThenable(self, thenable) {
+  // Either fulfill, reject or reject with error
+  var called = false;
+  function onError(value) {
+    if (called) {
+      return;
+    }
+    called = true;
+    handlers.reject(self, value);
+  }
+
+  function onSuccess(value) {
+    if (called) {
+      return;
+    }
+    called = true;
+    handlers.resolve(self, value);
+  }
+
+  function tryToUnwrap() {
+    thenable(onSuccess, onError);
+  }
+  
+  var result = tryCatch(tryToUnwrap);
+  if (result.status === 'error') {
+    onError(result.value);
+  }
+}
+exports.safely = safelyResolveThenable;
+},{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","./tryCatch":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/tryCatch.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/states.js":[function(require,module,exports){
+// Lazy man's symbols for states
+
+exports.REJECTED = ['REJECTED'];
+exports.FULFILLED = ['FULFILLED'];
+exports.PENDING = ['PENDING'];
+
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/tryCatch.js":[function(require,module,exports){
+'use strict';
+
+module.exports = tryCatch;
+
+function tryCatch(func, value) {
+  var out = {};
+  try {
+    out.value = func(value);
+    out.status = 'success';
+  } catch (e) {
+    out.status = 'error';
+    out.value = e;
+  }
+  return out;
+}
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/unwrap.js":[function(require,module,exports){
+'use strict';
+
+var immediate = require('immediate');
+var handlers = require('./handlers');
+module.exports = unwrap;
+
+function unwrap(promise, func, value) {
+  immediate(function () {
+    var returnValue;
+    try {
+      returnValue = func(value);
+    } catch (e) {
+      return handlers.reject(promise, e);
+    }
+    if (returnValue === promise) {
+      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+    } else {
+      handlers.resolve(promise, returnValue);
+    }
+  });
+}
+},{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/handlers.js","immediate":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/index.js":[function(require,module,exports){
+'use strict';
+var types = [
+  require('./nextTick'),
+  require('./mutation.js'),
+  require('./messageChannel'),
+  require('./stateChange'),
+  require('./timeout')
+];
+var draining;
+var queue = [];
+//named nextTick for less confusing stack traces
+function nextTick() {
+  draining = true;
+  var i, oldQueue;
+  var len = queue.length;
+  while (len) {
+    oldQueue = queue;
+    queue = [];
+    i = -1;
+    while (++i < len) {
+      oldQueue[i]();
+    }
+    len = queue.length;
+  }
+  draining = false;
+}
+var scheduleDrain;
+var i = -1;
+var len = types.length;
+while (++ i < len) {
+  if (types[i] && types[i].test && types[i].test()) {
+    scheduleDrain = types[i].install(nextTick);
+    break;
+  }
+}
+module.exports = immediate;
+function immediate(task) {
+  if (queue.push(task) === 1 && !draining) {
+    scheduleDrain();
+  }
+}
+},{"./messageChannel":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/messageChannel.js","./mutation.js":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/mutation.js","./nextTick":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","./stateChange":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/stateChange.js","./timeout":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/timeout.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/messageChannel.js":[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+  if (global.setImmediate) {
+    // we can only get here in IE10
+    // which doesn't handel postMessage well
+    return false;
+  }
+  return typeof global.MessageChannel !== 'undefined';
+};
+
+exports.install = function (func) {
+  var channel = new global.MessageChannel();
+  channel.port1.onmessage = func;
+  return function () {
+    channel.port2.postMessage(0);
+  };
+};
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/mutation.js":[function(require,module,exports){
+(function (global){
+'use strict';
+//based off rsvp https://github.com/tildeio/rsvp.js
+//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
+
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+exports.test = function () {
+  return Mutation;
+};
+
+exports.install = function (handle) {
+  var called = 0;
+  var observer = new Mutation(handle);
+  var element = global.document.createTextNode('');
+  observer.observe(element, {
+    characterData: true
+  });
+  return function () {
+    element.data = (called = ++called % 2);
+  };
+};
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/stateChange.js":[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+  return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
+};
+
+exports.install = function (handle) {
+  return function () {
+
+    // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+    // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+    var scriptEl = global.document.createElement('script');
+    scriptEl.onreadystatechange = function () {
+      handle();
+
+      scriptEl.onreadystatechange = null;
+      scriptEl.parentNode.removeChild(scriptEl);
+      scriptEl = null;
+    };
+    global.document.documentElement.appendChild(scriptEl);
+
+    return handle;
+  };
+};
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/timeout.js":[function(require,module,exports){
+'use strict';
+exports.test = function () {
+  return true;
+};
+
+exports.install = function (t) {
+  return function () {
+    setTimeout(t, 0);
+  };
+};
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js":[function(require,module,exports){
 "use strict";
 
@@ -187595,3169 +188041,4811 @@ module.exports = extend;
 
 
 
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/extras/ajax.js":[function(require,module,exports){
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/extras/ajax.js":[function(require,module,exports){
 'use strict';
 
 // allow external plugins to require('pouchdb/extras/ajax')
 module.exports = require('../lib/deps/ajax');
-},{"../lib/deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/extras/promise.js":[function(require,module,exports){
+},{"../lib/deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/ajax.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/extras/promise.js":[function(require,module,exports){
 'use strict';
 
 // allow external plugins to require('pouchdb/extras/promise')
 module.exports = require('../lib/deps/promise');
-},{"../lib/deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapter.js":[function(require,module,exports){
+},{"../lib/deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/ajax.js":[function(require,module,exports){
+(function (process){
 "use strict";
 
-var utils = require('./utils');
-var merge = require('./merge');
-var errors = require('./deps/errors');
-var EventEmitter = require('events').EventEmitter;
-var upsert = require('./deps/upsert');
-var Changes = require('./changes');
-var Promise = utils.Promise;
-
-/*
- * A generic pouch adapter
- */
-
-// returns first element of arr satisfying callback predicate
-function arrayFirst(arr, callback) {
-  for (var i = 0; i < arr.length; i++) {
-    if (callback(arr[i], i) === true) {
-      return arr[i];
-    }
-  }
-  return false;
-}
+var request = require('request');
 
-// Wrapper for functions that call the bulkdocs api with a single doc,
-// if the first result is an error, return an error
-function yankError(callback) {
-  return function (err, results) {
-    if (err || (results[0] && results[0].error)) {
-      callback(err || results[0]);
-    } else {
-      callback(null, results.length ? results[0]  : results);
-    }
-  };
-}
+var buffer = require('./buffer');
+var errors = require('./errors');
+var utils = require('../utils');
 
-// for every node in a revision tree computes its distance from the closest
-// leaf
-function computeHeight(revs) {
-  var height = {};
-  var edges = [];
-  merge.traverseRevTree(revs, function (isLeaf, pos, id, prnt) {
-    var rev = pos + "-" + id;
-    if (isLeaf) {
-      height[rev] = 0;
-    }
-    if (prnt !== undefined) {
-      edges.push({from: prnt, to: rev});
-    }
-    return rev;
-  });
+function ajax(options, adapterCallback) {
 
-  edges.reverse();
-  edges.forEach(function (edge) {
-    if (height[edge.from] === undefined) {
-      height[edge.from] = 1 + height[edge.to];
-    } else {
-      height[edge.from] = Math.min(height[edge.from], 1 + height[edge.to]);
+  var requestCompleted = false;
+  var callback = utils.getArguments(function (args) {
+    if (requestCompleted) {
+      return;
     }
+    adapterCallback.apply(this, args);
+    requestCompleted = true;
   });
-  return height;
-}
 
-function allDocsKeysQuery(api, opts, callback) {
-  var keys =  ('limit' in opts) ?
-      opts.keys.slice(opts.skip, opts.limit + opts.skip) :
-      (opts.skip > 0) ? opts.keys.slice(opts.skip) : opts.keys;
-  if (opts.descending) {
-    keys.reverse();
-  }
-  if (!keys.length) {
-    return api._allDocs({limit: 0}, callback);
+  if (typeof options === "function") {
+    callback = options;
+    options = {};
   }
-  var finalResults = {
-    offset: opts.skip
+
+  options = utils.clone(options);
+
+  var defaultOptions = {
+    method : "GET",
+    headers: {},
+    json: true,
+    processData: true,
+    timeout: 10000,
+    cache: false
   };
-  return Promise.all(keys.map(function (key) {
-    var subOpts = utils.extend(true, {key: key, deleted: 'ok'}, opts);
-    ['limit', 'skip', 'keys'].forEach(function (optKey) {
-      delete subOpts[optKey];
-    });
-    return new Promise(function (resolve, reject) {
-      api._allDocs(subOpts, function (err, res) {
-        if (err) {
-          return reject(err);
-        }
-        finalResults.total_rows = res.total_rows;
-        resolve(res.rows[0] || {key: key, error: 'not_found'});
-      });
-    });
-  })).then(function (results) {
-    finalResults.rows = results;
-    return finalResults;
-  });
-}
 
-utils.inherits(AbstractPouchDB, EventEmitter);
-module.exports = AbstractPouchDB;
+  options = utils.extend(true, defaultOptions, options);
 
-function AbstractPouchDB() {
-  EventEmitter.call(this);
-}
 
-AbstractPouchDB.prototype.post =
-  utils.adapterFun('post', function (doc, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  if (typeof doc !== 'object' || Array.isArray(doc)) {
-    return callback(errors.error(errors.NOT_AN_OBJECT));
+  function onSuccess(obj, resp, cb) {
+    if (!options.binary && !options.json && options.processData &&
+      typeof obj !== 'string') {
+      obj = JSON.stringify(obj);
+    } else if (!options.binary && options.json && typeof obj === 'string') {
+      try {
+        obj = JSON.parse(obj);
+      } catch (e) {
+        // Probably a malformed JSON from server
+        return cb(e);
+      }
+    }
+    if (Array.isArray(obj)) {
+      obj = obj.map(function (v) {
+        if (v.error || v.missing) {
+          return errors.generateErrorFromResponse(v);
+        } else {
+          return v;
+        }
+      });
+    }
+    cb(null, obj, resp);
   }
-  this.bulkDocs({docs: [doc]}, opts, yankError(callback));
-});
 
-AbstractPouchDB.prototype.put =
-  utils.adapterFun('put', utils.getArguments(function (args) {
-  var temp, temptype, opts, callback;
-  var doc = args.shift();
-  var id = '_id' in doc;
-  if (typeof doc !== 'object' || Array.isArray(doc)) {
-    callback = args.pop();
-    return callback(errors.error(errors.NOT_AN_OBJECT));
-  }
-  doc = utils.clone(doc);
-  while (true) {
-    temp = args.shift();
-    temptype = typeof temp;
-    if (temptype === "string" && !id) {
-      doc._id = temp;
-      id = true;
-    } else if (temptype === "string" && id && !('_rev' in doc)) {
-      doc._rev = temp;
-    } else if (temptype === "object") {
-      opts = temp;
-    } else if (temptype === "function") {
-      callback = temp;
+  function onError(err, cb) {
+    var errParsed, errObj;
+    if (err.code && err.status) {
+      var err2 = new Error(err.message || err.code);
+      err2.status = err.status;
+      return cb(err2);
     }
-    if (!args.length) {
-      break;
+    try {
+      errParsed = JSON.parse(err.responseText);
+      //would prefer not to have a try/catch clause
+      errObj = errors.generateErrorFromResponse(errParsed);
+    } catch (e) {
+      errObj = errors.generateErrorFromResponse(err);
     }
+    cb(errObj);
   }
-  opts = opts || {};
-  var error = utils.invalidIdError(doc._id);
-  if (error) {
-    return callback(error);
-  }
-  if (utils.isLocalId(doc._id) && typeof this._putLocal === 'function') {
-    if (doc._deleted) {
-      return this._removeLocal(doc, callback);
-    } else {
-      return this._putLocal(doc, callback);
+
+
+  if (options.json) {
+    if (!options.binary) {
+      options.headers.Accept = 'application/json';
     }
+    options.headers['Content-Type'] = options.headers['Content-Type'] ||
+      'application/json';
   }
-  this.bulkDocs({docs: [doc]}, opts, yankError(callback));
-}));
 
-AbstractPouchDB.prototype.putAttachment =
-  utils.adapterFun('putAttachment', function (docId, attachmentId, rev,
-                                              blob, type, callback) {
-  var api = this;
-  if (typeof type === 'function') {
-    callback = type;
-    type = blob;
-    blob = rev;
-    rev = null;
-  }
-  if (typeof type === 'undefined') {
-    type = blob;
-    blob = rev;
-    rev = null;
+  if (options.binary) {
+    options.encoding = null;
+    options.json = false;
   }
 
-  function createAttachment(doc) {
-    doc._attachments = doc._attachments || {};
-    doc._attachments[attachmentId] = {
-      content_type: type,
-      data: blob
-    };
-    return api.put(doc);
+  if (!options.processData) {
+    options.json = false;
   }
 
-  return api.get(docId).then(function (doc) {
-    if (doc._rev !== rev) {
-      throw errors.error(errors.REV_CONFLICT);
-    }
-
-    return createAttachment(doc);
-  }, function (err) {
-     // create new doc
-    if (err.reason === errors.MISSING_DOC.message) {
-      return createAttachment({_id: docId});
-    } else {
-      throw err;
+  function defaultBody(data) {
+    if (process.browser) {
+      return '';
     }
-  });
-});
+    return new buffer('', 'binary');
+  }
 
-AbstractPouchDB.prototype.removeAttachment =
-  utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
-                                                 callback) {
-  var self = this;
-  self.get(docId, function (err, obj) {
+  return request(options, function (err, response, body) {
     if (err) {
-      callback(err);
-      return;
-    }
-    if (obj._rev !== rev) {
-      callback(errors.error(errors.REV_CONFLICT));
-      return;
+      err.status = response ? response.statusCode : 400;
+      return onError(err, callback);
     }
-    if (!obj._attachments) {
-      return callback();
+
+    var error;
+    var content_type = response.headers && response.headers['content-type'];
+    var data = body || defaultBody();
+
+    // CouchDB doesn't always return the right content-type for JSON data, so
+    // we check for ^{ and }$ (ignoring leading/trailing whitespace)
+    if (!options.binary && (options.json || !options.processData) &&
+        typeof data !== 'object' &&
+        (/json/.test(content_type) ||
+         (/^[\s]*\{/.test(data) && /\}[\s]*$/.test(data)))) {
+      data = JSON.parse(data);
     }
-    delete obj._attachments[attachmentId];
-    if (Object.keys(obj._attachments).length === 0) {
-      delete obj._attachments;
+
+    if (response.statusCode >= 200 && response.statusCode < 300) {
+      onSuccess(data, response, callback);
+    } else {
+      if (options.binary) {
+        data = JSON.parse(data.toString());
+      }
+      error = errors.generateErrorFromResponse(data);
+      error.status = response.statusCode;
+      callback(error);
     }
-    self.put(obj, callback);
   });
-});
+}
 
-AbstractPouchDB.prototype.remove =
-  utils.adapterFun('remove', function (docOrId, optsOrRev, opts, callback) {
-  var doc;
-  if (typeof optsOrRev === 'string') {
-    // id, rev, opts, callback style
-    doc = {
-      _id: docOrId,
-      _rev: optsOrRev
-    };
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
+module.exports = ajax;
+
+}).call(this,require('_process'))
+},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/utils.js","./buffer":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/buffer-browser.js","./errors":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/errors.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","request":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/request-browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/blob.js":[function(require,module,exports){
+(function (global){
+"use strict";
+
+//Abstracts constructing a Blob object, so it also works in older
+//browsers that don't support the native Blob constructor. (i.e.
+//old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+  parts = parts || [];
+  properties = properties || {};
+  try {
+    return new Blob(parts, properties);
+  } catch (e) {
+    if (e.name !== "TypeError") {
+      throw e;
     }
-  } else {
-    // doc, opts, callback style
-    doc = docOrId;
-    if (typeof optsOrRev === 'function') {
-      callback = optsOrRev;
-      opts = {};
-    } else {
-      callback = opts;
-      opts = optsOrRev;
+    var BlobBuilder = global.BlobBuilder ||
+                      global.MSBlobBuilder ||
+                      global.MozBlobBuilder ||
+                      global.WebKitBlobBuilder;
+    var builder = new BlobBuilder();
+    for (var i = 0; i < parts.length; i += 1) {
+      builder.append(parts[i]);
     }
+    return builder.getBlob(properties.type);
   }
-  opts = utils.clone(opts || {});
-  opts.was_delete = true;
-  var newDoc = {_id: doc._id, _rev: (doc._rev || opts.rev)};
-  newDoc._deleted = true;
-  if (utils.isLocalId(newDoc._id) && typeof this._removeLocal === 'function') {
-    return this._removeLocal(doc, callback);
-  }
-  this.bulkDocs({docs: [newDoc]}, opts, yankError(callback));
-});
+}
 
-AbstractPouchDB.prototype.revsDiff =
-  utils.adapterFun('revsDiff', function (req, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  opts = utils.clone(opts);
-  var ids = Object.keys(req);
+module.exports = createBlob;
 
-  if (!ids.length) {
-    return callback(null, {});
-  }
 
-  var count = 0;
-  var missing = new utils.Map();
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/buffer-browser.js":[function(require,module,exports){
+// hey guess what, we don't need this in the browser
+module.exports = {};
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/errors.js":[function(require,module,exports){
+"use strict";
 
-  function addToMissing(id, revId) {
-    if (!missing.has(id)) {
-      missing.set(id, {missing: []});
-    }
-    missing.get(id).missing.push(revId);
-  }
+var inherits = require('inherits');
+inherits(PouchError, Error);
 
-  function processDoc(id, rev_tree) {
-    // Is this fast enough? Maybe we should switch to a set simulated by a map
-    var missingForId = req[id].slice(0);
-    merge.traverseRevTree(rev_tree, function (isLeaf, pos, revHash, ctx,
-      opts) {
-        var rev = pos + '-' + revHash;
-        var idx = missingForId.indexOf(rev);
-        if (idx === -1) {
-          return;
-        }
+function PouchError(opts) {
+  Error.call(opts.reason);
+  this.status = opts.status;
+  this.name = opts.error;
+  this.message = opts.reason;
+  this.error = true;
+}
 
-        missingForId.splice(idx, 1);
-        if (opts.status !== 'available') {
-          addToMissing(id, rev);
-        }
-      });
+PouchError.prototype.toString = function () {
+  return JSON.stringify({
+    status: this.status,
+    name: this.name,
+    message: this.message
+  });
+};
 
-    // Traversing the tree is synchronous, so now `missingForId` contains
-    // revisions that were not found in the tree
-    missingForId.forEach(function (rev) {
-      addToMissing(id, rev);
-    });
-  }
+exports.UNAUTHORIZED = new PouchError({
+  status: 401,
+  error: 'unauthorized',
+  reason: "Name or password is incorrect."
+});
 
-  ids.map(function (id) {
-    this._getRevisionTree(id, function (err, rev_tree) {
-      if (err && err.status === 404 && err.message === 'missing') {
-        missing.set(id, {missing: req[id]});
-      } else if (err) {
-        return callback(err);
-      } else {
-        processDoc(id, rev_tree);
-      }
+exports.MISSING_BULK_DOCS = new PouchError({
+  status: 400,
+  error: 'bad_request',
+  reason: "Missing JSON list of 'docs'"
+});
 
-      if (++count === ids.length) {
-        // convert LazyMap to object
-        var missingObj = {};
-        missing.forEach(function (value, key) {
-          missingObj[key] = value;
-        });
-        return callback(null, missingObj);
-      }
-    });
-  }, this);
+exports.MISSING_DOC = new PouchError({
+  status: 404,
+  error: 'not_found',
+  reason: 'missing'
 });
 
-// compact one document and fire callback
-// by compacting we mean removing all revisions which
-// are further from the leaf in revision tree than max_height
-AbstractPouchDB.prototype.compactDocument =
-  utils.adapterFun('compactDocument', function (docId, maxHeight, callback) {
-  var self = this;
-  this._getRevisionTree(docId, function (err, revTree) {
-    if (err) {
-      return callback(err);
-    }
-    var height = computeHeight(revTree);
-    var candidates = [];
-    var revs = [];
-    Object.keys(height).forEach(function (rev) {
-      if (height[rev] > maxHeight) {
-        candidates.push(rev);
-      }
-    });
+exports.REV_CONFLICT = new PouchError({
+  status: 409,
+  error: 'conflict',
+  reason: 'Document update conflict'
+});
 
-    merge.traverseRevTree(revTree, function (isLeaf, pos, revHash, ctx, opts) {
-      var rev = pos + '-' + revHash;
-      if (opts.status === 'available' && candidates.indexOf(rev) !== -1) {
-        revs.push(rev);
-      }
-    });
-    self._doCompaction(docId, revs, callback);
-  });
+exports.INVALID_ID = new PouchError({
+  status: 400,
+  error: 'invalid_id',
+  reason: '_id field must contain a string'
 });
 
-// compact the whole database using single document
-// compaction
-AbstractPouchDB.prototype.compact =
-  utils.adapterFun('compact', function (opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  var self = this;
+exports.MISSING_ID = new PouchError({
+  status: 412,
+  error: 'missing_id',
+  reason: '_id is required for puts'
+});
 
-  opts = utils.clone(opts || {});
+exports.RESERVED_ID = new PouchError({
+  status: 400,
+  error: 'bad_request',
+  reason: 'Only reserved document ids may start with underscore.'
+});
 
-  self.get('_local/compaction').catch(function () {
-    return false;
-  }).then(function (doc) {
-    if (typeof self._compact === 'function') {
-      if (doc && doc.last_seq) {
-        opts.last_seq = doc.last_seq;
-      }
-      return self._compact(opts, callback);
-    }
+exports.NOT_OPEN = new PouchError({
+  status: 412,
+  error: 'precondition_failed',
+  reason: 'Database not open'
+});
 
-  });
+exports.UNKNOWN_ERROR = new PouchError({
+  status: 500,
+  error: 'unknown_error',
+  reason: 'Database encountered an unknown error'
 });
-AbstractPouchDB.prototype._compact = function (opts, callback) {
-  var self = this;
-  var changesOpts = {
-    returnDocs: false,
-    last_seq: opts.last_seq || 0
-  };
-  var promises = [];
 
-  function onChange(row) {
-    promises.push(self.compactDocument(row.id, 0));
-  }
-  function onComplete(resp) {
-    var lastSeq = resp.last_seq;
-    Promise.all(promises).then(function () {
-      return upsert(self, '_local/compaction', function deltaFunc(doc) {
-        if (!doc.last_seq || doc.last_seq < lastSeq) {
-          doc.last_seq = lastSeq;
-          return doc;
-        }
-        return false; // somebody else got here first, don't update
-      });
-    }).then(function () {
-      callback(null, {ok: true});
-    }).catch(callback);
-  }
-  self.changes(changesOpts)
-    .on('change', onChange)
-    .on('complete', onComplete)
-    .on('error', callback);
-};
-/* Begin api wrappers. Specific functionality to storage belongs in the 
-   _[method] */
-AbstractPouchDB.prototype.get =
-  utils.adapterFun('get', function (id, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  if (typeof id !== 'string') {
-    return callback(errors.error(errors.INVALID_ID));
-  }
-  if (utils.isLocalId(id) && typeof this._getLocal === 'function') {
-    return this._getLocal(id, callback);
-  }
-  var leaves = [], self = this;
+exports.BAD_ARG = new PouchError({
+  status: 500,
+  error: 'badarg',
+  reason: 'Some query argument is invalid'
+});
 
-  function finishOpenRevs() {
-    var result = [];
-    var count = leaves.length;
-    if (!count) {
-      return callback(null, result);
-    }
-    // order with open_revs is unspecified
-    leaves.forEach(function (leaf) {
-      self.get(id, {
-        rev: leaf,
-        revs: opts.revs,
-        attachments: opts.attachments
-      }, function (err, doc) {
-        if (!err) {
-          result.push({ok: doc});
-        } else {
-          result.push({missing: leaf});
-        }
-        count--;
-        if (!count) {
-          callback(null, result);
-        }
-      });
-    });
-  }
+exports.INVALID_REQUEST = new PouchError({
+  status: 400,
+  error: 'invalid_request',
+  reason: 'Request was invalid'
+});
 
-  if (opts.open_revs) {
-    if (opts.open_revs === "all") {
-      this._getRevisionTree(id, function (err, rev_tree) {
-        if (err) {
-          return callback(err);
-        }
-        leaves = merge.collectLeaves(rev_tree).map(function (leaf) {
-          return leaf.rev;
-        });
-        finishOpenRevs();
-      });
-    } else {
-      if (Array.isArray(opts.open_revs)) {
-        leaves = opts.open_revs;
-        for (var i = 0; i < leaves.length; i++) {
-          var l = leaves[i];
-          // looks like it's the only thing couchdb checks
-          if (!(typeof(l) === "string" && /^\d+-/.test(l))) {
-            return callback(errors.error(errors.INVALID_REV));
-          }
-        }
-        finishOpenRevs();
-      } else {
-        return callback(errors.error(errors.UNKNOWN_ERROR,
-          'function_clause'));
-      }
-    }
-    return; // open_revs does not like other options
-  }
+exports.QUERY_PARSE_ERROR = new PouchError({
+  status: 400,
+  error: 'query_parse_error',
+  reason: 'Some query parameter is invalid'
+});
 
-  return this._get(id, opts, function (err, result) {
-    opts = utils.clone(opts);
-    if (err) {
-      return callback(err);
-    }
+exports.DOC_VALIDATION = new PouchError({
+  status: 500,
+  error: 'doc_validation',
+  reason: 'Bad special document member'
+});
 
-    var doc = result.doc;
-    var metadata = result.metadata;
-    var ctx = result.ctx;
+exports.BAD_REQUEST = new PouchError({
+  status: 400,
+  error: 'bad_request',
+  reason: 'Something wrong with the request'
+});
 
-    if (opts.conflicts) {
-      var conflicts = merge.collectConflicts(metadata);
-      if (conflicts.length) {
-        doc._conflicts = conflicts;
-      }
-    }
+exports.NOT_AN_OBJECT = new PouchError({
+  status: 400,
+  error: 'bad_request',
+  reason: 'Document must be a JSON object'
+});
 
-    if (utils.isDeleted(metadata, doc._rev)) {
-      doc._deleted = true;
-    }
+exports.DB_MISSING = new PouchError({
+  status: 404,
+  error: 'not_found',
+  reason: 'Database not found'
+});
 
-    if (opts.revs || opts.revs_info) {
-      var paths = merge.rootToLeaf(metadata.rev_tree);
-      var path = arrayFirst(paths, function (arr) {
-        return arr.ids.map(function (x) { return x.id; })
-          .indexOf(doc._rev.split('-')[1]) !== -1;
-      });
+exports.IDB_ERROR = new PouchError({
+  status: 500,
+  error: 'indexed_db_went_bad',
+  reason: 'unknown'
+});
 
-      var indexOfRev = path.ids.map(function (x) {return x.id; })
-        .indexOf(doc._rev.split('-')[1]) + 1;
-      var howMany = path.ids.length - indexOfRev;
-      path.ids.splice(indexOfRev, howMany);
-      path.ids.reverse();
+exports.WSQ_ERROR = new PouchError({
+  status: 500,
+  error: 'web_sql_went_bad',
+  reason: 'unknown'
+});
 
-      if (opts.revs) {
-        doc._revisions = {
-          start: (path.pos + path.ids.length) - 1,
-          ids: path.ids.map(function (rev) {
-            return rev.id;
-          })
-        };
-      }
-      if (opts.revs_info) {
-        var pos =  path.pos + path.ids.length;
-        doc._revs_info = path.ids.map(function (rev) {
-          pos--;
-          return {
-            rev: pos + '-' + rev.id,
-            status: rev.opts.status
-          };
-        });
-      }
-    }
+exports.LDB_ERROR = new PouchError({
+  status: 500,
+  error: 'levelDB_went_went_bad',
+  reason: 'unknown'
+});
 
-    if (opts.local_seq) {
-      utils.info('The "local_seq" option is deprecated and will be removed');
-      doc._local_seq = result.metadata.seq;
-    }
+exports.FORBIDDEN = new PouchError({
+  status: 403,
+  error: 'forbidden',
+  reason: 'Forbidden by design doc validate_doc_update function'
+});
 
-    if (opts.attachments && doc._attachments) {
-      var attachments = doc._attachments;
-      var count = Object.keys(attachments).length;
-      if (count === 0) {
-        return callback(null, doc);
-      }
-      Object.keys(attachments).forEach(function (key) {
-        this._getAttachment(attachments[key],
-                            {encode: true, ctx: ctx}, function (err, data) {
-          var att = doc._attachments[key];
-          att.data = data;
-          delete att.stub;
-          delete att.length;
-          if (!--count) {
-            callback(null, doc);
-          }
-        });
-      }, self);
-    } else {
-      if (doc._attachments) {
-        for (var key in doc._attachments) {
-          if (doc._attachments.hasOwnProperty(key)) {
-            doc._attachments[key].stub = true;
-          }
-        }
-      }
-      callback(null, doc);
-    }
-  });
+exports.INVALID_REV = new PouchError({
+  status: 400,
+  error: 'bad_request',
+  reason: 'Invalid rev format'
 });
 
-AbstractPouchDB.prototype.getAttachment =
-  utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
-                                              callback) {
-  var self = this;
-  if (opts instanceof Function) {
-    callback = opts;
-    opts = {};
-  }
-  opts = utils.clone(opts);
-  this._get(docId, opts, function (err, res) {
-    if (err) {
-      return callback(err);
-    }
-    if (res.doc._attachments && res.doc._attachments[attachmentId]) {
-      opts.ctx = res.ctx;
-      self._getAttachment(res.doc._attachments[attachmentId], opts, callback);
-    } else {
-      return callback(errors.error(errors.MISSING_DOC));
-    }
-  });
+exports.FILE_EXISTS = new PouchError({
+  status: 412,
+  error: 'file_exists',
+  reason: 'The database could not be created, the file already exists.'
 });
 
-AbstractPouchDB.prototype.allDocs =
-  utils.adapterFun('allDocs', function (opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  opts = utils.clone(opts);
-  opts.skip = typeof opts.skip !== 'undefined' ? opts.skip : 0;
-  if ('keys' in opts) {
-    if (!Array.isArray(opts.keys)) {
-      return callback(new TypeError('options.keys must be an array'));
+exports.MISSING_STUB = new PouchError({
+  status: 412,
+  error: 'missing_stub'
+});
+
+exports.error = function (error, reason, name) {
+  function CustomPouchError(reason) {
+    // inherit error properties from our parent error manually
+    // so as to allow proper JSON parsing.
+    /* jshint ignore:start */
+    for (var p in error) {
+      if (typeof error[p] !== 'function') {
+        this[p] = error[p];
+      }
     }
-    var incompatibleOpt =
-      ['startkey', 'endkey', 'key'].filter(function (incompatibleOpt) {
-      return incompatibleOpt in opts;
-    })[0];
-    if (incompatibleOpt) {
-      callback(errors.error(errors.QUERY_PARSE_ERROR,
-        'Query parameter `' + incompatibleOpt +
-        '` is not compatible with multi-get'
-      ));
-      return;
+    /* jshint ignore:end */
+    if (name !== undefined) {
+      this.name = name;
     }
-    if (this.type() !== 'http') {
-      return allDocsKeysQuery(this, opts, callback);
+    if (reason !== undefined) {
+      this.reason = reason;
     }
   }
+  CustomPouchError.prototype = PouchError.prototype;
+  return new CustomPouchError(reason);
+};
 
-  return this._allDocs(opts, callback);
-});
-
-AbstractPouchDB.prototype.changes = function (opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  return new Changes(this, opts, callback);
+// Find one of the errors defined above based on the value
+// of the specified property.
+// If reason is provided prefer the error matching that reason.
+// This is for differentiating between errors with the same name and status,
+// eg, bad_request.
+exports.getErrorTypeByProp = function (prop, value, reason) {
+  var errors = exports;
+  var keys = Object.keys(errors).filter(function (key) {
+    var error = errors[key];
+    return typeof error !== 'function' && error[prop] === value;
+  });
+  var key = reason && keys.filter(function (key) {
+        var error = errors[key];
+        return error.message === reason;
+      })[0] || keys[0];
+  return (key) ? errors[key] : null;
 };
 
-AbstractPouchDB.prototype.close =
-  utils.adapterFun('close', function (callback) {
-  this._closed = true;
-  return this._close(callback);
-});
+exports.generateErrorFromResponse = function (res) {
+  var error, errName, errType, errMsg, errReason;
+  var errors = exports;
 
-AbstractPouchDB.prototype.info = utils.adapterFun('info', function (callback) {
-  var self = this;
-  this._info(function (err, info) {
-    if (err) {
-      return callback(err);
-    }
-    // assume we know better than the adapter, unless it informs us
-    info.db_name = info.db_name || self._db_name;
-    info.auto_compaction = !!(self.auto_compaction && self.type() !== 'http');
-    callback(null, info);
-  });
-});
+  errName = (res.error === true && typeof res.name === 'string') ?
+              res.name :
+              res.error;
+  errReason = res.reason;
+  errType = errors.getErrorTypeByProp('name', errName, errReason);
 
-AbstractPouchDB.prototype.id = utils.adapterFun('id', function (callback) {
-  return this._id(callback);
-});
+  if (res.missing ||
+      errReason === 'missing' ||
+      errReason === 'deleted' ||
+      errName === 'not_found') {
+    errType = errors.MISSING_DOC;
+  } else if (errName === 'doc_validation') {
+    // doc validation needs special treatment since
+    // res.reason depends on the validation error.
+    // see utils.js
+    errType = errors.DOC_VALIDATION;
+    errMsg = errReason;
+  } else if (errName === 'bad_request' && errType.message !== errReason) {
+    // if bad_request error already found based on reason don't override.
 
-AbstractPouchDB.prototype.type = function () {
-  return (typeof this._type === 'function') ? this._type() : this.adapter;
-};
+    // attachment errors.
+    if (errReason.indexOf('unknown stub attachment') === 0) {
+      errType = errors.MISSING_STUB;
+      errMsg = errReason;
+    } else {
+      errType = errors.BAD_REQUEST;
+    }
+  }
 
-AbstractPouchDB.prototype.bulkDocs =
-  utils.adapterFun('bulkDocs', function (req, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
+  // fallback to error by statys or unknown error.
+  if (!errType) {
+    errType = errors.getErrorTypeByProp('status', res.status, errReason) ||
+                errors.UNKNOWN_ERROR;
   }
 
-  opts = utils.clone(opts);
+  error = errors.error(errType, errReason, errName);
 
-  if (Array.isArray(req)) {
-    req = {
-      docs: req
-    };
+  // Keep custom message.
+  if (errMsg) {
+    error.message = errMsg;
   }
 
-  if (!req || !req.docs || !Array.isArray(req.docs)) {
-    return callback(errors.error(errors.MISSING_BULK_DOCS));
+  // Keep helpful response data in our error messages.
+  if (res.id) {
+    error.id = res.id;
   }
-
-  for (var i = 0; i < req.docs.length; ++i) {
-    if (typeof req.docs[i] !== 'object' || Array.isArray(req.docs[i])) {
-      return callback(errors.error(errors.NOT_AN_OBJECT));
-    }
+  if (res.status) {
+    error.status = res.status;
   }
-
-  req = utils.clone(req);
-  if (!('new_edits' in opts)) {
-    if ('new_edits' in req) {
-      opts.new_edits = req.new_edits;
-    } else {
-      opts.new_edits = true;
-    }
+  if (res.statusText) {
+    error.name = res.statusText;
   }
-
-  if (!opts.new_edits && this.type() !== 'http') {
-    // ensure revisions of the same doc are sorted, so that
-    // the local adapter processes them correctly (#2935)
-    req.docs.sort(function (a, b) {
-      var idCompare = utils.compare(a._id, b._id);
-      if (idCompare !== 0) {
-        return idCompare;
-      }
-      var aStart = a._revisions ? a._revisions.start : 0;
-      var bStart = b._revisions ? b._revisions.start : 0;
-      return utils.compare(aStart, bStart);
-    });
+  if (res.missing) {
+    error.missing = res.missing;
   }
 
-  req.docs.forEach(function (doc) {
-    if (doc._deleted) {
-      delete doc._attachments; // ignore atts for deleted docs
-    }
-  });
-
-  return this._bulkDocs(req, opts, function (err, res) {
-    if (err) {
-      return callback(err);
-    }
-    if (!opts.new_edits) {
-      // this is what couch does when new_edits is false
-      res = res.filter(function (x) {
-        return x.error;
-      });
-    }
-    callback(null, res);
-  });
-});
+  return error;
+};
 
-AbstractPouchDB.prototype.registerDependentDatabase =
-  utils.adapterFun('registerDependentDatabase', function (dependentDb,
-                                                          callback) {
-  var depDB = new this.constructor(dependentDb, this.__opts);
+},{"inherits":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/inherits/inherits_browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/explain404.js":[function(require,module,exports){
+(function (process,global){
+'use strict';
 
-  function diffFun(doc) {
-    doc.dependentDbs = doc.dependentDbs || {};
-    if (doc.dependentDbs[dependentDb]) {
-      return false; // no update required
-    }
-    doc.dependentDbs[dependentDb] = true;
-    return doc;
+// designed to give info to browser users, who are disturbed
+// when they see 404s in the console
+function explain404(str) {
+  if (process.browser && 'console' in global && 'info' in console) {
+    console.info('The above 404 is totally normal. ' + str);
   }
-  upsert(this, '_local/_pouch_dependentDbs', diffFun, function (err) {
-    if (err) {
-      return callback(err);
-    }
-    return callback(null, {db: depDB});
-  });
-});
+}
 
-AbstractPouchDB.prototype.destroy =
-  utils.adapterFun('destroy', function (callback) {
+module.exports = explain404;
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/md5.js":[function(require,module,exports){
+(function (process,global){
+'use strict';
 
-  var self = this;
-  var usePrefix = 'use_prefix' in self ? self.use_prefix : true;
+var crypto = require('crypto');
+var Md5 = require('spark-md5');
+var setImmediateShim = global.setImmediate || global.setTimeout;
+var MD5_CHUNK_SIZE = 32768;
 
-  function destroyDb() {
-    // call destroy method of the particular adaptor
-    self._destroy(function (err, resp) {
-      if (err) {
-        return callback(err);
-      }
-      self.emit('destroyed');
-      callback(null, resp || { 'ok': true });
-    });
-  }
-  self.get('_local/_pouch_dependentDbs', function (err, localDoc) {
-    if (err) {
-      if (err.status !== 404) {
-        return callback(err);
-      } else { // no dependencies
-        return destroyDb();
-      }
-    }
-    var dependentDbs = localDoc.dependentDbs;
-    var PouchDB = self.constructor;
-    var deletedMap = Object.keys(dependentDbs).map(function (name) {
-      var trueName = usePrefix ?
-        name.replace(new RegExp('^' + PouchDB.prefix), '') : name;
-      return new PouchDB(trueName, self.__opts).destroy();
-    });
-    Promise.all(deletedMap).then(destroyDb, function (error) {
-      callback(error);
-    });
-  });
-});
-
-},{"./changes":"/Users/richard/src/beagle/node_modules/pouchdb/lib/changes.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./deps/upsert":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/upsert.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/http/http.js":[function(require,module,exports){
-(function (process){
-"use strict";
-
-var CHANGES_BATCH_SIZE = 25;
-
-// according to http://stackoverflow.com/a/417184/680742,
-// the de factor URL length limit is 2000 characters.
-// but since most of our measurements don't take the full
-// URL into account, we fudge it a bit.
-// TODO: we could measure the full URL to enforce exactly 2000 chars
-var MAX_URL_LENGTH = 1800;
-
-var utils = require('../../utils');
-var errors = require('../../deps/errors');
-var log = require('debug')('pouchdb:http');
-var isBrowser = typeof process === 'undefined' || process.browser;
-var buffer = require('../../deps/buffer');
+// convert a 64-bit int to a binary string
+function intToString(int) {
+  var bytes = [
+    (int & 0xff),
+    ((int >>> 8) & 0xff),
+    ((int >>> 16) & 0xff),
+    ((int >>> 24) & 0xff)
+  ];
+  return bytes.map(function (byte) {
+    return String.fromCharCode(byte);
+  }).join('');
+}
 
-function encodeDocId(id) {
-  if (/^_design/.test(id)) {
-    return '_design/' + encodeURIComponent(id.slice(8));
-  }
-  if (/^_local/.test(id)) {
-    return '_local/' + encodeURIComponent(id.slice(7));
+// convert an array of 64-bit ints into
+// a base64-encoded string
+function rawToBase64(raw) {
+  var res = '';
+  for (var i = 0; i < raw.length; i++) {
+    res += intToString(raw[i]);
   }
-  return encodeURIComponent(id);
+  return btoa(res);
 }
 
-function preprocessAttachments(doc) {
-  if (!doc._attachments || !Object.keys(doc._attachments)) {
-    return utils.Promise.resolve();
+function appendBuffer(buffer, data, start, end) {
+  if (start > 0 || end < data.byteLength) {
+    // only create a subarray if we really need to
+    data = new Uint8Array(data, start,
+      Math.min(end, data.byteLength) - start);
   }
+  buffer.append(data);
+}
 
-  return utils.Promise.all(Object.keys(doc._attachments).map(function (key) {
-    var attachment = doc._attachments[key];
-    if (attachment.data && typeof attachment.data !== 'string') {
-      if (isBrowser) {
-        return new utils.Promise(function (resolve) {
-          utils.readAsBinaryString(attachment.data, function (binary) {
-            attachment.data = utils.btoa(binary);
-            resolve();
-          });
-        });
-      } else {
-        attachment.data = attachment.data.toString('base64');
-      }
-    }
-  }));
+function appendString(buffer, data, start, end) {
+  if (start > 0 || end < data.length) {
+    // only create a substring if we really need to
+    data = data.substring(start, end);
+  }
+  buffer.appendBinary(data);
 }
 
-// Get all the information you possibly can about the URI given by name and
-// return it as a suitable object.
-function getHost(name, opts) {
-  // If the given name contains "http:"
-  if (/http(s?):/.test(name)) {
-    // Prase the URI into all its little bits
-    var uri = utils.parseUri(name);
+module.exports = function (data, callback) {
+  if (!process.browser) {
+    var base64 = crypto.createHash('md5').update(data).digest('base64');
+    callback(null, base64);
+    return;
+  }
+  var inputIsString = typeof data === 'string';
+  var len = inputIsString ? data.length : data.byteLength;
+  var chunkSize = Math.min(MD5_CHUNK_SIZE, len);
+  var chunks = Math.ceil(len / chunkSize);
+  var currentChunk = 0;
+  var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();
 
-    // Store the fact that it is a remote URI
-    uri.remote = true;
+  var append = inputIsString ? appendString : appendBuffer;
 
-    // Store the user and password as a separate auth object
-    if (uri.user || uri.password) {
-      uri.auth = {username: uri.user, password: uri.password};
+  function loadNextChunk() {
+    var start = currentChunk * chunkSize;
+    var end = start + chunkSize;
+    currentChunk++;
+    if (currentChunk < chunks) {
+      append(buffer, data, start, end);
+      setImmediateShim(loadNextChunk);
+    } else {
+      append(buffer, data, start, end);
+      var raw = buffer.end(true);
+      var base64 = rawToBase64(raw);
+      callback(null, base64);
+      buffer.destroy();
     }
+  }
+  loadNextChunk();
+};
 
-    // Split the path part of the URI into parts using '/' as the delimiter
-    // after removing any leading '/' and any trailing '/'
-    var parts = uri.path.replace(/(^\/|\/$)/g, '').split('/');
-
-    // Store the first part as the database name and remove it from the parts
-    // array
-    uri.db = parts.pop();
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","crypto":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","spark-md5":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-doc.js":[function(require,module,exports){
+'use strict';
 
-    // Restore the path by joining all the remaining parts (all the parts
-    // except for the database name) with '/'s
-    uri.path = parts.join('/');
-    opts = opts || {};
-    opts = utils.clone(opts);
-    uri.headers = opts.headers || (opts.ajax && opts.ajax.headers) || {};
+var errors = require('./errors');
+var uuid = require('./uuid');
 
-    if (opts.auth || uri.auth) {
-      var nAuth = opts.auth || uri.auth;
-      var token = utils.btoa(nAuth.username + ':' + nAuth.password);
-      uri.headers.Authorization = 'Basic ' + token;
-    }
+function toObject(array) {
+  return array.reduce(function (obj, item) {
+    obj[item] = true;
+    return obj;
+  }, {});
+}
+// List of top level reserved words for doc
+var reservedWords = toObject([
+  '_id',
+  '_rev',
+  '_attachments',
+  '_deleted',
+  '_revisions',
+  '_revs_info',
+  '_conflicts',
+  '_deleted_conflicts',
+  '_local_seq',
+  '_rev_tree',
+  //replication documents
+  '_replication_id',
+  '_replication_state',
+  '_replication_state_time',
+  '_replication_state_reason',
+  '_replication_stats',
+  // Specific to Couchbase Sync Gateway
+  '_removed'
+]);
 
-    if (opts.headers) {
-      uri.headers = opts.headers;
-    }
+// List of reserved words that should end up the document
+var dataWords = toObject([
+  '_attachments',
+  //replication documents
+  '_replication_id',
+  '_replication_state',
+  '_replication_state_time',
+  '_replication_state_reason',
+  '_replication_stats'
+]);
 
-    return uri;
+// Determine id an ID is valid
+//   - invalid IDs begin with an underescore that does not begin '_design' or
+//     '_local'
+//   - any other string value is a valid id
+// Returns the specific error object for each case
+exports.invalidIdError = function (id) {
+  var err;
+  if (!id) {
+    err = errors.error(errors.MISSING_ID);
+  } else if (typeof id !== 'string') {
+    err = errors.error(errors.INVALID_ID);
+  } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
+    err = errors.error(errors.RESERVED_ID);
+  }
+  if (err) {
+    throw err;
   }
+};
 
-  // If the given name does not contain 'http:' then return a very basic object
-  // with no host, the current path, the given name as the database name and no
-  // username/password
-  return {host: '', path: '/', db: name, auth: false};
+function parseRevisionInfo(rev) {
+  if (!/^\d+\-./.test(rev)) {
+    return errors.error(errors.INVALID_REV);
+  }
+  var idx = rev.indexOf('-');
+  var left = rev.substring(0, idx);
+  var right = rev.substring(idx + 1);
+  return {
+    prefix: parseInt(left, 10),
+    id: right
+  };
 }
 
-// Generate a URL with the host data given by opts and the given path
-function genDBUrl(opts, path) {
-  return genUrl(opts, opts.db + '/' + path);
-}
+function makeRevTreeFromRevisions(revisions, opts) {
+  var pos = revisions.start - revisions.ids.length + 1;
 
-// Generate a URL with the host data given by opts and the given path
-function genUrl(opts, path) {
-  if (opts.remote) {
-    // If the host already has a path, then we need to have a path delimiter
-    // Otherwise, the path delimiter is the empty string
-    var pathDel = !opts.path ? '' : '/';
+  var revisionIds = revisions.ids;
+  var ids = [revisionIds[0], opts, []];
 
-    // If the host already has a path, then we need to have a path delimiter
-    // Otherwise, the path delimiter is the empty string
-    return opts.protocol + '://' + opts.host + ':' + opts.port + '/' +
-           opts.path + pathDel + path;
+  for (var i = 1, len = revisionIds.length; i < len; i++) {
+    ids = [revisionIds[i], {status: 'missing'}, [ids]];
   }
 
-  return '/' + path;
+  return [{
+    pos: pos,
+    ids: ids
+  }];
 }
 
-// Implements the PouchDB API for dealing with CouchDB instances over HTTP
-function HttpPouch(opts, callback) {
-  // The functions that will be publicly available for HttpPouch
-  var api = this;
-  api.getHost = opts.getHost ? opts.getHost : getHost;
-
-  // Parse the URI given by opts.name into an easy-to-use object
-  var host = api.getHost(opts.name, opts);
-
-  // Generate the database URL based on the host
-  var dbUrl = genDBUrl(host, '');
-
-  api.getUrl = function () {return dbUrl; };
-  api.getHeaders = function () {return utils.clone(host.headers); };
+// Preprocess documents, parse their revisions, assign an id and a
+// revision for new writes that are missing them, etc
+exports.parseDoc = function (doc, newEdits) {
 
-  var ajaxOpts = opts.ajax || {};
-  opts = utils.clone(opts);
-  function ajax(options, callback) {
-    var reqOpts = utils.extend(true, utils.clone(ajaxOpts), options);
-    log(reqOpts.method + ' ' + reqOpts.url);
-    return utils.ajax(reqOpts, callback);
+  var nRevNum;
+  var newRevId;
+  var revInfo;
+  var opts = {status: 'available'};
+  if (doc._deleted) {
+    opts.deleted = true;
   }
 
-  // Create a new CouchDB database based on the given opts
-  var createDB = function () {
-    ajax({headers: host.headers, method: 'PUT', url: dbUrl}, function (err) {
-      // If we get an "Unauthorized" error
-      if (err && err.status === 401) {
-        // Test if the database already exists
-        ajax({headers: host.headers, method: 'HEAD', url: dbUrl},
-             function (err) {
-          // If there is still an error
-          if (err) {
-            // Give the error to the callback to deal with
-            callback(err);
-          } else {
-            // Continue as if there had been no errors
-            callback(null, api);
-          }
-        });
-        // If there were no errros or if the only error is "Precondition Failed"
-        // (note: "Precondition Failed" occurs when we try to create a database
-        // that already exists)
-      } else if (!err || err.status === 412) {
-        // Continue as if there had been no errors
-        callback(null, api);
-      } else {
-        callback(err);
+  if (newEdits) {
+    if (!doc._id) {
+      doc._id = uuid();
+    }
+    newRevId = uuid(32, 16).toLowerCase();
+    if (doc._rev) {
+      revInfo = parseRevisionInfo(doc._rev);
+      if (revInfo.error) {
+        return revInfo;
       }
-    });
-  };
-
-  if (!opts.skipSetup) {
-    ajax({headers: host.headers, method: 'GET', url: dbUrl}, function (err) {
-      //check if the db exists
-      if (err) {
-        if (err.status === 404) {
-          utils.explain404(
-            'PouchDB is just detecting if the remote DB exists.');
-          //if it doesn't, create it
-          createDB();
-        } else {
-          callback(err);
-        }
-      } else {
-        //go do stuff with the db
-        callback(null, api);
+      doc._rev_tree = [{
+        pos: revInfo.prefix,
+        ids: [revInfo.id, {status: 'missing'}, [[newRevId, opts, []]]]
+      }];
+      nRevNum = revInfo.prefix + 1;
+    } else {
+      doc._rev_tree = [{
+        pos: 1,
+        ids : [newRevId, opts, []]
+      }];
+      nRevNum = 1;
+    }
+  } else {
+    if (doc._revisions) {
+      doc._rev_tree = makeRevTreeFromRevisions(doc._revisions, opts);
+      nRevNum = doc._revisions.start;
+      newRevId = doc._revisions.ids[0];
+    }
+    if (!doc._rev_tree) {
+      revInfo = parseRevisionInfo(doc._rev);
+      if (revInfo.error) {
+        return revInfo;
       }
-    });
+      nRevNum = revInfo.prefix;
+      newRevId = revInfo.id;
+      doc._rev_tree = [{
+        pos: nRevNum,
+        ids: [newRevId, opts, []]
+      }];
+    }
   }
 
-  api.type = function () {
-    return 'http';
-  };
-
-  api.id = utils.adapterFun('id', function (callback) {
-    ajax({
-      headers: host.headers,
-      method: 'GET',
-      url: genUrl(host, '')
-    }, function (err, result) {
-      var uuid = (result && result.uuid) ?
-        result.uuid + host.db : genDBUrl(host, '');
-      callback(null, uuid);
-    });
-  });
-
-  api.request = utils.adapterFun('request', function (options, callback) {
-    options.headers = host.headers;
-    options.url = genDBUrl(host, options.url);
-    ajax(options, callback);
-  });
+  exports.invalidIdError(doc._id);
 
-  // Sends a POST request to the host calling the couchdb _compact function
-  //    version: The version of CouchDB it is running
-  api.compact = utils.adapterFun('compact', function (opts, callback) {
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    opts = utils.clone(opts);
-    ajax({
-      headers: host.headers,
-      url: genDBUrl(host, '_compact'),
-      method: 'POST'
-    }, function () {
-      function ping() {
-        api.info(function (err, res) {
-          if (!res.compact_running) {
-            callback(null, {ok: true});
-          } else {
-            setTimeout(ping, opts.interval || 200);
-          }
-        });
-      }
-      // Ping the http if it's finished compaction
-      if (typeof callback === "function") {
-        ping();
-      }
-    });
-  });
+  doc._rev = nRevNum + '-' + newRevId;
 
-  // Calls GET on the host, which gets back a JSON string containing
-  //    couchdb: A welcome string
-  //    version: The version of CouchDB it is running
-  api._info = function (callback) {
-    ajax({
-      headers: host.headers,
-      method: 'GET',
-      url: genDBUrl(host, '')
-    }, function (err, res) {
-      if (err) {
-        callback(err);
+  var result = {metadata : {}, data : {}};
+  for (var key in doc) {
+    if (doc.hasOwnProperty(key)) {
+      var specialKey = key[0] === '_';
+      if (specialKey && !reservedWords[key]) {
+        var error = errors.error(errors.DOC_VALIDATION, key);
+        error.message = errors.DOC_VALIDATION.message + ': ' + key;
+        throw error;
+      } else if (specialKey && !dataWords[key]) {
+        result.metadata[key.slice(1)] = doc[key];
       } else {
-        res.host = genDBUrl(host, '');
-        callback(null, res);
+        result.data[key] = doc[key];
       }
-    });
-  };
-
-  // Get the document with the given id from the database given by host.
-  // The id could be solely the _id in the database, or it may be a
-  // _design/ID or _local/ID path
-  api.get = utils.adapterFun('get', function (id, opts, callback) {
-    // If no options were given, set the callback to the second parameter
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    opts = utils.clone(opts);
-    if (opts.auto_encode === undefined) {
-      opts.auto_encode = true;
     }
+  }
+  return result;
+};
+},{"./errors":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/errors.js","./uuid":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/uuid.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-uri.js":[function(require,module,exports){
+'use strict';
 
-    // List of parameters to add to the GET request
-    var params = [];
+// originally parseUri 1.2.2, now patched by us
+// (c) Steven Levithan <stevenlevithan.com>
+// MIT License
+var options = {
+  strictMode: false,
+  key: ["source", "protocol", "authority", "userInfo", "user", "password",
+    "host", "port", "relative", "path", "directory", "file", "query",
+    "anchor"],
+  q:   {
+    name:   "queryKey",
+    parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+  },
+  parser: {
+    /* jshint maxlen: false */
+    strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+    loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+  }
+};
+function parseUri(str) {
+  var o = options;
+  var m = o.parser[o.strictMode ? "strict" : "loose"].exec(str);
+  var uri = {};
+  var i = 14;
 
-    // If it exists, add the opts.revs value to the list of parameters.
-    // If revs=true then the resulting JSON will include a field
-    // _revisions containing an array of the revision IDs.
-    if (opts.revs) {
-      params.push('revs=true');
-    }
+  while (i--) {
+    var key = o.key[i];
+    var value = m[i] || "";
+    var encoded = ['user', 'password'].indexOf(key) !== -1;
+    uri[key] = encoded ? decodeURIComponent(value) : value;
+  }
 
-    // If it exists, add the opts.revs_info value to the list of parameters.
-    // If revs_info=true then the resulting JSON will include the field
-    // _revs_info containing an array of objects in which each object
-    // representing an available revision.
-    if (opts.revs_info) {
-      params.push('revs_info=true');
+  uri[o.q.name] = {};
+  uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+    if ($1) {
+      uri[o.q.name][$1] = $2;
     }
+  });
 
-    if (opts.local_seq) {
-      params.push('local_seq=true');
-    }
-    // If it exists, add the opts.open_revs value to the list of parameters.
-    // If open_revs=all then the resulting JSON will include all the leaf
-    // revisions. If open_revs=["rev1", "rev2",...] then the resulting JSON
-    // will contain an array of objects containing data of all revisions
-    if (opts.open_revs) {
-      if (opts.open_revs !== "all") {
-        opts.open_revs = JSON.stringify(opts.open_revs);
-      }
-      params.push('open_revs=' + opts.open_revs);
-    }
+  return uri;
+}
 
-    // If it exists, add the opts.attachments value to the list of parameters.
-    // If attachments=true the resulting JSON will include the base64-encoded
-    // contents in the "data" property of each attachment.
-    if (opts.attachments) {
-      params.push('attachments=true');
-    }
 
-    // If it exists, add the opts.rev value to the list of parameters.
-    // If rev is given a revision number then get the specified revision.
-    if (opts.rev) {
-      params.push('rev=' + opts.rev);
-    }
+module.exports = parseUri;
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/promise.js":[function(require,module,exports){
+'use strict';
 
-    // If it exists, add the opts.conflicts value to the list of parameters.
-    // If conflicts=true then the resulting JSON will include the field
-    // _conflicts containing all the conflicting revisions.
-    if (opts.conflicts) {
-      params.push('conflicts=' + opts.conflicts);
-    }
+if (typeof Promise === 'function') {
+  module.exports = Promise;
+} else {
+  module.exports = require('bluebird');
+}
+},{"bluebird":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/request-browser.js":[function(require,module,exports){
+/* global fetch */
+/* global Headers */
+'use strict';
 
-    // Format the list of parameters into a valid URI query string
-    params = params.join('&');
-    params = params === '' ? '' : '?' + params;
+var createBlob = require('./blob.js');
+var utils = require('../utils');
 
-    if (opts.auto_encode) {
-      id = encodeDocId(id);
-    }
+function wrappedFetch() {
+  var wrappedPromise = {};
 
-    // Set the options for the ajax call
-    var options = {
-      headers: host.headers,
-      method: 'GET',
-      url: genDBUrl(host, id + params)
-    };
-    var getRequestAjaxOpts = opts.ajax || {};
-    utils.extend(true, options, getRequestAjaxOpts);
+  var promise = new utils.Promise(function(resolve, reject) {
+    wrappedPromise.resolve = resolve;
+    wrappedPromise.reject = reject;
+  });
 
-    // If the given id contains at least one '/' and the part before the '/'
-    // is NOT "_design" and is NOT "_local"
-    // OR
-    // If the given id contains at least two '/' and the part before the first
-    // '/' is "_design".
-    // TODO This second condition seems strange since if parts[0] === '_design'
-    // then we already know that parts[0] !== '_local'.
-    var parts = id.split('/');
-    if ((parts.length > 1 && parts[0] !== '_design' && parts[0] !== '_local') ||
-        (parts.length > 2 && parts[0] === '_design' && parts[0] !== '_local')) {
-      // Binary is expected back from the server
-      options.binary = true;
-    }
+  var args = new Array(arguments.length);
 
-    // Get the document
-    ajax(options, function (err, doc, xhr) {
-      // If the document does not exist, send an error to the callback
-      if (err) {
-        return callback(err);
-      }
+  for (var i = 0; i < args.length; i++) {
+    args[i] = arguments[i];
+  }
 
-      // Send the document to the callback
-      callback(null, doc, xhr);
-    });
+  wrappedPromise.then = promise.then.bind(promise);
+  wrappedPromise.catch = promise.catch.bind(promise);
+  wrappedPromise.promise = promise;
+
+  fetch.apply(null, args).then(function(response) {
+    wrappedPromise.resolve(response);
+  }, function(error) {
+    wrappedPromise.reject(error);
+  }).catch(function(error) {
+    wrappedPromise.catch(error);
   });
 
-  // Delete the document given by doc from the database given by host.
-  api.remove = utils.adapterFun('remove',
-      function (docOrId, optsOrRev, opts, callback) {
-    var doc;
-    if (typeof optsOrRev === 'string') {
-      // id, rev, opts, callback style
-      doc = {
-        _id: docOrId,
-        _rev: optsOrRev
-      };
-      if (typeof opts === 'function') {
-        callback = opts;
-        opts = {};
-      }
-    } else {
-      // doc, opts, callback style
-      doc = docOrId;
-      if (typeof optsOrRev === 'function') {
-        callback = optsOrRev;
-        opts = {};
-      } else {
-        callback = opts;
-        opts = optsOrRev;
-      }
-    }
+  return wrappedPromise;
+}
 
-    var rev = (doc._rev || opts.rev);
+function fetchRequest(options, callback) {
+  var wrappedPromise, timer, fetchResponse;
 
-    // Delete the document
-    ajax({
-      headers: host.headers,
-      method: 'DELETE',
-      url: genDBUrl(host, encodeDocId(doc._id)) + '?rev=' + rev
-    }, callback);
-  });
+  var headers = new Headers();
 
-  function encodeAttachmentId(attachmentId) {
-    return attachmentId.split("/").map(encodeURIComponent).join("/");
+  var fetchOptions = {
+    method: options.method,
+    credentials: 'include',
+    headers: headers
+  };
+
+  if (options.json) {
+    headers.set('Accept', 'application/json');
+    headers.set('Content-Type', options.headers['Content-Type'] ||
+      'application/json');
   }
 
-  // Get the attachment
-  api.getAttachment =
-    utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
-                                                callback) {
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    opts = utils.clone(opts);
-    if (opts.auto_encode === undefined) {
-      opts.auto_encode = true;
-    }
-    if (opts.auto_encode) {
-      docId = encodeDocId(docId);
+  if (options.body && (options.body instanceof Blob)) {
+    utils.readAsBinaryString(options.body, function(binary) {
+      fetchOptions.body = utils.fixBinary(binary);
+    });
+  } else if (options.body &&
+             options.processData &&
+             typeof options.body !== 'string') {
+    fetchOptions.body = JSON.stringify(options.body);
+  } else if ('body' in options) {
+    fetchOptions.body = options.body;
+  } else {
+    fetchOptions.body = null;
+  }
+
+  Object.keys(options.headers).forEach(function(key) {
+    if (options.headers.hasOwnProperty(key)) {
+      headers.set(key, options.headers[key]);
     }
-    opts.auto_encode = false;
-    api.get(docId + '/' + encodeAttachmentId(attachmentId), opts, callback);
   });
 
-  // Remove the attachment given by the id and rev
-  api.removeAttachment =
-    utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
-                                                   callback) {
+  wrappedPromise = wrappedFetch(options.url, fetchOptions);
 
-    var url = genDBUrl(host, encodeDocId(docId) + '/' +
-      encodeAttachmentId(attachmentId)) + '?rev=' + rev;
+  if (options.timeout > 0) {
+    timer = setTimeout(function() {
+      wrappedPromise.reject(new Error('Load timeout for resource: ' +
+        options.url));
+    }, options.timeout);
+  }
 
-    ajax({
-      headers: host.headers,
-      method: 'DELETE',
-      url: url
-    }, callback);
-  });
+  wrappedPromise.promise.then(function(response) {
+    var result;
 
-  // Add the attachment given by blob and its contentType property
-  // to the document with the given id, the revision given by rev, and
-  // add it to the database given by host.
-  api.putAttachment =
-    utils.adapterFun('putAttachment', function (docId, attachmentId, rev, blob,
-                                                type, callback) {
-    if (typeof type === 'function') {
-      callback = type;
-      type = blob;
-      blob = rev;
-      rev = null;
-    }
-    if (typeof type === 'undefined') {
-      type = blob;
-      blob = rev;
-      rev = null;
-    }
-    var id = encodeDocId(docId) + '/' + encodeAttachmentId(attachmentId);
-    var url = genDBUrl(host, id);
-    if (rev) {
-      url += '?rev=' + rev;
-    }
+    fetchResponse = response;
 
-    if (typeof blob === 'string') {
-      var binary;
-      try {
-        binary = utils.atob(blob);
-      } catch (err) {
-        // it's not base64-encoded, so throw error
-        return callback(errors.error(errors.BAD_ARG,
-                        'Attachments need to be base64 encoded'));
-      }
-      if (isBrowser) {
-        blob = utils.createBlob([utils.fixBinary(binary)], {type: type});
-      } else {
-        blob = binary ? new buffer(binary, 'binary') : '';
-      }
+    if (options.timeout > 0) {
+      clearTimeout(timer);
     }
 
-    var opts = {
-      headers: utils.clone(host.headers),
-      method: 'PUT',
-      url: url,
-      processData: false,
-      body: blob,
-      timeout: 60000
-    };
-    opts.headers['Content-Type'] = type;
-    // Add the attachment
-    ajax(opts, callback);
-  });
-
-  // Add the document given by doc (in JSON string format) to the database
-  // given by host. This fails if the doc has no _id field.
-  api.put = utils.adapterFun('put', utils.getArguments(function (args) {
-    var temp, temptype, opts;
-    var doc = args.shift();
-    var id = '_id' in doc;
-    var callback = args.pop();
-    if (typeof doc !== 'object' || Array.isArray(doc)) {
-      return callback(errors.error(errors.NOT_AN_OBJECT));
+    if (response.status >= 200 && response.status < 300) {
+      return options.binary ? response.blob() : response.text();
     }
 
-    doc = utils.clone(doc);
+    return result.json();
+  }).then(function(result) {
+    if (fetchResponse.status >= 200 && fetchResponse.status < 300) {
+      callback(null, fetchResponse, result);
+    } else {
+      callback(result, fetchResponse);
+    }
+  }).catch(function(error) {
+    callback(error, fetchResponse);
+  });
 
-    preprocessAttachments(doc).then(function () {
-      while (true) {
-        temp = args.shift();
-        temptype = typeof temp;
-        if (temptype === "string" && !id) {
-          doc._id = temp;
-          id = true;
-        } else if (temptype === "string" && id && !('_rev' in doc)) {
-          doc._rev = temp;
-        } else if (temptype === "object") {
-          opts = utils.clone(temp);
-        }
-        if (!args.length) {
-          break;
-        }
-      }
-      opts = opts || {};
-      var error = utils.invalidIdError(doc._id);
-      if (error) {
-        throw error;
-      }
+  return {abort: wrappedPromise.reject};
+}
 
-      // List of parameter to add to the PUT request
-      var params = [];
+function xhRequest(options, callback) {
 
-      // If it exists, add the opts.new_edits value to the list of parameters.
-      // If new_edits = false then the database will NOT assign this document a
-      // new revision number
-      if (opts && typeof opts.new_edits !== 'undefined') {
-        params.push('new_edits=' + opts.new_edits);
-      }
+  var xhr, timer, hasUpload;
 
-      // Format the list of parameters into a valid URI query string
-      params = params.join('&');
-      if (params !== '') {
-        params = '?' + params;
-      }
+  var abortReq = function () {
+    xhr.abort();
+  };
 
-      // Add the document
-      ajax({
-        headers: host.headers,
-        method: 'PUT',
-        url: genDBUrl(host, encodeDocId(doc._id)) + params,
-        body: doc
-      }, function (err, res) {
-        if (err) {
-          return callback(err);
-        }
-        res.ok = true;
-        callback(null, res);
-      });
-    }).catch(callback);
+  if (options.xhr) {
+    xhr = new options.xhr();
+  } else {
+    xhr = new XMLHttpRequest();
+  }
 
-  }));
+  // cache-buster, specifically designed to work around IE's aggressive caching
+  // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
+  if (options.method === 'GET' && !options.cache) {
+    var hasArgs = options.url.indexOf('?') !== -1;
+    options.url += (hasArgs ? '&' : '?') + '_nonce=' + Date.now();
+  }
 
-  // Add the document given by doc (in JSON string format) to the database
-  // given by host. This does not assume that doc is a new document 
-  // (i.e. does not have a _id or a _rev field.)
-  api.post = utils.adapterFun('post', function (doc, opts, callback) {
-    // If no options were given, set the callback to be the second parameter
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    opts = utils.clone(opts);
-    if (typeof doc !== 'object') {
-      return callback(errors.error(errors.NOT_AN_OBJECT));
-    }
-    if (! ("_id" in doc)) {
-      doc._id = utils.uuid();
-    }
-    api.put(doc, opts, function (err, res) {
-      if (err) {
-        return callback(err);
-      }
-      res.ok = true;
-      callback(null, res);
-    });
-  });
+  xhr.open(options.method, options.url);
+  xhr.withCredentials = true;
 
-  // Update/create multiple documents given by req in the database
-  // given by host.
-  api._bulkDocs = function (req, opts, callback) {
-    // If opts.new_edits exists add it to the document data to be
-    // send to the database.
-    // If new_edits=false then it prevents the database from creating
-    // new revision numbers for the documents. Instead it just uses
-    // the old ones. This is used in database replication.
-    if (typeof opts.new_edits !== 'undefined') {
-      req.new_edits = opts.new_edits;
+  if (options.method === 'GET') {
+    delete options.headers['Content-Type'];
+  } else if (options.json) {
+    options.headers.Accept = 'application/json';
+    options.headers['Content-Type'] = options.headers['Content-Type'] ||
+      'application/json';
+    if (options.body &&
+        options.processData &&
+        typeof options.body !== "string") {
+      options.body = JSON.stringify(options.body);
     }
+  }
 
-    utils.Promise.all(req.docs.map(preprocessAttachments)).then(function () {
-      // Update/create the documents
-      ajax({
-        headers: host.headers,
-        method: 'POST',
-        url: genDBUrl(host, '_bulk_docs'),
-        body: req
-      }, function (err, results) {
-        if (err) {
-          return callback(err);
-        }
-        results.forEach(function (result) {
-          result.ok = true; // smooths out cloudant not adding this
-        });
-        callback(null, results);
-      });
-    }).catch(callback);
-  };
+  if (options.binary) {
+    xhr.responseType = 'arraybuffer';
+  }
 
-  // Get a listing of the documents in the database given
-  // by host and ordered by increasing id.
-  api.allDocs = utils.adapterFun('allDocs', function (opts, callback) {
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    opts = utils.clone(opts);
-    // List of parameters to add to the GET request
-    var params = [];
-    var body;
-    var method = 'GET';
+  if (!('body' in options)) {
+    options.body = null;
+  }
 
-    if (opts.conflicts) {
-      params.push('conflicts=true');
+  for (var key in options.headers) {
+    if (options.headers.hasOwnProperty(key)) {
+      xhr.setRequestHeader(key, options.headers[key]);
     }
+  }
 
-    // If opts.descending is truthy add it to params
-    if (opts.descending) {
-      params.push('descending=true');
+  if (options.timeout > 0) {
+    timer = setTimeout(abortReq, options.timeout);
+    xhr.onprogress = function () {
+      clearTimeout(timer);
+      timer = setTimeout(abortReq, options.timeout);
+    };
+    if (typeof hasUpload === 'undefined') {
+      // IE throws an error if you try to access it directly
+      hasUpload = Object.keys(xhr).indexOf('upload') !== -1 &&
+                  typeof xhr.upload !== 'undefined';
     }
-
-    // If opts.include_docs exists, add the include_docs value to the
-    // list of parameters.
-    // If include_docs=true then include the associated document with each
-    // result.
-    if (opts.include_docs) {
-      params.push('include_docs=true');
+    if (hasUpload) { // does not exist in ie9
+      xhr.upload.onprogress = xhr.onprogress;
     }
+  }
 
-    if (opts.attachments) {
-      // added in CouchDB 1.6.0
-      params.push('attachments=true');
+  xhr.onreadystatechange = function () {
+    if (xhr.readyState !== 4) {
+      return;
     }
 
-    if (opts.key) {
-      params.push('key=' + encodeURIComponent(JSON.stringify(opts.key)));
-    }
+    var response = {
+      statusCode: xhr.status
+    };
 
-    // If opts.startkey exists, add the startkey value to the list of
-    // parameters.
-    // If startkey is given then the returned list of documents will
-    // start with the document whose id is startkey.
-    if (opts.startkey) {
-      params.push('startkey=' +
-        encodeURIComponent(JSON.stringify(opts.startkey)));
+    if (xhr.status >= 200 && xhr.status < 300) {
+      var data;
+      if (options.binary) {
+        data = createBlob([xhr.response || ''], {
+          type: xhr.getResponseHeader('Content-Type')
+        });
+      } else {
+        data = xhr.responseText;
+      }
+      callback(null, response, data);
+    } else {
+      var err = {};
+      try {
+        err = JSON.parse(xhr.response);
+      } catch(e) {}
+      callback(err, response);
     }
+  };
 
-    // If opts.endkey exists, add the endkey value to the list of parameters.
-    // If endkey is given then the returned list of docuemnts will
-    // end with the document whose id is endkey.
-    if (opts.endkey) {
-      params.push('endkey=' + encodeURIComponent(JSON.stringify(opts.endkey)));
-    }
+  if (options.body && (options.body instanceof Blob)) {
+    utils.readAsBinaryString(options.body, function (binary) {
+      xhr.send(utils.fixBinary(binary));
+    });
+  } else {
+    xhr.send(options.body);
+  }
 
-    if (typeof opts.inclusive_end !== 'undefined') {
-      params.push('inclusive_end=' + !!opts.inclusive_end);
-    }
+  return {abort: abortReq};
+}
 
-    // If opts.limit exists, add the limit value to the parameter list.
-    if (typeof opts.limit !== 'undefined') {
-      params.push('limit=' + opts.limit);
-    }
-
-    if (typeof opts.skip !== 'undefined') {
-      params.push('skip=' + opts.skip);
-    }
-
-    // Format the list of parameters into a valid URI query string
-    params = params.join('&');
-    if (params !== '') {
-      params = '?' + params;
-    }
-
-    if (typeof opts.keys !== 'undefined') {
-
-
-      var keysAsString =
-        'keys=' + encodeURIComponent(JSON.stringify(opts.keys));
-      if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {
-        // If the keys are short enough, do a GET. we do this to work around
-        // Safari not understanding 304s on POSTs (see issue #1239)
-        params += (params.indexOf('?') !== -1 ? '&' : '?') + keysAsString;
-      } else {
-        // If keys are too long, issue a POST request to circumvent GET
-        // query string limits
-        // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
-        method = 'POST';
-        body = JSON.stringify({keys: opts.keys});
-      }
-    }
+module.exports = function(options, callback) {
+  if (typeof XMLHttpRequest === 'undefined' && !options.xhr) {
+    return fetchRequest(options, callback);
+  } else {
+    return xhRequest(options, callback);
+  }
+};
 
-    // Get the document listing
-    ajax({
-      headers: host.headers,
-      method: method,
-      url: genDBUrl(host, '_all_docs' + params),
-      body: body
-    }, callback);
-  });
+},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/utils.js","./blob.js":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/blob.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/uuid.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/merge.js":[function(require,module,exports){
+'use strict';
+var extend = require('pouchdb-extend');
 
-  // Get a list of changes made to documents in the database given by host.
-  // TODO According to the README, there should be two other methods here,
-  // api.changes.addListener and api.changes.removeListener.
-  api._changes = function (opts) {
-    // We internally page the results of a changes request, this means
-    // if there is a large set of changes to be returned we can start
-    // processing them quicker instead of waiting on the entire
-    // set of changes to return and attempting to process them at once
-    var batchSize = 'batch_size' in opts ? opts.batch_size : CHANGES_BATCH_SIZE;
 
-    opts = utils.clone(opts);
-    opts.timeout = opts.timeout || 30 * 1000;
+// for a better overview of what this is doing, read:
+// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
+//
+// But for a quick intro, CouchDB uses a revision tree to store a documents
+// history, A -> B -> C, when a document has conflicts, that is a branch in the
+// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
+//
+// KeyTree = [Path ... ]
+// Path = {pos: position_from_root, ids: Tree}
+// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
 
-    // We give a 5 second buffer for CouchDB changes to respond with
-    // an ok timeout
-    var params = { timeout: opts.timeout - (5 * 1000) };
-    var limit = (typeof opts.limit !== 'undefined') ? opts.limit : false;
-    if (limit === 0) {
-      limit = 1;
-    }
-    var returnDocs;
-    if ('returnDocs' in opts) {
-      returnDocs = opts.returnDocs;
+// classic binary search
+function binarySearch(arr, item, comparator) {
+  var low = 0;
+  var high = arr.length;
+  var mid;
+  while (low < high) {
+    mid = (low + high) >>> 1;
+    if (comparator(arr[mid], item) < 0) {
+      low = mid + 1;
     } else {
-      returnDocs = true;
+      high = mid;
     }
-    //
-    var leftToFetch = limit;
+  }
+  return low;
+}
 
-    if (opts.style) {
-      params.style = opts.style;
-    }
+// assuming the arr is sorted, insert the item in the proper place
+function insertSorted(arr, item, comparator) {
+  var idx = binarySearch(arr, item, comparator);
+  arr.splice(idx, 0, item);
+}
 
-    if (opts.include_docs || opts.filter && typeof opts.filter === 'function') {
-      params.include_docs = true;
-    }
+// Turn a path as a flat array into a tree with a single branch
+function pathToTree(path) {
+  var doc = path.shift();
+  var root = [doc.id, doc.opts, []];
+  var leaf = root;
+  var nleaf;
 
-    if (opts.attachments) {
-      params.attachments = true;
-    }
+  while (path.length) {
+    doc = path.shift();
+    nleaf = [doc.id, doc.opts, []];
+    leaf[2].push(nleaf);
+    leaf = nleaf;
+  }
+  return root;
+}
 
-    if (opts.continuous) {
-      params.feed = 'longpoll';
-    }
+// compare the IDs of two trees
+function compareTree(a, b) {
+  return a[0] < b[0] ? -1 : 1;
+}
 
-    if (opts.conflicts) {
-      params.conflicts = true;
-    }
+// Merge two trees together
+// The roots of tree1 and tree2 must be the same revision
+function mergeTree(in_tree1, in_tree2) {
+  var queue = [{tree1: in_tree1, tree2: in_tree2}];
+  var conflicts = false;
+  while (queue.length > 0) {
+    var item = queue.pop();
+    var tree1 = item.tree1;
+    var tree2 = item.tree2;
 
-    if (opts.descending) {
-      params.descending = true;
+    if (tree1[1].status || tree2[1].status) {
+      tree1[1].status =
+        (tree1[1].status ===  'available' ||
+         tree2[1].status === 'available') ? 'available' : 'missing';
     }
 
-    if (opts.filter && typeof opts.filter === 'string') {
-      params.filter = opts.filter;
-      if (opts.filter === '_view' &&
-          opts.view &&
-          typeof opts.view === 'string') {
-        params.view = opts.view;
+    for (var i = 0; i < tree2[2].length; i++) {
+      if (!tree1[2][0]) {
+        conflicts = 'new_leaf';
+        tree1[2][0] = tree2[2][i];
+        continue;
       }
-    }
 
-    // If opts.query_params exists, pass it through to the changes request.
-    // These parameters may be used by the filter on the source database.
-    if (opts.query_params && typeof opts.query_params === 'object') {
-      for (var param_name in opts.query_params) {
-        if (opts.query_params.hasOwnProperty(param_name)) {
-          params[param_name] = opts.query_params[param_name];
+      var merged = false;
+      for (var j = 0; j < tree1[2].length; j++) {
+        if (tree1[2][j][0] === tree2[2][i][0]) {
+          queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
+          merged = true;
         }
       }
-    }
-
-    var method = 'GET';
-    var body;
-
-    if (opts.doc_ids) {
-      // set this automagically for the user; it's annoying that couchdb
-      // requires both a "filter" and a "doc_ids" param.
-      params.filter = '_doc_ids';
-
-      var docIdsJson = JSON.stringify(opts.doc_ids);
-
-      if (docIdsJson.length < MAX_URL_LENGTH) {
-        params.doc_ids = docIdsJson;
-      } else {
-        // anything greater than ~2000 is unsafe for gets, so
-        // use POST instead
-        method = 'POST';
-        body = {doc_ids: opts.doc_ids };
+      if (!merged) {
+        conflicts = 'new_branch';
+        insertSorted(tree1[2], tree2[2][i], compareTree);
       }
     }
+  }
+  return {conflicts: conflicts, tree: in_tree1};
+}
 
-    if (opts.continuous && api._useSSE) {
-      return  api.sse(opts, params, returnDocs);
-    }
-    var xhr;
-    var lastFetchedSeq;
-
-    // Get all the changes starting wtih the one immediately after the
-    // sequence number given by since.
-    var fetch = function (since, callback) {
-      if (opts.aborted) {
-        return;
-      }
-      params.since = since;
-      if (typeof params.since === "object") {
-        params.since = JSON.stringify(params.since);
-      }
-
-      if (opts.descending) {
-        if (limit) {
-          params.limit = leftToFetch;
-        }
-      } else {
-        params.limit = (!limit || leftToFetch > batchSize) ?
-          batchSize : leftToFetch;
-      }
-
-      var paramStr = '?' + Object.keys(params).map(function (k) {
-        return k + '=' + params[k];
-      }).join('&');
-
-      // Set the options for the ajax call
-      var xhrOpts = {
-        headers: host.headers,
-        method: method,
-        url: genDBUrl(host, '_changes' + paramStr),
-        // _changes can take a long time to generate, especially when filtered
-        timeout: opts.timeout,
-        body: body
-      };
-      lastFetchedSeq = since;
+function doMerge(tree, path, dontExpand) {
+  var restree = [];
+  var conflicts = false;
+  var merged = false;
+  var res;
 
-      if (opts.aborted) {
-        return;
-      }
+  if (!tree.length) {
+    return {tree: [path], conflicts: 'new_leaf'};
+  }
 
-      // Get the changes
-      xhr = ajax(xhrOpts, callback);
-    };
+  tree.forEach(function (branch) {
+    if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
+      // Paths start at the same position and have the same root, so they need
+      // merged
+      res = mergeTree(branch.ids, path.ids);
+      restree.push({pos: branch.pos, ids: res.tree});
+      conflicts = conflicts || res.conflicts;
+      merged = true;
+    } else if (dontExpand !== true) {
+      // The paths start at a different position, take the earliest path and
+      // traverse up until it as at the same point from root as the path we
+      // want to merge.  If the keys match we return the longer path with the
+      // other merged After stemming we dont want to expand the trees
 
-    // If opts.since exists, get all the changes from the sequence
-    // number given by opts.since. Otherwise, get all the changes
-    // from the sequence number 0.
-    var fetchTimeout = 10;
-    var fetchRetryCount = 0;
+      var t1 = branch.pos < path.pos ? branch : path;
+      var t2 = branch.pos < path.pos ? path : branch;
+      var diff = t2.pos - t1.pos;
 
-    var results = {results: []};
+      var candidateParents = [];
 
-    var fetched = function (err, res) {
-      if (opts.aborted) {
-        return;
-      }
-      var raw_results_length = 0;
-      // If the result of the ajax call (res) contains changes (res.results)
-      if (res && res.results) {
-        raw_results_length = res.results.length;
-        results.last_seq = res.last_seq;
-        // For each change
-        var req = {};
-        req.query = opts.query_params;
-        res.results = res.results.filter(function (c) {
-          leftToFetch--;
-          var ret = utils.filterChange(opts)(c);
-          if (ret) {
-            if (returnDocs) {
-              results.results.push(c);
-            }
-            utils.call(opts.onChange, c);
+      var trees = [];
+      trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
+      while (trees.length > 0) {
+        var item = trees.pop();
+        if (item.diff === 0) {
+          if (item.ids[0] === t2.ids[0]) {
+            candidateParents.push(item);
           }
-          return ret;
+          continue;
+        }
+        if (!item.ids) {
+          continue;
+        }
+        /*jshint loopfunc:true */
+        item.ids[2].forEach(function (el, idx) {
+          trees.push(
+            {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
         });
-      } else if (err) {
-        // In case of an error, stop listening for changes and call
-        // opts.complete
-        opts.aborted = true;
-        utils.call(opts.complete, err);
-        return;
       }
 
-      // The changes feed may have timed out with no results
-      // if so reuse last update sequence
-      if (res && res.last_seq) {
-        lastFetchedSeq = res.last_seq;
+      var el = candidateParents[0];
+
+      if (!el) {
+        restree.push(branch);
+      } else {
+        res = mergeTree(el.ids, t2.ids);
+        el.parent[2][el.parentIdx] = res.tree;
+        restree.push({pos: t1.pos, ids: t1.ids});
+        conflicts = conflicts || res.conflicts;
+        merged = true;
       }
+    } else {
+      restree.push(branch);
+    }
+  });
 
-      var finished = (limit && leftToFetch <= 0) ||
-        (res && raw_results_length < batchSize) ||
-        (opts.descending);
+  // We didnt find
+  if (!merged) {
+    restree.push(path);
+  }
 
-      if ((opts.continuous && !(limit && leftToFetch <= 0)) || !finished) {
-        // Increase retry delay exponentially as long as errors persist
-        if (err) {
-          fetchRetryCount += 1;
-        } else {
-          fetchRetryCount = 0;
-        }
-        var timeoutMultiplier = 1 << fetchRetryCount;
-        var retryWait = fetchTimeout * timeoutMultiplier;
-        var maximumWait = opts.maximumWait || 30000;
+  restree.sort(function (a, b) {
+    return a.pos - b.pos;
+  });
 
-        if (retryWait > maximumWait) {
-          utils.call(opts.complete, err || errors.error(errors.UNKNOWN_ERROR));
-          return;
-        }
+  return {
+    tree: restree,
+    conflicts: conflicts || 'internal_node'
+  };
+}
 
-        // Queue a call to fetch again with the newest sequence number
-        setTimeout(function () { fetch(lastFetchedSeq, fetched); }, retryWait);
-      } else {
-        // We're done, call the callback
-        utils.call(opts.complete, null, results);
-      }
+// To ensure we dont grow the revision tree infinitely, we stem old revisions
+function stem(tree, depth) {
+  // First we break out the tree into a complete list of root to leaf paths,
+  // we cut off the start of the path and generate a new set of flat trees
+  var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
+    var stemmed = path.ids.slice(-depth);
+    return {
+      pos: path.pos + (path.ids.length - stemmed.length),
+      ids: pathToTree(stemmed)
     };
+  });
+  // Then we remerge all those flat trees together, ensuring that we dont
+  // connect trees that would go beyond the depth limit
+  return stemmedPaths.reduce(function (prev, current) {
+    return doMerge(prev, current, true).tree;
+  }, [stemmedPaths.shift()]);
+}
 
-    fetch(opts.since || 0, fetched);
+var PouchMerge = {};
 
-    // Return a method to cancel this method from processing any more
-    return {
-      cancel: function () {
-        opts.aborted = true;
-        if (xhr) {
-          xhr.abort();
-        }
-      }
-    };
+PouchMerge.merge = function (tree, path, depth) {
+  // Ugh, nicer way to not modify arguments in place?
+  tree = extend(true, [], tree);
+  path = extend(true, {}, path);
+  var newTree = doMerge(tree, path);
+  return {
+    tree: stem(newTree.tree, depth),
+    conflicts: newTree.conflicts
   };
+};
 
-  api.sse = function (opts, params, returnDocs) {
-    params.feed = 'eventsource';
-    params.since = opts.since || 0;
-    params.limit = opts.limit;
-    delete params.timeout;
-    var paramStr = '?' + Object.keys(params).map(function (k) {
-      return k + '=' + params[k];
-    }).join('&');
-    var url = genDBUrl(host, '_changes' + paramStr);
-    var source = new EventSource(url);
-    var results = {
-      results: [],
-      last_seq: false
-    };
-    var dispatched = false;
-    var open = false;
-    source.addEventListener('message', msgHandler, false);
-    source.onopen = function () {
-      open = true;
-    };
-    source.onerror = errHandler;
-    return {
-      cancel: function () {
-        if (dispatched) {
-          return dispatched.cancel();
-        }
-        source.removeEventListener('message', msgHandler, false);
-        source.close();
-      }
-    };
-    function msgHandler(e) {
-      var data = JSON.parse(e.data);
-      if (returnDocs) {
-        results.results.push(data);
-      }
-      results.last_seq = data.seq;
-      utils.call(opts.onChange, data);
+// We fetch all leafs of the revision tree, and sort them based on tree length
+// and whether they were deleted, undeleted documents with the longest revision
+// tree (most edits) win
+// The final sort algorithm is slightly documented in a sidebar here:
+// http://guide.couchdb.org/draft/conflicts.html
+PouchMerge.winningRev = function (metadata) {
+  var leafs = [];
+  PouchMerge.traverseRevTree(metadata.rev_tree,
+                              function (isLeaf, pos, id, something, opts) {
+    if (isLeaf) {
+      leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
     }
-    function errHandler(err) {
-      source.removeEventListener('message', msgHandler, false);
-      if (open === false) {
-        // errored before it opened
-        // likely doesn't support EventSource
-        api._useSSE = false;
-        dispatched = api._changes(opts);
-        return;
-      }
-      source.close();
-      utils.call(opts.complete, err);
+  });
+  leafs.sort(function (a, b) {
+    if (a.deleted !== b.deleted) {
+      return a.deleted > b.deleted ? 1 : -1;
     }
-    
-  };
+    if (a.pos !== b.pos) {
+      return b.pos - a.pos;
+    }
+    return a.id < b.id ? 1 : -1;
+  });
 
-  api._useSSE = false;
-  // Currently disabled due to failing chrome tests in saucelabs
-  // api._useSSE = typeof global.EventSource === 'function';
+  return leafs[0].pos + '-' + leafs[0].id;
+};
 
-  // Given a set of document/revision IDs (given by req), tets the subset of
-  // those that do NOT correspond to revisions stored in the database.
-  // See http://wiki.apache.org/couchdb/HttpPostRevsDiff
-  api.revsDiff = utils.adapterFun('revsDiff', function (req, opts, callback) {
-    // If no options were given, set the callback to be the second parameter
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
+// Pretty much all below can be combined into a higher order function to
+// traverse revisions
+// The return value from the callback will be passed as context to all
+// children of that node
+PouchMerge.traverseRevTree = function (revs, callback) {
+  var toVisit = revs.slice();
+
+  var node;
+  while ((node = toVisit.pop())) {
+    var pos = node.pos;
+    var tree = node.ids;
+    var branches = tree[2];
+    var newCtx =
+      callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
+    for (var i = 0, len = branches.length; i < len; i++) {
+      toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
     }
+  }
+};
 
-    // Get the missing document/revision IDs
-    ajax({
-      headers: host.headers,
-      method: 'POST',
-      url: genDBUrl(host, '_revs_diff'),
-      body: JSON.stringify(req)
-    }, callback);
+PouchMerge.collectLeaves = function (revs) {
+  var leaves = [];
+  PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
+    if (isLeaf) {
+      leaves.push({rev: pos + "-" + id, pos: pos, opts: opts});
+    }
   });
+  leaves.sort(function (a, b) {
+    return b.pos - a.pos;
+  });
+  leaves.forEach(function (leaf) { delete leaf.pos; });
+  return leaves;
+};
 
-  api._close = function (callback) {
-    callback();
-  };
-
-  api._destroy = function (callback) {
-    ajax({
-      url: genDBUrl(host, ''),
-      method: 'DELETE',
-      headers: host.headers
-    }, function (err, resp) {
-      if (err) {
-        api.emit('error', err);
-        callback(err);
-      } else {
-        api.emit('destroyed');
-        api.constructor.emit('destroyed', opts.name);
-        callback(null, resp);
-      }
-    });
-  };
-}
-
-// HttpPouch is a valid adapter.
-HttpPouch.valid = function () {
-  return true;
+// returns revs of all conflicts that is leaves such that
+// 1. are not deleted and
+// 2. are different than winning revision
+PouchMerge.collectConflicts = function (metadata) {
+  var win = PouchMerge.winningRev(metadata);
+  var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
+  var conflicts = [];
+  leaves.forEach(function (leaf) {
+    if (leaf.rev !== win && !leaf.opts.deleted) {
+      conflicts.push(leaf.rev);
+    }
+  });
+  return conflicts;
 };
 
-module.exports = HttpPouch;
+PouchMerge.rootToLeaf = function (tree) {
+  var paths = [];
+  PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
+    history = history ? history.slice(0) : [];
+    history.push({id: id, opts: opts});
+    if (isLeaf) {
+      var rootPos = pos + 1 - history.length;
+      paths.unshift({pos: rootPos, ids: history});
+    }
+    return history;
+  });
+  return paths;
+};
 
-}).call(this,require('_process'))
-},{"../../deps/buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-all-docs.js":[function(require,module,exports){
-'use strict';
 
-var merge = require('../../merge');
-var errors = require('../../deps/errors');
-var idbUtils = require('./idb-utils');
-var idbConstants = require('./idb-constants');
+module.exports = PouchMerge;
 
-var ATTACH_STORE = idbConstants.ATTACH_STORE;
-var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
-var DOC_STORE = idbConstants.DOC_STORE;
+},{"pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/utils.js":[function(require,module,exports){
+(function (process){
+/*jshint strict: false */
+/*global chrome */
+var merge = require('./merge');
+exports.extend = require('pouchdb-extend');
+exports.ajax = require('./deps/ajax');
+exports.createBlob = require('./deps/blob');
+exports.uuid = require('./deps/uuid');
+exports.getArguments = require('argsarray');
+var buffer = require('./deps/buffer');
+var errors = require('./deps/errors');
+var EventEmitter = require('events').EventEmitter;
+var collections = require('pouchdb-collections');
+exports.Map = collections.Map;
+exports.Set = collections.Set;
+var parseDoc = require('./deps/parse-doc');
 
-var decodeDoc = idbUtils.decodeDoc;
-var decodeMetadata = idbUtils.decodeMetadata;
-var fetchAttachmentsIfNecessary = idbUtils.fetchAttachmentsIfNecessary;
-var postProcessAttachments = idbUtils.postProcessAttachments;
-var openTransactionSafely = idbUtils.openTransactionSafely;
+var Promise = require('./deps/promise');
+exports.Promise = Promise;
 
-function createKeyRange(start, end, inclusiveEnd, key, descending) {
-  try {
-    if (start && end) {
-      if (descending) {
-        return IDBKeyRange.bound(end, start, !inclusiveEnd, false);
-      } else {
-        return IDBKeyRange.bound(start, end, false, !inclusiveEnd);
-      }
-    } else if (start) {
-      if (descending) {
-        return IDBKeyRange.upperBound(start);
-      } else {
-        return IDBKeyRange.lowerBound(start);
-      }
-    } else if (end) {
-      if (descending) {
-        return IDBKeyRange.lowerBound(end, !inclusiveEnd);
-      } else {
-        return IDBKeyRange.upperBound(end, !inclusiveEnd);
-      }
-    } else if (key) {
-      return IDBKeyRange.only(key);
+exports.lastIndexOf = function (str, char) {
+  for (var i = str.length - 1; i >= 0; i--) {
+    if (str.charAt(i) === char) {
+      return i;
     }
-  } catch (e) {
-    return {error: e};
   }
-  return null;
-}
+  return -1;
+};
 
-function handleKeyRangeError(api, opts, err, callback) {
-  if (err.name === "DataError" && err.code === 0) {
-    // data error, start is less than end
-    return callback(null, {
-      total_rows: api._meta.docCount,
-      offset: opts.skip,
-      rows: []
-    });
+exports.clone = function (obj) {
+  return exports.extend(true, {}, obj);
+};
+
+// like underscore/lodash _.pick()
+exports.pick = function (obj, arr) {
+  var res = {};
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var prop = arr[i];
+    res[prop] = obj[prop];
   }
-  callback(errors.error(errors.IDB_ERROR, err.name, err.message));
+  return res;
+};
+
+exports.inherits = require('inherits');
+
+function isChromeApp() {
+  return (typeof chrome !== "undefined" &&
+          typeof chrome.storage !== "undefined" &&
+          typeof chrome.storage.local !== "undefined");
 }
 
-function idbAllDocs(opts, api, idb, callback) {
+// Pretty dumb name for a function, just wraps callback calls so we dont
+// to if (callback) callback() everywhere
+exports.call = exports.getArguments(function (args) {
+  if (!args.length) {
+    return;
+  }
+  var fun = args.shift();
+  if (typeof fun === 'function') {
+    fun.apply(this, args);
+  }
+});
 
-  function allDocsQuery(opts, callback) {
-    var start = 'startkey' in opts ? opts.startkey : false;
-    var end = 'endkey' in opts ? opts.endkey : false;
-    var key = 'key' in opts ? opts.key : false;
-    var skip = opts.skip || 0;
-    var limit = typeof opts.limit === 'number' ? opts.limit : -1;
-    var inclusiveEnd = opts.inclusive_end !== false;
-    var descending = 'descending' in opts && opts.descending ? 'prev' : null;
+exports.isLocalId = function (id) {
+  return (/^_local/).test(id);
+};
 
-    var keyRange = createKeyRange(start, end, inclusiveEnd, key, descending);
-    if (keyRange && keyRange.error) {
-      return handleKeyRangeError(api, opts, keyRange.error, callback);
+// check if a specific revision of a doc has been deleted
+//  - metadata: the metadata object from the doc store
+//  - rev: (optional) the revision to check. defaults to winning revision
+exports.isDeleted = function (metadata, rev) {
+  if (!rev) {
+    rev = merge.winningRev(metadata);
+  }
+  var dashIndex = rev.indexOf('-');
+  if (dashIndex !== -1) {
+    rev = rev.substring(dashIndex + 1);
+  }
+  var deleted = false;
+  merge.traverseRevTree(metadata.rev_tree,
+  function (isLeaf, pos, id, acc, opts) {
+    if (id === rev) {
+      deleted = !!opts.deleted;
     }
+  });
 
-    var stores = [DOC_STORE, BY_SEQ_STORE];
+  return deleted;
+};
 
-    if (opts.attachments) {
-      stores.push(ATTACH_STORE);
-    }
-    var txnResult = openTransactionSafely(idb, stores, 'readonly');
-    if (txnResult.error) {
-      return callback(txnResult.error);
+exports.revExists = function (metadata, rev) {
+  var found = false;
+  merge.traverseRevTree(metadata.rev_tree, function (leaf, pos, id) {
+    if ((pos + '-' + id) === rev) {
+      found = true;
     }
-    var txn = txnResult.txn;
-    var docStore = txn.objectStore(DOC_STORE);
-    var seqStore = txn.objectStore(BY_SEQ_STORE);
-    var cursor = descending ?
-      docStore.openCursor(keyRange, descending) :
-      docStore.openCursor(keyRange);
-    var docIdRevIndex = seqStore.index('_doc_id_rev');
-    var results = [];
-    var docCount = 0;
+  });
+  return found;
+};
 
-    // if the user specifies include_docs=true, then we don't
-    // want to block the main cursor while we're fetching the doc
-    function fetchDocAsynchronously(metadata, row, winningRev) {
-      var key = metadata.id + "::" + winningRev;
-      docIdRevIndex.get(key).onsuccess =  function onGetDoc(e) {
-        row.doc = decodeDoc(e.target.result);
-        if (opts.conflicts) {
-          row.doc._conflicts = merge.collectConflicts(metadata);
-        }
-        fetchAttachmentsIfNecessary(row.doc, opts, txn);
-      };
-    }
+exports.filterChange = function filterChange(opts) {
+  var req = {};
+  var hasFilter = opts.filter && typeof opts.filter === 'function';
+  req.query = opts.query_params;
 
-    function allDocsInner(cursor, winningRev, metadata) {
-      var row = {
-        id: metadata.id,
-        key: metadata.id,
-        value: {
-          rev: winningRev
-        }
-      };
-      var deleted = metadata.deleted;
-      if (opts.deleted === 'ok') {
-        results.push(row);
-        // deleted docs are okay with "keys" requests
-        if (deleted) {
-          row.value.deleted = true;
-          row.doc = null;
-        } else if (opts.include_docs) {
-          fetchDocAsynchronously(metadata, row, winningRev);
-        }
-      } else if (!deleted && skip-- <= 0) {
-        results.push(row);
-        if (opts.include_docs) {
-          fetchDocAsynchronously(metadata, row, winningRev);
-        }
-        if (--limit === 0) {
-          return;
+  return function filter(change) {
+    if (!change.doc) {
+      // CSG sends events on the changes feed that don't have documents,
+      // this hack makes a whole lot of existing code robust.
+      change.doc = {};
+    }
+    if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
+      return false;
+    }
+    if (!opts.include_docs) {
+      delete change.doc;
+    } else if (!opts.attachments) {
+      for (var att in change.doc._attachments) {
+        if (change.doc._attachments.hasOwnProperty(att)) {
+          change.doc._attachments[att].stub = true;
         }
       }
-      cursor.continue();
     }
+    return true;
+  };
+};
 
-    function onGetCursor(e) {
-      docCount = api._meta.docCount; // do this within the txn for consistency
-      var cursor = e.target.result;
-      if (!cursor) {
-        return;
-      }
-      var metadata = decodeMetadata(cursor.value);
-      var winningRev = metadata.winningRev;
+exports.parseDoc = parseDoc.parseDoc;
+exports.invalidIdError = parseDoc.invalidIdError;
 
-      allDocsInner(cursor, winningRev, metadata);
-    }
+exports.isCordova = function () {
+  return (typeof cordova !== "undefined" ||
+          typeof PhoneGap !== "undefined" ||
+          typeof phonegap !== "undefined");
+};
 
-    function onResultsReady() {
-      callback(null, {
-        total_rows: docCount,
-        offset: opts.skip,
-        rows: results
+exports.hasLocalStorage = function () {
+  if (isChromeApp()) {
+    return false;
+  }
+  try {
+    return localStorage;
+  } catch (e) {
+    return false;
+  }
+};
+exports.Changes = Changes;
+exports.inherits(Changes, EventEmitter);
+function Changes() {
+  if (!(this instanceof Changes)) {
+    return new Changes();
+  }
+  var self = this;
+  EventEmitter.call(this);
+  this.isChrome = isChromeApp();
+  this.listeners = {};
+  this.hasLocal = false;
+  if (!this.isChrome) {
+    this.hasLocal = exports.hasLocalStorage();
+  }
+  if (this.isChrome) {
+    chrome.storage.onChanged.addListener(function (e) {
+      // make sure it's event addressed to us
+      if (e.db_name != null) {
+        //object only has oldValue, newValue members
+        self.emit(e.dbName.newValue);
+      }
+    });
+  } else if (this.hasLocal) {
+    if (typeof addEventListener !== 'undefined') {
+      addEventListener("storage", function (e) {
+        self.emit(e.key);
+      });
+    } else { // old IE
+      window.attachEvent("storage", function (e) {
+        self.emit(e.key);
       });
     }
+  }
 
-    function onTxnComplete() {
-      if (opts.attachments) {
-        postProcessAttachments(results).then(onResultsReady);
-      } else {
-        onResultsReady();
-      }
+}
+Changes.prototype.addListener = function (dbName, id, db, opts) {
+  if (this.listeners[id]) {
+    return;
+  }
+  var self = this;
+  var inprogress = false;
+  function eventFunction() {
+    if (!self.listeners[id]) {
+      return;
+    }
+    if (inprogress) {
+      inprogress = 'waiting';
+      return;
     }
+    inprogress = true;
+    db.changes({
+      style: opts.style,
+      include_docs: opts.include_docs,
+      attachments: opts.attachments,
+      conflicts: opts.conflicts,
+      continuous: false,
+      descending: false,
+      filter: opts.filter,
+      doc_ids: opts.doc_ids,
+      view: opts.view,
+      since: opts.since,
+      query_params: opts.query_params
+    }).on('change', function (c) {
+      if (c.seq > opts.since && !opts.cancelled) {
+        opts.since = c.seq;
+        exports.call(opts.onChange, c);
+      }
+    }).on('complete', function () {
+      if (inprogress === 'waiting') {
+        process.nextTick(function () {
+          self.notify(dbName);
+        });
+      }
+      inprogress = false;
+    }).on('error', function () {
+      inprogress = false;
+    });
+  }
+  this.listeners[id] = eventFunction;
+  this.on(dbName, eventFunction);
+};
 
-    txn.oncomplete = onTxnComplete;
-    cursor.onsuccess = onGetCursor;
+Changes.prototype.removeListener = function (dbName, id) {
+  if (!(id in this.listeners)) {
+    return;
   }
+  EventEmitter.prototype.removeListener.call(this, dbName,
+    this.listeners[id]);
+};
 
-  function allDocs(opts, callback) {
 
-    if (opts.limit === 0) {
-      return callback(null, {
-        total_rows: api._meta.docCount,
-        offset: opts.skip,
-        rows: []
-      });
-    }
-    allDocsQuery(opts, callback);
+Changes.prototype.notifyLocalWindows = function (dbName) {
+  //do a useless change on a storage thing
+  //in order to get other windows's listeners to activate
+  if (this.isChrome) {
+    chrome.storage.local.set({dbName: dbName});
+  } else if (this.hasLocal) {
+    localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
   }
+};
 
-  allDocs(opts, callback);
-}
+Changes.prototype.notify = function (dbName) {
+  this.emit(dbName);
+  this.notifyLocalWindows(dbName);
+};
 
-module.exports = idbAllDocs;
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-blob-support.js":[function(require,module,exports){
-'use strict';
+if (typeof atob === 'function') {
+  exports.atob = function (str) {
+    return atob(str);
+  };
+} else {
+  exports.atob = function (str) {
+    var base64 = new buffer(str, 'base64');
+    // Node.js will just skip the characters it can't encode instead of
+    // throwing and exception
+    if (base64.toString('base64') !== str) {
+      throw ("Cannot base64 encode full string");
+    }
+    return base64.toString('binary');
+  };
+}
 
-var utils = require('../../utils');
-var idbConstants = require('./idb-constants');
-var DETECT_BLOB_SUPPORT_STORE = idbConstants.DETECT_BLOB_SUPPORT_STORE;
+if (typeof btoa === 'function') {
+  exports.btoa = function (str) {
+    return btoa(str);
+  };
+} else {
+  exports.btoa = function (str) {
+    return new buffer(str, 'binary').toString('base64');
+  };
+}
 
-//
-// Detect blob support. Chrome didn't support it until version 38.
-// In version 37 they had a broken version where PNGs (and possibly
-// other binary types) aren't stored correctly, because when you fetch
-// them, the content type is always null.
-//
-// Furthermore, they have some outstanding bugs where blobs occasionally
-// are read by FileReader as null, or by ajax as 404s.
-//
-// Sadly we use the 404 bug to detect the FileReader bug, so if they
-// get fixed independently and released in different versions of Chrome,
-// then the bug could come back. So it's worthwhile to watch these issues:
-// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916
-// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836
-//
-function checkBlobSupport(txn, idb) {
-  return new utils.Promise(function (resolve, reject) {
-    var blob = utils.createBlob([''], {type: 'image/png'});
-    txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');
-    txn.oncomplete = function () {
-      // have to do it in a separate transaction, else the correct
-      // content type is always returned
-      var blobTxn = idb.transaction([DETECT_BLOB_SUPPORT_STORE],
-        'readwrite');
-      var getBlobReq = blobTxn.objectStore(
-        DETECT_BLOB_SUPPORT_STORE).get('key');
-      getBlobReq.onerror = reject;
-      getBlobReq.onsuccess = function (e) {
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+exports.fixBinary = function (bin) {
+  if (!process.browser) {
+    // don't need to do this in Node
+    return bin;
+  }
 
-        var storedBlob = e.target.result;
-        var url = URL.createObjectURL(storedBlob);
+  var length = bin.length;
+  var buf = new ArrayBuffer(length);
+  var arr = new Uint8Array(buf);
+  for (var i = 0; i < length; i++) {
+    arr[i] = bin.charCodeAt(i);
+  }
+  return buf;
+};
 
-        utils.ajax({
-          url: url,
-          cache: true,
-          binary: true
-        }, function (err, res) {
-          if (err && err.status === 405) {
-            // firefox won't let us do that. but firefox doesn't
-            // have the blob type bug that Chrome does, so that's ok
-            resolve(true);
+// shim for browsers that don't support it
+exports.readAsBinaryString = function (blob, callback) {
+  var reader = new FileReader();
+  var hasBinaryString = typeof reader.readAsBinaryString === 'function';
+  reader.onloadend = function (e) {
+    var result = e.target.result || '';
+    if (hasBinaryString) {
+      return callback(result);
+    }
+    callback(exports.arrayBufferToBinaryString(result));
+  };
+  if (hasBinaryString) {
+    reader.readAsBinaryString(blob);
+  } else {
+    reader.readAsArrayBuffer(blob);
+  }
+};
+
+// simplified API. universal browser support is assumed
+exports.readAsArrayBuffer = function (blob, callback) {
+  var reader = new FileReader();
+  reader.onloadend = function (e) {
+    var result = e.target.result || new ArrayBuffer(0);
+    callback(result);
+  };
+  reader.readAsArrayBuffer(blob);
+};
+
+exports.once = function (fun) {
+  var called = false;
+  return exports.getArguments(function (args) {
+    if (called) {
+      throw new Error('once called  more than once');
+    } else {
+      called = true;
+      fun.apply(this, args);
+    }
+  });
+};
+
+exports.toPromise = function (func) {
+  //create the function we will be returning
+  return exports.getArguments(function (args) {
+    var self = this;
+    var tempCB =
+      (typeof args[args.length - 1] === 'function') ? args.pop() : false;
+    // if the last argument is a function, assume its a callback
+    var usedCB;
+    if (tempCB) {
+      // if it was a callback, create a new callback which calls it,
+      // but do so async so we don't trap any errors
+      usedCB = function (err, resp) {
+        process.nextTick(function () {
+          tempCB(err, resp);
+        });
+      };
+    }
+    var promise = new Promise(function (fulfill, reject) {
+      var resp;
+      try {
+        var callback = exports.once(function (err, mesg) {
+          if (err) {
+            reject(err);
           } else {
-            resolve(!!(res && res.type === 'image/png'));
-            if (err && err.status === 404) {
-              utils.explain404('PouchDB is just detecting blob URL support.');
-            }
+            fulfill(mesg);
           }
-          URL.revokeObjectURL(url);
         });
-      };
+        // create a callback for this invocation
+        // apply the function in the orig context
+        args.push(callback);
+        resp = func.apply(self, args);
+        if (resp && typeof resp.then === 'function') {
+          fulfill(resp);
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
+    // if there is a callback, call it back
+    if (usedCB) {
+      promise.then(function (result) {
+        usedCB(null, result);
+      }, usedCB);
+    }
+    promise.cancel = function () {
+      return this;
     };
-  }).catch(function () {
-    return false; // error, so assume unsupported
+    return promise;
   });
-}
-
-module.exports = checkBlobSupport;
-},{"../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-bulk-docs.js":[function(require,module,exports){
-'use strict';
-
-var utils = require('../../utils');
-var errors = require('../../deps/errors');
-var idbUtils = require('./idb-utils');
-var idbConstants = require('./idb-constants');
-
-var ATTACH_AND_SEQ_STORE = idbConstants.ATTACH_AND_SEQ_STORE;
-var ATTACH_STORE = idbConstants.ATTACH_STORE;
-var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
-var DOC_STORE = idbConstants.DOC_STORE;
-var LOCAL_STORE = idbConstants.LOCAL_STORE;
-var META_STORE = idbConstants.META_STORE;
-
-var compactRevs = idbUtils.compactRevs;
-var decodeMetadata = idbUtils.decodeMetadata;
-var encodeMetadata = idbUtils.encodeMetadata;
-var idbError = idbUtils.idbError;
-var openTransactionSafely = idbUtils.openTransactionSafely;
+};
 
-function idbBulkDocs(req, opts, api, idb, Changes, callback) {
-  var docInfos = req.docs;
-  var txn;
-  var docStore;
-  var bySeqStore;
-  var attachStore;
-  var attachAndSeqStore;
-  var docInfoError;
-  var docCountDelta = 0;
+exports.adapterFun = function (name, callback) {
+  var log = require('debug')('pouchdb:api');
 
-  for (var i = 0, len = docInfos.length; i < len; i++) {
-    var doc = docInfos[i];
-    if (doc._id && utils.isLocalId(doc._id)) {
-      continue;
+  function logApiCall(self, name, args) {
+    if (!log.enabled) {
+      return;
     }
-    doc = docInfos[i] = utils.parseDoc(doc, opts.new_edits);
-    if (doc.error && !docInfoError) {
-      docInfoError = doc;
+    var logArgs = [self._db_name, name];
+    for (var i = 0; i < args.length - 1; i++) {
+      logArgs.push(args[i]);
     }
-  }
+    log.apply(null, logArgs);
 
-  if (docInfoError) {
-    return callback(docInfoError);
+    // override the callback itself to log the response
+    var origCallback = args[args.length - 1];
+    args[args.length - 1] = function (err, res) {
+      var responseArgs = [self._db_name, name];
+      responseArgs = responseArgs.concat(
+        err ? ['error', err] : ['success', res]
+      );
+      log.apply(null, responseArgs);
+      origCallback(err, res);
+    };
   }
 
-  var results = new Array(docInfos.length);
-  var fetchedDocs = new utils.Map();
-  var preconditionErrored = false;
-  var blobType = api._meta.blobSupport ? 'blob' : 'base64';
 
-  utils.preprocessAttachments(docInfos, blobType, function (err) {
-    if (err) {
-      return callback(err);
+  return exports.toPromise(exports.getArguments(function (args) {
+    if (this._closed) {
+      return Promise.reject(new Error('database is closed'));
     }
-    startTransaction();
-  });
-
-  function startTransaction() {
-
-    var stores = [
-      DOC_STORE, BY_SEQ_STORE,
-      ATTACH_STORE, META_STORE,
-      LOCAL_STORE, ATTACH_AND_SEQ_STORE
-    ];
-    var txnResult = openTransactionSafely(idb, stores, 'readwrite');
-    if (txnResult.error) {
-      return callback(txnResult.error);
+    var self = this;
+    logApiCall(self, name, args);
+    if (!this.taskqueue.isReady) {
+      return new Promise(function (fulfill, reject) {
+        self.taskqueue.addTask(function (failed) {
+          if (failed) {
+            reject(failed);
+          } else {
+            fulfill(self[name].apply(self, args));
+          }
+        });
+      });
     }
-    txn = txnResult.txn;
-    txn.onerror = idbError(callback);
-    txn.ontimeout = idbError(callback);
-    txn.oncomplete = complete;
-    docStore = txn.objectStore(DOC_STORE);
-    bySeqStore = txn.objectStore(BY_SEQ_STORE);
-    attachStore = txn.objectStore(ATTACH_STORE);
-    attachAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);
+    return callback.apply(this, args);
+  }));
+};
 
-    verifyAttachments(function (err) {
-      if (err) {
-        preconditionErrored = true;
-        return callback(err);
-      }
-      fetchExistingDocs();
-    });
+//Can't find original post, but this is close
+//http://stackoverflow.com/questions/6965107/ (continues on next line)
+//converting-between-strings-and-arraybuffers
+exports.arrayBufferToBinaryString = function (buffer) {
+  var binary = "";
+  var bytes = new Uint8Array(buffer);
+  var length = bytes.byteLength;
+  for (var i = 0; i < length; i++) {
+    binary += String.fromCharCode(bytes[i]);
   }
+  return binary;
+};
 
-  function processDocs() {
-
-    utils.processDocs(docInfos, api, fetchedDocs, txn, results,
-      writeDoc, opts);
-  }
+exports.cancellableFun = function (fun, self, opts) {
 
-  function fetchExistingDocs() {
+  opts = opts ? exports.clone(true, {}, opts) : {};
 
-    if (!docInfos.length) {
+  var emitter = new EventEmitter();
+  var oldComplete = opts.complete || function () { };
+  var complete = opts.complete = exports.once(function (err, resp) {
+    if (err) {
+      oldComplete(err);
+    } else {
+      emitter.emit('end', resp);
+      oldComplete(null, resp);
+    }
+    emitter.removeAllListeners();
+  });
+  var oldOnChange = opts.onChange || function () {};
+  var lastChange = 0;
+  self.on('destroyed', function () {
+    emitter.removeAllListeners();
+  });
+  opts.onChange = function (change) {
+    oldOnChange(change);
+    if (change.seq <= lastChange) {
       return;
     }
-
-    var numFetched = 0;
-
-    function checkDone() {
-      if (++numFetched === docInfos.length) {
-        processDocs();
-      }
+    lastChange = change.seq;
+    emitter.emit('change', change);
+    if (change.deleted) {
+      emitter.emit('delete', change);
+    } else if (change.changes.length === 1 &&
+      change.changes[0].rev.slice(0, 1) === '1-') {
+      emitter.emit('create', change);
+    } else {
+      emitter.emit('update', change);
     }
+  };
+  var promise = new Promise(function (fulfill, reject) {
+    opts.complete = function (err, res) {
+      if (err) {
+        reject(err);
+      } else {
+        fulfill(res);
+      }
+    };
+  });
 
-    function readMetadata(event) {
-      var metadata = decodeMetadata(event.target.result);
+  promise.then(function (result) {
+    complete(null, result);
+  }, complete);
 
-      if (metadata) {
-        fetchedDocs.set(metadata.id, metadata);
-      }
-      checkDone();
+  // this needs to be overwridden by caller, dont fire complete until
+  // the task is ready
+  promise.cancel = function () {
+    promise.isCancelled = true;
+    if (self.taskqueue.isReady) {
+      opts.complete(null, {status: 'cancelled'});
     }
+  };
 
-    for (var i = 0, len = docInfos.length; i < len; i++) {
-      var docInfo = docInfos[i];
-      if (docInfo._id && utils.isLocalId(docInfo._id)) {
-        checkDone(); // skip local docs
-        continue;
+  if (!self.taskqueue.isReady) {
+    self.taskqueue.addTask(function () {
+      if (promise.isCancelled) {
+        opts.complete(null, {status: 'cancelled'});
+      } else {
+        fun(self, opts, promise);
       }
-      var req = docStore.get(docInfo.metadata.id);
-      req.onsuccess = readMetadata;
-    }
+    });
+  } else {
+    fun(self, opts, promise);
   }
+  promise.on = emitter.on.bind(emitter);
+  promise.once = emitter.once.bind(emitter);
+  promise.addListener = emitter.addListener.bind(emitter);
+  promise.removeListener = emitter.removeListener.bind(emitter);
+  promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
+  promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
+  promise.listeners = emitter.listeners.bind(emitter);
+  promise.emit = emitter.emit.bind(emitter);
+  return promise;
+};
 
-  function complete() {
-    if (preconditionErrored) {
-      return;
-    }
-
-    Changes.notify(api._meta.name);
-    api._meta.docCount += docCountDelta;
-    callback(null, results);
-  }
+exports.MD5 = exports.toPromise(require('./deps/md5'));
 
-  function verifyAttachment(digest, callback) {
+exports.explain404 = require('./deps/explain404');
 
-    var req = attachStore.get(digest);
-    req.onsuccess = function (e) {
-      if (!e.target.result) {
-        var err = errors.error(errors.MISSING_STUB,
-          'unknown stub attachment with digest ' +
-          digest);
-        err.status = 412;
-        callback(err);
-      } else {
-        callback();
-      }
-    };
+exports.info = function (str) {
+  if (typeof console !== 'undefined' && 'info' in console) {
+    console.info(str);
   }
+};
 
-  function verifyAttachments(finish) {
+exports.parseUri = require('./deps/parse-uri');
 
+exports.compare = function (left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+};
 
-    var digests = [];
-    docInfos.forEach(function (docInfo) {
-      if (docInfo.data && docInfo.data._attachments) {
-        Object.keys(docInfo.data._attachments).forEach(function (filename) {
-          var att = docInfo.data._attachments[filename];
-          if (att.stub) {
-            digests.push(att.digest);
-          }
-        });
-      }
-    });
-    if (!digests.length) {
-      return finish();
-    }
-    var numDone = 0;
-    var err;
+exports.updateDoc = function updateDoc(prev, docInfo, results,
+                                       i, cb, writeDoc, newEdits) {
 
-    function checkDone() {
-      if (++numDone === digests.length) {
-        finish(err);
-      }
-    }
-    digests.forEach(function (digest) {
-      verifyAttachment(digest, function (attErr) {
-        if (attErr && !err) {
-          err = attErr;
-        }
-        checkDone();
-      });
-    });
+  if (exports.revExists(prev, docInfo.metadata.rev)) {
+    results[i] = docInfo;
+    return cb();
   }
 
-  function writeDoc(docInfo, winningRev, winningRevIsDeleted, newRevIsDeleted,
-                    isUpdate, delta, resultsIdx, callback) {
-
-    docCountDelta += delta;
+  // TODO: some of these can be pre-calculated, but it's safer to just
+  // call merge.winningRev() and exports.isDeleted() all over again
+  var previousWinningRev = merge.winningRev(prev);
+  var previouslyDeleted = exports.isDeleted(prev, previousWinningRev);
+  var deleted = exports.isDeleted(docInfo.metadata);
+  var isRoot = /^1-/.test(docInfo.metadata.rev);
 
-    var doc = docInfo.data;
-    doc._id = docInfo.metadata.id;
-    doc._rev = docInfo.metadata.rev;
+  if (previouslyDeleted && !deleted && newEdits && isRoot) {
+    var newDoc = docInfo.data;
+    newDoc._rev = previousWinningRev;
+    newDoc._id = docInfo.metadata.id;
+    docInfo = exports.parseDoc(newDoc, newEdits);
+  }
 
-    if (newRevIsDeleted) {
-      doc._deleted = true;
-    }
+  var merged = merge.merge(prev.rev_tree, docInfo.metadata.rev_tree[0], 1000);
 
-    var hasAttachments = doc._attachments &&
-      Object.keys(doc._attachments).length;
-    if (hasAttachments) {
-      return writeAttachments(docInfo, winningRev, winningRevIsDeleted,
-        isUpdate, resultsIdx, callback);
-    }
+  var inConflict = newEdits && (((previouslyDeleted && deleted) ||
+    (!previouslyDeleted && merged.conflicts !== 'new_leaf') ||
+    (previouslyDeleted && !deleted && merged.conflicts === 'new_branch')));
 
-    finishDoc(docInfo, winningRev, winningRevIsDeleted,
-      isUpdate, resultsIdx, callback);
+  if (inConflict) {
+    var err = errors.error(errors.REV_CONFLICT);
+    results[i] = err;
+    return cb();
   }
 
-  function autoCompact(docInfo) {
-
-    var revsToDelete = utils.compactTree(docInfo.metadata);
-    compactRevs(revsToDelete, docInfo.metadata.id, txn);
+  var newRev = docInfo.metadata.rev;
+  docInfo.metadata.rev_tree = merged.tree;
+  if (prev.rev_map) {
+    docInfo.metadata.rev_map = prev.rev_map; // used by leveldb
   }
 
-  function finishDoc(docInfo, winningRev, winningRevIsDeleted,
-                     isUpdate, resultsIdx, callback) {
+  // recalculate
+  var winningRev = merge.winningRev(docInfo.metadata);
+  var winningRevIsDeleted = exports.isDeleted(docInfo.metadata, winningRev);
 
-    var doc = docInfo.data;
-    var metadata = docInfo.metadata;
+  // calculate the total number of documents that were added/removed,
+  // from the perspective of total_rows/doc_count
+  var delta = (previouslyDeleted === winningRevIsDeleted) ? 0 :
+      previouslyDeleted < winningRevIsDeleted ? -1 : 1;
 
-    doc._doc_id_rev = metadata.id + '::' + metadata.rev;
-    delete doc._id;
-    delete doc._rev;
+  var newRevIsDeleted = exports.isDeleted(docInfo.metadata, newRev);
 
-    function afterPutDoc(e) {
-      if (isUpdate && api.auto_compaction) {
-        autoCompact(docInfo);
-      }
-      metadata.seq = e.target.result;
-      // Current _rev is calculated from _rev_tree on read
-      delete metadata.rev;
-      var metadataToStore = encodeMetadata(metadata, winningRev,
-        winningRevIsDeleted);
-      var metaDataReq = docStore.put(metadataToStore);
-      metaDataReq.onsuccess = afterPutMetadata;
-    }
+  writeDoc(docInfo, winningRev, winningRevIsDeleted, newRevIsDeleted,
+    true, delta, i, cb);
+};
 
-    function afterPutDocError(e) {
-      // ConstraintError, need to update, not put (see #1638 for details)
-      e.preventDefault(); // avoid transaction abort
-      e.stopPropagation(); // avoid transaction onerror
-      var index = bySeqStore.index('_doc_id_rev');
-      var getKeyReq = index.getKey(doc._doc_id_rev);
-      getKeyReq.onsuccess = function (e) {
-        var putReq = bySeqStore.put(doc, e.target.result);
-        putReq.onsuccess = afterPutDoc;
-      };
-    }
+exports.processDocs = function processDocs(docInfos, api, fetchedDocs,
+                                           tx, results, writeDoc, opts,
+                                           overallCallback) {
 
-    function afterPutMetadata() {
-      results[resultsIdx] = {
-        ok: true,
-        id: metadata.id,
-        rev: winningRev
-      };
-      fetchedDocs.set(docInfo.metadata.id, docInfo.metadata);
-      insertAttachmentMappings(docInfo, metadata.seq, callback);
+  if (!docInfos.length) {
+    return;
+  }
+
+  function insertDoc(docInfo, resultsIdx, callback) {
+    // Cant insert new deleted documents
+    var winningRev = merge.winningRev(docInfo.metadata);
+    var deleted = exports.isDeleted(docInfo.metadata, winningRev);
+    if ('was_delete' in opts && deleted) {
+      results[resultsIdx] = errors.error(errors.MISSING_DOC, 'deleted');
+      return callback();
     }
 
-    var putReq = bySeqStore.put(doc);
+    var delta = deleted ? 0 : 1;
 
-    putReq.onsuccess = afterPutDoc;
-    putReq.onerror = afterPutDocError;
+    writeDoc(docInfo, winningRev, deleted, deleted, false,
+      delta, resultsIdx, callback);
   }
 
-  function writeAttachments(docInfo, winningRev, winningRevIsDeleted,
-                            isUpdate, resultsIdx, callback) {
+  var newEdits = opts.new_edits;
+  var idsToDocs = new exports.Map();
 
+  var docsDone = 0;
+  var docsToDo = docInfos.length;
 
-    var doc = docInfo.data;
+  function checkAllDocsDone() {
+    if (++docsDone === docsToDo && overallCallback) {
+      overallCallback();
+    }
+  }
 
-    var numDone = 0;
-    var attachments = Object.keys(doc._attachments);
+  docInfos.forEach(function (currentDoc, resultsIdx) {
 
-    function collectResults() {
-      if (numDone === attachments.length) {
-        finishDoc(docInfo, winningRev, winningRevIsDeleted,
-          isUpdate, resultsIdx, callback);
-      }
+    if (currentDoc._id && exports.isLocalId(currentDoc._id)) {
+      api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+        currentDoc, {ctx: tx}, function (err) {
+          if (err) {
+            results[resultsIdx] = err;
+          } else {
+            results[resultsIdx] = {ok: true};
+          }
+          checkAllDocsDone();
+        });
+      return;
     }
 
-    function attachmentSaved() {
-      numDone++;
-      collectResults();
+    var id = currentDoc.metadata.id;
+    if (idsToDocs.has(id)) {
+      docsToDo--; // duplicate
+      idsToDocs.get(id).push([currentDoc, resultsIdx]);
+    } else {
+      idsToDocs.set(id, [[currentDoc, resultsIdx]]);
     }
+  });
 
-    attachments.forEach(function (key) {
-      var att = docInfo.data._attachments[key];
-      if (!att.stub) {
-        var data = att.data;
-        delete att.data;
-        var digest = att.digest;
-        saveAttachment(digest, data, attachmentSaved);
+  // in the case of new_edits, the user can provide multiple docs
+  // with the same id. these need to be processed sequentially
+  idsToDocs.forEach(function (docs, id) {
+    var numDone = 0;
+
+    function docWritten() {
+      if (++numDone < docs.length) {
+        nextDoc();
       } else {
-        numDone++;
-        collectResults();
+        checkAllDocsDone();
       }
-    });
-  }
-
-  // map seqs to attachment digests, which
-  // we will need later during compaction
-  function insertAttachmentMappings(docInfo, seq, callback) {
-
-    var attsAdded = 0;
-    var attsToAdd = Object.keys(docInfo.data._attachments || {});
-
-    if (!attsToAdd.length) {
-      return callback();
     }
+    function nextDoc() {
+      var value = docs[numDone];
+      var currentDoc = value[0];
+      var resultsIdx = value[1];
 
-    function checkDone() {
-      if (++attsAdded === attsToAdd.length) {
-        callback();
+      if (fetchedDocs.has(id)) {
+        exports.updateDoc(fetchedDocs.get(id), currentDoc, results,
+          resultsIdx, docWritten, writeDoc, newEdits);
+      } else {
+        insertDoc(currentDoc, resultsIdx, docWritten);
       }
     }
+    nextDoc();
+  });
+};
 
-    function add(att) {
-      var digest = docInfo.data._attachments[att].digest;
-      var req = attachAndSeqStore.put({
-        seq: seq,
-        digestSeq: digest + '::' + seq
-      });
+exports.preprocessAttachments = function preprocessAttachments(
+    docInfos, blobType, callback) {
 
-      req.onsuccess = checkDone;
-      req.onerror = function (e) {
-        // this callback is for a constaint error, which we ignore
-        // because this docid/rev has already been associated with
-        // the digest (e.g. when new_edits == false)
-        e.preventDefault(); // avoid transaction abort
-        e.stopPropagation(); // avoid transaction onerror
-        checkDone();
-      };
-    }
-    for (var i = 0; i < attsToAdd.length; i++) {
-      add(attsToAdd[i]); // do in parallel
+  if (!docInfos.length) {
+    return callback();
+  }
+
+  var docv = 0;
+
+  function parseBase64(data) {
+    try {
+      return exports.atob(data);
+    } catch (e) {
+      var err = errors.error(errors.BAD_ARG,
+                             'Attachments need to be base64 encoded');
+      return {error: err};
     }
   }
 
-  function saveAttachment(digest, data, callback) {
+  function preprocessAttachment(att, callback) {
+    if (att.stub) {
+      return callback();
+    }
+    if (typeof att.data === 'string') {
+      // input is a base64 string
 
+      var asBinary = parseBase64(att.data);
+      if (asBinary.error) {
+        return callback(asBinary.error);
+      }
 
-    var getKeyReq = attachStore.count(digest);
-    getKeyReq.onsuccess = function(e) {
-      var count = e.target.result;
-      if (count) {
-        return callback(); // already exists
+      att.length = asBinary.length;
+      if (blobType === 'blob') {
+        att.data = exports.createBlob([exports.fixBinary(asBinary)],
+          {type: att.content_type});
+      } else if (blobType === 'base64') {
+        att.data = exports.btoa(asBinary);
+      } else { // binary
+        att.data = asBinary;
       }
-      var newAtt = {
-        digest: digest,
-        body: data
-      };
-      var putReq = attachStore.put(newAtt);
-      putReq.onsuccess = callback;
-    };
+      exports.MD5(asBinary).then(function (result) {
+        att.digest = 'md5-' + result;
+        callback();
+      });
+    } else { // input is a blob
+      exports.readAsArrayBuffer(att.data, function (buff) {
+        if (blobType === 'binary') {
+          att.data = exports.arrayBufferToBinaryString(buff);
+        } else if (blobType === 'base64') {
+          att.data = exports.btoa(exports.arrayBufferToBinaryString(buff));
+        }
+        exports.MD5(buff).then(function (result) {
+          att.digest = 'md5-' + result;
+          att.length = buff.byteLength;
+          callback();
+        });
+      });
+    }
   }
-}
 
-module.exports = idbBulkDocs;
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js":[function(require,module,exports){
-'use strict';
+  var overallErr;
 
-// IndexedDB requires a versioned database structure, so we use the
-// version here to manage migrations.
-exports.ADAPTER_VERSION = 5;
+  docInfos.forEach(function (docInfo) {
+    var attachments = docInfo.data && docInfo.data._attachments ?
+      Object.keys(docInfo.data._attachments) : [];
+    var recv = 0;
 
-// The object stores created for each database
-// DOC_STORE stores the document meta data, its revision history and state
-// Keyed by document id
-exports. DOC_STORE = 'document-store';
-// BY_SEQ_STORE stores a particular version of a document, keyed by its
-// sequence id
-exports.BY_SEQ_STORE = 'by-sequence';
-// Where we store attachments
-exports.ATTACH_STORE = 'attach-store';
-// Where we store many-to-many relations
-// between attachment digests and seqs
-exports.ATTACH_AND_SEQ_STORE = 'attach-seq-store';
+    if (!attachments.length) {
+      return done();
+    }
 
-// Where we store database-wide meta data in a single record
-// keyed by id: META_STORE
-exports.META_STORE = 'meta-store';
-// Where we store local documents
-exports.LOCAL_STORE = 'local-store';
-// Where we detect blob support
-exports.DETECT_BLOB_SUPPORT_STORE = 'detect-blob-support';
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js":[function(require,module,exports){
-(function (process){
-'use strict';
+    function processedAttachment(err) {
+      overallErr = err;
+      recv++;
+      if (recv === attachments.length) {
+        done();
+      }
+    }
 
-var errors = require('../../deps/errors');
-var utils = require('../../utils');
-var constants = require('./idb-constants');
+    for (var key in docInfo.data._attachments) {
+      if (docInfo.data._attachments.hasOwnProperty(key)) {
+        preprocessAttachment(docInfo.data._attachments[key],
+          processedAttachment);
+      }
+    }
+  });
 
-function tryCode(fun, that, args) {
-  try {
-    fun.apply(that, args);
-  } catch (err) { // shouldn't happen
-    if (typeof PouchDB !== 'undefined') {
-      PouchDB.emit('error', err);
+  function done() {
+    docv++;
+    if (docInfos.length === docv) {
+      if (overallErr) {
+        callback(overallErr);
+      } else {
+        callback();
+      }
     }
   }
-}
-
-exports.taskQueue = {
-  running: false,
-  queue: []
 };
 
-exports.applyNext = function () {
-  if (exports.taskQueue.running || !exports.taskQueue.queue.length) {
-    return;
-  }
-  exports.taskQueue.running = true;
-  var item = exports.taskQueue.queue.shift();
-  item.action(function (err, res) {
-    tryCode(item.callback, this, [err, res]);
-    exports.taskQueue.running = false;
-    process.nextTick(exports.applyNext);
+// compact a tree by marking its non-leafs as missing,
+// and return a list of revs to delete
+exports.compactTree = function compactTree(metadata) {
+  var revs = [];
+  merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
+                                                     revHash, ctx, opts) {
+    if (opts.status === 'available' && !isLeaf) {
+      revs.push(pos + '-' + revHash);
+      opts.status = 'missing';
+    }
   });
+  return revs;
 };
 
-exports.idbError = function (callback) {
-  return function (event) {
-    var message = (event.target && event.target.error &&
-      event.target.error.name) || event.target;
-    callback(errors.error(errors.IDB_ERROR, message, event.type));
-  };
-};
-
-// Unfortunately, the metadata has to be stringified
-// when it is put into the database, because otherwise
-// IndexedDB can throw errors for deeply-nested objects.
-// Originally we just used JSON.parse/JSON.stringify; now
-// we use this custom vuvuzela library that avoids recursion.
-// If we could do it all over again, we'd probably use a
-// format for the revision trees other than JSON.
-exports.encodeMetadata = function (metadata, winningRev, deleted) {
-  return {
-    data: utils.safeJsonStringify(metadata),
-    winningRev: winningRev,
-    deletedOrLocal: deleted ? '1' : '0',
-    seq: metadata.seq, // highest seq for this doc
-    id: metadata.id
-  };
-};
-
-exports.decodeMetadata = function (storedObject) {
-  if (!storedObject) {
-    return null;
-  }
-  var metadata = utils.safeJsonParse(storedObject.data);
-  metadata.winningRev = storedObject.winningRev;
-  metadata.deleted = storedObject.deletedOrLocal === '1';
-  metadata.seq = storedObject.seq;
-  return metadata;
-};
+var vuvuzela = require('vuvuzela');
 
-// read the doc back out from the database. we don't store the
-// _id or _rev because we already have _doc_id_rev.
-exports.decodeDoc = function (doc) {
-  if (!doc) {
-    return doc;
+exports.safeJsonParse = function safeJsonParse(str) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return vuvuzela.parse(str);
   }
-  var idx = utils.lastIndexOf(doc._doc_id_rev, ':');
-  doc._id = doc._doc_id_rev.substring(0, idx - 1);
-  doc._rev = doc._doc_id_rev.substring(idx + 1);
-  delete doc._doc_id_rev;
-  return doc;
 };
 
-// Read a blob from the database, encoding as necessary
-// and translating from base64 if the IDB doesn't support
-// native Blobs
-exports.readBlobData = function (body, type, encode, callback) {
-  if (encode) {
-    if (!body) {
-      callback('');
-    } else if (typeof body !== 'string') { // we have blob support
-      utils.readAsBinaryString(body, function (binary) {
-        callback(utils.btoa(binary));
-      });
-    } else { // no blob support
-      callback(body);
-    }
-  } else {
-    if (!body) {
-      callback(utils.createBlob([''], {type: type}));
-    } else if (typeof body !== 'string') { // we have blob support
-      callback(body);
-    } else { // no blob support
-      body = utils.fixBinary(atob(body));
-      callback(utils.createBlob([body], {type: type}));
-    }
+exports.safeJsonStringify = function safeJsonStringify(json) {
+  try {
+    return JSON.stringify(json);
+  } catch (e) {
+    return vuvuzela.stringify(json);
   }
 };
 
-exports.fetchAttachmentsIfNecessary = function (doc, opts, txn, cb) {
-  var attachments = Object.keys(doc._attachments || {});
-  if (!attachments.length) {
-    return cb && cb();
-  }
-  var numDone = 0;
-
-  function checkDone() {
-    if (++numDone === attachments.length && cb) {
-      cb();
-    }
-  }
+}).call(this,require('_process'))
+},{"./deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/ajax.js","./deps/blob":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/blob.js","./deps/buffer":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/buffer-browser.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/errors.js","./deps/explain404":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/explain404.js","./deps/md5":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/md5.js","./deps/parse-doc":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-doc.js","./deps/parse-uri":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-uri.js","./deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/promise.js","./deps/uuid":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/uuid.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/merge.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","argsarray":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/argsarray/index.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/browser.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js","inherits":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/inherits/inherits_browser.js","pouchdb-collections":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/pouchdb-collections/index.js","pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js","vuvuzela":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/vuvuzela/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/argsarray/index.js":[function(require,module,exports){
+'use strict';
 
-  function fetchAttachment(doc, att) {
-    var attObj = doc._attachments[att];
-    var digest = attObj.digest;
-    var req = txn.objectStore(constants.ATTACH_STORE).get(digest);
-    req.onsuccess = function (e) {
-      attObj.body = e.target.result.body;
-      checkDone();
-    };
-  }
+module.exports = argsArray;
 
-  attachments.forEach(function (att) {
-    if (opts.attachments && opts.include_docs) {
-      fetchAttachment(doc, att);
+function argsArray(fun) {
+  return function () {
+    var len = arguments.length;
+    if (len) {
+      var args = [];
+      var i = -1;
+      while (++i < len) {
+        args[i] = arguments[i];
+      }
+      return fun.call(this, args);
     } else {
-      doc._attachments[att].stub = true;
-      checkDone();
+      return fun.call(this, []);
     }
-  });
-};
+  };
+}
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/browser.js":[function(require,module,exports){
 
-// IDB-specific postprocessing necessary because
-// we don't know whether we stored a true Blob or
-// a base64-encoded string, and if it's a Blob it
-// needs to be read outside of the transaction context
-exports.postProcessAttachments = function (results) {
-  return utils.Promise.all(results.map(function (row) {
-    if (row.doc && row.doc._attachments) {
-      var attNames = Object.keys(row.doc._attachments);
-      return utils.Promise.all(attNames.map(function (att) {
-        var attObj = row.doc._attachments[att];
-        if (!('body' in attObj)) { // already processed
-          return;
-        }
-        var body = attObj.body;
-        var type = attObj.content_type;
-        return new utils.Promise(function (resolve) {
-          exports.readBlobData(body, type, true, function (base64) {
-            row.doc._attachments[att] = utils.extend(
-              utils.pick(attObj, ['digest', 'content_type']),
-              {data: base64}
-            );
-            resolve();
-          });
-        });
-      }));
-    }
-  }));
-};
+/**
+ * This is the web browser implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
 
-exports.compactRevs = function (revs, docId, txn) {
+exports = module.exports = require('./debug');
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = 'undefined' != typeof chrome
+               && 'undefined' != typeof chrome.storage
+                  ? chrome.storage.local
+                  : localstorage();
 
-  var possiblyOrphanedDigests = [];
-  var seqStore = txn.objectStore(constants.BY_SEQ_STORE);
-  var attStore = txn.objectStore(constants.ATTACH_STORE);
-  var attAndSeqStore = txn.objectStore(constants.ATTACH_AND_SEQ_STORE);
-  var count = revs.length;
+/**
+ * Colors.
+ */
 
-  function checkDone() {
-    count--;
-    if (!count) { // done processing all revs
-      deleteOrphanedAttachments();
-    }
-  }
+exports.colors = [
+  'lightseagreen',
+  'forestgreen',
+  'goldenrod',
+  'dodgerblue',
+  'darkorchid',
+  'crimson'
+];
 
-  function deleteOrphanedAttachments() {
-    if (!possiblyOrphanedDigests.length) {
-      return;
-    }
-    possiblyOrphanedDigests.forEach(function (digest) {
-      var countReq = attAndSeqStore.index('digestSeq').count(
-        IDBKeyRange.bound(
-          digest + '::', digest + '::\uffff', false, false));
-      countReq.onsuccess = function (e) {
-        var count = e.target.result;
-        if (!count) {
-          // orphaned
-          attStore.delete(digest);
-        }
-      };
-    });
-  }
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
 
-  revs.forEach(function (rev) {
-    var index = seqStore.index('_doc_id_rev');
-    var key = docId + "::" + rev;
-    index.getKey(key).onsuccess = function (e) {
-      var seq = e.target.result;
-      if (typeof seq !== 'number') {
-        return checkDone();
-      }
-      seqStore.delete(seq);
+function useColors() {
+  // is webkit? http://stackoverflow.com/a/16459606/376773
+  return ('WebkitAppearance' in document.documentElement.style) ||
+    // is firebug? http://stackoverflow.com/a/398120/376773
+    (window.console && (console.firebug || (console.exception && console.table))) ||
+    // is firefox >= v31?
+    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+    (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31);
+}
 
-      var cursor = attAndSeqStore.index('seq')
-        .openCursor(IDBKeyRange.only(seq));
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
 
-      cursor.onsuccess = function (event) {
-        var cursor = event.target.result;
-        if (cursor) {
-          var digest = cursor.value.digestSeq.split('::')[0];
-          possiblyOrphanedDigests.push(digest);
-          attAndSeqStore.delete(cursor.primaryKey);
-          cursor.continue();
-        } else { // done
-          checkDone();
-        }
-      };
-    };
-  });
+exports.formatters.j = function(v) {
+  return JSON.stringify(v);
 };
 
-exports.openTransactionSafely = function (idb, stores, mode) {
-  try {
-    return {
-      txn: idb.transaction(stores, mode)
-    };
-  } catch (err) {
-    return {
-      error: err
-    };
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs() {
+  var args = arguments;
+  var useColors = this.useColors;
+
+  args[0] = (useColors ? '%c' : '')
+    + this.namespace
+    + (useColors ? ' %c' : ' ')
+    + args[0]
+    + (useColors ? '%c ' : ' ')
+    + '+' + exports.humanize(this.diff);
+
+  if (!useColors) return args;
+
+  var c = 'color: ' + this.color;
+  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));
+
+  // the final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-z%]/g, function(match) {
+    if ('%%' === match) return;
+    index++;
+    if ('%c' === match) {
+      // we only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+
+  args.splice(lastC, 0, c);
+  return args;
+}
+
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+function log() {
+  // this hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return 'object' === typeof console
+    && console.log
+    && Function.prototype.apply.call(console.log, console, arguments);
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+function save(namespaces) {
+  try {
+    if (null == namespaces) {
+      exports.storage.removeItem('debug');
+    } else {
+      exports.storage.debug = namespaces;
+    }
+  } catch(e) {}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+  var r;
+  try {
+    r = exports.storage.debug;
+  } catch(e) {}
+  return r;
+}
+
+/**
+ * Enable namespaces listed in `localStorage.debug` initially.
+ */
+
+exports.enable(load());
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage(){
+  try {
+    return window.localStorage;
+  } catch (e) {}
+}
+
+},{"./debug":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/debug.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/debug.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/nodemailer-mailgun-transport/node_modules/mailgun-js/node_modules/debug/debug.js"][0].apply(exports,arguments)
+},{"ms":"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js":[function(require,module,exports){
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} options
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options){
+  options = options || {};
+  if ('string' == typeof val) return parse(val);
+  return options.long
+    ? long(val)
+    : short(val);
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = '' + str;
+  if (str.length > 10000) return;
+  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
+  if (!match) return;
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function short(ms) {
+  if (ms >= d) return Math.round(ms / d) + 'd';
+  if (ms >= h) return Math.round(ms / h) + 'h';
+  if (ms >= m) return Math.round(ms / m) + 'm';
+  if (ms >= s) return Math.round(ms / s) + 's';
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function long(ms) {
+  return plural(ms, d, 'day')
+    || plural(ms, h, 'hour')
+    || plural(ms, m, 'minute')
+    || plural(ms, s, 'second')
+    || ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, n, name) {
+  if (ms < n) return;
+  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
+  return Math.ceil(ms / n) + ' ' + name + 's';
+}
+
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/pouchdb-collections/index.js":[function(require,module,exports){
+'use strict';
+exports.Map = LazyMap; // TODO: use ES6 map
+exports.Set = LazySet; // TODO: use ES6 set
+// based on https://github.com/montagejs/collections
+function LazyMap() {
+  this.store = {};
+}
+LazyMap.prototype.mangle = function (key) {
+  if (typeof key !== "string") {
+    throw new TypeError("key must be a string but Got " + key);
+  }
+  return '$' + key;
+};
+LazyMap.prototype.unmangle = function (key) {
+  return key.substring(1);
+};
+LazyMap.prototype.get = function (key) {
+  var mangled = this.mangle(key);
+  if (mangled in this.store) {
+    return this.store[mangled];
+  } else {
+    return void 0;
+  }
+};
+LazyMap.prototype.set = function (key, value) {
+  var mangled = this.mangle(key);
+  this.store[mangled] = value;
+  return true;
+};
+LazyMap.prototype.has = function (key) {
+  var mangled = this.mangle(key);
+  return mangled in this.store;
+};
+LazyMap.prototype.delete = function (key) {
+  var mangled = this.mangle(key);
+  if (mangled in this.store) {
+    delete this.store[mangled];
+    return true;
+  }
+  return false;
+};
+LazyMap.prototype.forEach = function (cb) {
+  var self = this;
+  var keys = Object.keys(self.store);
+  keys.forEach(function (key) {
+    var value = self.store[key];
+    key = self.unmangle(key);
+    cb(value, key);
+  });
+};
+
+function LazySet(array) {
+  this.store = new LazyMap();
+
+  // init with an array
+  if (array && Array.isArray(array)) {
+    for (var i = 0, len = array.length; i < len; i++) {
+      this.add(array[i]);
+    }
+  }
+}
+LazySet.prototype.add = function (key) {
+  return this.store.set(key, true);
+};
+LazySet.prototype.has = function (key) {
+  return this.store.has(key);
+};
+LazySet.prototype.delete = function (key) {
+  return this.store.delete(key);
+};
+
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js":[function(require,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+    if (typeof exports === 'object') {
+        // Node/CommonJS
+        module.exports = factory();
+    } else if (typeof define === 'function' && define.amd) {
+        // AMD
+        define(factory);
+    } else {
+        // Browser globals (with support for web workers)
+        var glob;
+        try {
+            glob = window;
+        } catch (e) {
+            glob = self;
+        }
+
+        glob.SparkMD5 = factory();
+    }
+}(function (undefined) {
+
+    'use strict';
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /*
+     * Fastest md5 implementation around (JKM md5)
+     * Credits: Joseph Myers
+     *
+     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+     * @see http://jsperf.com/md5-shootout/7
+     */
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
+        return (a + b) & 0xFFFFFFFF;
+    },
+
+    cmn = function (q, a, b, x, s, t) {
+        a = add32(add32(a, q), add32(x, t));
+        return add32((a << s) | (a >>> (32 - s)), b);
+    },
+
+    ff = function (a, b, c, d, x, s, t) {
+        return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+    },
+
+    gg = function (a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+    },
+
+    hh = function (a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    },
+
+    ii = function (a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | (~d)), a, b, x, s, t);
+    },
+
+    md5cycle = function (x, k) {
+        var a = x[0],
+            b = x[1],
+            c = x[2],
+            d = x[3];
+
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+
+        x[0] = add32(a, x[0]);
+        x[1] = add32(b, x[1]);
+        x[2] = add32(c, x[2]);
+        x[3] = add32(d, x[3]);
+    },
+
+    /* there needs to be support for Unicode here,
+       * unless we pretend that we can redefine the MD-5
+       * algorithm for multi-byte characters (perhaps
+       * by adding every four 16-bit characters and
+       * shortening the sum to 32 bits). Otherwise
+       * I suggest performing MD-5 as if every character
+       * was two bytes--e.g., 0040 0025 = @%--but then
+       * how will an ordinary MD-5 sum be matched?
+       * There is no way to standardize text to something
+       * like UTF-8 before transformation; speed cost is
+       * utterly prohibitive. The JavaScript standard
+       * itself needs to look at this: it should start
+       * providing access to strings as preformed UTF-8
+       * 8-bit unsigned value arrays.
+       */
+    md5blk = function (s) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    },
+
+    md5blk_array = function (a) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+    },
+
+    md51 = function (s) {
+        var n = s.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+        return state;
+    },
+
+    md51_array = function (a) {
+        var n = a.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+
+        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+        // containing the last element of the parent array if the sub array specified starts
+        // beyond the length of the parent array - weird.
+        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+        length = a.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= a[i] << ((i % 4) << 3);
+        }
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+
+        return state;
+    },
+
+    hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+    rhex = function (n) {
+        var s = '',
+            j;
+        for (j = 0; j < 4; j += 1) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+        }
+        return s;
+    },
+
+    hex = function (x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+            x[i] = rhex(x[i]);
+        }
+        return x.join('');
+    },
+
+    md5 = function (s) {
+        return hex(md51(s));
+    },
+
+
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * SparkMD5 OOP implementation.
+     *
+     * Use this class to perform an incremental md5, otherwise use the
+     * static methods instead.
+     */
+    SparkMD5 = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+
+    // In some cases the fast add32 function cannot be used..
+    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
+
+    /**
+     * Appends a string.
+     * A conversion will be applied if an utf8 string is detected.
+     *
+     * @param {String} str The string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.append = function (str) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        // then append as binary
+        this.appendBinary(str);
+
+        return this;
+    };
+
+    /**
+     * Appends a binary string.
+     *
+     * @param {String} contents The binary string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.appendBinary = function (contents) {
+        this._buff += contents;
+        this._length += contents.length;
+
+        var length = this._buff.length,
+            i;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+        }
+
+        this._buff = this._buff.substr(i - 64);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            i,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Finish the final calculation based on the tail.
+     *
+     * @param {Array}  tail   The tail (will be modified)
+     * @param {Number} length The length of the remaining buffer
+     */
+    SparkMD5.prototype._finish = function (tail, length) {
+        var i = length,
+            tmp,
+            lo,
+            hi;
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(this._state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Do the final computation based on the tail and length
+        // Beware that the final length may not fit in 32 bits so we take care of that
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._state, tail);
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.reset = function () {
+        this._buff = "";
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.prototype.destroy = function () {
+        delete this._state;
+        delete this._buff;
+        delete this._length;
+    };
+
+
+    /**
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
+     *
+     * @param {String}  str The string
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hash = function (str, raw) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        var hash = md51(str);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * Performs the md5 hash on a binary string.
+     *
+     * @param {String}  content The binary string
+     * @param {Boolean} raw     True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hashBinary = function (content, raw) {
+        var hash = md51(content);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * SparkMD5 OOP implementation for array buffers.
+     *
+     * Use this class to perform an incremental md5 ONLY for array buffers.
+     */
+    SparkMD5.ArrayBuffer = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * Appends an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array to be appended
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+        // TODO: we could avoid the concatenation here but the algorithm would be more complex
+        //       if you find yourself needing extra performance, please make a PR.
+        var buff = this._concatArrayBuffer(this._buff, arr),
+            length = buff.length,
+            i;
+
+        this._length += arr.byteLength;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+        }
+
+        // Avoids IE10 weirdness (documented above)
+        this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.reset = function () {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+    /**
+     * Concats two array buffers, returning a new one.
+     *
+     * @param  {ArrayBuffer} first  The first array buffer
+     * @param  {ArrayBuffer} second The second array buffer
+     *
+     * @return {ArrayBuffer} The new array buffer
+     */
+    SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+        var firstLength = first.length,
+            result = new Uint8Array(firstLength + second.byteLength);
+
+        result.set(first);
+        result.set(new Uint8Array(second), firstLength);
+
+        return result;
+    };
+
+    /**
+     * Performs the md5 hash on an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array buffer
+     * @param {Boolean}     raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+        var hash = md51_array(new Uint8Array(arr));
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    return SparkMD5;
+}));
+
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/vuvuzela/index.js":[function(require,module,exports){
+'use strict';
+
+/**
+ * Stringify/parse functions that don't operate
+ * recursively, so they avoid call stack exceeded
+ * errors.
+ */
+exports.stringify = function stringify(input) {
+  var queue = [];
+  queue.push({obj: input});
+
+  var res = '';
+  var next, obj, prefix, val, i, arrayPrefix, keys, k, key, value, objPrefix;
+  while ((next = queue.pop())) {
+    obj = next.obj;
+    prefix = next.prefix || '';
+    val = next.val || '';
+    res += prefix;
+    if (val) {
+      res += val;
+    } else if (typeof obj !== 'object') {
+      res += typeof obj === 'undefined' ? null : JSON.stringify(obj);
+    } else if (obj === null) {
+      res += 'null';
+    } else if (Array.isArray(obj)) {
+      queue.push({val: ']'});
+      for (i = obj.length - 1; i >= 0; i--) {
+        arrayPrefix = i === 0 ? '' : ',';
+        queue.push({obj: obj[i], prefix: arrayPrefix});
+      }
+      queue.push({val: '['});
+    } else { // object
+      keys = [];
+      for (k in obj) {
+        if (obj.hasOwnProperty(k)) {
+          keys.push(k);
+        }
+      }
+      queue.push({val: '}'});
+      for (i = keys.length - 1; i >= 0; i--) {
+        key = keys[i];
+        value = obj[key];
+        objPrefix = (i > 0 ? ',' : '');
+        objPrefix += JSON.stringify(key) + ':';
+        queue.push({obj: value, prefix: objPrefix});
+      }
+      queue.push({val: '{'});
+    }
+  }
+  return res;
+};
+
+// Convenience function for the parse function.
+// This pop function is basically copied from
+// pouchCollate.parseIndexableString
+function pop(obj, stack, metaStack) {
+  var lastMetaElement = metaStack[metaStack.length - 1];
+  if (obj === lastMetaElement.element) {
+    // popping a meta-element, e.g. an object whose value is another object
+    metaStack.pop();
+    lastMetaElement = metaStack[metaStack.length - 1];
+  }
+  var element = lastMetaElement.element;
+  var lastElementIndex = lastMetaElement.index;
+  if (Array.isArray(element)) {
+    element.push(obj);
+  } else if (lastElementIndex === stack.length - 2) { // obj with key+value
+    var key = stack.pop();
+    element[key] = obj;
+  } else {
+    stack.push(obj); // obj with key only
+  }
+}
+
+exports.parse = function (str) {
+  var stack = [];
+  var metaStack = []; // stack for arrays and objects
+  var i = 0;
+  var collationIndex,parsedNum,numChar;
+  var parsedString,lastCh,numConsecutiveSlashes,ch;
+  var arrayElement, objElement;
+  while (true) {
+    collationIndex = str[i++];
+    if (collationIndex === '}' ||
+        collationIndex === ']' ||
+        typeof collationIndex === 'undefined') {
+      if (stack.length === 1) {
+        return stack.pop();
+      } else {
+        pop(stack.pop(), stack, metaStack);
+        continue;
+      }
+    }
+    switch (collationIndex) {
+      case ' ':
+      case '\t':
+      case '\n':
+      case ':':
+      case ',':
+        break;
+      case 'n':
+        i += 3; // 'ull'
+        pop(null, stack, metaStack);
+        break;
+      case 't':
+        i += 3; // 'rue'
+        pop(true, stack, metaStack);
+        break;
+      case 'f':
+        i += 4; // 'alse'
+        pop(false, stack, metaStack);
+        break;
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+      case '-':
+        parsedNum = '';
+        i--;
+        while (true) {
+          numChar = str[i++];
+          if (/[\d\.\-e\+]/.test(numChar)) {
+            parsedNum += numChar;
+          } else {
+            i--;
+            break;
+          }
+        }
+        pop(parseFloat(parsedNum), stack, metaStack);
+        break;
+      case '"':
+        parsedString = '';
+        lastCh = void 0;
+        numConsecutiveSlashes = 0;
+        while (true) {
+          ch = str[i++];
+          if (ch !== '"' || (lastCh === '\\' &&
+              numConsecutiveSlashes % 2 === 1)) {
+            parsedString += ch;
+            lastCh = ch;
+            if (lastCh === '\\') {
+              numConsecutiveSlashes++;
+            } else {
+              numConsecutiveSlashes = 0;
+            }
+          } else {
+            break;
+          }
+        }
+        pop(JSON.parse('"' + parsedString + '"'), stack, metaStack);
+        break;
+      case '[':
+        arrayElement = { element: [], index: stack.length };
+        stack.push(arrayElement.element);
+        metaStack.push(arrayElement);
+        break;
+      case '{':
+        objElement = { element: {}, index: stack.length };
+        stack.push(objElement.element);
+        metaStack.push(objElement);
+        break;
+      default:
+        throw new Error(
+          'unexpectedly reached end of input: ' + collationIndex);
+    }
+  }
+};
+
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapter.js":[function(require,module,exports){
+"use strict";
+
+var utils = require('./utils');
+var merge = require('./merge');
+var errors = require('./deps/errors');
+var EventEmitter = require('events').EventEmitter;
+var upsert = require('./deps/upsert');
+var Changes = require('./changes');
+var Promise = utils.Promise;
+
+/*
+ * A generic pouch adapter
+ */
+
+// returns first element of arr satisfying callback predicate
+function arrayFirst(arr, callback) {
+  for (var i = 0; i < arr.length; i++) {
+    if (callback(arr[i], i) === true) {
+      return arr[i];
+    }
+  }
+  return false;
+}
+
+// Wrapper for functions that call the bulkdocs api with a single doc,
+// if the first result is an error, return an error
+function yankError(callback) {
+  return function (err, results) {
+    if (err || (results[0] && results[0].error)) {
+      callback(err || results[0]);
+    } else {
+      callback(null, results.length ? results[0]  : results);
+    }
+  };
+}
+
+// for every node in a revision tree computes its distance from the closest
+// leaf
+function computeHeight(revs) {
+  var height = {};
+  var edges = [];
+  merge.traverseRevTree(revs, function (isLeaf, pos, id, prnt) {
+    var rev = pos + "-" + id;
+    if (isLeaf) {
+      height[rev] = 0;
+    }
+    if (prnt !== undefined) {
+      edges.push({from: prnt, to: rev});
+    }
+    return rev;
+  });
+
+  edges.reverse();
+  edges.forEach(function (edge) {
+    if (height[edge.from] === undefined) {
+      height[edge.from] = 1 + height[edge.to];
+    } else {
+      height[edge.from] = Math.min(height[edge.from], 1 + height[edge.to]);
+    }
+  });
+  return height;
+}
+
+function allDocsKeysQuery(api, opts, callback) {
+  var keys =  ('limit' in opts) ?
+      opts.keys.slice(opts.skip, opts.limit + opts.skip) :
+      (opts.skip > 0) ? opts.keys.slice(opts.skip) : opts.keys;
+  if (opts.descending) {
+    keys.reverse();
+  }
+  if (!keys.length) {
+    return api._allDocs({limit: 0}, callback);
+  }
+  var finalResults = {
+    offset: opts.skip
+  };
+  return Promise.all(keys.map(function (key) {
+    var subOpts = utils.extend(true, {key: key, deleted: 'ok'}, opts);
+    ['limit', 'skip', 'keys'].forEach(function (optKey) {
+      delete subOpts[optKey];
+    });
+    return new Promise(function (resolve, reject) {
+      api._allDocs(subOpts, function (err, res) {
+        if (err) {
+          return reject(err);
+        }
+        finalResults.total_rows = res.total_rows;
+        resolve(res.rows[0] || {key: key, error: 'not_found'});
+      });
+    });
+  })).then(function (results) {
+    finalResults.rows = results;
+    return finalResults;
+  });
+}
+
+utils.inherits(AbstractPouchDB, EventEmitter);
+module.exports = AbstractPouchDB;
+
+function AbstractPouchDB() {
+  EventEmitter.call(this);
+}
+
+AbstractPouchDB.prototype.post =
+  utils.adapterFun('post', function (doc, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  if (typeof doc !== 'object' || Array.isArray(doc)) {
+    return callback(errors.error(errors.NOT_AN_OBJECT));
+  }
+  this.bulkDocs({docs: [doc]}, opts, yankError(callback));
+});
+
+AbstractPouchDB.prototype.put =
+  utils.adapterFun('put', utils.getArguments(function (args) {
+  var temp, temptype, opts, callback;
+  var doc = args.shift();
+  var id = '_id' in doc;
+  if (typeof doc !== 'object' || Array.isArray(doc)) {
+    callback = args.pop();
+    return callback(errors.error(errors.NOT_AN_OBJECT));
+  }
+  doc = utils.clone(doc);
+  while (true) {
+    temp = args.shift();
+    temptype = typeof temp;
+    if (temptype === "string" && !id) {
+      doc._id = temp;
+      id = true;
+    } else if (temptype === "string" && id && !('_rev' in doc)) {
+      doc._rev = temp;
+    } else if (temptype === "object") {
+      opts = temp;
+    } else if (temptype === "function") {
+      callback = temp;
+    }
+    if (!args.length) {
+      break;
+    }
+  }
+  opts = opts || {};
+  var error = utils.invalidIdError(doc._id);
+  if (error) {
+    return callback(error);
+  }
+  if (utils.isLocalId(doc._id) && typeof this._putLocal === 'function') {
+    if (doc._deleted) {
+      return this._removeLocal(doc, callback);
+    } else {
+      return this._putLocal(doc, callback);
+    }
+  }
+  this.bulkDocs({docs: [doc]}, opts, yankError(callback));
+}));
+
+AbstractPouchDB.prototype.putAttachment =
+  utils.adapterFun('putAttachment', function (docId, attachmentId, rev,
+                                              blob, type, callback) {
+  var api = this;
+  if (typeof type === 'function') {
+    callback = type;
+    type = blob;
+    blob = rev;
+    rev = null;
+  }
+  if (typeof type === 'undefined') {
+    type = blob;
+    blob = rev;
+    rev = null;
+  }
+
+  function createAttachment(doc) {
+    doc._attachments = doc._attachments || {};
+    doc._attachments[attachmentId] = {
+      content_type: type,
+      data: blob
+    };
+    return api.put(doc);
+  }
+
+  return api.get(docId).then(function (doc) {
+    if (doc._rev !== rev) {
+      throw errors.error(errors.REV_CONFLICT);
+    }
+
+    return createAttachment(doc);
+  }, function (err) {
+     // create new doc
+    if (err.reason === errors.MISSING_DOC.message) {
+      return createAttachment({_id: docId});
+    } else {
+      throw err;
+    }
+  });
+});
+
+AbstractPouchDB.prototype.removeAttachment =
+  utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
+                                                 callback) {
+  var self = this;
+  self.get(docId, function (err, obj) {
+    if (err) {
+      callback(err);
+      return;
+    }
+    if (obj._rev !== rev) {
+      callback(errors.error(errors.REV_CONFLICT));
+      return;
+    }
+    if (!obj._attachments) {
+      return callback();
+    }
+    delete obj._attachments[attachmentId];
+    if (Object.keys(obj._attachments).length === 0) {
+      delete obj._attachments;
+    }
+    self.put(obj, callback);
+  });
+});
+
+AbstractPouchDB.prototype.remove =
+  utils.adapterFun('remove', function (docOrId, optsOrRev, opts, callback) {
+  var doc;
+  if (typeof optsOrRev === 'string') {
+    // id, rev, opts, callback style
+    doc = {
+      _id: docOrId,
+      _rev: optsOrRev
+    };
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+  } else {
+    // doc, opts, callback style
+    doc = docOrId;
+    if (typeof optsOrRev === 'function') {
+      callback = optsOrRev;
+      opts = {};
+    } else {
+      callback = opts;
+      opts = optsOrRev;
+    }
+  }
+  opts = utils.clone(opts || {});
+  opts.was_delete = true;
+  var newDoc = {_id: doc._id, _rev: (doc._rev || opts.rev)};
+  newDoc._deleted = true;
+  if (utils.isLocalId(newDoc._id) && typeof this._removeLocal === 'function') {
+    return this._removeLocal(doc, callback);
+  }
+  this.bulkDocs({docs: [newDoc]}, opts, yankError(callback));
+});
+
+AbstractPouchDB.prototype.revsDiff =
+  utils.adapterFun('revsDiff', function (req, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  opts = utils.clone(opts);
+  var ids = Object.keys(req);
+
+  if (!ids.length) {
+    return callback(null, {});
+  }
+
+  var count = 0;
+  var missing = new utils.Map();
+
+  function addToMissing(id, revId) {
+    if (!missing.has(id)) {
+      missing.set(id, {missing: []});
+    }
+    missing.get(id).missing.push(revId);
+  }
+
+  function processDoc(id, rev_tree) {
+    // Is this fast enough? Maybe we should switch to a set simulated by a map
+    var missingForId = req[id].slice(0);
+    merge.traverseRevTree(rev_tree, function (isLeaf, pos, revHash, ctx,
+      opts) {
+        var rev = pos + '-' + revHash;
+        var idx = missingForId.indexOf(rev);
+        if (idx === -1) {
+          return;
+        }
+
+        missingForId.splice(idx, 1);
+        if (opts.status !== 'available') {
+          addToMissing(id, rev);
+        }
+      });
+
+    // Traversing the tree is synchronous, so now `missingForId` contains
+    // revisions that were not found in the tree
+    missingForId.forEach(function (rev) {
+      addToMissing(id, rev);
+    });
+  }
+
+  ids.map(function (id) {
+    this._getRevisionTree(id, function (err, rev_tree) {
+      if (err && err.status === 404 && err.message === 'missing') {
+        missing.set(id, {missing: req[id]});
+      } else if (err) {
+        return callback(err);
+      } else {
+        processDoc(id, rev_tree);
+      }
+
+      if (++count === ids.length) {
+        // convert LazyMap to object
+        var missingObj = {};
+        missing.forEach(function (value, key) {
+          missingObj[key] = value;
+        });
+        return callback(null, missingObj);
+      }
+    });
+  }, this);
+});
+
+// compact one document and fire callback
+// by compacting we mean removing all revisions which
+// are further from the leaf in revision tree than max_height
+AbstractPouchDB.prototype.compactDocument =
+  utils.adapterFun('compactDocument', function (docId, maxHeight, callback) {
+  var self = this;
+  this._getRevisionTree(docId, function (err, revTree) {
+    if (err) {
+      return callback(err);
+    }
+    var height = computeHeight(revTree);
+    var candidates = [];
+    var revs = [];
+    Object.keys(height).forEach(function (rev) {
+      if (height[rev] > maxHeight) {
+        candidates.push(rev);
+      }
+    });
+
+    merge.traverseRevTree(revTree, function (isLeaf, pos, revHash, ctx, opts) {
+      var rev = pos + '-' + revHash;
+      if (opts.status === 'available' && candidates.indexOf(rev) !== -1) {
+        revs.push(rev);
+      }
+    });
+    self._doCompaction(docId, revs, callback);
+  });
+});
+
+// compact the whole database using single document
+// compaction
+AbstractPouchDB.prototype.compact =
+  utils.adapterFun('compact', function (opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  var self = this;
+
+  opts = utils.clone(opts || {});
+
+  self.get('_local/compaction').catch(function () {
+    return false;
+  }).then(function (doc) {
+    if (typeof self._compact === 'function') {
+      if (doc && doc.last_seq) {
+        opts.last_seq = doc.last_seq;
+      }
+      return self._compact(opts, callback);
+    }
+
+  });
+});
+AbstractPouchDB.prototype._compact = function (opts, callback) {
+  var self = this;
+  var changesOpts = {
+    returnDocs: false,
+    last_seq: opts.last_seq || 0
+  };
+  var promises = [];
+
+  function onChange(row) {
+    promises.push(self.compactDocument(row.id, 0));
+  }
+  function onComplete(resp) {
+    var lastSeq = resp.last_seq;
+    Promise.all(promises).then(function () {
+      return upsert(self, '_local/compaction', function deltaFunc(doc) {
+        if (!doc.last_seq || doc.last_seq < lastSeq) {
+          doc.last_seq = lastSeq;
+          return doc;
+        }
+        return false; // somebody else got here first, don't update
+      });
+    }).then(function () {
+      callback(null, {ok: true});
+    }).catch(callback);
   }
+  self.changes(changesOpts)
+    .on('change', onChange)
+    .on('complete', onComplete)
+    .on('error', callback);
 };
-}).call(this,require('_process'))
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb.js":[function(require,module,exports){
-(function (process){
-'use strict';
+/* Begin api wrappers. Specific functionality to storage belongs in the 
+   _[method] */
+AbstractPouchDB.prototype.get =
+  utils.adapterFun('get', function (id, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  if (typeof id !== 'string') {
+    return callback(errors.error(errors.INVALID_ID));
+  }
+  if (utils.isLocalId(id) && typeof this._getLocal === 'function') {
+    return this._getLocal(id, callback);
+  }
+  var leaves = [], self = this;
 
-var utils = require('../../utils');
-var merge = require('../../merge');
-var errors = require('../../deps/errors');
-var idbUtils = require('./idb-utils');
-var idbConstants = require('./idb-constants');
-var idbBulkDocs = require('./idb-bulk-docs');
-var idbAllDocs = require('./idb-all-docs');
-var checkBlobSupport = require('./idb-blob-support');
+  function finishOpenRevs() {
+    var result = [];
+    var count = leaves.length;
+    if (!count) {
+      return callback(null, result);
+    }
+    // order with open_revs is unspecified
+    leaves.forEach(function (leaf) {
+      self.get(id, {
+        rev: leaf,
+        revs: opts.revs,
+        attachments: opts.attachments
+      }, function (err, doc) {
+        if (!err) {
+          result.push({ok: doc});
+        } else {
+          result.push({missing: leaf});
+        }
+        count--;
+        if (!count) {
+          callback(null, result);
+        }
+      });
+    });
+  }
 
-var ADAPTER_VERSION = idbConstants.ADAPTER_VERSION;
-var ATTACH_AND_SEQ_STORE = idbConstants.ATTACH_AND_SEQ_STORE;
-var ATTACH_STORE = idbConstants.ATTACH_STORE;
-var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
-var DETECT_BLOB_SUPPORT_STORE = idbConstants.DETECT_BLOB_SUPPORT_STORE;
-var DOC_STORE = idbConstants.DOC_STORE;
-var LOCAL_STORE = idbConstants.LOCAL_STORE;
-var META_STORE = idbConstants.META_STORE;
+  if (opts.open_revs) {
+    if (opts.open_revs === "all") {
+      this._getRevisionTree(id, function (err, rev_tree) {
+        if (err) {
+          return callback(err);
+        }
+        leaves = merge.collectLeaves(rev_tree).map(function (leaf) {
+          return leaf.rev;
+        });
+        finishOpenRevs();
+      });
+    } else {
+      if (Array.isArray(opts.open_revs)) {
+        leaves = opts.open_revs;
+        for (var i = 0; i < leaves.length; i++) {
+          var l = leaves[i];
+          // looks like it's the only thing couchdb checks
+          if (!(typeof(l) === "string" && /^\d+-/.test(l))) {
+            return callback(errors.error(errors.INVALID_REV));
+          }
+        }
+        finishOpenRevs();
+      } else {
+        return callback(errors.error(errors.UNKNOWN_ERROR,
+          'function_clause'));
+      }
+    }
+    return; // open_revs does not like other options
+  }
 
-var applyNext = idbUtils.applyNext;
-var compactRevs = idbUtils.compactRevs;
-var decodeDoc = idbUtils.decodeDoc;
-var decodeMetadata = idbUtils.decodeMetadata;
-var encodeMetadata = idbUtils.encodeMetadata;
-var fetchAttachmentsIfNecessary = idbUtils.fetchAttachmentsIfNecessary;
-var idbError = idbUtils.idbError;
-var postProcessAttachments = idbUtils.postProcessAttachments;
-var readBlobData = idbUtils.readBlobData;
-var taskQueue = idbUtils.taskQueue;
-var openTransactionSafely = idbUtils.openTransactionSafely;
+  return this._get(id, opts, function (err, result) {
+    opts = utils.clone(opts);
+    if (err) {
+      return callback(err);
+    }
 
-var cachedDBs = {};
-var blobSupportPromise;
+    var doc = result.doc;
+    var metadata = result.metadata;
+    var ctx = result.ctx;
 
-function IdbPouch(opts, callback) {
-  var api = this;
+    if (opts.conflicts) {
+      var conflicts = merge.collectConflicts(metadata);
+      if (conflicts.length) {
+        doc._conflicts = conflicts;
+      }
+    }
 
-  taskQueue.queue.push({
-    action: function (thisCallback) {
-      init(api, opts, thisCallback);
-    },
-    callback: callback
+    if (utils.isDeleted(metadata, doc._rev)) {
+      doc._deleted = true;
+    }
+
+    if (opts.revs || opts.revs_info) {
+      var paths = merge.rootToLeaf(metadata.rev_tree);
+      var path = arrayFirst(paths, function (arr) {
+        return arr.ids.map(function (x) { return x.id; })
+          .indexOf(doc._rev.split('-')[1]) !== -1;
+      });
+
+      var indexOfRev = path.ids.map(function (x) {return x.id; })
+        .indexOf(doc._rev.split('-')[1]) + 1;
+      var howMany = path.ids.length - indexOfRev;
+      path.ids.splice(indexOfRev, howMany);
+      path.ids.reverse();
+
+      if (opts.revs) {
+        doc._revisions = {
+          start: (path.pos + path.ids.length) - 1,
+          ids: path.ids.map(function (rev) {
+            return rev.id;
+          })
+        };
+      }
+      if (opts.revs_info) {
+        var pos =  path.pos + path.ids.length;
+        doc._revs_info = path.ids.map(function (rev) {
+          pos--;
+          return {
+            rev: pos + '-' + rev.id,
+            status: rev.opts.status
+          };
+        });
+      }
+    }
+
+    if (opts.local_seq) {
+      utils.info('The "local_seq" option is deprecated and will be removed');
+      doc._local_seq = result.metadata.seq;
+    }
+
+    if (opts.attachments && doc._attachments) {
+      var attachments = doc._attachments;
+      var count = Object.keys(attachments).length;
+      if (count === 0) {
+        return callback(null, doc);
+      }
+      Object.keys(attachments).forEach(function (key) {
+        this._getAttachment(attachments[key],
+                            {encode: true, ctx: ctx}, function (err, data) {
+          var att = doc._attachments[key];
+          att.data = data;
+          delete att.stub;
+          delete att.length;
+          if (!--count) {
+            callback(null, doc);
+          }
+        });
+      }, self);
+    } else {
+      if (doc._attachments) {
+        for (var key in doc._attachments) {
+          if (doc._attachments.hasOwnProperty(key)) {
+            doc._attachments[key].stub = true;
+          }
+        }
+      }
+      callback(null, doc);
+    }
   });
-  applyNext();
-}
+});
 
-function init(api, opts, callback) {
+AbstractPouchDB.prototype.getAttachment =
+  utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
+                                              callback) {
+  var self = this;
+  if (opts instanceof Function) {
+    callback = opts;
+    opts = {};
+  }
+  opts = utils.clone(opts);
+  this._get(docId, opts, function (err, res) {
+    if (err) {
+      return callback(err);
+    }
+    if (res.doc._attachments && res.doc._attachments[attachmentId]) {
+      opts.ctx = res.ctx;
+      self._getAttachment(res.doc._attachments[attachmentId], opts, callback);
+    } else {
+      return callback(errors.error(errors.MISSING_DOC));
+    }
+  });
+});
 
-  var dbName = opts.name;
+AbstractPouchDB.prototype.allDocs =
+  utils.adapterFun('allDocs', function (opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  opts = utils.clone(opts);
+  opts.skip = typeof opts.skip !== 'undefined' ? opts.skip : 0;
+  if ('keys' in opts) {
+    if (!Array.isArray(opts.keys)) {
+      return callback(new TypeError('options.keys must be an array'));
+    }
+    var incompatibleOpt =
+      ['startkey', 'endkey', 'key'].filter(function (incompatibleOpt) {
+      return incompatibleOpt in opts;
+    })[0];
+    if (incompatibleOpt) {
+      callback(errors.error(errors.QUERY_PARSE_ERROR,
+        'Query parameter `' + incompatibleOpt +
+        '` is not compatible with multi-get'
+      ));
+      return;
+    }
+    if (this.type() !== 'http') {
+      return allDocsKeysQuery(this, opts, callback);
+    }
+  }
 
-  var idb = null;
-  api._meta = null;
+  return this._allDocs(opts, callback);
+});
 
-  // called when creating a fresh new database
-  function createSchema(db) {
-    var docStore = db.createObjectStore(DOC_STORE, {keyPath : 'id'});
-    db.createObjectStore(BY_SEQ_STORE, {autoIncrement: true})
-      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
-    db.createObjectStore(ATTACH_STORE, {keyPath: 'digest'});
-    db.createObjectStore(META_STORE, {keyPath: 'id', autoIncrement: false});
-    db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
+AbstractPouchDB.prototype.changes = function (opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  return new Changes(this, opts, callback);
+};
 
-    // added in v2
-    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});
+AbstractPouchDB.prototype.close =
+  utils.adapterFun('close', function (callback) {
+  this._closed = true;
+  return this._close(callback);
+});
 
-    // added in v3
-    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'});
+AbstractPouchDB.prototype.info = utils.adapterFun('info', function (callback) {
+  var self = this;
+  this._info(function (err, info) {
+    if (err) {
+      return callback(err);
+    }
+    // assume we know better than the adapter, unless it informs us
+    info.db_name = info.db_name || self._db_name;
+    info.auto_compaction = !!(self.auto_compaction && self.type() !== 'http');
+    callback(null, info);
+  });
+});
 
-    // added in v4
-    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,
-      {autoIncrement: true});
-    attAndSeqStore.createIndex('seq', 'seq');
-    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});
+AbstractPouchDB.prototype.id = utils.adapterFun('id', function (callback) {
+  return this._id(callback);
+});
+
+AbstractPouchDB.prototype.type = function () {
+  return (typeof this._type === 'function') ? this._type() : this.adapter;
+};
+
+AbstractPouchDB.prototype.bulkDocs =
+  utils.adapterFun('bulkDocs', function (req, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
   }
 
-  // migration to version 2
-  // unfortunately "deletedOrLocal" is a misnomer now that we no longer
-  // store local docs in the main doc-store, but whaddyagonnado
-  function addDeletedOrLocalIndex(txn, callback) {
-    var docStore = txn.objectStore(DOC_STORE);
-    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});
+  opts = utils.clone(opts);
 
-    docStore.openCursor().onsuccess = function (event) {
-      var cursor = event.target.result;
-      if (cursor) {
-        var metadata = cursor.value;
-        var deleted = utils.isDeleted(metadata);
-        metadata.deletedOrLocal = deleted ? "1" : "0";
-        docStore.put(metadata);
-        cursor.continue();
-      } else {
-        callback();
-      }
+  if (Array.isArray(req)) {
+    req = {
+      docs: req
     };
   }
 
-  // migration to version 3 (part 1)
-  function createLocalStoreSchema(db) {
-    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'})
-      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
+  if (!req || !req.docs || !Array.isArray(req.docs)) {
+    return callback(errors.error(errors.MISSING_BULK_DOCS));
   }
 
-  // migration to version 3 (part 2)
-  function migrateLocalStore(txn, cb) {
-    var localStore = txn.objectStore(LOCAL_STORE);
-    var docStore = txn.objectStore(DOC_STORE);
-    var seqStore = txn.objectStore(BY_SEQ_STORE);
+  for (var i = 0; i < req.docs.length; ++i) {
+    if (typeof req.docs[i] !== 'object' || Array.isArray(req.docs[i])) {
+      return callback(errors.error(errors.NOT_AN_OBJECT));
+    }
+  }
 
-    var cursor = docStore.openCursor();
-    cursor.onsuccess = function (event) {
-      var cursor = event.target.result;
-      if (cursor) {
-        var metadata = cursor.value;
-        var docId = metadata.id;
-        var local = utils.isLocalId(docId);
-        var rev = merge.winningRev(metadata);
-        if (local) {
-          var docIdRev = docId + "::" + rev;
-          // remove all seq entries
-          // associated with this docId
-          var start = docId + "::";
-          var end = docId + "::~";
-          var index = seqStore.index('_doc_id_rev');
-          var range = IDBKeyRange.bound(start, end, false, false);
-          var seqCursor = index.openCursor(range);
-          seqCursor.onsuccess = function (e) {
-            seqCursor = e.target.result;
-            if (!seqCursor) {
-              // done
-              docStore.delete(cursor.primaryKey);
-              cursor.continue();
-            } else {
-              var data = seqCursor.value;
-              if (data._doc_id_rev === docIdRev) {
-                localStore.put(data);
-              }
-              seqStore.delete(seqCursor.primaryKey);
-              seqCursor.continue();
-            }
-          };
-        } else {
-          cursor.continue();
-        }
-      } else if (cb) {
-        cb();
+  req = utils.clone(req);
+  if (!('new_edits' in opts)) {
+    if ('new_edits' in req) {
+      opts.new_edits = req.new_edits;
+    } else {
+      opts.new_edits = true;
+    }
+  }
+
+  if (!opts.new_edits && this.type() !== 'http') {
+    // ensure revisions of the same doc are sorted, so that
+    // the local adapter processes them correctly (#2935)
+    req.docs.sort(function (a, b) {
+      var idCompare = utils.compare(a._id, b._id);
+      if (idCompare !== 0) {
+        return idCompare;
       }
-    };
+      var aStart = a._revisions ? a._revisions.start : 0;
+      var bStart = b._revisions ? b._revisions.start : 0;
+      return utils.compare(aStart, bStart);
+    });
   }
 
-  // migration to version 4 (part 1)
-  function addAttachAndSeqStore(db) {
-    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,
-      {autoIncrement: true});
-    attAndSeqStore.createIndex('seq', 'seq');
-    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});
+  req.docs.forEach(function (doc) {
+    if (doc._deleted) {
+      delete doc._attachments; // ignore atts for deleted docs
+    }
+  });
+
+  return this._bulkDocs(req, opts, function (err, res) {
+    if (err) {
+      return callback(err);
+    }
+    if (!opts.new_edits) {
+      // this is what couch does when new_edits is false
+      res = res.filter(function (x) {
+        return x.error;
+      });
+    }
+    callback(null, res);
+  });
+});
+
+AbstractPouchDB.prototype.registerDependentDatabase =
+  utils.adapterFun('registerDependentDatabase', function (dependentDb,
+                                                          callback) {
+  var depDB = new this.constructor(dependentDb, this.__opts);
+
+  function diffFun(doc) {
+    doc.dependentDbs = doc.dependentDbs || {};
+    if (doc.dependentDbs[dependentDb]) {
+      return false; // no update required
+    }
+    doc.dependentDbs[dependentDb] = true;
+    return doc;
   }
+  upsert(this, '_local/_pouch_dependentDbs', diffFun, function (err) {
+    if (err) {
+      return callback(err);
+    }
+    return callback(null, {db: depDB});
+  });
+});
 
-  // migration to version 4 (part 2)
-  function migrateAttsAndSeqs(txn, callback) {
-    var seqStore = txn.objectStore(BY_SEQ_STORE);
-    var attStore = txn.objectStore(ATTACH_STORE);
-    var attAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);
+AbstractPouchDB.prototype.destroy =
+  utils.adapterFun('destroy', function (callback) {
 
-    // need to actually populate the table. this is the expensive part,
-    // so as an optimization, check first that this database even
-    // contains attachments
-    var req = attStore.count();
-    req.onsuccess = function (e) {
-      var count = e.target.result;
-      if (!count) {
-        return callback(); // done
+  var self = this;
+  var usePrefix = 'use_prefix' in self ? self.use_prefix : true;
+
+  function destroyDb() {
+    // call destroy method of the particular adaptor
+    self._destroy(function (err, resp) {
+      if (err) {
+        return callback(err);
+      }
+      self.emit('destroyed');
+      callback(null, resp || { 'ok': true });
+    });
+  }
+  self.get('_local/_pouch_dependentDbs', function (err, localDoc) {
+    if (err) {
+      if (err.status !== 404) {
+        return callback(err);
+      } else { // no dependencies
+        return destroyDb();
       }
+    }
+    var dependentDbs = localDoc.dependentDbs;
+    var PouchDB = self.constructor;
+    var deletedMap = Object.keys(dependentDbs).map(function (name) {
+      var trueName = usePrefix ?
+        name.replace(new RegExp('^' + PouchDB.prefix), '') : name;
+      return new PouchDB(trueName, self.__opts).destroy();
+    });
+    Promise.all(deletedMap).then(destroyDb, function (error) {
+      callback(error);
+    });
+  });
+});
 
-      seqStore.openCursor().onsuccess = function (e) {
-        var cursor = e.target.result;
-        if (!cursor) {
-          return callback(); // done
-        }
-        var doc = cursor.value;
-        var seq = cursor.primaryKey;
-        var atts = Object.keys(doc._attachments || {});
-        var digestMap = {};
-        for (var j = 0; j < atts.length; j++) {
-          var att = doc._attachments[atts[j]];
-          digestMap[att.digest] = true; // uniq digests, just in case
-        }
-        var digests = Object.keys(digestMap);
-        for (j = 0; j < digests.length; j++) {
-          var digest = digests[j];
-          attAndSeqStore.put({
-            seq: seq,
-            digestSeq: digest + '::' + seq
+},{"./changes":"/Users/richard/src/beagle/node_modules/pouchdb/lib/changes.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./deps/upsert":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/upsert.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/http/http.js":[function(require,module,exports){
+(function (process){
+"use strict";
+
+var CHANGES_BATCH_SIZE = 25;
+
+// according to http://stackoverflow.com/a/417184/680742,
+// the de factor URL length limit is 2000 characters.
+// but since most of our measurements don't take the full
+// URL into account, we fudge it a bit.
+// TODO: we could measure the full URL to enforce exactly 2000 chars
+var MAX_URL_LENGTH = 1800;
+
+var utils = require('../../utils');
+var errors = require('../../deps/errors');
+var log = require('debug')('pouchdb:http');
+var isBrowser = typeof process === 'undefined' || process.browser;
+var buffer = require('../../deps/buffer');
+
+function encodeDocId(id) {
+  if (/^_design/.test(id)) {
+    return '_design/' + encodeURIComponent(id.slice(8));
+  }
+  if (/^_local/.test(id)) {
+    return '_local/' + encodeURIComponent(id.slice(7));
+  }
+  return encodeURIComponent(id);
+}
+
+function preprocessAttachments(doc) {
+  if (!doc._attachments || !Object.keys(doc._attachments)) {
+    return utils.Promise.resolve();
+  }
+
+  return utils.Promise.all(Object.keys(doc._attachments).map(function (key) {
+    var attachment = doc._attachments[key];
+    if (attachment.data && typeof attachment.data !== 'string') {
+      if (isBrowser) {
+        return new utils.Promise(function (resolve) {
+          utils.readAsBinaryString(attachment.data, function (binary) {
+            attachment.data = utils.btoa(binary);
+            resolve();
           });
+        });
+      } else {
+        attachment.data = attachment.data.toString('base64');
+      }
+    }
+  }));
+}
+
+// Get all the information you possibly can about the URI given by name and
+// return it as a suitable object.
+function getHost(name, opts) {
+  // If the given name contains "http:"
+  if (/http(s?):/.test(name)) {
+    // Prase the URI into all its little bits
+    var uri = utils.parseUri(name);
+
+    // Store the fact that it is a remote URI
+    uri.remote = true;
+
+    // Store the user and password as a separate auth object
+    if (uri.user || uri.password) {
+      uri.auth = {username: uri.user, password: uri.password};
+    }
+
+    // Split the path part of the URI into parts using '/' as the delimiter
+    // after removing any leading '/' and any trailing '/'
+    var parts = uri.path.replace(/(^\/|\/$)/g, '').split('/');
+
+    // Store the first part as the database name and remove it from the parts
+    // array
+    uri.db = parts.pop();
+
+    // Restore the path by joining all the remaining parts (all the parts
+    // except for the database name) with '/'s
+    uri.path = parts.join('/');
+    opts = opts || {};
+    opts = utils.clone(opts);
+    uri.headers = opts.headers || (opts.ajax && opts.ajax.headers) || {};
+
+    if (opts.auth || uri.auth) {
+      var nAuth = opts.auth || uri.auth;
+      var token = utils.btoa(nAuth.username + ':' + nAuth.password);
+      uri.headers.Authorization = 'Basic ' + token;
+    }
+
+    if (opts.headers) {
+      uri.headers = opts.headers;
+    }
+
+    return uri;
+  }
+
+  // If the given name does not contain 'http:' then return a very basic object
+  // with no host, the current path, the given name as the database name and no
+  // username/password
+  return {host: '', path: '/', db: name, auth: false};
+}
+
+// Generate a URL with the host data given by opts and the given path
+function genDBUrl(opts, path) {
+  return genUrl(opts, opts.db + '/' + path);
+}
+
+// Generate a URL with the host data given by opts and the given path
+function genUrl(opts, path) {
+  if (opts.remote) {
+    // If the host already has a path, then we need to have a path delimiter
+    // Otherwise, the path delimiter is the empty string
+    var pathDel = !opts.path ? '' : '/';
+
+    // If the host already has a path, then we need to have a path delimiter
+    // Otherwise, the path delimiter is the empty string
+    return opts.protocol + '://' + opts.host + ':' + opts.port + '/' +
+           opts.path + pathDel + path;
+  }
+
+  return '/' + path;
+}
+
+// Implements the PouchDB API for dealing with CouchDB instances over HTTP
+function HttpPouch(opts, callback) {
+  // The functions that will be publicly available for HttpPouch
+  var api = this;
+  api.getHost = opts.getHost ? opts.getHost : getHost;
+
+  // Parse the URI given by opts.name into an easy-to-use object
+  var host = api.getHost(opts.name, opts);
+
+  // Generate the database URL based on the host
+  var dbUrl = genDBUrl(host, '');
+
+  api.getUrl = function () {return dbUrl; };
+  api.getHeaders = function () {return utils.clone(host.headers); };
+
+  var ajaxOpts = opts.ajax || {};
+  opts = utils.clone(opts);
+  function ajax(options, callback) {
+    var reqOpts = utils.extend(true, utils.clone(ajaxOpts), options);
+    log(reqOpts.method + ' ' + reqOpts.url);
+    return utils.ajax(reqOpts, callback);
+  }
+
+  // Create a new CouchDB database based on the given opts
+  var createDB = function () {
+    ajax({headers: host.headers, method: 'PUT', url: dbUrl}, function (err) {
+      // If we get an "Unauthorized" error
+      if (err && err.status === 401) {
+        // Test if the database already exists
+        ajax({headers: host.headers, method: 'HEAD', url: dbUrl},
+             function (err) {
+          // If there is still an error
+          if (err) {
+            // Give the error to the callback to deal with
+            callback(err);
+          } else {
+            // Continue as if there had been no errors
+            callback(null, api);
+          }
+        });
+        // If there were no errros or if the only error is "Precondition Failed"
+        // (note: "Precondition Failed" occurs when we try to create a database
+        // that already exists)
+      } else if (!err || err.status === 412) {
+        // Continue as if there had been no errors
+        callback(null, api);
+      } else {
+        callback(err);
+      }
+    });
+  };
+
+  if (!opts.skipSetup) {
+    ajax({headers: host.headers, method: 'GET', url: dbUrl}, function (err) {
+      //check if the db exists
+      if (err) {
+        if (err.status === 404) {
+          utils.explain404(
+            'PouchDB is just detecting if the remote DB exists.');
+          //if it doesn't, create it
+          createDB();
+        } else {
+          callback(err);
         }
-        cursor.continue();
-      };
+      } else {
+        //go do stuff with the db
+        callback(null, api);
+      }
+    });
+  }
+
+  api.type = function () {
+    return 'http';
+  };
+
+  api.id = utils.adapterFun('id', function (callback) {
+    ajax({
+      headers: host.headers,
+      method: 'GET',
+      url: genUrl(host, '')
+    }, function (err, result) {
+      var uuid = (result && result.uuid) ?
+        result.uuid + host.db : genDBUrl(host, '');
+      callback(null, uuid);
+    });
+  });
+
+  api.request = utils.adapterFun('request', function (options, callback) {
+    options.headers = host.headers;
+    options.url = genDBUrl(host, options.url);
+    ajax(options, callback);
+  });
+
+  // Sends a POST request to the host calling the couchdb _compact function
+  //    version: The version of CouchDB it is running
+  api.compact = utils.adapterFun('compact', function (opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    opts = utils.clone(opts);
+    ajax({
+      headers: host.headers,
+      url: genDBUrl(host, '_compact'),
+      method: 'POST'
+    }, function () {
+      function ping() {
+        api.info(function (err, res) {
+          if (!res.compact_running) {
+            callback(null, {ok: true});
+          } else {
+            setTimeout(ping, opts.interval || 200);
+          }
+        });
+      }
+      // Ping the http if it's finished compaction
+      if (typeof callback === "function") {
+        ping();
+      }
+    });
+  });
+
+  // Calls GET on the host, which gets back a JSON string containing
+  //    couchdb: A welcome string
+  //    version: The version of CouchDB it is running
+  api._info = function (callback) {
+    ajax({
+      headers: host.headers,
+      method: 'GET',
+      url: genDBUrl(host, '')
+    }, function (err, res) {
+      if (err) {
+        callback(err);
+      } else {
+        res.host = genDBUrl(host, '');
+        callback(null, res);
+      }
+    });
+  };
+
+  // Get the document with the given id from the database given by host.
+  // The id could be solely the _id in the database, or it may be a
+  // _design/ID or _local/ID path
+  api.get = utils.adapterFun('get', function (id, opts, callback) {
+    // If no options were given, set the callback to the second parameter
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    opts = utils.clone(opts);
+    if (opts.auto_encode === undefined) {
+      opts.auto_encode = true;
+    }
+
+    // List of parameters to add to the GET request
+    var params = [];
+
+    // If it exists, add the opts.revs value to the list of parameters.
+    // If revs=true then the resulting JSON will include a field
+    // _revisions containing an array of the revision IDs.
+    if (opts.revs) {
+      params.push('revs=true');
+    }
+
+    // If it exists, add the opts.revs_info value to the list of parameters.
+    // If revs_info=true then the resulting JSON will include the field
+    // _revs_info containing an array of objects in which each object
+    // representing an available revision.
+    if (opts.revs_info) {
+      params.push('revs_info=true');
+    }
+
+    if (opts.local_seq) {
+      params.push('local_seq=true');
+    }
+    // If it exists, add the opts.open_revs value to the list of parameters.
+    // If open_revs=all then the resulting JSON will include all the leaf
+    // revisions. If open_revs=["rev1", "rev2",...] then the resulting JSON
+    // will contain an array of objects containing data of all revisions
+    if (opts.open_revs) {
+      if (opts.open_revs !== "all") {
+        opts.open_revs = JSON.stringify(opts.open_revs);
+      }
+      params.push('open_revs=' + opts.open_revs);
+    }
+
+    // If it exists, add the opts.attachments value to the list of parameters.
+    // If attachments=true the resulting JSON will include the base64-encoded
+    // contents in the "data" property of each attachment.
+    if (opts.attachments) {
+      params.push('attachments=true');
+    }
+
+    // If it exists, add the opts.rev value to the list of parameters.
+    // If rev is given a revision number then get the specified revision.
+    if (opts.rev) {
+      params.push('rev=' + opts.rev);
+    }
+
+    // If it exists, add the opts.conflicts value to the list of parameters.
+    // If conflicts=true then the resulting JSON will include the field
+    // _conflicts containing all the conflicting revisions.
+    if (opts.conflicts) {
+      params.push('conflicts=' + opts.conflicts);
+    }
+
+    // Format the list of parameters into a valid URI query string
+    params = params.join('&');
+    params = params === '' ? '' : '?' + params;
+
+    if (opts.auto_encode) {
+      id = encodeDocId(id);
+    }
+
+    // Set the options for the ajax call
+    var options = {
+      headers: host.headers,
+      method: 'GET',
+      url: genDBUrl(host, id + params)
     };
+    var getRequestAjaxOpts = opts.ajax || {};
+    utils.extend(true, options, getRequestAjaxOpts);
+
+    // If the given id contains at least one '/' and the part before the '/'
+    // is NOT "_design" and is NOT "_local"
+    // OR
+    // If the given id contains at least two '/' and the part before the first
+    // '/' is "_design".
+    // TODO This second condition seems strange since if parts[0] === '_design'
+    // then we already know that parts[0] !== '_local'.
+    var parts = id.split('/');
+    if ((parts.length > 1 && parts[0] !== '_design' && parts[0] !== '_local') ||
+        (parts.length > 2 && parts[0] === '_design' && parts[0] !== '_local')) {
+      // Binary is expected back from the server
+      options.binary = true;
+    }
+
+    // Get the document
+    ajax(options, function (err, doc, xhr) {
+      // If the document does not exist, send an error to the callback
+      if (err) {
+        return callback(err);
+      }
+
+      // Send the document to the callback
+      callback(null, doc, xhr);
+    });
+  });
+
+  // Delete the document given by doc from the database given by host.
+  api.remove = utils.adapterFun('remove',
+      function (docOrId, optsOrRev, opts, callback) {
+    var doc;
+    if (typeof optsOrRev === 'string') {
+      // id, rev, opts, callback style
+      doc = {
+        _id: docOrId,
+        _rev: optsOrRev
+      };
+      if (typeof opts === 'function') {
+        callback = opts;
+        opts = {};
+      }
+    } else {
+      // doc, opts, callback style
+      doc = docOrId;
+      if (typeof optsOrRev === 'function') {
+        callback = optsOrRev;
+        opts = {};
+      } else {
+        callback = opts;
+        opts = optsOrRev;
+      }
+    }
+
+    var rev = (doc._rev || opts.rev);
+
+    // Delete the document
+    ajax({
+      headers: host.headers,
+      method: 'DELETE',
+      url: genDBUrl(host, encodeDocId(doc._id)) + '?rev=' + rev
+    }, callback);
+  });
+
+  function encodeAttachmentId(attachmentId) {
+    return attachmentId.split("/").map(encodeURIComponent).join("/");
   }
 
-  // migration to version 5
-  // Instead of relying on on-the-fly migration of metadata,
-  // this brings the doc-store to its modern form:
-  // - metadata.winningrev
-  // - metadata.seq
-  // - stringify the metadata when storing it
-  function migrateMetadata(txn) {
+  // Get the attachment
+  api.getAttachment =
+    utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
+                                                callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    opts = utils.clone(opts);
+    if (opts.auto_encode === undefined) {
+      opts.auto_encode = true;
+    }
+    if (opts.auto_encode) {
+      docId = encodeDocId(docId);
+    }
+    opts.auto_encode = false;
+    api.get(docId + '/' + encodeAttachmentId(attachmentId), opts, callback);
+  });
 
-    function decodeMetadataCompat(storedObject) {
-      if (!storedObject.data) {
-        // old format, when we didn't store it stringified
-        storedObject.deleted = storedObject.deletedOrLocal === '1';
-        return storedObject;
+  // Remove the attachment given by the id and rev
+  api.removeAttachment =
+    utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
+                                                   callback) {
+
+    var url = genDBUrl(host, encodeDocId(docId) + '/' +
+      encodeAttachmentId(attachmentId)) + '?rev=' + rev;
+
+    ajax({
+      headers: host.headers,
+      method: 'DELETE',
+      url: url
+    }, callback);
+  });
+
+  // Add the attachment given by blob and its contentType property
+  // to the document with the given id, the revision given by rev, and
+  // add it to the database given by host.
+  api.putAttachment =
+    utils.adapterFun('putAttachment', function (docId, attachmentId, rev, blob,
+                                                type, callback) {
+    if (typeof type === 'function') {
+      callback = type;
+      type = blob;
+      blob = rev;
+      rev = null;
+    }
+    if (typeof type === 'undefined') {
+      type = blob;
+      blob = rev;
+      rev = null;
+    }
+    var id = encodeDocId(docId) + '/' + encodeAttachmentId(attachmentId);
+    var url = genDBUrl(host, id);
+    if (rev) {
+      url += '?rev=' + rev;
+    }
+
+    if (typeof blob === 'string') {
+      var binary;
+      try {
+        binary = utils.atob(blob);
+      } catch (err) {
+        // it's not base64-encoded, so throw error
+        return callback(errors.error(errors.BAD_ARG,
+                        'Attachments need to be base64 encoded'));
+      }
+      if (isBrowser) {
+        blob = utils.createBlob([utils.fixBinary(binary)], {type: type});
+      } else {
+        blob = binary ? new buffer(binary, 'binary') : '';
       }
-      return decodeMetadata(storedObject);
     }
 
-    // ensure that every metadata has a winningRev and seq,
-    // which was previously created on-the-fly but better to migrate
-    var bySeqStore = txn.objectStore(BY_SEQ_STORE);
-    var docStore = txn.objectStore(DOC_STORE);
-    var cursor = docStore.openCursor();
-    cursor.onsuccess = function (e) {
-      var cursor = e.target.result;
-      if (!cursor) {
-        return; // done
-      }
-      var metadata = decodeMetadataCompat(cursor.value);
+    var opts = {
+      headers: utils.clone(host.headers),
+      method: 'PUT',
+      url: url,
+      processData: false,
+      body: blob,
+      timeout: 60000
+    };
+    opts.headers['Content-Type'] = type;
+    // Add the attachment
+    ajax(opts, callback);
+  });
 
-      metadata.winningRev = metadata.winningRev || merge.winningRev(metadata);
+  // Add the document given by doc (in JSON string format) to the database
+  // given by host. This fails if the doc has no _id field.
+  api.put = utils.adapterFun('put', utils.getArguments(function (args) {
+    var temp, temptype, opts;
+    var doc = args.shift();
+    var id = '_id' in doc;
+    var callback = args.pop();
+    if (typeof doc !== 'object' || Array.isArray(doc)) {
+      return callback(errors.error(errors.NOT_AN_OBJECT));
+    }
 
-      function fetchMetadataSeq() {
-        // metadata.seq was added post-3.2.0, so if it's missing,
-        // we need to fetch it manually
-        var start = metadata.id + '::';
-        var end = metadata.id + '::\uffff';
-        var req = bySeqStore.index('_doc_id_rev').openCursor(
-          IDBKeyRange.bound(start, end));
+    doc = utils.clone(doc);
 
-        var metadataSeq = 0;
-        req.onsuccess = function (e) {
-          var cursor = e.target.result;
-          if (!cursor) {
-            metadata.seq = metadataSeq;
-            return onGetMetadataSeq();
-          }
-          var seq = cursor.primaryKey;
-          if (seq > metadataSeq) {
-            metadataSeq = seq;
-          }
-          cursor.continue();
-        };
+    preprocessAttachments(doc).then(function () {
+      while (true) {
+        temp = args.shift();
+        temptype = typeof temp;
+        if (temptype === "string" && !id) {
+          doc._id = temp;
+          id = true;
+        } else if (temptype === "string" && id && !('_rev' in doc)) {
+          doc._rev = temp;
+        } else if (temptype === "object") {
+          opts = utils.clone(temp);
+        }
+        if (!args.length) {
+          break;
+        }
+      }
+      opts = opts || {};
+      var error = utils.invalidIdError(doc._id);
+      if (error) {
+        throw error;
       }
 
-      function onGetMetadataSeq() {
-        var metadataToStore = encodeMetadata(metadata,
-          metadata.winningRev, metadata.deleted);
+      // List of parameter to add to the PUT request
+      var params = [];
 
-        var req = docStore.put(metadataToStore);
-        req.onsuccess = function () {
-          cursor.continue();
-        };
+      // If it exists, add the opts.new_edits value to the list of parameters.
+      // If new_edits = false then the database will NOT assign this document a
+      // new revision number
+      if (opts && typeof opts.new_edits !== 'undefined') {
+        params.push('new_edits=' + opts.new_edits);
       }
 
-      if (metadata.seq) {
-        return onGetMetadataSeq();
+      // Format the list of parameters into a valid URI query string
+      params = params.join('&');
+      if (params !== '') {
+        params = '?' + params;
       }
 
-      fetchMetadataSeq();
-    };
-
-  }
+      // Add the document
+      ajax({
+        headers: host.headers,
+        method: 'PUT',
+        url: genDBUrl(host, encodeDocId(doc._id)) + params,
+        body: doc
+      }, function (err, res) {
+        if (err) {
+          return callback(err);
+        }
+        res.ok = true;
+        callback(null, res);
+      });
+    }).catch(callback);
 
-  api.type = function () {
-    return 'idb';
-  };
+  }));
 
-  api._id = utils.toPromise(function (callback) {
-    callback(null, api._meta.instanceId);
+  // Add the document given by doc (in JSON string format) to the database
+  // given by host. This does not assume that doc is a new document 
+  // (i.e. does not have a _id or a _rev field.)
+  api.post = utils.adapterFun('post', function (doc, opts, callback) {
+    // If no options were given, set the callback to be the second parameter
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    opts = utils.clone(opts);
+    if (typeof doc !== 'object') {
+      return callback(errors.error(errors.NOT_AN_OBJECT));
+    }
+    if (! ("_id" in doc)) {
+      doc._id = utils.uuid();
+    }
+    api.put(doc, opts, function (err, res) {
+      if (err) {
+        return callback(err);
+      }
+      res.ok = true;
+      callback(null, res);
+    });
   });
 
-  api._bulkDocs = function idb_bulkDocs(req, opts, callback) {
-    idbBulkDocs(req, opts, api, idb, IdbPouch.Changes, callback);
+  // Update/create multiple documents given by req in the database
+  // given by host.
+  api._bulkDocs = function (req, opts, callback) {
+    // If opts.new_edits exists add it to the document data to be
+    // send to the database.
+    // If new_edits=false then it prevents the database from creating
+    // new revision numbers for the documents. Instead it just uses
+    // the old ones. This is used in database replication.
+    if (typeof opts.new_edits !== 'undefined') {
+      req.new_edits = opts.new_edits;
+    }
+
+    utils.Promise.all(req.docs.map(preprocessAttachments)).then(function () {
+      // Update/create the documents
+      ajax({
+        headers: host.headers,
+        method: 'POST',
+        url: genDBUrl(host, '_bulk_docs'),
+        body: req
+      }, function (err, results) {
+        if (err) {
+          return callback(err);
+        }
+        results.forEach(function (result) {
+          result.ok = true; // smooths out cloudant not adding this
+        });
+        callback(null, results);
+      });
+    }).catch(callback);
   };
 
-  // First we look up the metadata in the ids database, then we fetch the
-  // current revision(s) from the by sequence store
-  api._get = function idb_get(id, opts, callback) {
-    var doc;
-    var metadata;
-    var err;
-    var txn;
+  // Get a listing of the documents in the database given
+  // by host and ordered by increasing id.
+  api.allDocs = utils.adapterFun('allDocs', function (opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
     opts = utils.clone(opts);
-    if (opts.ctx) {
-      txn = opts.ctx;
-    } else {
-      var txnResult = openTransactionSafely(idb,
-        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
-      if (txnResult.error) {
-        return callback(txnResult.error);
-      }
-      txn = txnResult.txn;
+    // List of parameters to add to the GET request
+    var params = [];
+    var body;
+    var method = 'GET';
+
+    if (opts.conflicts) {
+      params.push('conflicts=true');
     }
 
-    function finish() {
-      callback(err, {doc: doc, metadata: metadata, ctx: txn});
+    // If opts.descending is truthy add it to params
+    if (opts.descending) {
+      params.push('descending=true');
     }
 
-    txn.objectStore(DOC_STORE).get(id).onsuccess = function (e) {
-      metadata = decodeMetadata(e.target.result);
-      // we can determine the result here if:
-      // 1. there is no such document
-      // 2. the document is deleted and we don't ask about specific rev
-      // When we ask with opts.rev we expect the answer to be either
-      // doc (possibly with _deleted=true) or missing error
-      if (!metadata) {
-        err = errors.error(errors.MISSING_DOC, 'missing');
-        return finish();
-      }
-      if (utils.isDeleted(metadata) && !opts.rev) {
-        err = errors.error(errors.MISSING_DOC, "deleted");
-        return finish();
-      }
-      var objectStore = txn.objectStore(BY_SEQ_STORE);
+    // If opts.include_docs exists, add the include_docs value to the
+    // list of parameters.
+    // If include_docs=true then include the associated document with each
+    // result.
+    if (opts.include_docs) {
+      params.push('include_docs=true');
+    }
 
-      var rev = opts.rev || metadata.winningRev;
-      var key = metadata.id + '::' + rev;
+    if (opts.attachments) {
+      // added in CouchDB 1.6.0
+      params.push('attachments=true');
+    }
 
-      objectStore.index('_doc_id_rev').get(key).onsuccess = function (e) {
-        doc = e.target.result;
-        if (doc) {
-          doc = decodeDoc(doc);
-        }
-        if (!doc) {
-          err = errors.error(errors.MISSING_DOC, 'missing');
-          return finish();
-        }
-        finish();
-      };
-    };
-  };
+    if (opts.key) {
+      params.push('key=' + encodeURIComponent(JSON.stringify(opts.key)));
+    }
 
-  api._getAttachment = function (attachment, opts, callback) {
-    var txn;
-    opts = utils.clone(opts);
-    if (opts.ctx) {
-      txn = opts.ctx;
-    } else {
-      var txnResult = openTransactionSafely(idb,
-        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
-      if (txnResult.error) {
-        return callback(txnResult.error);
-      }
-      txn = txnResult.txn;
+    // If opts.startkey exists, add the startkey value to the list of
+    // parameters.
+    // If startkey is given then the returned list of documents will
+    // start with the document whose id is startkey.
+    if (opts.startkey) {
+      params.push('startkey=' +
+        encodeURIComponent(JSON.stringify(opts.startkey)));
     }
-    var digest = attachment.digest;
-    var type = attachment.content_type;
 
-    txn.objectStore(ATTACH_STORE).get(digest).onsuccess = function (e) {
-      var body = e.target.result.body;
-      readBlobData(body, type, opts.encode, function (blobData) {
-        callback(null, blobData);
-      });
-    };
-  };
+    // If opts.endkey exists, add the endkey value to the list of parameters.
+    // If endkey is given then the returned list of docuemnts will
+    // end with the document whose id is endkey.
+    if (opts.endkey) {
+      params.push('endkey=' + encodeURIComponent(JSON.stringify(opts.endkey)));
+    }
 
-  api._info = function idb_info(callback) {
+    if (typeof opts.inclusive_end !== 'undefined') {
+      params.push('inclusive_end=' + !!opts.inclusive_end);
+    }
 
-    if (idb === null || !cachedDBs[dbName]) {
-      var error = new Error('db isn\'t open');
-      error.id = 'idbNull';
-      return callback(error);
+    // If opts.limit exists, add the limit value to the parameter list.
+    if (typeof opts.limit !== 'undefined') {
+      params.push('limit=' + opts.limit);
     }
-    var updateSeq;
-    var docCount;
 
-    var txnResult = openTransactionSafely(idb, [BY_SEQ_STORE], 'readonly');
-    if (txnResult.error) {
-      return callback(txnResult.error);
+    if (typeof opts.skip !== 'undefined') {
+      params.push('skip=' + opts.skip);
     }
-    var txn = txnResult.txn;
-    var cursor = txn.objectStore(BY_SEQ_STORE).openCursor(null, 'prev');
-    cursor.onsuccess = function (event) {
-      var cursor = event.target.result;
-      updateSeq = cursor ? cursor.key : 0;
-      // count within the same txn for consistency
-      docCount = api._meta.docCount;
-    };
 
-    txn.oncomplete = function () {
-      callback(null, {
-        doc_count: docCount,
-        update_seq: updateSeq,
-        // for debugging
-        idb_attachment_format: (api._meta.blobSupport ? 'binary' : 'base64')
-      });
-    };
-  };
+    // Format the list of parameters into a valid URI query string
+    params = params.join('&');
+    if (params !== '') {
+      params = '?' + params;
+    }
 
-  api._allDocs = function idb_allDocs(opts, callback) {
-    idbAllDocs(opts, api, idb, callback);
-  };
+    if (typeof opts.keys !== 'undefined') {
 
-  api._changes = function (opts) {
-    opts = utils.clone(opts);
 
-    if (opts.continuous) {
-      var id = dbName + ':' + utils.uuid();
-      IdbPouch.Changes.addListener(dbName, id, api, opts);
-      IdbPouch.Changes.notify(dbName);
-      return {
-        cancel: function () {
-          IdbPouch.Changes.removeListener(dbName, id);
-        }
-      };
+      var keysAsString =
+        'keys=' + encodeURIComponent(JSON.stringify(opts.keys));
+      if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {
+        // If the keys are short enough, do a GET. we do this to work around
+        // Safari not understanding 304s on POSTs (see issue #1239)
+        params += (params.indexOf('?') !== -1 ? '&' : '?') + keysAsString;
+      } else {
+        // If keys are too long, issue a POST request to circumvent GET
+        // query string limits
+        // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
+        method = 'POST';
+        body = JSON.stringify({keys: opts.keys});
+      }
     }
 
-    var docIds = opts.doc_ids && new utils.Set(opts.doc_ids);
-    var descending = opts.descending ? 'prev' : null;
+    // Get the document listing
+    ajax({
+      headers: host.headers,
+      method: method,
+      url: genDBUrl(host, '_all_docs' + params),
+      body: body
+    }, callback);
+  });
 
-    opts.since = opts.since || 0;
-    var lastSeq = opts.since;
+  // Get a list of changes made to documents in the database given by host.
+  // TODO According to the README, there should be two other methods here,
+  // api.changes.addListener and api.changes.removeListener.
+  api._changes = function (opts) {
+    // We internally page the results of a changes request, this means
+    // if there is a large set of changes to be returned we can start
+    // processing them quicker instead of waiting on the entire
+    // set of changes to return and attempting to process them at once
+    var batchSize = 'batch_size' in opts ? opts.batch_size : CHANGES_BATCH_SIZE;
 
-    var limit = 'limit' in opts ? opts.limit : -1;
+    opts = utils.clone(opts);
+    opts.timeout = opts.timeout || 30 * 1000;
+
+    // We give a 5 second buffer for CouchDB changes to respond with
+    // an ok timeout
+    var params = { timeout: opts.timeout - (5 * 1000) };
+    var limit = (typeof opts.limit !== 'undefined') ? opts.limit : false;
     if (limit === 0) {
-      limit = 1; // per CouchDB _changes spec
+      limit = 1;
     }
     var returnDocs;
     if ('returnDocs' in opts) {
@@ -190765,595 +192853,718 @@ function init(api, opts, callback) {
     } else {
       returnDocs = true;
     }
+    //
+    var leftToFetch = limit;
 
-    var results = [];
-    var numResults = 0;
-    var filter = utils.filterChange(opts);
-    var docIdsToMetadata = new utils.Map();
+    if (opts.style) {
+      params.style = opts.style;
+    }
 
-    var txn;
-    var bySeqStore;
-    var docStore;
+    if (opts.include_docs || opts.filter && typeof opts.filter === 'function') {
+      params.include_docs = true;
+    }
 
-    function onGetCursor(cursor) {
+    if (opts.attachments) {
+      params.attachments = true;
+    }
 
-      var doc = decodeDoc(cursor.value);
-      var seq = cursor.key;
+    if (opts.continuous) {
+      params.feed = 'longpoll';
+    }
 
-      if (docIds && !docIds.has(doc._id)) {
-        return cursor.continue();
-      }
+    if (opts.conflicts) {
+      params.conflicts = true;
+    }
 
-      var metadata;
+    if (opts.descending) {
+      params.descending = true;
+    }
 
-      function onGetMetadata() {
-        if (metadata.seq !== seq) {
-          // some other seq is later
-          return cursor.continue();
+    if (opts.filter && typeof opts.filter === 'string') {
+      params.filter = opts.filter;
+      if (opts.filter === '_view' &&
+          opts.view &&
+          typeof opts.view === 'string') {
+        params.view = opts.view;
+      }
+    }
+
+    // If opts.query_params exists, pass it through to the changes request.
+    // These parameters may be used by the filter on the source database.
+    if (opts.query_params && typeof opts.query_params === 'object') {
+      for (var param_name in opts.query_params) {
+        if (opts.query_params.hasOwnProperty(param_name)) {
+          params[param_name] = opts.query_params[param_name];
         }
+      }
+    }
 
-        lastSeq = seq;
+    var method = 'GET';
+    var body;
 
-        if (metadata.winningRev === doc._rev) {
-          return onGetWinningDoc(doc);
-        }
+    if (opts.doc_ids) {
+      // set this automagically for the user; it's annoying that couchdb
+      // requires both a "filter" and a "doc_ids" param.
+      params.filter = '_doc_ids';
 
-        fetchWinningDoc();
-      }
+      var docIdsJson = JSON.stringify(opts.doc_ids);
 
-      function fetchWinningDoc() {
-        var docIdRev = doc._id + '::' + metadata.winningRev;
-        var req = bySeqStore.index('_doc_id_rev').openCursor(
-          IDBKeyRange.bound(docIdRev, docIdRev + '\uffff'));
-        req.onsuccess = function (e) {
-          onGetWinningDoc(decodeDoc(e.target.result.value));
-        };
+      if (docIdsJson.length < MAX_URL_LENGTH) {
+        params.doc_ids = docIdsJson;
+      } else {
+        // anything greater than ~2000 is unsafe for gets, so
+        // use POST instead
+        method = 'POST';
+        body = {doc_ids: opts.doc_ids };
       }
+    }
 
-      function onGetWinningDoc(winningDoc) {
+    if (opts.continuous && api._useSSE) {
+      return  api.sse(opts, params, returnDocs);
+    }
+    var xhr;
+    var lastFetchedSeq;
 
-        var change = opts.processChange(winningDoc, metadata, opts);
-        change.seq = metadata.seq;
-        if (filter(change)) {
-          numResults++;
-          if (returnDocs) {
-            results.push(change);
-          }
-          // process the attachment immediately
-          // for the benefit of live listeners
-          if (opts.attachments && opts.include_docs) {
-            fetchAttachmentsIfNecessary(winningDoc, opts, txn, function () {
-              postProcessAttachments([change]).then(function () {
-                opts.onChange(change);
-              });
-            });
-          } else {
-            opts.onChange(change);
-          }
-        }
-        if (numResults !== limit) {
-          cursor.continue();
-        }
+    // Get all the changes starting wtih the one immediately after the
+    // sequence number given by since.
+    var fetch = function (since, callback) {
+      if (opts.aborted) {
+        return;
+      }
+      params.since = since;
+      if (typeof params.since === "object") {
+        params.since = JSON.stringify(params.since);
       }
 
-      metadata = docIdsToMetadata.get(doc._id);
-      if (metadata) { // cached
-        return onGetMetadata();
+      if (opts.descending) {
+        if (limit) {
+          params.limit = leftToFetch;
+        }
+      } else {
+        params.limit = (!limit || leftToFetch > batchSize) ?
+          batchSize : leftToFetch;
       }
-      // metadata not cached, have to go fetch it
-      docStore.get(doc._id).onsuccess = function (event) {
-        metadata = decodeMetadata(event.target.result);
-        docIdsToMetadata.set(doc._id, metadata);
-        onGetMetadata();
-      };
-    }
 
-    function onsuccess(event) {
-      var cursor = event.target.result;
+      var paramStr = '?' + Object.keys(params).map(function (k) {
+        return k + '=' + params[k];
+      }).join('&');
 
-      if (!cursor) {
+      // Set the options for the ajax call
+      var xhrOpts = {
+        headers: host.headers,
+        method: method,
+        url: genDBUrl(host, '_changes' + paramStr),
+        // _changes can take a long time to generate, especially when filtered
+        timeout: opts.timeout,
+        body: body
+      };
+      lastFetchedSeq = since;
+
+      if (opts.aborted) {
         return;
       }
-      onGetCursor(cursor);
-    }
 
-    function fetchChanges() {
-      var objectStores = [DOC_STORE, BY_SEQ_STORE];
-      if (opts.attachments) {
-        objectStores.push(ATTACH_STORE);
+      // Get the changes
+      xhr = ajax(xhrOpts, callback);
+    };
+
+    // If opts.since exists, get all the changes from the sequence
+    // number given by opts.since. Otherwise, get all the changes
+    // from the sequence number 0.
+    var fetchTimeout = 10;
+    var fetchRetryCount = 0;
+
+    var results = {results: []};
+
+    var fetched = function (err, res) {
+      if (opts.aborted) {
+        return;
       }
-      var txnResult = openTransactionSafely(idb, objectStores, 'readonly');
-      if (txnResult.error) {
-        return opts.complete(txnResult.error);
+      var raw_results_length = 0;
+      // If the result of the ajax call (res) contains changes (res.results)
+      if (res && res.results) {
+        raw_results_length = res.results.length;
+        results.last_seq = res.last_seq;
+        // For each change
+        var req = {};
+        req.query = opts.query_params;
+        res.results = res.results.filter(function (c) {
+          leftToFetch--;
+          var ret = utils.filterChange(opts)(c);
+          if (ret) {
+            if (returnDocs) {
+              results.results.push(c);
+            }
+            utils.call(opts.onChange, c);
+          }
+          return ret;
+        });
+      } else if (err) {
+        // In case of an error, stop listening for changes and call
+        // opts.complete
+        opts.aborted = true;
+        utils.call(opts.complete, err);
+        return;
       }
-      txn = txnResult.txn;
-      txn.onerror = idbError(opts.complete);
-      txn.oncomplete = onTxnComplete;
 
-      bySeqStore = txn.objectStore(BY_SEQ_STORE);
-      docStore = txn.objectStore(DOC_STORE);
+      // The changes feed may have timed out with no results
+      // if so reuse last update sequence
+      if (res && res.last_seq) {
+        lastFetchedSeq = res.last_seq;
+      }
 
-      var req;
+      var finished = (limit && leftToFetch <= 0) ||
+        (res && raw_results_length < batchSize) ||
+        (opts.descending);
 
-      if (descending) {
-        req = bySeqStore.openCursor(
+      if ((opts.continuous && !(limit && leftToFetch <= 0)) || !finished) {
+        // Increase retry delay exponentially as long as errors persist
+        if (err) {
+          fetchRetryCount += 1;
+        } else {
+          fetchRetryCount = 0;
+        }
+        var timeoutMultiplier = 1 << fetchRetryCount;
+        var retryWait = fetchTimeout * timeoutMultiplier;
+        var maximumWait = opts.maximumWait || 30000;
 
-          null, descending);
+        if (retryWait > maximumWait) {
+          utils.call(opts.complete, err || errors.error(errors.UNKNOWN_ERROR));
+          return;
+        }
+
+        // Queue a call to fetch again with the newest sequence number
+        setTimeout(function () { fetch(lastFetchedSeq, fetched); }, retryWait);
       } else {
-        req = bySeqStore.openCursor(
-          IDBKeyRange.lowerBound(opts.since, true));
+        // We're done, call the callback
+        utils.call(opts.complete, null, results);
       }
+    };
 
-      req.onsuccess = onsuccess;
-    }
-
-    fetchChanges();
-
-    function onTxnComplete() {
+    fetch(opts.since || 0, fetched);
 
-      function finish() {
-        opts.complete(null, {
-          results: results,
-          last_seq: lastSeq
-        });
+    // Return a method to cancel this method from processing any more
+    return {
+      cancel: function () {
+        opts.aborted = true;
+        if (xhr) {
+          xhr.abort();
+        }
       }
+    };
+  };
 
-      if (!opts.continuous && opts.attachments) {
-        // cannot guarantee that postProcessing was already done,
-        // so do it again
-        postProcessAttachments(results).then(finish);
-      } else {
-        finish();
+  api.sse = function (opts, params, returnDocs) {
+    params.feed = 'eventsource';
+    params.since = opts.since || 0;
+    params.limit = opts.limit;
+    delete params.timeout;
+    var paramStr = '?' + Object.keys(params).map(function (k) {
+      return k + '=' + params[k];
+    }).join('&');
+    var url = genDBUrl(host, '_changes' + paramStr);
+    var source = new EventSource(url);
+    var results = {
+      results: [],
+      last_seq: false
+    };
+    var dispatched = false;
+    var open = false;
+    source.addEventListener('message', msgHandler, false);
+    source.onopen = function () {
+      open = true;
+    };
+    source.onerror = errHandler;
+    return {
+      cancel: function () {
+        if (dispatched) {
+          return dispatched.cancel();
+        }
+        source.removeEventListener('message', msgHandler, false);
+        source.close();
+      }
+    };
+    function msgHandler(e) {
+      var data = JSON.parse(e.data);
+      if (returnDocs) {
+        results.results.push(data);
+      }
+      results.last_seq = data.seq;
+      utils.call(opts.onChange, data);
+    }
+    function errHandler(err) {
+      source.removeEventListener('message', msgHandler, false);
+      if (open === false) {
+        // errored before it opened
+        // likely doesn't support EventSource
+        api._useSSE = false;
+        dispatched = api._changes(opts);
+        return;
       }
+      source.close();
+      utils.call(opts.complete, err);
     }
+    
   };
 
-  api._close = function (callback) {
-    if (idb === null) {
-      return callback(errors.error(errors.NOT_OPEN));
+  api._useSSE = false;
+  // Currently disabled due to failing chrome tests in saucelabs
+  // api._useSSE = typeof global.EventSource === 'function';
+
+  // Given a set of document/revision IDs (given by req), tets the subset of
+  // those that do NOT correspond to revisions stored in the database.
+  // See http://wiki.apache.org/couchdb/HttpPostRevsDiff
+  api.revsDiff = utils.adapterFun('revsDiff', function (req, opts, callback) {
+    // If no options were given, set the callback to be the second parameter
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
     }
 
-    // https://developer.mozilla.org/en-US/docs/IndexedDB/IDBDatabase#close
-    // "Returns immediately and closes the connection in a separate thread..."
-    idb.close();
-    delete cachedDBs[dbName];
-    idb = null;
+    // Get the missing document/revision IDs
+    ajax({
+      headers: host.headers,
+      method: 'POST',
+      url: genDBUrl(host, '_revs_diff'),
+      body: JSON.stringify(req)
+    }, callback);
+  });
+
+  api._close = function (callback) {
     callback();
   };
 
-  api._getRevisionTree = function (docId, callback) {
-    var txnResult = openTransactionSafely(idb, [DOC_STORE], 'readonly');
-    if (txnResult.error) {
-      return callback(txnResult.error);
-    }
-    var txn = txnResult.txn;
-    var req = txn.objectStore(DOC_STORE).get(docId);
-    req.onsuccess = function (event) {
-      var doc = decodeMetadata(event.target.result);
-      if (!doc) {
-        callback(errors.error(errors.MISSING_DOC));
+  api._destroy = function (callback) {
+    ajax({
+      url: genDBUrl(host, ''),
+      method: 'DELETE',
+      headers: host.headers
+    }, function (err, resp) {
+      if (err) {
+        api.emit('error', err);
+        callback(err);
       } else {
-        callback(null, doc.rev_tree);
+        api.emit('destroyed');
+        api.constructor.emit('destroyed', opts.name);
+        callback(null, resp);
       }
-    };
+    });
   };
+}
 
-  // This function removes revisions of document docId
-  // which are listed in revs and sets this document
-  // revision to to rev_tree
-  api._doCompaction = function (docId, revs, callback) {
-    var stores = [
-      DOC_STORE,
-      BY_SEQ_STORE,
-      ATTACH_STORE,
-      ATTACH_AND_SEQ_STORE
-    ];
-    var txnResult = openTransactionSafely(idb, stores, 'readwrite');
-    if (txnResult.error) {
-      return callback(txnResult.error);
-    }
-    var txn = txnResult.txn;
+// HttpPouch is a valid adapter.
+HttpPouch.valid = function () {
+  return true;
+};
 
-    var docStore = txn.objectStore(DOC_STORE);
+module.exports = HttpPouch;
 
-    docStore.get(docId).onsuccess = function (event) {
-      var metadata = decodeMetadata(event.target.result);
-      merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
-                                                         revHash, ctx, opts) {
-        var rev = pos + '-' + revHash;
-        if (revs.indexOf(rev) !== -1) {
-          opts.status = 'missing';
-        }
-      });
-      compactRevs(revs, docId, txn);
-      var winningRev = metadata.winningRev;
-      var deleted = metadata.deleted;
-      txn.objectStore(DOC_STORE).put(
-        encodeMetadata(metadata, winningRev, deleted));
-    };
-    txn.onerror = idbError(callback);
-    txn.oncomplete = function () {
-      utils.call(callback);
-    };
-  };
+}).call(this,require('_process'))
+},{"../../deps/buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-all-docs.js":[function(require,module,exports){
+'use strict';
 
+var merge = require('../../merge');
+var errors = require('../../deps/errors');
+var idbUtils = require('./idb-utils');
+var idbConstants = require('./idb-constants');
 
-  api._getLocal = function (id, callback) {
-    var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readonly');
-    if (txnResult.error) {
-      return callback(txnResult.error);
-    }
-    var tx = txnResult.txn;
-    var req = tx.objectStore(LOCAL_STORE).get(id);
+var ATTACH_STORE = idbConstants.ATTACH_STORE;
+var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
+var DOC_STORE = idbConstants.DOC_STORE;
 
-    req.onerror = idbError(callback);
-    req.onsuccess = function (e) {
-      var doc = e.target.result;
-      if (!doc) {
-        callback(errors.error(errors.MISSING_DOC));
+var decodeDoc = idbUtils.decodeDoc;
+var decodeMetadata = idbUtils.decodeMetadata;
+var fetchAttachmentsIfNecessary = idbUtils.fetchAttachmentsIfNecessary;
+var postProcessAttachments = idbUtils.postProcessAttachments;
+var openTransactionSafely = idbUtils.openTransactionSafely;
+
+function createKeyRange(start, end, inclusiveEnd, key, descending) {
+  try {
+    if (start && end) {
+      if (descending) {
+        return IDBKeyRange.bound(end, start, !inclusiveEnd, false);
       } else {
-        delete doc['_doc_id_rev']; // for backwards compat
-        callback(null, doc);
+        return IDBKeyRange.bound(start, end, false, !inclusiveEnd);
       }
-    };
-  };
+    } else if (start) {
+      if (descending) {
+        return IDBKeyRange.upperBound(start);
+      } else {
+        return IDBKeyRange.lowerBound(start);
+      }
+    } else if (end) {
+      if (descending) {
+        return IDBKeyRange.lowerBound(end, !inclusiveEnd);
+      } else {
+        return IDBKeyRange.upperBound(end, !inclusiveEnd);
+      }
+    } else if (key) {
+      return IDBKeyRange.only(key);
+    }
+  } catch (e) {
+    return {error: e};
+  }
+  return null;
+}
 
-  api._putLocal = function (doc, opts, callback) {
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
+function handleKeyRangeError(api, opts, err, callback) {
+  if (err.name === "DataError" && err.code === 0) {
+    // data error, start is less than end
+    return callback(null, {
+      total_rows: api._meta.docCount,
+      offset: opts.skip,
+      rows: []
+    });
+  }
+  callback(errors.error(errors.IDB_ERROR, err.name, err.message));
+}
+
+function idbAllDocs(opts, api, idb, callback) {
+
+  function allDocsQuery(opts, callback) {
+    var start = 'startkey' in opts ? opts.startkey : false;
+    var end = 'endkey' in opts ? opts.endkey : false;
+    var key = 'key' in opts ? opts.key : false;
+    var skip = opts.skip || 0;
+    var limit = typeof opts.limit === 'number' ? opts.limit : -1;
+    var inclusiveEnd = opts.inclusive_end !== false;
+    var descending = 'descending' in opts && opts.descending ? 'prev' : null;
+
+    var keyRange = createKeyRange(start, end, inclusiveEnd, key, descending);
+    if (keyRange && keyRange.error) {
+      return handleKeyRangeError(api, opts, keyRange.error, callback);
     }
-    delete doc._revisions; // ignore this, trust the rev
-    var oldRev = doc._rev;
-    var id = doc._id;
-    if (!oldRev) {
-      doc._rev = '0-1';
-    } else {
-      doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+
+    var stores = [DOC_STORE, BY_SEQ_STORE];
+
+    if (opts.attachments) {
+      stores.push(ATTACH_STORE);
     }
+    var txnResult = openTransactionSafely(idb, stores, 'readonly');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    var txn = txnResult.txn;
+    var docStore = txn.objectStore(DOC_STORE);
+    var seqStore = txn.objectStore(BY_SEQ_STORE);
+    var cursor = descending ?
+      docStore.openCursor(keyRange, descending) :
+      docStore.openCursor(keyRange);
+    var docIdRevIndex = seqStore.index('_doc_id_rev');
+    var results = [];
+    var docCount = 0;
 
-    var tx = opts.ctx;
-    var ret;
-    if (!tx) {
-      var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');
-      if (txnResult.error) {
-        return callback(txnResult.error);
-      }
-      tx = txnResult.txn;
-      tx.onerror = idbError(callback);
-      tx.oncomplete = function () {
-        if (ret) {
-          callback(null, ret);
+    // if the user specifies include_docs=true, then we don't
+    // want to block the main cursor while we're fetching the doc
+    function fetchDocAsynchronously(metadata, row, winningRev) {
+      var key = metadata.id + "::" + winningRev;
+      docIdRevIndex.get(key).onsuccess =  function onGetDoc(e) {
+        row.doc = decodeDoc(e.target.result);
+        if (opts.conflicts) {
+          row.doc._conflicts = merge.collectConflicts(metadata);
         }
+        fetchAttachmentsIfNecessary(row.doc, opts, txn);
       };
     }
 
-    var oStore = tx.objectStore(LOCAL_STORE);
-    var req;
-    if (oldRev) {
-      req = oStore.get(id);
-      req.onsuccess = function (e) {
-        var oldDoc = e.target.result;
-        if (!oldDoc || oldDoc._rev !== oldRev) {
-          callback(errors.error(errors.REV_CONFLICT));
-        } else { // update
-          var req = oStore.put(doc);
-          req.onsuccess = function () {
-            ret = {ok: true, id: doc._id, rev: doc._rev};
-            if (opts.ctx) { // return immediately
-              callback(null, ret);
-            }
-          };
+    function allDocsInner(cursor, winningRev, metadata) {
+      var row = {
+        id: metadata.id,
+        key: metadata.id,
+        value: {
+          rev: winningRev
         }
       };
-    } else { // new doc
-      req = oStore.add(doc);
-      req.onerror = function (e) {
-        // constraint error, already exists
-        callback(errors.error(errors.REV_CONFLICT));
-        e.preventDefault(); // avoid transaction abort
-        e.stopPropagation(); // avoid transaction onerror
-      };
-      req.onsuccess = function () {
-        ret = {ok: true, id: doc._id, rev: doc._rev};
-        if (opts.ctx) { // return immediately
-          callback(null, ret);
+      var deleted = metadata.deleted;
+      if (opts.deleted === 'ok') {
+        results.push(row);
+        // deleted docs are okay with "keys" requests
+        if (deleted) {
+          row.value.deleted = true;
+          row.doc = null;
+        } else if (opts.include_docs) {
+          fetchDocAsynchronously(metadata, row, winningRev);
         }
-      };
-    }
-  };
-
-  api._removeLocal = function (doc, callback) {
-    var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');
-    if (txnResult.error) {
-      return callback(txnResult.error);
-    }
-    var tx = txnResult.txn;
-    var ret;
-    tx.oncomplete = function () {
-      if (ret) {
-        callback(null, ret);
-      }
-    };
-    var id = doc._id;
-    var oStore = tx.objectStore(LOCAL_STORE);
-    var req = oStore.get(id);
-
-    req.onerror = idbError(callback);
-    req.onsuccess = function (e) {
-      var oldDoc = e.target.result;
-      if (!oldDoc || oldDoc._rev !== doc._rev) {
-        callback(errors.error(errors.MISSING_DOC));
-      } else {
-        oStore.delete(id);
-        ret = {ok: true, id: id, rev: '0-0'};
-      }
-    };
-  };
-
-  api._destroy = function (callback) {
-    IdbPouch.Changes.removeAllListeners(dbName);
-
-    //Close open request for "dbName" database to fix ie delay.
-    if (IdbPouch.openReqList[dbName] && IdbPouch.openReqList[dbName].result) {
-      IdbPouch.openReqList[dbName].result.close();
-      delete cachedDBs[dbName];
+      } else if (!deleted && skip-- <= 0) {
+        results.push(row);
+        if (opts.include_docs) {
+          fetchDocAsynchronously(metadata, row, winningRev);
+        }
+        if (--limit === 0) {
+          return;
+        }
+      }
+      cursor.continue();
     }
-    var req = indexedDB.deleteDatabase(dbName);
 
-    req.onsuccess = function () {
-      //Remove open request from the list.
-      if (IdbPouch.openReqList[dbName]) {
-        IdbPouch.openReqList[dbName] = null;
-      }
-      if (utils.hasLocalStorage() && (dbName in localStorage)) {
-        delete localStorage[dbName];
+    function onGetCursor(e) {
+      docCount = api._meta.docCount; // do this within the txn for consistency
+      var cursor = e.target.result;
+      if (!cursor) {
+        return;
       }
-      callback(null, { 'ok': true });
-    };
-
-    req.onerror = idbError(callback);
-  };
-
-  var cached = cachedDBs[dbName];
-
-  if (cached) {
-    idb = cached.idb;
-    api._meta = cached.global;
-    process.nextTick(function () {
-      callback(null, api);
-    });
-    return;
-  }
-
-  var req = indexedDB.open(dbName, ADAPTER_VERSION);
-
-  if (!('openReqList' in IdbPouch)) {
-    IdbPouch.openReqList = {};
-  }
-  IdbPouch.openReqList[dbName] = req;
+      var metadata = decodeMetadata(cursor.value);
+      var winningRev = metadata.winningRev;
 
-  req.onupgradeneeded = function (e) {
-    var db = e.target.result;
-    if (e.oldVersion < 1) {
-      return createSchema(db); // new db, initial schema
+      allDocsInner(cursor, winningRev, metadata);
     }
-    // do migrations
-
-    var txn = e.currentTarget.transaction;
-    // these migrations have to be done in this function, before
-    // control is returned to the event loop, because IndexedDB
 
-    if (e.oldVersion < 3) {
-      createLocalStoreSchema(db); // v2 -> v3
-    }
-    if (e.oldVersion < 4) {
-      addAttachAndSeqStore(db); // v3 -> v4
+    function onResultsReady() {
+      callback(null, {
+        total_rows: docCount,
+        offset: opts.skip,
+        rows: results
+      });
     }
 
-    var migrations = [
-      addDeletedOrLocalIndex, // v1 -> v2
-      migrateLocalStore,      // v2 -> v3
-      migrateAttsAndSeqs,     // v3 -> v4
-      migrateMetadata         // v4 -> v5
-    ];
-
-    var i = e.oldVersion;
-
-    function next() {
-      var migration = migrations[i - 1];
-      i++;
-      if (migration) {
-        migration(txn, next);
+    function onTxnComplete() {
+      if (opts.attachments) {
+        postProcessAttachments(results).then(onResultsReady);
+      } else {
+        onResultsReady();
       }
     }
 
-    next();
-  };
-
-  req.onsuccess = function (e) {
+    txn.oncomplete = onTxnComplete;
+    cursor.onsuccess = onGetCursor;
+  }
 
-    idb = e.target.result;
+  function allDocs(opts, callback) {
 
-    idb.onversionchange = function () {
-      idb.close();
-      delete cachedDBs[dbName];
-    };
-    idb.onabort = function () {
-      idb.close();
-      delete cachedDBs[dbName];
-    };
+    if (opts.limit === 0) {
+      return callback(null, {
+        total_rows: api._meta.docCount,
+        offset: opts.skip,
+        rows: []
+      });
+    }
+    allDocsQuery(opts, callback);
+  }
 
-    var txn = idb.transaction([
-        META_STORE,
-        DETECT_BLOB_SUPPORT_STORE,
-        DOC_STORE
-      ], 'readwrite');
+  allDocs(opts, callback);
+}
 
-    var req = txn.objectStore(META_STORE).get(META_STORE);
+module.exports = idbAllDocs;
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-blob-support.js":[function(require,module,exports){
+'use strict';
 
-    var blobSupport = null;
-    var docCount = null;
-    var instanceId = null;
+var utils = require('../../utils');
+var idbConstants = require('./idb-constants');
+var DETECT_BLOB_SUPPORT_STORE = idbConstants.DETECT_BLOB_SUPPORT_STORE;
 
-    req.onsuccess = function (e) {
+//
+// Detect blob support. Chrome didn't support it until version 38.
+// In version 37 they had a broken version where PNGs (and possibly
+// other binary types) aren't stored correctly, because when you fetch
+// them, the content type is always null.
+//
+// Furthermore, they have some outstanding bugs where blobs occasionally
+// are read by FileReader as null, or by ajax as 404s.
+//
+// Sadly we use the 404 bug to detect the FileReader bug, so if they
+// get fixed independently and released in different versions of Chrome,
+// then the bug could come back. So it's worthwhile to watch these issues:
+// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916
+// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836
+//
+function checkBlobSupport(txn, idb) {
+  return new utils.Promise(function (resolve, reject) {
+    var blob = utils.createBlob([''], {type: 'image/png'});
+    txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');
+    txn.oncomplete = function () {
+      // have to do it in a separate transaction, else the correct
+      // content type is always returned
+      var blobTxn = idb.transaction([DETECT_BLOB_SUPPORT_STORE],
+        'readwrite');
+      var getBlobReq = blobTxn.objectStore(
+        DETECT_BLOB_SUPPORT_STORE).get('key');
+      getBlobReq.onerror = reject;
+      getBlobReq.onsuccess = function (e) {
 
-      var checkSetupComplete = function () {
-        if (blobSupport === null || docCount === null ||
-            instanceId === null) {
-          return;
-        } else {
-          api._meta = {
-            name: dbName,
-            instanceId: instanceId,
-            blobSupport: blobSupport,
-            docCount: docCount
-          };
+        var storedBlob = e.target.result;
+        var url = URL.createObjectURL(storedBlob);
 
-          cachedDBs[dbName] = {
-            idb: idb,
-            global: api._meta
-          };
-          callback(null, api);
-        }
+        utils.ajax({
+          url: url,
+          cache: true,
+          binary: true
+        }, function (err, res) {
+          if (err && err.status === 405) {
+            // firefox won't let us do that. but firefox doesn't
+            // have the blob type bug that Chrome does, so that's ok
+            resolve(true);
+          } else {
+            resolve(!!(res && res.type === 'image/png'));
+            if (err && err.status === 404) {
+              utils.explain404('PouchDB is just detecting blob URL support.');
+            }
+          }
+          URL.revokeObjectURL(url);
+        });
       };
+    };
+  }).catch(function () {
+    return false; // error, so assume unsupported
+  });
+}
 
-      //
-      // fetch/store the id
-      //
-
-      var meta = e.target.result || {id: META_STORE};
-      if (dbName  + '_id' in meta) {
-        instanceId = meta[dbName + '_id'];
-        checkSetupComplete();
-      } else {
-        instanceId = utils.uuid();
-        meta[dbName + '_id'] = instanceId;
-        txn.objectStore(META_STORE).put(meta).onsuccess = function () {
-          checkSetupComplete();
-        };
-      }
+module.exports = checkBlobSupport;
+},{"../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-bulk-docs.js":[function(require,module,exports){
+'use strict';
 
-      //
-      // check blob support
-      //
+var utils = require('../../utils');
+var errors = require('../../deps/errors');
+var idbUtils = require('./idb-utils');
+var idbConstants = require('./idb-constants');
 
-      if (!blobSupportPromise) {
-        // make sure blob support is only checked once
-        blobSupportPromise = checkBlobSupport(txn, idb);
-      }
+var ATTACH_AND_SEQ_STORE = idbConstants.ATTACH_AND_SEQ_STORE;
+var ATTACH_STORE = idbConstants.ATTACH_STORE;
+var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
+var DOC_STORE = idbConstants.DOC_STORE;
+var LOCAL_STORE = idbConstants.LOCAL_STORE;
+var META_STORE = idbConstants.META_STORE;
 
-      blobSupportPromise.then(function (val) {
-        blobSupport = val;
-        checkSetupComplete();
-      });
+var compactRevs = idbUtils.compactRevs;
+var decodeMetadata = idbUtils.decodeMetadata;
+var encodeMetadata = idbUtils.encodeMetadata;
+var idbError = idbUtils.idbError;
+var openTransactionSafely = idbUtils.openTransactionSafely;
 
-      //
-      // count docs
-      //
+function idbBulkDocs(req, opts, api, idb, Changes, callback) {
+  var docInfos = req.docs;
+  var txn;
+  var docStore;
+  var bySeqStore;
+  var attachStore;
+  var attachAndSeqStore;
+  var docInfoError;
+  var docCountDelta = 0;
 
-      var index = txn.objectStore(DOC_STORE).index('deletedOrLocal');
-      index.count(IDBKeyRange.only('0')).onsuccess = function (e) {
-        docCount = e.target.result;
-        checkSetupComplete();
-      };
+  for (var i = 0, len = docInfos.length; i < len; i++) {
+    var doc = docInfos[i];
+    if (doc._id && utils.isLocalId(doc._id)) {
+      continue;
+    }
+    doc = docInfos[i] = utils.parseDoc(doc, opts.new_edits);
+    if (doc.error && !docInfoError) {
+      docInfoError = doc;
+    }
+  }
 
-    };
-  };
+  if (docInfoError) {
+    return callback(docInfoError);
+  }
 
-  req.onerror = idbError(callback);
+  var results = new Array(docInfos.length);
+  var fetchedDocs = new utils.Map();
+  var preconditionErrored = false;
+  var blobType = api._meta.blobSupport ? 'blob' : 'base64';
 
-}
+  utils.preprocessAttachments(docInfos, blobType, function (err) {
+    if (err) {
+      return callback(err);
+    }
+    startTransaction();
+  });
 
-IdbPouch.valid = function () {
-  // Issue #2533, we finally gave up on doing bug
-  // detection instead of browser sniffing. Safari brought us
-  // to our knees.
-  var isSafari = typeof openDatabase !== 'undefined' &&
-    /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) &&
-    !/Chrome/.test(navigator.userAgent) &&
-    !/BlackBerry/.test(navigator.platform);
+  function startTransaction() {
 
-  // some outdated implementations of IDB that appear on Samsung
-  // and HTC Android devices <4.4 are missing IDBKeyRange
-  return !isSafari && typeof indexedDB !== 'undefined' &&
-    typeof IDBKeyRange !== 'undefined';
-};
+    var stores = [
+      DOC_STORE, BY_SEQ_STORE,
+      ATTACH_STORE, META_STORE,
+      LOCAL_STORE, ATTACH_AND_SEQ_STORE
+    ];
+    var txnResult = openTransactionSafely(idb, stores, 'readwrite');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    txn = txnResult.txn;
+    txn.onerror = idbError(callback);
+    txn.ontimeout = idbError(callback);
+    txn.oncomplete = complete;
+    docStore = txn.objectStore(DOC_STORE);
+    bySeqStore = txn.objectStore(BY_SEQ_STORE);
+    attachStore = txn.objectStore(ATTACH_STORE);
+    attachAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);
 
-IdbPouch.Changes = new utils.Changes();
+    verifyAttachments(function (err) {
+      if (err) {
+        preconditionErrored = true;
+        return callback(err);
+      }
+      fetchExistingDocs();
+    });
+  }
 
-module.exports = IdbPouch;
+  function processDocs() {
 
-}).call(this,require('_process'))
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-all-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-all-docs.js","./idb-blob-support":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-blob-support.js","./idb-bulk-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-bulk-docs.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-bulk-docs.js":[function(require,module,exports){
-'use strict';
+    utils.processDocs(docInfos, api, fetchedDocs, txn, results,
+      writeDoc, opts);
+  }
 
-var utils = require('../../utils');
-var errors = require('../../deps/errors');
+  function fetchExistingDocs() {
 
-var websqlUtils = require('./websql-utils');
-var websqlConstants = require('./websql-constants');
+    if (!docInfos.length) {
+      return;
+    }
 
-var DOC_STORE = websqlConstants.DOC_STORE;
-var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
-var ATTACH_STORE = websqlConstants.ATTACH_STORE;
-var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
+    var numFetched = 0;
 
-var select = websqlUtils.select;
-var stringifyDoc = websqlUtils.stringifyDoc;
-var compactRevs = websqlUtils.compactRevs;
-var unknownError = websqlUtils.unknownError;
+    function checkDone() {
+      if (++numFetched === docInfos.length) {
+        processDocs();
+      }
+    }
 
-function websqlBulkDocs(req, opts, api, db, Changes, callback) {
-  var newEdits = opts.new_edits;
-  var userDocs = req.docs;
+    function readMetadata(event) {
+      var metadata = decodeMetadata(event.target.result);
 
-  // Parse the docs, give them a sequence number for the result
-  var docInfos = userDocs.map(function (doc) {
-    if (doc._id && utils.isLocalId(doc._id)) {
-      return doc;
+      if (metadata) {
+        fetchedDocs.set(metadata.id, metadata);
+      }
+      checkDone();
     }
-    var newDoc = utils.parseDoc(doc, newEdits);
-    return newDoc;
-  });
 
-  var docInfoErrors = docInfos.filter(function (docInfo) {
-    return docInfo.error;
-  });
-  if (docInfoErrors.length) {
-    return callback(docInfoErrors[0]);
+    for (var i = 0, len = docInfos.length; i < len; i++) {
+      var docInfo = docInfos[i];
+      if (docInfo._id && utils.isLocalId(docInfo._id)) {
+        checkDone(); // skip local docs
+        continue;
+      }
+      var req = docStore.get(docInfo.metadata.id);
+      req.onsuccess = readMetadata;
+    }
   }
 
-  var tx;
-  var results = new Array(docInfos.length);
-  var fetchedDocs = new utils.Map();
-
-  var preconditionErrored;
   function complete() {
     if (preconditionErrored) {
-      return callback(preconditionErrored);
+      return;
     }
-    Changes.notify(api._name);
-    api._docCount = -1; // invalidate
+
+    Changes.notify(api._meta.name);
+    api._meta.docCount += docCountDelta;
     callback(null, results);
   }
 
   function verifyAttachment(digest, callback) {
-    var sql = 'SELECT count(*) as cnt FROM ' + ATTACH_STORE +
-      ' WHERE digest=?';
-    tx.executeSql(sql, [digest], function (tx, result) {
-      if (result.rows.item(0).cnt === 0) {
+
+    var req = attachStore.get(digest);
+    req.onsuccess = function (e) {
+      if (!e.target.result) {
         var err = errors.error(errors.MISSING_STUB,
           'unknown stub attachment with digest ' +
           digest);
+        err.status = 412;
         callback(err);
       } else {
         callback();
       }
-    });
+    };
   }
 
   function verifyAttachments(finish) {
+
+
     var digests = [];
     docInfos.forEach(function (docInfo) {
       if (docInfo.data && docInfo.data._attachments) {
@@ -191389,96 +193600,103 @@ function websqlBulkDocs(req, opts, api, db, Changes, callback) {
   function writeDoc(docInfo, winningRev, winningRevIsDeleted, newRevIsDeleted,
                     isUpdate, delta, resultsIdx, callback) {
 
-    function finish() {
-      var data = docInfo.data;
-      var deletedInt = newRevIsDeleted ? 1 : 0;
+    docCountDelta += delta;
 
-      var id = data._id;
-      var rev = data._rev;
-      var json = stringifyDoc(data);
-      var sql = 'INSERT INTO ' + BY_SEQ_STORE +
-        ' (doc_id, rev, json, deleted) VALUES (?, ?, ?, ?);';
-      var sqlArgs = [id, rev, json, deletedInt];
+    var doc = docInfo.data;
+    doc._id = docInfo.metadata.id;
+    doc._rev = docInfo.metadata.rev;
 
-      // map seqs to attachment digests, which
-      // we will need later during compaction
-      function insertAttachmentMappings(seq, callback) {
-        var attsAdded = 0;
-        var attsToAdd = Object.keys(data._attachments || {});
+    if (newRevIsDeleted) {
+      doc._deleted = true;
+    }
 
-        if (!attsToAdd.length) {
-          return callback();
-        }
-        function checkDone() {
-          if (++attsAdded === attsToAdd.length) {
-            callback();
-          }
-          return false; // ack handling a constraint error
-        }
-        function add(att) {
-          var sql = 'INSERT INTO ' + ATTACH_AND_SEQ_STORE +
-            ' (digest, seq) VALUES (?,?)';
-          var sqlArgs = [data._attachments[att].digest, seq];
-          tx.executeSql(sql, sqlArgs, checkDone, checkDone);
-          // second callback is for a constaint error, which we ignore
-          // because this docid/rev has already been associated with
-          // the digest (e.g. when new_edits == false)
-        }
-        for (var i = 0; i < attsToAdd.length; i++) {
-          add(attsToAdd[i]); // do in parallel
-        }
+    var hasAttachments = doc._attachments &&
+      Object.keys(doc._attachments).length;
+    if (hasAttachments) {
+      return writeAttachments(docInfo, winningRev, winningRevIsDeleted,
+        isUpdate, resultsIdx, callback);
+    }
+
+    finishDoc(docInfo, winningRev, winningRevIsDeleted,
+      isUpdate, resultsIdx, callback);
+  }
+
+  function autoCompact(docInfo) {
+
+    var revsToDelete = utils.compactTree(docInfo.metadata);
+    compactRevs(revsToDelete, docInfo.metadata.id, txn);
+  }
+
+  function finishDoc(docInfo, winningRev, winningRevIsDeleted,
+                     isUpdate, resultsIdx, callback) {
+
+    var doc = docInfo.data;
+    var metadata = docInfo.metadata;
+
+    doc._doc_id_rev = metadata.id + '::' + metadata.rev;
+    delete doc._id;
+    delete doc._rev;
+
+    function afterPutDoc(e) {
+      if (isUpdate && api.auto_compaction) {
+        autoCompact(docInfo);
       }
+      metadata.seq = e.target.result;
+      // Current _rev is calculated from _rev_tree on read
+      delete metadata.rev;
+      var metadataToStore = encodeMetadata(metadata, winningRev,
+        winningRevIsDeleted);
+      var metaDataReq = docStore.put(metadataToStore);
+      metaDataReq.onsuccess = afterPutMetadata;
+    }
 
-      tx.executeSql(sql, sqlArgs, function (tx, result) {
-        var seq = result.insertId;
-        insertAttachmentMappings(seq, function () {
-          dataWritten(tx, seq);
-        });
-      }, function () {
-        // constraint error, recover by updating instead (see #1638)
-        var fetchSql = select('seq', BY_SEQ_STORE, null,
-          'doc_id=? AND rev=?');
-        tx.executeSql(fetchSql, [id, rev], function (tx, res) {
-          var seq = res.rows.item(0).seq;
-          var sql = 'UPDATE ' + BY_SEQ_STORE +
-            ' SET json=?, deleted=? WHERE doc_id=? AND rev=?;';
-          var sqlArgs = [json, deletedInt, id, rev];
-          tx.executeSql(sql, sqlArgs, function (tx) {
-            insertAttachmentMappings(seq, function () {
-              dataWritten(tx, seq);
-            });
-          });
-        });
-        return false; // ack that we've handled the error
-      });
+    function afterPutDocError(e) {
+      // ConstraintError, need to update, not put (see #1638 for details)
+      e.preventDefault(); // avoid transaction abort
+      e.stopPropagation(); // avoid transaction onerror
+      var index = bySeqStore.index('_doc_id_rev');
+      var getKeyReq = index.getKey(doc._doc_id_rev);
+      getKeyReq.onsuccess = function (e) {
+        var putReq = bySeqStore.put(doc, e.target.result);
+        putReq.onsuccess = afterPutDoc;
+      };
     }
 
-    function collectResults(attachmentErr) {
-      if (!err) {
-        if (attachmentErr) {
-          err = attachmentErr;
-          callback(err);
-        } else if (recv === attachments.length) {
-          finish();
-        }
-      }
+    function afterPutMetadata() {
+      results[resultsIdx] = {
+        ok: true,
+        id: metadata.id,
+        rev: winningRev
+      };
+      fetchedDocs.set(docInfo.metadata.id, docInfo.metadata);
+      insertAttachmentMappings(docInfo, metadata.seq, callback);
     }
 
-    var err = null;
-    var recv = 0;
+    var putReq = bySeqStore.put(doc);
 
-    docInfo.data._id = docInfo.metadata.id;
-    docInfo.data._rev = docInfo.metadata.rev;
-    var attachments = Object.keys(docInfo.data._attachments || {});
+    putReq.onsuccess = afterPutDoc;
+    putReq.onerror = afterPutDocError;
+  }
 
+  function writeAttachments(docInfo, winningRev, winningRevIsDeleted,
+                            isUpdate, resultsIdx, callback) {
 
-    if (newRevIsDeleted) {
-      docInfo.data._deleted = true;
+
+    var doc = docInfo.data;
+
+    var numDone = 0;
+    var attachments = Object.keys(doc._attachments);
+
+    function collectResults() {
+      if (numDone === attachments.length) {
+        finishDoc(docInfo, winningRev, winningRevIsDeleted,
+          isUpdate, resultsIdx, callback);
+      }
     }
 
-    function attachmentSaved(err) {
-      recv++;
-      collectResults(err);
+    function attachmentSaved() {
+      numDone++;
+      collectResults();
     }
 
     attachments.forEach(function (key) {
@@ -191489,410 +193707,210 @@ function websqlBulkDocs(req, opts, api, db, Changes, callback) {
         var digest = att.digest;
         saveAttachment(digest, data, attachmentSaved);
       } else {
-        recv++;
+        numDone++;
         collectResults();
       }
     });
-
-    if (!attachments.length) {
-      finish();
-    }
-
-    function autoCompact() {
-      if (!isUpdate || !api.auto_compaction) {
-        return; // nothing to do
-      }
-      var id = docInfo.metadata.id;
-      var revsToDelete = utils.compactTree(docInfo.metadata);
-      compactRevs(revsToDelete, id, tx);
-    }
-
-    function dataWritten(tx, seq) {
-      autoCompact();
-      docInfo.metadata.seq = seq;
-      delete docInfo.metadata.rev;
-
-      var sql = isUpdate ?
-      'UPDATE ' + DOC_STORE +
-      ' SET json=?, max_seq=?, winningseq=' +
-      '(SELECT seq FROM ' + BY_SEQ_STORE +
-      ' WHERE doc_id=' + DOC_STORE + '.id AND rev=?) WHERE id=?'
-        : 'INSERT INTO ' + DOC_STORE +
-      ' (id, winningseq, max_seq, json) VALUES (?,?,?,?);';
-      var metadataStr = utils.safeJsonStringify(docInfo.metadata);
-      var id = docInfo.metadata.id;
-      var params = isUpdate ?
-        [metadataStr, seq, winningRev, id] :
-        [id, seq, seq, metadataStr];
-      tx.executeSql(sql, params, function () {
-        results[resultsIdx] = {
-          ok: true,
-          id: docInfo.metadata.id,
-          rev: winningRev
-        };
-        fetchedDocs.set(id, docInfo.metadata);
-        callback();
-      });
-    }
   }
 
-  function processDocs() {
-    utils.processDocs(docInfos, api, fetchedDocs,
-      tx, results, writeDoc, opts);
-  }
+  // map seqs to attachment digests, which
+  // we will need later during compaction
+  function insertAttachmentMappings(docInfo, seq, callback) {
 
-  function fetchExistingDocs(callback) {
-    if (!docInfos.length) {
+    var attsAdded = 0;
+    var attsToAdd = Object.keys(docInfo.data._attachments || {});
+
+    if (!attsToAdd.length) {
       return callback();
     }
 
-    var numFetched = 0;
-
     function checkDone() {
-      if (++numFetched === docInfos.length) {
+      if (++attsAdded === attsToAdd.length) {
         callback();
       }
     }
 
-    docInfos.forEach(function (docInfo) {
-      if (docInfo._id && utils.isLocalId(docInfo._id)) {
-        return checkDone(); // skip local docs
-      }
-      var id = docInfo.metadata.id;
-      tx.executeSql('SELECT json FROM ' + DOC_STORE +
-      ' WHERE id = ?', [id], function (tx, result) {
-        if (result.rows.length) {
-          var metadata = utils.safeJsonParse(result.rows.item(0).json);
-          fetchedDocs.set(id, metadata);
-        }
-        checkDone();
+    function add(att) {
+      var digest = docInfo.data._attachments[att].digest;
+      var req = attachAndSeqStore.put({
+        seq: seq,
+        digestSeq: digest + '::' + seq
       });
-    });
+
+      req.onsuccess = checkDone;
+      req.onerror = function (e) {
+        // this callback is for a constaint error, which we ignore
+        // because this docid/rev has already been associated with
+        // the digest (e.g. when new_edits == false)
+        e.preventDefault(); // avoid transaction abort
+        e.stopPropagation(); // avoid transaction onerror
+        checkDone();
+      };
+    }
+    for (var i = 0; i < attsToAdd.length; i++) {
+      add(attsToAdd[i]); // do in parallel
+    }
   }
 
   function saveAttachment(digest, data, callback) {
-    var sql = 'SELECT digest FROM ' + ATTACH_STORE + ' WHERE digest=?';
-    tx.executeSql(sql, [digest], function (tx, result) {
-      if (result.rows.length) { // attachment already exists
-        return callback();
+
+
+    var getKeyReq = attachStore.count(digest);
+    getKeyReq.onsuccess = function(e) {
+      var count = e.target.result;
+      if (count) {
+        return callback(); // already exists
       }
-      // we could just insert before selecting and catch the error,
-      // but my hunch is that it's cheaper not to serialize the blob
-      // from JS to C if we don't have to (TODO: confirm this)
-      sql = 'INSERT INTO ' + ATTACH_STORE +
-      ' (digest, body, escaped) VALUES (?,?,1)';
-      tx.executeSql(sql, [digest, websqlUtils.escapeBlob(data)], function () {
-        callback();
-      }, function () {
-        // ignore constaint errors, means it already exists
-        callback();
-        return false; // ack we handled the error
-      });
-    });
+      var newAtt = {
+        digest: digest,
+        body: data
+      };
+      var putReq = attachStore.put(newAtt);
+      putReq.onsuccess = callback;
+    };
   }
-
-  utils.preprocessAttachments(docInfos, 'binary', function (err) {
-    if (err) {
-      return callback(err);
-    }
-    db.transaction(function (txn) {
-      tx = txn;
-      verifyAttachments(function (err) {
-        if (err) {
-          preconditionErrored = err;
-        } else {
-          fetchExistingDocs(processDocs);
-        }
-      });
-    }, unknownError(callback), complete);
-  });
 }
 
-module.exports = websqlBulkDocs;
-
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js","./websql-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js":[function(require,module,exports){
+module.exports = idbBulkDocs;
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js":[function(require,module,exports){
 'use strict';
 
-function quote(str) {
-  return "'" + str + "'";
-}
-
-exports.ADAPTER_VERSION = 7; // used to manage migrations
+// IndexedDB requires a versioned database structure, so we use the
+// version here to manage migrations.
+exports.ADAPTER_VERSION = 5;
 
 // The object stores created for each database
 // DOC_STORE stores the document meta data, its revision history and state
-exports.DOC_STORE = quote('document-store');
+// Keyed by document id
+exports. DOC_STORE = 'document-store';
 // BY_SEQ_STORE stores a particular version of a document, keyed by its
 // sequence id
-exports.BY_SEQ_STORE = quote('by-sequence');
+exports.BY_SEQ_STORE = 'by-sequence';
 // Where we store attachments
-exports.ATTACH_STORE = quote('attach-store');
-exports.LOCAL_STORE = quote('local-store');
-exports.META_STORE = quote('metadata-store');
-// where we store many-to-many relations between attachment
-// digests and seqs
-exports.ATTACH_AND_SEQ_STORE = quote('attach-seq-store');
-
+exports.ATTACH_STORE = 'attach-store';
+// Where we store many-to-many relations
+// between attachment digests and seqs
+exports.ATTACH_AND_SEQ_STORE = 'attach-seq-store';
 
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js":[function(require,module,exports){
+// Where we store database-wide meta data in a single record
+// keyed by id: META_STORE
+exports.META_STORE = 'meta-store';
+// Where we store local documents
+exports.LOCAL_STORE = 'local-store';
+// Where we detect blob support
+exports.DETECT_BLOB_SUPPORT_STORE = 'detect-blob-support';
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js":[function(require,module,exports){
+(function (process){
 'use strict';
 
-var utils = require('../../utils');
 var errors = require('../../deps/errors');
+var utils = require('../../utils');
+var constants = require('./idb-constants');
 
-var websqlConstants = require('./websql-constants');
-
-var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
-var ATTACH_STORE = websqlConstants.ATTACH_STORE;
-var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
-
-// escapeBlob and unescapeBlob are workarounds for a websql bug:
-// https://code.google.com/p/chromium/issues/detail?id=422690
-// https://bugs.webkit.org/show_bug.cgi?id=137637
-// The goal is to never actually insert the \u0000 character
-// in the database.
-function escapeBlob(str) {
-  return str
-    .replace(/\u0002/g, '\u0002\u0002')
-    .replace(/\u0001/g, '\u0001\u0002')
-    .replace(/\u0000/g, '\u0001\u0001');
-}
-
-function unescapeBlob(str) {
-  return str
-    .replace(/\u0001\u0001/g, '\u0000')
-    .replace(/\u0001\u0002/g, '\u0001')
-    .replace(/\u0002\u0002/g, '\u0002');
-}
-
-function stringifyDoc(doc) {
-  // don't bother storing the id/rev. it uses lots of space,
-  // in persistent map/reduce especially
-  delete doc._id;
-  delete doc._rev;
-  return JSON.stringify(doc);
-}
-
-function unstringifyDoc(doc, id, rev) {
-  doc = JSON.parse(doc);
-  doc._id = id;
-  doc._rev = rev;
-  return doc;
-}
-
-// question mark groups IN queries, e.g. 3 -> '(?,?,?)'
-function qMarks(num) {
-  var s = '(';
-  while (num--) {
-    s += '?';
-    if (num) {
-      s += ',';
+function tryCode(fun, that, args) {
+  try {
+    fun.apply(that, args);
+  } catch (err) { // shouldn't happen
+    if (typeof PouchDB !== 'undefined') {
+      PouchDB.emit('error', err);
     }
   }
-  return s + ')';
-}
-
-function select(selector, table, joiner, where, orderBy) {
-  return 'SELECT ' + selector + ' FROM ' +
-    (typeof table === 'string' ? table : table.join(' JOIN ')) +
-    (joiner ? (' ON ' + joiner) : '') +
-    (where ? (' WHERE ' +
-    (typeof where === 'string' ? where : where.join(' AND '))) : '') +
-    (orderBy ? (' ORDER BY ' + orderBy) : '');
 }
 
-function compactRevs(revs, docId, tx) {
+exports.taskQueue = {
+  running: false,
+  queue: []
+};
 
-  if (!revs.length) {
+exports.applyNext = function () {
+  if (exports.taskQueue.running || !exports.taskQueue.queue.length) {
     return;
   }
-
-  var numDone = 0;
-  var seqs = [];
-
-  function checkDone() {
-    if (++numDone === revs.length) { // done
-      deleteOrphans();
-    }
-  }
-
-  function deleteOrphans() {
-    // find orphaned attachment digests
-
-    if (!seqs.length) {
-      return;
-    }
-
-    var sql = 'SELECT DISTINCT digest AS digest FROM ' +
-      ATTACH_AND_SEQ_STORE + ' WHERE seq IN ' + qMarks(seqs.length);
-
-    tx.executeSql(sql, seqs, function (tx, res) {
-
-      var digestsToCheck = [];
-      for (var i = 0; i < res.rows.length; i++) {
-        digestsToCheck.push(res.rows.item(i).digest);
-      }
-      if (!digestsToCheck.length) {
-        return;
-      }
-
-      var sql = 'DELETE FROM ' + ATTACH_AND_SEQ_STORE +
-        ' WHERE seq IN (' +
-        seqs.map(function () { return '?'; }).join(',') +
-        ')';
-      tx.executeSql(sql, seqs, function (tx) {
-
-        var sql = 'SELECT digest FROM ' + ATTACH_AND_SEQ_STORE +
-          ' WHERE digest IN (' +
-          digestsToCheck.map(function () { return '?'; }).join(',') +
-          ')';
-        tx.executeSql(sql, digestsToCheck, function (tx, res) {
-          var nonOrphanedDigests = new utils.Set();
-          for (var i = 0; i < res.rows.length; i++) {
-            nonOrphanedDigests.add(res.rows.item(i).digest);
-          }
-          digestsToCheck.forEach(function (digest) {
-            if (nonOrphanedDigests.has(digest)) {
-              return;
-            }
-            tx.executeSql(
-              'DELETE FROM ' + ATTACH_AND_SEQ_STORE + ' WHERE digest=?',
-              [digest]);
-            tx.executeSql(
-              'DELETE FROM ' + ATTACH_STORE + ' WHERE digest=?', [digest]);
-          });
-        });
-      });
-    });
-  }
-
-  // update by-seq and attach stores in parallel
-  revs.forEach(function (rev) {
-    var sql = 'SELECT seq FROM ' + BY_SEQ_STORE +
-      ' WHERE doc_id=? AND rev=?';
-
-    tx.executeSql(sql, [docId, rev], function (tx, res) {
-      if (!res.rows.length) { // already deleted
-        return checkDone();
-      }
-      var seq = res.rows.item(0).seq;
-      seqs.push(seq);
-
-      tx.executeSql(
-        'DELETE FROM ' + BY_SEQ_STORE + ' WHERE seq=?', [seq], checkDone);
-    });
+  exports.taskQueue.running = true;
+  var item = exports.taskQueue.queue.shift();
+  item.action(function (err, res) {
+    tryCode(item.callback, this, [err, res]);
+    exports.taskQueue.running = false;
+    process.nextTick(exports.applyNext);
   });
-}
+};
 
-function unknownError(callback) {
+exports.idbError = function (callback) {
   return function (event) {
-    // event may actually be a SQLError object, so report is as such
-    var errorNameMatch = event && event.constructor.toString()
-        .match(/function ([^\(]+)/);
-    var errorName = (errorNameMatch && errorNameMatch[1]) || event.type;
-    var errorReason = event.target || event.message;
-    callback(errors.error(errors.WSQ_ERROR, errorReason, errorName));
+    var message = (event.target && event.target.error &&
+      event.target.error.name) || event.target;
+    callback(errors.error(errors.IDB_ERROR, message, event.type));
   };
-}
-
-function getSize(opts) {
-  if ('size' in opts) {
-    // triggers immediate popup in iOS, fixes #2347
-    // e.g. 5000001 asks for 5 MB, 10000001 asks for 10 MB,
-    return opts.size * 1000000;
-  }
-  // In iOS, doesn't matter as long as it's <= 5000000.
-  // Except that if you request too much, our tests fail
-  // because of the native "do you accept?" popup.
-  // In Android <=4.3, this value is actually used as an
-  // honest-to-god ceiling for data, so we need to
-  // set it to a decently high number.
-  var isAndroid = /Android/.test(window.navigator.userAgent);
-  return isAndroid ? 5000000 : 1; // in PhantomJS, if you use 0 it will crash
-}
-
-function createOpenDBFunction() {
-  if (typeof sqlitePlugin !== 'undefined') {
-    // The SQLite Plugin started deviating pretty heavily from the
-    // standard openDatabase() function, as they started adding more features.
-    // It's better to just use their "new" format and pass in a big ol'
-    // options object.
-    return sqlitePlugin.openDatabase.bind(sqlitePlugin);
-  }
-
-  if (typeof openDatabase !== 'undefined') {
-    return function openDB(opts) {
-      // Traditional WebSQL API
-      return openDatabase(opts.name, opts.version, opts.description, opts.size);
-    };
-  }
-}
-
-var cachedDatabases = {};
-
-function openDB(opts) {
+};
 
-  var openDBFunction = createOpenDBFunction();
+// Unfortunately, the metadata has to be stringified
+// when it is put into the database, because otherwise
+// IndexedDB can throw errors for deeply-nested objects.
+// Originally we just used JSON.parse/JSON.stringify; now
+// we use this custom vuvuzela library that avoids recursion.
+// If we could do it all over again, we'd probably use a
+// format for the revision trees other than JSON.
+exports.encodeMetadata = function (metadata, winningRev, deleted) {
+  return {
+    data: utils.safeJsonStringify(metadata),
+    winningRev: winningRev,
+    deletedOrLocal: deleted ? '1' : '0',
+    seq: metadata.seq, // highest seq for this doc
+    id: metadata.id
+  };
+};
 
-  var db = cachedDatabases[opts.name];
-  if (!db) {
-    db = cachedDatabases[opts.name] = openDBFunction(opts);
-    db._sqlitePlugin = typeof sqlitePlugin !== 'undefined';
+exports.decodeMetadata = function (storedObject) {
+  if (!storedObject) {
+    return null;
   }
-  return db;
-}
-
-function valid() {
-  // SQLitePlugin leaks this global object, which we can use
-  // to detect if it's installed or not. The benefit is that it's
-  // declared immediately, before the 'deviceready' event has fired.
-  return typeof openDatabase !== 'undefined' ||
-    typeof SQLitePlugin !== 'undefined';
-}
-
-module.exports = {
-  escapeBlob: escapeBlob,
-  unescapeBlob: unescapeBlob,
-  stringifyDoc: stringifyDoc,
-  unstringifyDoc: unstringifyDoc,
-  qMarks: qMarks,
-  select: select,
-  compactRevs: compactRevs,
-  unknownError: unknownError,
-  getSize: getSize,
-  openDB: openDB,
-  valid: valid
+  var metadata = utils.safeJsonParse(storedObject.data);
+  metadata.winningRev = storedObject.winningRev;
+  metadata.deleted = storedObject.deletedOrLocal === '1';
+  metadata.seq = storedObject.seq;
+  return metadata;
 };
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql.js":[function(require,module,exports){
-'use strict';
 
-var utils = require('../../utils');
-var merge = require('../../merge');
-var errors = require('../../deps/errors');
-var parseHexString = require('../../deps/parse-hex');
-
-var websqlConstants = require('./websql-constants');
-var websqlUtils = require('./websql-utils');
-var websqlBulkDocs = require('./websql-bulk-docs');
-
-var ADAPTER_VERSION = websqlConstants.ADAPTER_VERSION;
-var DOC_STORE = websqlConstants.DOC_STORE;
-var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
-var ATTACH_STORE = websqlConstants.ATTACH_STORE;
-var LOCAL_STORE = websqlConstants.LOCAL_STORE;
-var META_STORE = websqlConstants.META_STORE;
-var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
+// read the doc back out from the database. we don't store the
+// _id or _rev because we already have _doc_id_rev.
+exports.decodeDoc = function (doc) {
+  if (!doc) {
+    return doc;
+  }
+  var idx = utils.lastIndexOf(doc._doc_id_rev, ':');
+  doc._id = doc._doc_id_rev.substring(0, idx - 1);
+  doc._rev = doc._doc_id_rev.substring(idx + 1);
+  delete doc._doc_id_rev;
+  return doc;
+};
 
-var qMarks = websqlUtils.qMarks;
-var stringifyDoc = websqlUtils.stringifyDoc;
-var unstringifyDoc = websqlUtils.unstringifyDoc;
-var select = websqlUtils.select;
-var compactRevs = websqlUtils.compactRevs;
-var unknownError = websqlUtils.unknownError;
-var getSize = websqlUtils.getSize;
-var openDB = websqlUtils.openDB;
+// Read a blob from the database, encoding as necessary
+// and translating from base64 if the IDB doesn't support
+// native Blobs
+exports.readBlobData = function (body, type, encode, callback) {
+  if (encode) {
+    if (!body) {
+      callback('');
+    } else if (typeof body !== 'string') { // we have blob support
+      utils.readAsBinaryString(body, function (binary) {
+        callback(utils.btoa(binary));
+      });
+    } else { // no blob support
+      callback(body);
+    }
+  } else {
+    if (!body) {
+      callback(utils.createBlob([''], {type: type}));
+    } else if (typeof body !== 'string') { // we have blob support
+      callback(body);
+    } else { // no blob support
+      body = utils.fixBinary(atob(body));
+      callback(utils.createBlob([body], {type: type}));
+    }
+  }
+};
 
-function fetchAttachmentsIfNecessary(doc, opts, api, txn, cb) {
+exports.fetchAttachmentsIfNecessary = function (doc, opts, txn, cb) {
   var attachments = Object.keys(doc._attachments || {});
   if (!attachments.length) {
     return cb && cb();
@@ -191907,14 +193925,12 @@ function fetchAttachmentsIfNecessary(doc, opts, api, txn, cb) {
 
   function fetchAttachment(doc, att) {
     var attObj = doc._attachments[att];
-    var attOpts = {encode: true, ctx: txn};
-    api._getAttachment(attObj, attOpts, function (_, base64) {
-      doc._attachments[att] = utils.extend(
-        utils.pick(attObj, ['digest', 'content_type']),
-        { data: base64 }
-      );
+    var digest = attObj.digest;
+    var req = txn.objectStore(constants.ATTACH_STORE).get(digest);
+    req.onsuccess = function (e) {
+      attObj.body = e.target.result.body;
       checkDone();
-    });
+    };
   }
 
   attachments.forEach(function (att) {
@@ -191925,5140 +193941,4406 @@ function fetchAttachmentsIfNecessary(doc, opts, api, txn, cb) {
       checkDone();
     }
   });
-}
+};
 
-var POUCH_VERSION = 1;
+// IDB-specific postprocessing necessary because
+// we don't know whether we stored a true Blob or
+// a base64-encoded string, and if it's a Blob it
+// needs to be read outside of the transaction context
+exports.postProcessAttachments = function (results) {
+  return utils.Promise.all(results.map(function (row) {
+    if (row.doc && row.doc._attachments) {
+      var attNames = Object.keys(row.doc._attachments);
+      return utils.Promise.all(attNames.map(function (att) {
+        var attObj = row.doc._attachments[att];
+        if (!('body' in attObj)) { // already processed
+          return;
+        }
+        var body = attObj.body;
+        var type = attObj.content_type;
+        return new utils.Promise(function (resolve) {
+          exports.readBlobData(body, type, true, function (base64) {
+            row.doc._attachments[att] = utils.extend(
+              utils.pick(attObj, ['digest', 'content_type']),
+              {data: base64}
+            );
+            resolve();
+          });
+        });
+      }));
+    }
+  }));
+};
 
-// these indexes cover the ground for most allDocs queries
-var BY_SEQ_STORE_DELETED_INDEX_SQL =
-  'CREATE INDEX IF NOT EXISTS \'by-seq-deleted-idx\' ON ' +
-  BY_SEQ_STORE + ' (seq, deleted)';
-var BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL =
-  'CREATE UNIQUE INDEX IF NOT EXISTS \'by-seq-doc-id-rev\' ON ' +
-    BY_SEQ_STORE + ' (doc_id, rev)';
-var DOC_STORE_WINNINGSEQ_INDEX_SQL =
-  'CREATE INDEX IF NOT EXISTS \'doc-winningseq-idx\' ON ' +
-  DOC_STORE + ' (winningseq)';
-var ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL =
-  'CREATE INDEX IF NOT EXISTS \'attach-seq-seq-idx\' ON ' +
-    ATTACH_AND_SEQ_STORE + ' (seq)';
-var ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL =
-  'CREATE UNIQUE INDEX IF NOT EXISTS \'attach-seq-digest-idx\' ON ' +
-    ATTACH_AND_SEQ_STORE + ' (digest, seq)';
+exports.compactRevs = function (revs, docId, txn) {
 
-var DOC_STORE_AND_BY_SEQ_JOINER = BY_SEQ_STORE +
-  '.seq = ' + DOC_STORE + '.winningseq';
+  var possiblyOrphanedDigests = [];
+  var seqStore = txn.objectStore(constants.BY_SEQ_STORE);
+  var attStore = txn.objectStore(constants.ATTACH_STORE);
+  var attAndSeqStore = txn.objectStore(constants.ATTACH_AND_SEQ_STORE);
+  var count = revs.length;
 
-var SELECT_DOCS = BY_SEQ_STORE + '.seq AS seq, ' +
-  BY_SEQ_STORE + '.deleted AS deleted, ' +
-  BY_SEQ_STORE + '.json AS data, ' +
-  BY_SEQ_STORE + '.rev AS rev, ' +
-  DOC_STORE + '.json AS metadata';
+  function checkDone() {
+    count--;
+    if (!count) { // done processing all revs
+      deleteOrphanedAttachments();
+    }
+  }
 
-function WebSqlPouch(opts, callback) {
-  var api = this;
-  var instanceId = null;
-  var size = getSize(opts);
-  var idRequests = [];
-  var encoding;
+  function deleteOrphanedAttachments() {
+    if (!possiblyOrphanedDigests.length) {
+      return;
+    }
+    possiblyOrphanedDigests.forEach(function (digest) {
+      var countReq = attAndSeqStore.index('digestSeq').count(
+        IDBKeyRange.bound(
+          digest + '::', digest + '::\uffff', false, false));
+      countReq.onsuccess = function (e) {
+        var count = e.target.result;
+        if (!count) {
+          // orphaned
+          attStore.delete(digest);
+        }
+      };
+    });
+  }
 
-  api._docCount = -1; // cache sqlite count(*) for performance
-  api._name = opts.name;
+  revs.forEach(function (rev) {
+    var index = seqStore.index('_doc_id_rev');
+    var key = docId + "::" + rev;
+    index.getKey(key).onsuccess = function (e) {
+      var seq = e.target.result;
+      if (typeof seq !== 'number') {
+        return checkDone();
+      }
+      seqStore.delete(seq);
 
-  var db = openDB({
-    name: api._name,
-    version: POUCH_VERSION,
-    description: api._name,
-    size: size,
-    location: opts.location,
-    createFromLocation: opts.createFromLocation
+      var cursor = attAndSeqStore.index('seq')
+        .openCursor(IDBKeyRange.only(seq));
+
+      cursor.onsuccess = function (event) {
+        var cursor = event.target.result;
+        if (cursor) {
+          var digest = cursor.value.digestSeq.split('::')[0];
+          possiblyOrphanedDigests.push(digest);
+          attAndSeqStore.delete(cursor.primaryKey);
+          cursor.continue();
+        } else { // done
+          checkDone();
+        }
+      };
+    };
   });
-  if (!db) {
-    return callback(errors.error(errors.UNKNOWN_ERROR));
-  } else if (typeof db.readTransaction !== 'function') {
-    // doesn't exist in sqlite plugin
-    db.readTransaction = db.transaction;
-  }
+};
 
-  function dbCreated() {
-    // note the db name in case the browser upgrades to idb
-    if (utils.hasLocalStorage()) {
-      window.localStorage['_pouch__websqldb_' + api._name] = true;
-    }
-    callback(null, api);
+exports.openTransactionSafely = function (idb, stores, mode) {
+  try {
+    return {
+      txn: idb.transaction(stores, mode)
+    };
+  } catch (err) {
+    return {
+      error: err
+    };
   }
+};
+}).call(this,require('_process'))
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb.js":[function(require,module,exports){
+(function (process){
+'use strict';
 
-  // In this migration, we added the 'deleted' and 'local' columns to the
-  // by-seq and doc store tables.
-  // To preserve existing user data, we re-process all the existing JSON
-  // and add these values.
-  // Called migration2 because it corresponds to adapter version (db_version) #2
-  function runMigration2(tx, callback) {
-    // index used for the join in the allDocs query
-    tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
-
-    tx.executeSql('ALTER TABLE ' + BY_SEQ_STORE +
-      ' ADD COLUMN deleted TINYINT(1) DEFAULT 0', [], function () {
-      tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
-      tx.executeSql('ALTER TABLE ' + DOC_STORE +
-        ' ADD COLUMN local TINYINT(1) DEFAULT 0', [], function () {
-        tx.executeSql('CREATE INDEX IF NOT EXISTS \'doc-store-local-idx\' ON ' +
-          DOC_STORE + ' (local, id)');
+var utils = require('../../utils');
+var merge = require('../../merge');
+var errors = require('../../deps/errors');
+var idbUtils = require('./idb-utils');
+var idbConstants = require('./idb-constants');
+var idbBulkDocs = require('./idb-bulk-docs');
+var idbAllDocs = require('./idb-all-docs');
+var checkBlobSupport = require('./idb-blob-support');
 
-        var sql = 'SELECT ' + DOC_STORE + '.winningseq AS seq, ' + DOC_STORE +
-          '.json AS metadata FROM ' + BY_SEQ_STORE + ' JOIN ' + DOC_STORE +
-          ' ON ' + BY_SEQ_STORE + '.seq = ' + DOC_STORE + '.winningseq';
+var ADAPTER_VERSION = idbConstants.ADAPTER_VERSION;
+var ATTACH_AND_SEQ_STORE = idbConstants.ATTACH_AND_SEQ_STORE;
+var ATTACH_STORE = idbConstants.ATTACH_STORE;
+var BY_SEQ_STORE = idbConstants.BY_SEQ_STORE;
+var DETECT_BLOB_SUPPORT_STORE = idbConstants.DETECT_BLOB_SUPPORT_STORE;
+var DOC_STORE = idbConstants.DOC_STORE;
+var LOCAL_STORE = idbConstants.LOCAL_STORE;
+var META_STORE = idbConstants.META_STORE;
 
-        tx.executeSql(sql, [], function (tx, result) {
+var applyNext = idbUtils.applyNext;
+var compactRevs = idbUtils.compactRevs;
+var decodeDoc = idbUtils.decodeDoc;
+var decodeMetadata = idbUtils.decodeMetadata;
+var encodeMetadata = idbUtils.encodeMetadata;
+var fetchAttachmentsIfNecessary = idbUtils.fetchAttachmentsIfNecessary;
+var idbError = idbUtils.idbError;
+var postProcessAttachments = idbUtils.postProcessAttachments;
+var readBlobData = idbUtils.readBlobData;
+var taskQueue = idbUtils.taskQueue;
+var openTransactionSafely = idbUtils.openTransactionSafely;
 
-          var deleted = [];
-          var local = [];
+var cachedDBs = {};
+var blobSupportPromise;
 
-          for (var i = 0; i < result.rows.length; i++) {
-            var item = result.rows.item(i);
-            var seq = item.seq;
-            var metadata = JSON.parse(item.metadata);
-            if (utils.isDeleted(metadata)) {
-              deleted.push(seq);
-            }
-            if (utils.isLocalId(metadata.id)) {
-              local.push(metadata.id);
-            }
-          }
-          tx.executeSql('UPDATE ' + DOC_STORE + 'SET local = 1 WHERE id IN ' +
-            qMarks(local.length), local, function () {
-            tx.executeSql('UPDATE ' + BY_SEQ_STORE +
-              ' SET deleted = 1 WHERE seq IN ' +
-              qMarks(deleted.length), deleted, callback);
-          });
-        });
-      });
-    });
-  }
+function IdbPouch(opts, callback) {
+  var api = this;
 
-  // in this migration, we make all the local docs unversioned
-  function runMigration3(tx, callback) {
-    var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
-      ' (id UNIQUE, rev, json)';
-    tx.executeSql(local, [], function () {
-      var sql = 'SELECT ' + DOC_STORE + '.id AS id, ' +
-        BY_SEQ_STORE + '.json AS data ' +
-        'FROM ' + BY_SEQ_STORE + ' JOIN ' +
-        DOC_STORE + ' ON ' + BY_SEQ_STORE + '.seq = ' +
-        DOC_STORE + '.winningseq WHERE local = 1';
-      tx.executeSql(sql, [], function (tx, res) {
-        var rows = [];
-        for (var i = 0; i < res.rows.length; i++) {
-          rows.push(res.rows.item(i));
-        }
-        function doNext() {
-          if (!rows.length) {
-            return callback(tx);
-          }
-          var row = rows.shift();
-          var rev = JSON.parse(row.data)._rev;
-          tx.executeSql('INSERT INTO ' + LOCAL_STORE +
-              ' (id, rev, json) VALUES (?,?,?)',
-              [row.id, rev, row.data], function (tx) {
-            tx.executeSql('DELETE FROM ' + DOC_STORE + ' WHERE id=?',
-                [row.id], function (tx) {
-              tx.executeSql('DELETE FROM ' + BY_SEQ_STORE + ' WHERE seq=?',
-                  [row.seq], function () {
-                doNext();
-              });
-            });
-          });
-        }
-        doNext();
-      });
-    });
-  }
+  taskQueue.queue.push({
+    action: function (thisCallback) {
+      init(api, opts, thisCallback);
+    },
+    callback: callback
+  });
+  applyNext();
+}
 
-  // in this migration, we remove doc_id_rev and just use rev
-  function runMigration4(tx, callback) {
+function init(api, opts, callback) {
 
-    function updateRows(rows) {
-      function doNext() {
-        if (!rows.length) {
-          return callback(tx);
-        }
-        var row = rows.shift();
-        var doc_id_rev = parseHexString(row.hex, encoding);
-        var idx = doc_id_rev.lastIndexOf('::');
-        var doc_id = doc_id_rev.substring(0, idx);
-        var rev = doc_id_rev.substring(idx + 2);
-        var sql = 'UPDATE ' + BY_SEQ_STORE +
-          ' SET doc_id=?, rev=? WHERE doc_id_rev=?';
-        tx.executeSql(sql, [doc_id, rev, doc_id_rev], function () {
-          doNext();
-        });
-      }
-      doNext();
-    }
+  var dbName = opts.name;
 
-    var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN doc_id';
-    tx.executeSql(sql, [], function (tx) {
-      var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN rev';
-      tx.executeSql(sql, [], function (tx) {
-        tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL, [], function (tx) {
-          var sql = 'SELECT hex(doc_id_rev) as hex FROM ' + BY_SEQ_STORE;
-          tx.executeSql(sql, [], function (tx, res) {
-            var rows = [];
-            for (var i = 0; i < res.rows.length; i++) {
-              rows.push(res.rows.item(i));
-            }
-            updateRows(rows);
-          });
-        });
-      });
-    });
-  }
+  var idb = null;
+  api._meta = null;
 
-  // in this migration, we add the attach_and_seq table
-  // for issue #2818
-  function runMigration5(tx, callback) {
+  // called when creating a fresh new database
+  function createSchema(db) {
+    var docStore = db.createObjectStore(DOC_STORE, {keyPath : 'id'});
+    db.createObjectStore(BY_SEQ_STORE, {autoIncrement: true})
+      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
+    db.createObjectStore(ATTACH_STORE, {keyPath: 'digest'});
+    db.createObjectStore(META_STORE, {keyPath: 'id', autoIncrement: false});
+    db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
 
-    function migrateAttsAndSeqs(tx) {
-      // need to actually populate the table. this is the expensive part,
-      // so as an optimization, check first that this database even
-      // contains attachments
-      var sql = 'SELECT COUNT(*) AS cnt FROM ' + ATTACH_STORE;
-      tx.executeSql(sql, [], function (tx, res) {
-        var count = res.rows.item(0).cnt;
-        if (!count) {
-          return callback(tx);
-        }
+    // added in v2
+    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});
 
-        var offset = 0;
-        var pageSize = 10;
-        function nextPage() {
-          var sql = select(
-            SELECT_DOCS + ', ' + DOC_STORE + '.id AS id',
-            [DOC_STORE, BY_SEQ_STORE],
-            DOC_STORE_AND_BY_SEQ_JOINER,
-            null,
-            DOC_STORE + '.id '
-          );
-          sql += ' LIMIT ' + pageSize + ' OFFSET ' + offset;
-          offset += pageSize;
-          tx.executeSql(sql, [], function (tx, res) {
-            if (!res.rows.length) {
-              return callback(tx);
-            }
-            var digestSeqs = {};
-            function addDigestSeq(digest, seq) {
-              // uniq digest/seq pairs, just in case there are dups
-              var seqs = digestSeqs[digest] = (digestSeqs[digest] || []);
-              if (seqs.indexOf(seq) === -1) {
-                seqs.push(seq);
-              }
-            }
-            for (var i = 0; i < res.rows.length; i++) {
-              var row = res.rows.item(i);
-              var doc = unstringifyDoc(row.data, row.id, row.rev);
-              var atts = Object.keys(doc._attachments || {});
-              for (var j = 0; j < atts.length; j++) {
-                var att = doc._attachments[atts[j]];
-                addDigestSeq(att.digest, row.seq);
-              }
-            }
-            var digestSeqPairs = [];
-            Object.keys(digestSeqs).forEach(function (digest) {
-              var seqs = digestSeqs[digest];
-              seqs.forEach(function (seq) {
-                digestSeqPairs.push([digest, seq]);
-              });
-            });
-            if (!digestSeqPairs.length) {
-              return nextPage();
-            }
-            var numDone = 0;
-            digestSeqPairs.forEach(function (pair) {
-              var sql = 'INSERT INTO ' + ATTACH_AND_SEQ_STORE +
-                ' (digest, seq) VALUES (?,?)';
-              tx.executeSql(sql, pair, function () {
-                if (++numDone === digestSeqPairs.length) {
-                  nextPage();
-                }
-              });
-            });
-          });
-        }
-        nextPage();
-      });
-    }
+    // added in v3
+    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'});
 
-    var attachAndRev = 'CREATE TABLE IF NOT EXISTS ' +
-      ATTACH_AND_SEQ_STORE + ' (digest, seq INTEGER)';
-    tx.executeSql(attachAndRev, [], function (tx) {
-      tx.executeSql(
-        ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL, [], function (tx) {
-          tx.executeSql(
-            ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL, [],
-            migrateAttsAndSeqs);
-        });
-    });
+    // added in v4
+    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,
+      {autoIncrement: true});
+    attAndSeqStore.createIndex('seq', 'seq');
+    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});
   }
 
-  // in this migration, we use escapeBlob() and unescapeBlob()
-  // instead of reading out the binary as HEX, which is slow
-  function runMigration6(tx, callback) {
-    var sql = 'ALTER TABLE ' + ATTACH_STORE +
-      ' ADD COLUMN escaped TINYINT(1) DEFAULT 0';
-    tx.executeSql(sql, [], callback);
+  // migration to version 2
+  // unfortunately "deletedOrLocal" is a misnomer now that we no longer
+  // store local docs in the main doc-store, but whaddyagonnado
+  function addDeletedOrLocalIndex(txn, callback) {
+    var docStore = txn.objectStore(DOC_STORE);
+    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});
+
+    docStore.openCursor().onsuccess = function (event) {
+      var cursor = event.target.result;
+      if (cursor) {
+        var metadata = cursor.value;
+        var deleted = utils.isDeleted(metadata);
+        metadata.deletedOrLocal = deleted ? "1" : "0";
+        docStore.put(metadata);
+        cursor.continue();
+      } else {
+        callback();
+      }
+    };
   }
 
-  // issue #3136, in this migration we need a "latest seq" as well
-  // as the "winning seq" in the doc store
-  function runMigration7(tx, callback) {
-    var sql = 'ALTER TABLE ' + DOC_STORE +
-      ' ADD COLUMN max_seq INTEGER';
-    tx.executeSql(sql, [], function (tx) {
-      var sql = 'UPDATE ' + DOC_STORE + ' SET max_seq=(SELECT MAX(seq) FROM ' +
-        BY_SEQ_STORE + ' WHERE doc_id=id)';
-      tx.executeSql(sql, [], function (tx) {
-        // add unique index after filling, else we'll get a constraint
-        // error when we do the ALTER TABLE
-        var sql =
-          'CREATE UNIQUE INDEX IF NOT EXISTS \'doc-max-seq-idx\' ON ' +
-          DOC_STORE + ' (max_seq)';
-        tx.executeSql(sql, [], callback);
-      });
-    });
+  // migration to version 3 (part 1)
+  function createLocalStoreSchema(db) {
+    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'})
+      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
   }
 
-  function checkEncoding(tx, cb) {
-    // UTF-8 on chrome/android, UTF-16 on safari < 7.1
-    tx.executeSql('SELECT HEX("a") AS hex', [], function (tx, res) {
-        var hex = res.rows.item(0).hex;
-        encoding = hex.length === 2 ? 'UTF-8' : 'UTF-16';
+  // migration to version 3 (part 2)
+  function migrateLocalStore(txn, cb) {
+    var localStore = txn.objectStore(LOCAL_STORE);
+    var docStore = txn.objectStore(DOC_STORE);
+    var seqStore = txn.objectStore(BY_SEQ_STORE);
+
+    var cursor = docStore.openCursor();
+    cursor.onsuccess = function (event) {
+      var cursor = event.target.result;
+      if (cursor) {
+        var metadata = cursor.value;
+        var docId = metadata.id;
+        var local = utils.isLocalId(docId);
+        var rev = merge.winningRev(metadata);
+        if (local) {
+          var docIdRev = docId + "::" + rev;
+          // remove all seq entries
+          // associated with this docId
+          var start = docId + "::";
+          var end = docId + "::~";
+          var index = seqStore.index('_doc_id_rev');
+          var range = IDBKeyRange.bound(start, end, false, false);
+          var seqCursor = index.openCursor(range);
+          seqCursor.onsuccess = function (e) {
+            seqCursor = e.target.result;
+            if (!seqCursor) {
+              // done
+              docStore.delete(cursor.primaryKey);
+              cursor.continue();
+            } else {
+              var data = seqCursor.value;
+              if (data._doc_id_rev === docIdRev) {
+                localStore.put(data);
+              }
+              seqStore.delete(seqCursor.primaryKey);
+              seqCursor.continue();
+            }
+          };
+        } else {
+          cursor.continue();
+        }
+      } else if (cb) {
         cb();
       }
-    );
+    };
   }
 
-  function onGetInstanceId() {
-    while (idRequests.length > 0) {
-      var idCallback = idRequests.pop();
-      idCallback(null, instanceId);
-    }
+  // migration to version 4 (part 1)
+  function addAttachAndSeqStore(db) {
+    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,
+      {autoIncrement: true});
+    attAndSeqStore.createIndex('seq', 'seq');
+    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});
   }
 
-  function onGetVersion(tx, dbVersion) {
-    if (dbVersion === 0) {
-      // initial schema
+  // migration to version 4 (part 2)
+  function migrateAttsAndSeqs(txn, callback) {
+    var seqStore = txn.objectStore(BY_SEQ_STORE);
+    var attStore = txn.objectStore(ATTACH_STORE);
+    var attAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);
 
-      var meta = 'CREATE TABLE IF NOT EXISTS ' + META_STORE +
-        ' (dbid, db_version INTEGER)';
-      var attach = 'CREATE TABLE IF NOT EXISTS ' + ATTACH_STORE +
-        ' (digest UNIQUE, escaped TINYINT(1), body BLOB)';
-      var attachAndRev = 'CREATE TABLE IF NOT EXISTS ' +
-        ATTACH_AND_SEQ_STORE + ' (digest, seq INTEGER)';
-      // TODO: migrate winningseq to INTEGER
-      var doc = 'CREATE TABLE IF NOT EXISTS ' + DOC_STORE +
-        ' (id unique, json, winningseq, max_seq INTEGER UNIQUE)';
-      var seq = 'CREATE TABLE IF NOT EXISTS ' + BY_SEQ_STORE +
-        ' (seq INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, ' +
-        'json, deleted TINYINT(1), doc_id, rev)';
-      var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
-        ' (id UNIQUE, rev, json)';
+    // need to actually populate the table. this is the expensive part,
+    // so as an optimization, check first that this database even
+    // contains attachments
+    var req = attStore.count();
+    req.onsuccess = function (e) {
+      var count = e.target.result;
+      if (!count) {
+        return callback(); // done
+      }
 
-      // creates
-      tx.executeSql(attach);
-      tx.executeSql(local);
-      tx.executeSql(attachAndRev, [], function () {
-        tx.executeSql(ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL);
-        tx.executeSql(ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL);
-      });
-      tx.executeSql(doc, [], function () {
-        tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
-        tx.executeSql(seq, [], function () {
-          tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
-          tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL);
-          tx.executeSql(meta, [], function () {
-            // mark the db version, and new dbid
-            var initSeq = 'INSERT INTO ' + META_STORE +
-              ' (db_version, dbid) VALUES (?,?)';
-            instanceId = utils.uuid();
-            var initSeqArgs = [ADAPTER_VERSION, instanceId];
-            tx.executeSql(initSeq, initSeqArgs, function () {
-              onGetInstanceId();
-            });
+      seqStore.openCursor().onsuccess = function (e) {
+        var cursor = e.target.result;
+        if (!cursor) {
+          return callback(); // done
+        }
+        var doc = cursor.value;
+        var seq = cursor.primaryKey;
+        var atts = Object.keys(doc._attachments || {});
+        var digestMap = {};
+        for (var j = 0; j < atts.length; j++) {
+          var att = doc._attachments[atts[j]];
+          digestMap[att.digest] = true; // uniq digests, just in case
+        }
+        var digests = Object.keys(digestMap);
+        for (j = 0; j < digests.length; j++) {
+          var digest = digests[j];
+          attAndSeqStore.put({
+            seq: seq,
+            digestSeq: digest + '::' + seq
           });
-        });
-      });
-    } else { // version > 0
-
-      var setupDone = function () {
-        var migrated = dbVersion < ADAPTER_VERSION;
-        if (migrated) {
-          // update the db version within this transaction
-          tx.executeSql('UPDATE ' + META_STORE + ' SET db_version = ' +
-            ADAPTER_VERSION);
         }
-        // notify db.id() callers
-        var sql = 'SELECT dbid FROM ' + META_STORE;
-        tx.executeSql(sql, [], function (tx, result) {
-          instanceId = result.rows.item(0).dbid;
-          onGetInstanceId();
-        });
+        cursor.continue();
       };
+    };
+  }
 
-      // would love to use promises here, but then websql
-      // ends the transaction early
-      var tasks = [
-        runMigration2,
-        runMigration3,
-        runMigration4,
-        runMigration5,
-        runMigration6,
-        runMigration7,
-        setupDone
-      ];
+  // migration to version 5
+  // Instead of relying on on-the-fly migration of metadata,
+  // this brings the doc-store to its modern form:
+  // - metadata.winningrev
+  // - metadata.seq
+  // - stringify the metadata when storing it
+  function migrateMetadata(txn) {
 
-      // run each migration sequentially
-      var i = dbVersion;
-      var nextMigration = function (tx) {
-        tasks[i - 1](tx, nextMigration);
-        i++;
-      };
-      nextMigration(tx);
+    function decodeMetadataCompat(storedObject) {
+      if (!storedObject.data) {
+        // old format, when we didn't store it stringified
+        storedObject.deleted = storedObject.deletedOrLocal === '1';
+        return storedObject;
+      }
+      return decodeMetadata(storedObject);
     }
-  }
 
-  function setup() {
-    db.transaction(function (tx) {
-      // first check the encoding
-      checkEncoding(tx, function () {
-        // then get the version
-        fetchVersion(tx);
-      });
-    }, unknownError(callback), dbCreated);
-  }
+    // ensure that every metadata has a winningRev and seq,
+    // which was previously created on-the-fly but better to migrate
+    var bySeqStore = txn.objectStore(BY_SEQ_STORE);
+    var docStore = txn.objectStore(DOC_STORE);
+    var cursor = docStore.openCursor();
+    cursor.onsuccess = function (e) {
+      var cursor = e.target.result;
+      if (!cursor) {
+        return; // done
+      }
+      var metadata = decodeMetadataCompat(cursor.value);
 
-  function fetchVersion(tx) {
-    var sql = 'SELECT sql FROM sqlite_master WHERE tbl_name = ' + META_STORE;
-    tx.executeSql(sql, [], function (tx, result) {
-      if (!result.rows.length) {
-        // database hasn't even been created yet (version 0)
-        onGetVersion(tx, 0);
-      } else if (!/db_version/.test(result.rows.item(0).sql)) {
-        // table was created, but without the new db_version column,
-        // so add it.
-        tx.executeSql('ALTER TABLE ' + META_STORE +
-          ' ADD COLUMN db_version INTEGER', [], function () {
-          // before version 2, this column didn't even exist
-          onGetVersion(tx, 1);
-        });
-      } else { // column exists, we can safely get it
-        tx.executeSql('SELECT db_version FROM ' + META_STORE,
-          [], function (tx, result) {
-          var dbVersion = result.rows.item(0).db_version;
-          onGetVersion(tx, dbVersion);
-        });
+      metadata.winningRev = metadata.winningRev || merge.winningRev(metadata);
+
+      function fetchMetadataSeq() {
+        // metadata.seq was added post-3.2.0, so if it's missing,
+        // we need to fetch it manually
+        var start = metadata.id + '::';
+        var end = metadata.id + '::\uffff';
+        var req = bySeqStore.index('_doc_id_rev').openCursor(
+          IDBKeyRange.bound(start, end));
+
+        var metadataSeq = 0;
+        req.onsuccess = function (e) {
+          var cursor = e.target.result;
+          if (!cursor) {
+            metadata.seq = metadataSeq;
+            return onGetMetadataSeq();
+          }
+          var seq = cursor.primaryKey;
+          if (seq > metadataSeq) {
+            metadataSeq = seq;
+          }
+          cursor.continue();
+        };
       }
-    });
-  }
 
-  if (utils.isCordova()) {
-    //to wait until custom api is made in pouch.adapters before doing setup
-    window.addEventListener(api._name + '_pouch', function cordova_init() {
-      window.removeEventListener(api._name + '_pouch', cordova_init, false);
-      setup();
-    }, false);
-  } else {
-    setup();
+      function onGetMetadataSeq() {
+        var metadataToStore = encodeMetadata(metadata,
+          metadata.winningRev, metadata.deleted);
+
+        var req = docStore.put(metadataToStore);
+        req.onsuccess = function () {
+          cursor.continue();
+        };
+      }
+
+      if (metadata.seq) {
+        return onGetMetadataSeq();
+      }
+
+      fetchMetadataSeq();
+    };
+
   }
 
   api.type = function () {
-    return 'websql';
+    return 'idb';
   };
 
   api._id = utils.toPromise(function (callback) {
-    callback(null, instanceId);
+    callback(null, api._meta.instanceId);
   });
 
-  api._info = function (callback) {
-    db.readTransaction(function (tx) {
-      countDocs(tx, function (docCount) {
-        var sql = 'SELECT MAX(seq) AS seq FROM ' + BY_SEQ_STORE;
-        tx.executeSql(sql, [], function (tx, res) {
-          var updateSeq = res.rows.item(0).seq || 0;
-          callback(null, {
-            doc_count: docCount,
-            update_seq: updateSeq,
-            // for debugging
-            sqlite_plugin: db._sqlitePlugin,
-            websql_encoding: encoding
-          });
-        });
-      });
-    }, unknownError(callback));
-  };
-
-  api._bulkDocs = function (req, opts, callback) {
-    websqlBulkDocs(req, opts, api, db, WebSqlPouch.Changes, callback);
+  api._bulkDocs = function idb_bulkDocs(req, opts, callback) {
+    idbBulkDocs(req, opts, api, idb, IdbPouch.Changes, callback);
   };
 
-  api._get = function (id, opts, callback) {
-    opts = utils.clone(opts);
+  // First we look up the metadata in the ids database, then we fetch the
+  // current revision(s) from the by sequence store
+  api._get = function idb_get(id, opts, callback) {
     var doc;
     var metadata;
     var err;
-    if (!opts.ctx) {
-      db.readTransaction(function (txn) {
-        opts.ctx = txn;
-        api._get(id, opts, callback);
-      });
-      return;
+    var txn;
+    opts = utils.clone(opts);
+    if (opts.ctx) {
+      txn = opts.ctx;
+    } else {
+      var txnResult = openTransactionSafely(idb,
+        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
+      if (txnResult.error) {
+        return callback(txnResult.error);
+      }
+      txn = txnResult.txn;
     }
-    var tx = opts.ctx;
 
     function finish() {
-      callback(err, {doc: doc, metadata: metadata, ctx: tx});
+      callback(err, {doc: doc, metadata: metadata, ctx: txn});
     }
 
-    var sql;
-    var sqlArgs;
-    if (opts.rev) {
-      sql = select(
-        SELECT_DOCS,
-        [DOC_STORE, BY_SEQ_STORE],
-        DOC_STORE + '.id=' + BY_SEQ_STORE + '.doc_id',
-        [BY_SEQ_STORE + '.doc_id=?', BY_SEQ_STORE + '.rev=?']);
-      sqlArgs = [id, opts.rev];
-    } else {
-      sql = select(
-        SELECT_DOCS,
-        [DOC_STORE, BY_SEQ_STORE],
-        DOC_STORE_AND_BY_SEQ_JOINER,
-        DOC_STORE + '.id=?');
-      sqlArgs = [id];
-    }
-    tx.executeSql(sql, sqlArgs, function (a, results) {
-      if (!results.rows.length) {
+    txn.objectStore(DOC_STORE).get(id).onsuccess = function (e) {
+      metadata = decodeMetadata(e.target.result);
+      // we can determine the result here if:
+      // 1. there is no such document
+      // 2. the document is deleted and we don't ask about specific rev
+      // When we ask with opts.rev we expect the answer to be either
+      // doc (possibly with _deleted=true) or missing error
+      if (!metadata) {
         err = errors.error(errors.MISSING_DOC, 'missing');
         return finish();
       }
-      var item = results.rows.item(0);
-      metadata = utils.safeJsonParse(item.metadata);
-      if (item.deleted && !opts.rev) {
-        err = errors.error(errors.MISSING_DOC, 'deleted');
+      if (utils.isDeleted(metadata) && !opts.rev) {
+        err = errors.error(errors.MISSING_DOC, "deleted");
         return finish();
       }
-      doc = unstringifyDoc(item.data, metadata.id, item.rev);
-      finish();
-    });
-  };
-
-  function countDocs(tx, callback) {
-
-    if (api._docCount !== -1) {
-      return callback(api._docCount);
-    }
-
-    // count the total rows
-    var sql = select(
-      'COUNT(' + DOC_STORE + '.id) AS \'num\'',
-      [DOC_STORE, BY_SEQ_STORE],
-      DOC_STORE_AND_BY_SEQ_JOINER,
-      BY_SEQ_STORE + '.deleted=0');
-
-    tx.executeSql(sql, [], function (tx, result) {
-      api._docCount = result.rows.item(0).num;
-      callback(api._docCount);
-    });
-  }
-
-  api._allDocs = function (opts, callback) {
-    var results = [];
-    var totalRows;
-
-    var start = 'startkey' in opts ? opts.startkey : false;
-    var end = 'endkey' in opts ? opts.endkey : false;
-    var key = 'key' in opts ? opts.key : false;
-    var descending = 'descending' in opts ? opts.descending : false;
-    var limit = 'limit' in opts ? opts.limit : -1;
-    var offset = 'skip' in opts ? opts.skip : 0;
-    var inclusiveEnd = opts.inclusive_end !== false;
+      var objectStore = txn.objectStore(BY_SEQ_STORE);
 
-    var sqlArgs = [];
-    var criteria = [];
+      var rev = opts.rev || metadata.winningRev;
+      var key = metadata.id + '::' + rev;
 
-    if (key !== false) {
-      criteria.push(DOC_STORE + '.id = ?');
-      sqlArgs.push(key);
-    } else if (start !== false || end !== false) {
-      if (start !== false) {
-        criteria.push(DOC_STORE + '.id ' + (descending ? '<=' : '>=') + ' ?');
-        sqlArgs.push(start);
-      }
-      if (end !== false) {
-        var comparator = descending ? '>' : '<';
-        if (inclusiveEnd) {
-          comparator += '=';
+      objectStore.index('_doc_id_rev').get(key).onsuccess = function (e) {
+        doc = e.target.result;
+        if (doc) {
+          doc = decodeDoc(doc);
         }
-        criteria.push(DOC_STORE + '.id ' + comparator + ' ?');
-        sqlArgs.push(end);
-      }
-      if (key !== false) {
-        criteria.push(DOC_STORE + '.id = ?');
-        sqlArgs.push(key);
-      }
-    }
+        if (!doc) {
+          err = errors.error(errors.MISSING_DOC, 'missing');
+          return finish();
+        }
+        finish();
+      };
+    };
+  };
 
-    if (opts.deleted !== 'ok') {
-      // report deleted if keys are specified
-      criteria.push(BY_SEQ_STORE + '.deleted = 0');
+  api._getAttachment = function (attachment, opts, callback) {
+    var txn;
+    opts = utils.clone(opts);
+    if (opts.ctx) {
+      txn = opts.ctx;
+    } else {
+      var txnResult = openTransactionSafely(idb,
+        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
+      if (txnResult.error) {
+        return callback(txnResult.error);
+      }
+      txn = txnResult.txn;
     }
+    var digest = attachment.digest;
+    var type = attachment.content_type;
 
-    db.readTransaction(function (tx) {
-
-      // first count up the total rows
-      countDocs(tx, function (count) {
-        totalRows = count;
+    txn.objectStore(ATTACH_STORE).get(digest).onsuccess = function (e) {
+      var body = e.target.result.body;
+      readBlobData(body, type, opts.encode, function (blobData) {
+        callback(null, blobData);
+      });
+    };
+  };
 
-        if (limit === 0) {
-          return;
-        }
+  api._info = function idb_info(callback) {
 
-        // then actually fetch the documents
-        var sql = select(
-          SELECT_DOCS,
-          [DOC_STORE, BY_SEQ_STORE],
-          DOC_STORE_AND_BY_SEQ_JOINER,
-          criteria,
-          DOC_STORE + '.id ' + (descending ? 'DESC' : 'ASC')
-          );
-        sql += ' LIMIT ' + limit + ' OFFSET ' + offset;
+    if (idb === null || !cachedDBs[dbName]) {
+      var error = new Error('db isn\'t open');
+      error.id = 'idbNull';
+      return callback(error);
+    }
+    var updateSeq;
+    var docCount;
 
-        tx.executeSql(sql, sqlArgs, function (tx, result) {
-          for (var i = 0, l = result.rows.length; i < l; i++) {
-            var item = result.rows.item(i);
-            var metadata = utils.safeJsonParse(item.metadata);
-            var id = metadata.id;
-            var data = unstringifyDoc(item.data, id, item.rev);
-            var winningRev = data._rev;
-            var doc = {
-              id: id,
-              key: id,
-              value: {rev: winningRev}
-            };
-            if (opts.include_docs) {
-              doc.doc = data;
-              doc.doc._rev = winningRev;
-              if (opts.conflicts) {
-                doc.doc._conflicts = merge.collectConflicts(metadata);
-              }
-              fetchAttachmentsIfNecessary(doc.doc, opts, api, tx);
-            }
-            if (item.deleted) {
-              if (opts.deleted === 'ok') {
-                doc.value.deleted = true;
-                doc.doc = null;
-              } else {
-                continue;
-              }
-            }
-            results.push(doc);
-          }
-        });
-      });
-    }, unknownError(callback), function () {
+    var txnResult = openTransactionSafely(idb, [BY_SEQ_STORE], 'readonly');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    var txn = txnResult.txn;
+    var cursor = txn.objectStore(BY_SEQ_STORE).openCursor(null, 'prev');
+    cursor.onsuccess = function (event) {
+      var cursor = event.target.result;
+      updateSeq = cursor ? cursor.key : 0;
+      // count within the same txn for consistency
+      docCount = api._meta.docCount;
+    };
+
+    txn.oncomplete = function () {
       callback(null, {
-        total_rows: totalRows,
-        offset: opts.skip,
-        rows: results
+        doc_count: docCount,
+        update_seq: updateSeq,
+        // for debugging
+        idb_attachment_format: (api._meta.blobSupport ? 'binary' : 'base64')
       });
-    });
+    };
+  };
+
+  api._allDocs = function idb_allDocs(opts, callback) {
+    idbAllDocs(opts, api, idb, callback);
   };
 
   api._changes = function (opts) {
     opts = utils.clone(opts);
 
     if (opts.continuous) {
-      var id = api._name + ':' + utils.uuid();
-      WebSqlPouch.Changes.addListener(api._name, id, api, opts);
-      WebSqlPouch.Changes.notify(api._name);
+      var id = dbName + ':' + utils.uuid();
+      IdbPouch.Changes.addListener(dbName, id, api, opts);
+      IdbPouch.Changes.notify(dbName);
       return {
         cancel: function () {
-          WebSqlPouch.Changes.removeListener(api._name, id);
+          IdbPouch.Changes.removeListener(dbName, id);
         }
       };
     }
 
-    var descending = opts.descending;
+    var docIds = opts.doc_ids && new utils.Set(opts.doc_ids);
+    var descending = opts.descending ? 'prev' : null;
 
-    // Ignore the `since` parameter when `descending` is true
-    opts.since = opts.since && !descending ? opts.since : 0;
+    opts.since = opts.since || 0;
+    var lastSeq = opts.since;
 
     var limit = 'limit' in opts ? opts.limit : -1;
     if (limit === 0) {
       limit = 1; // per CouchDB _changes spec
     }
-
     var returnDocs;
     if ('returnDocs' in opts) {
       returnDocs = opts.returnDocs;
     } else {
       returnDocs = true;
     }
+
     var results = [];
     var numResults = 0;
+    var filter = utils.filterChange(opts);
+    var docIdsToMetadata = new utils.Map();
 
-    function fetchChanges() {
-
-      var selectStmt =
-        DOC_STORE + '.json AS metadata, ' +
-        DOC_STORE + '.max_seq AS maxSeq, ' +
-        BY_SEQ_STORE + '.json AS winningDoc, ' +
-        BY_SEQ_STORE + '.rev AS winningRev ';
-
-      var from = DOC_STORE + ' JOIN ' + BY_SEQ_STORE;
-
-      var joiner = DOC_STORE + '.id=' + BY_SEQ_STORE + '.doc_id' +
-        ' AND ' + DOC_STORE + '.winningseq=' + BY_SEQ_STORE + '.seq';
-
-      var criteria = ['maxSeq > ?'];
-      var sqlArgs = [opts.since];
-
-      if (opts.doc_ids) {
-        criteria.push(DOC_STORE + '.id IN ' + qMarks(opts.doc_ids.length));
-        sqlArgs = sqlArgs.concat(opts.doc_ids);
-      }
+    var txn;
+    var bySeqStore;
+    var docStore;
 
-      var orderBy = 'maxSeq ' + (descending ? 'DESC' : 'ASC');
+    function onGetCursor(cursor) {
 
-      var sql = select(selectStmt, from, joiner, criteria, orderBy);
+      var doc = decodeDoc(cursor.value);
+      var seq = cursor.key;
 
-      var filter = utils.filterChange(opts);
-      if (!opts.view && !opts.filter) {
-        // we can just limit in the query
-        sql += ' LIMIT ' + limit;
+      if (docIds && !docIds.has(doc._id)) {
+        return cursor.continue();
       }
 
-      var lastSeq = opts.since || 0;
-      db.readTransaction(function (tx) {
-        tx.executeSql(sql, sqlArgs, function (tx, result) {
-          function reportChange(change) {
-            return function () {
-              opts.onChange(change);
-            };
-          }
-          for (var i = 0, l = result.rows.length; i < l; i++) {
-            var item = result.rows.item(i);
-            var metadata = utils.safeJsonParse(item.metadata);
-            lastSeq = item.maxSeq;
+      var metadata;
 
-            var doc = unstringifyDoc(item.winningDoc, metadata.id,
-              item.winningRev);
-            var change = opts.processChange(doc, metadata, opts);
-            change.seq = item.maxSeq;
-            if (filter(change)) {
-              numResults++;
-              if (returnDocs) {
-                results.push(change);
-              }
-              // process the attachment immediately
-              // for the benefit of live listeners
-              if (opts.attachments && opts.include_docs) {
-                fetchAttachmentsIfNecessary(doc, opts, api, tx,
-                  reportChange(change));
-              } else {
-                reportChange(change)();
-              }
-            }
-            if (numResults === limit) {
-              break;
-            }
-          }
-        });
-      }, unknownError(opts.complete), function () {
-        if (!opts.continuous) {
-          opts.complete(null, {
-            results: results,
-            last_seq: lastSeq
-          });
+      function onGetMetadata() {
+        if (metadata.seq !== seq) {
+          // some other seq is later
+          return cursor.continue();
         }
-      });
-    }
 
-    fetchChanges();
-  };
+        lastSeq = seq;
 
-  api._close = function (callback) {
-    //WebSQL databases do not need to be closed
-    callback();
-  };
+        if (metadata.winningRev === doc._rev) {
+          return onGetWinningDoc(doc);
+        }
 
-  api._getAttachment = function (attachment, opts, callback) {
-    var res;
-    var tx = opts.ctx;
-    var digest = attachment.digest;
-    var type = attachment.content_type;
-    var sql = 'SELECT escaped, ' +
-      'CASE WHEN escaped = 1 THEN body ELSE HEX(body) END AS body FROM ' +
-      ATTACH_STORE + ' WHERE digest=?';
-    tx.executeSql(sql, [digest], function (tx, result) {
-      // websql has a bug where \u0000 causes early truncation in strings
-      // and blobs. to work around this, we used to use the hex() function,
-      // but that's not performant. after migration 6, we remove \u0000
-      // and add it back in afterwards
-      var item = result.rows.item(0);
-      var data = item.escaped ? websqlUtils.unescapeBlob(item.body) :
-        parseHexString(item.body, encoding);
-      if (opts.encode) {
-        res = btoa(data);
-      } else {
-        data = utils.fixBinary(data);
-        res = utils.createBlob([data], {type: type});
+        fetchWinningDoc();
       }
-      callback(null, res);
-    });
-  };
 
-  api._getRevisionTree = function (docId, callback) {
-    db.readTransaction(function (tx) {
-      var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
-      tx.executeSql(sql, [docId], function (tx, result) {
-        if (!result.rows.length) {
-          callback(errors.error(errors.MISSING_DOC));
-        } else {
-          var data = utils.safeJsonParse(result.rows.item(0).metadata);
-          callback(null, data.rev_tree);
-        }
-      });
-    });
-  };
+      function fetchWinningDoc() {
+        var docIdRev = doc._id + '::' + metadata.winningRev;
+        var req = bySeqStore.index('_doc_id_rev').openCursor(
+          IDBKeyRange.bound(docIdRev, docIdRev + '\uffff'));
+        req.onsuccess = function (e) {
+          onGetWinningDoc(decodeDoc(e.target.result.value));
+        };
+      }
 
-  api._doCompaction = function (docId, revs, callback) {
-    if (!revs.length) {
-      return callback();
-    }
-    db.transaction(function (tx) {
+      function onGetWinningDoc(winningDoc) {
 
-      // update doc store
-      var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
-      tx.executeSql(sql, [docId], function (tx, result) {
-        var metadata = utils.safeJsonParse(result.rows.item(0).metadata);
-        merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
-                                                           revHash, ctx, opts) {
-          var rev = pos + '-' + revHash;
-          if (revs.indexOf(rev) !== -1) {
-            opts.status = 'missing';
+        var change = opts.processChange(winningDoc, metadata, opts);
+        change.seq = metadata.seq;
+        if (filter(change)) {
+          numResults++;
+          if (returnDocs) {
+            results.push(change);
           }
-        });
-
-        var sql = 'UPDATE ' + DOC_STORE + ' SET json = ? WHERE id = ?';
-        tx.executeSql(sql, [utils.safeJsonStringify(metadata), docId]);
-      });
-
-      compactRevs(revs, docId, tx);
-    }, unknownError(callback), function () {
-      callback();
-    });
-  };
-
-  api._getLocal = function (id, callback) {
-    db.readTransaction(function (tx) {
-      var sql = 'SELECT json, rev FROM ' + LOCAL_STORE + ' WHERE id=?';
-      tx.executeSql(sql, [id], function (tx, res) {
-        if (res.rows.length) {
-          var item = res.rows.item(0);
-          var doc = unstringifyDoc(item.json, id, item.rev);
-          callback(null, doc);
-        } else {
-          callback(errors.error(errors.MISSING_DOC));
-        }
-      });
-    });
-  };
-
-  api._putLocal = function (doc, opts, callback) {
-    if (typeof opts === 'function') {
-      callback = opts;
-      opts = {};
-    }
-    delete doc._revisions; // ignore this, trust the rev
-    var oldRev = doc._rev;
-    var id = doc._id;
-    var newRev;
-    if (!oldRev) {
-      newRev = doc._rev = '0-1';
-    } else {
-      newRev = doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
-    }
-    var json = stringifyDoc(doc);
-
-    var ret;
-    function putLocal(tx) {
-      var sql;
-      var values;
-      if (oldRev) {
-        sql = 'UPDATE ' + LOCAL_STORE + ' SET rev=?, json=? ' +
-          'WHERE id=? AND rev=?';
-        values = [newRev, json, id, oldRev];
-      } else {
-        sql = 'INSERT INTO ' + LOCAL_STORE + ' (id, rev, json) VALUES (?,?,?)';
-        values = [id, newRev, json];
-      }
-      tx.executeSql(sql, values, function (tx, res) {
-        if (res.rowsAffected) {
-          ret = {ok: true, id: id, rev: newRev};
-          if (opts.ctx) { // return immediately
-            callback(null, ret);
+          // process the attachment immediately
+          // for the benefit of live listeners
+          if (opts.attachments && opts.include_docs) {
+            fetchAttachmentsIfNecessary(winningDoc, opts, txn, function () {
+              postProcessAttachments([change]).then(function () {
+                opts.onChange(change);
+              });
+            });
+          } else {
+            opts.onChange(change);
           }
-        } else {
-          callback(errors.error(errors.REV_CONFLICT));
-        }
-      }, function () {
-        callback(errors.error(errors.REV_CONFLICT));
-        return false; // ack that we handled the error
-      });
-    }
-
-    if (opts.ctx) {
-      putLocal(opts.ctx);
-    } else {
-      db.transaction(function (tx) {
-        putLocal(tx);
-      }, unknownError(callback), function () {
-        if (ret) {
-          callback(null, ret);
         }
-      });
-    }
-  };
-
-  api._removeLocal = function (doc, callback) {
-    var ret;
-    db.transaction(function (tx) {
-      var sql = 'DELETE FROM ' + LOCAL_STORE + ' WHERE id=? AND rev=?';
-      var params = [doc._id, doc._rev];
-      tx.executeSql(sql, params, function (tx, res) {
-        if (!res.rowsAffected) {
-          return callback(errors.error(errors.MISSING_DOC));
+        if (numResults !== limit) {
+          cursor.continue();
         }
-        ret = {ok: true, id: doc._id, rev: '0-0'};
-      });
-    }, unknownError(callback), function () {
-      if (ret) {
-        callback(null, ret);
-      }
-    });
-  };
-
-  api._destroy = function (callback) {
-    WebSqlPouch.Changes.removeAllListeners(api._name);
-    db.transaction(function (tx) {
-      var stores = [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE, META_STORE,
-        LOCAL_STORE, ATTACH_AND_SEQ_STORE];
-      stores.forEach(function (store) {
-        tx.executeSql('DROP TABLE IF EXISTS ' + store, []);
-      });
-    }, unknownError(callback), function () {
-      if (utils.hasLocalStorage()) {
-        delete window.localStorage['_pouch__websqldb_' + api._name];
-        delete window.localStorage[api._name];
       }
-      callback(null, {'ok': true});
-    });
-  };
-}
-
-WebSqlPouch.valid = websqlUtils.valid;
-
-WebSqlPouch.Changes = new utils.Changes();
-
-module.exports = WebSqlPouch;
-
-},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../deps/parse-hex":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-hex.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-bulk-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-bulk-docs.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js","./websql-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/changes.js":[function(require,module,exports){
-'use strict';
-var utils = require('./utils');
-var merge = require('./merge');
-var errors = require('./deps/errors');
-var EE = require('events').EventEmitter;
-var evalFilter = require('./evalFilter');
-var evalView = require('./evalView');
-module.exports = Changes;
-utils.inherits(Changes, EE);
-
-function Changes(db, opts, callback) {
-  EE.call(this);
-  var self = this;
-  this.db = db;
-  opts = opts ? utils.clone(opts) : {};
-  var oldComplete = callback || opts.complete || function () {};
-  var complete = opts.complete = utils.once(function (err, resp) {
-    if (err) {
-      self.emit('error', err);
-    } else {
-      self.emit('complete', resp);
-    }
-    self.removeAllListeners();
-    db.removeListener('destroyed', onDestroy);
-  });
-  if (oldComplete) {
-    self.on('complete', function (resp) {
-      oldComplete(null, resp);
-    });
-    self.on('error', function (err) {
-      oldComplete(err);
-    });
-  }
-  var oldOnChange = opts.onChange;
-  if (oldOnChange) {
-    self.on('change', oldOnChange);
-  }
-  function onDestroy() {
-    self.cancel();
-  }
-  db.once('destroyed', onDestroy);
-
-  opts.onChange = function (change) {
-    if (opts.isCancelled) {
-      return;
-    }
-    self.emit('change', change);
-    if (self.startSeq && self.startSeq <= change.seq) {
-      self.emit('uptodate');
-      self.startSeq = false;
-    }
-    if (change.deleted) {
-      self.emit('delete', change);
-    } else if (change.changes.length === 1 &&
-      change.changes[0].rev.slice(0, 2) === '1-') {
-      self.emit('create', change);
-    } else {
-      self.emit('update', change);
-    }
-  };
 
-  var promise = new utils.Promise(function (fulfill, reject) {
-    opts.complete = function (err, res) {
-      if (err) {
-        reject(err);
-      } else {
-        fulfill(res);
+      metadata = docIdsToMetadata.get(doc._id);
+      if (metadata) { // cached
+        return onGetMetadata();
       }
-    };
-  });
-  self.once('cancel', function () {
-    if (oldOnChange) {
-      self.removeListener('change', oldOnChange);
+      // metadata not cached, have to go fetch it
+      docStore.get(doc._id).onsuccess = function (event) {
+        metadata = decodeMetadata(event.target.result);
+        docIdsToMetadata.set(doc._id, metadata);
+        onGetMetadata();
+      };
     }
-    opts.complete(null, {status: 'cancelled'});
-  });
-  this.then = promise.then.bind(promise);
-  this['catch'] = promise['catch'].bind(promise);
-  this.then(function (result) {
-    complete(null, result);
-  }, complete);
-
 
+    function onsuccess(event) {
+      var cursor = event.target.result;
 
-  if (!db.taskqueue.isReady) {
-    db.taskqueue.addTask(function () {
-      if (self.isCancelled) {
-        self.emit('cancel');
-      } else {
-        self.doChanges(opts);
+      if (!cursor) {
+        return;
       }
-    });
-  } else {
-    self.doChanges(opts);
-  }
-}
-Changes.prototype.cancel = function () {
-  this.isCancelled = true;
-  if (this.db.taskqueue.isReady) {
-    this.emit('cancel');
-  }
-};
-function processChange(doc, metadata, opts) {
-  var changeList = [{rev: doc._rev}];
-  if (opts.style === 'all_docs') {
-    changeList = merge.collectLeaves(metadata.rev_tree)
-    .map(function (x) { return {rev: x.rev}; });
-  }
-  var change = {
-    id: metadata.id,
-    changes: changeList,
-    doc: doc
-  };
-
-  if (utils.isDeleted(metadata, doc._rev)) {
-    change.deleted = true;
-  }
-  if (opts.conflicts) {
-    change.doc._conflicts = merge.collectConflicts(metadata);
-    if (!change.doc._conflicts.length) {
-      delete change.doc._conflicts;
+      onGetCursor(cursor);
     }
-  }
-  return change;
-}
-
-Changes.prototype.doChanges = function (opts) {
-  var self = this;
-  var callback = opts.complete;
-
-  opts = utils.clone(opts);
-  if ('live' in opts && !('continuous' in opts)) {
-    opts.continuous = opts.live;
-  }
-  opts.processChange = processChange;
 
-  if (opts.since === 'latest') {
-    opts.since = 'now';
-  }
-  if (!opts.since) {
-    opts.since = 0;
-  }
-  if (opts.since === 'now') {
-    this.db.info().then(function (info) {
-      if (self.isCancelled) {
-        callback(null, {status: 'cancelled'});
-        return;
+    function fetchChanges() {
+      var objectStores = [DOC_STORE, BY_SEQ_STORE];
+      if (opts.attachments) {
+        objectStores.push(ATTACH_STORE);
       }
-      opts.since = info.update_seq;
-      self.doChanges(opts);
-    }, callback);
-    return;
-  }
-
-  if (opts.continuous && opts.since !== 'now') {
-    this.db.info().then(function (info) {
-      self.startSeq = info.update_seq;
-    }, function (err) {
-      if (err.id === 'idbNull') {
-        //db closed before this returned
-        //thats ok
-        return;
+      var txnResult = openTransactionSafely(idb, objectStores, 'readonly');
+      if (txnResult.error) {
+        return opts.complete(txnResult.error);
       }
-      throw err;
-    });
-  }
+      txn = txnResult.txn;
+      txn.onerror = idbError(opts.complete);
+      txn.oncomplete = onTxnComplete;
 
-  if (this.db.type() !== 'http' &&
-      opts.filter && typeof opts.filter === 'string' &&
-      !opts.doc_ids) {
-    return this.filterChanges(opts);
-  }
+      bySeqStore = txn.objectStore(BY_SEQ_STORE);
+      docStore = txn.objectStore(DOC_STORE);
 
-  if (!('descending' in opts)) {
-    opts.descending = false;
-  }
+      var req;
 
-  // 0 and 1 should return 1 document
-  opts.limit = opts.limit === 0 ? 1 : opts.limit;
-  opts.complete = callback;
-  var newPromise = this.db._changes(opts);
-  if (newPromise && typeof newPromise.cancel === 'function') {
-    var cancel = self.cancel;
-    self.cancel = utils.getArguments(function (args) {
-      newPromise.cancel();
-      cancel.apply(this, args);
-    });
-  }
-};
+      if (descending) {
+        req = bySeqStore.openCursor(
 
-Changes.prototype.filterChanges = function (opts) {
-  var self = this;
-  var callback = opts.complete;
-  if (opts.filter === '_view') {
-    if (!opts.view || typeof opts.view !== 'string') {
-      var err = errors.error(errors.BAD_REQUEST,
-                             '`view` filter parameter is not provided.');
-      callback(err);
-      return;
-    }
-    // fetch a view from a design doc, make it behave like a filter
-    var viewName = opts.view.split('/');
-    this.db.get('_design/' + viewName[0], function (err, ddoc) {
-      if (self.isCancelled) {
-        callback(null, {status: 'cancelled'});
-        return;
-      }
-      if (err) {
-        callback(errors.generateErrorFromResponse(err));
-        return;
-      }
-      if (ddoc && ddoc.views && ddoc.views[viewName[1]]) {
-        
-        var filter = evalView(ddoc.views[viewName[1]].map);
-        opts.filter = filter;
-        self.doChanges(opts);
-        return;
-      }
-      var msg = ddoc.views ? 'missing json key: ' + viewName[1] :
-        'missing json key: views';
-      if (!err) {
-        err = errors.error(errors.MISSING_DOC, msg);
-      }
-      callback(err);
-      return;
-    });
-  } else {
-    // fetch a filter from a design doc
-    var filterName = opts.filter.split('/');
-    this.db.get('_design/' + filterName[0], function (err, ddoc) {
-      if (self.isCancelled) {
-        callback(null, {status: 'cancelled'});
-        return;
-      }
-      if (err) {
-        callback(errors.generateErrorFromResponse(err));
-        return;
-      }
-      if (ddoc && ddoc.filters && ddoc.filters[filterName[1]]) {
-        var filter = evalFilter(ddoc.filters[filterName[1]]);
-        opts.filter = filter;
-        self.doChanges(opts);
-        return;
+          null, descending);
       } else {
-        var msg = (ddoc && ddoc.filters) ? 'missing json key: ' + filterName[1]
-          : 'missing json key: filters';
-        if (!err) {
-          err = errors.error(errors.MISSING_DOC, msg);
-        }
-        callback(err);
-        return;
+        req = bySeqStore.openCursor(
+          IDBKeyRange.lowerBound(opts.since, true));
       }
-    });
-  }
-};
-},{"./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./evalFilter":"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalFilter.js","./evalView":"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalView.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/checkpointer.js":[function(require,module,exports){
-'use strict';
-
-var Promise = require('./deps/promise');
-var explain404 = require('./deps/explain404');
-var pouchCollate = require('pouchdb-collate');
-var collate = pouchCollate.collate;
 
-function updateCheckpoint(db, id, checkpoint, returnValue) {
-  return db.get(id).catch(function (err) {
-    if (err.status === 404) {
-      if (db.type() === 'http') {
-        explain404(
-          'PouchDB is just checking if a remote checkpoint exists.');
-      }
-      return {_id: id};
-    }
-    throw err;
-  }).then(function (doc) {
-    if (returnValue.cancelled) {
-      return;
+      req.onsuccess = onsuccess;
     }
-    doc.last_seq = checkpoint;
-    return db.put(doc).catch(function (err) {
-      if (err.status === 409) {
-        // retry; someone is trying to write a checkpoint simultaneously
-        return updateCheckpoint(db, id, checkpoint, returnValue);
-      }
-      throw err;
-    });
-  });
-}
 
-function Checkpointer(src, target, id, returnValue) {
-  this.src = src;
-  this.target = target;
-  this.id = id;
-  this.returnValue = returnValue;
-}
-
-Checkpointer.prototype.writeCheckpoint = function (checkpoint) {
-  var self = this;
-  return this.updateTarget(checkpoint).then(function () {
-    return self.updateSource(checkpoint);
-  });
-};
+    fetchChanges();
 
-Checkpointer.prototype.updateTarget = function (checkpoint) {
-  return updateCheckpoint(this.target, this.id, checkpoint, this.returnValue);
-};
+    function onTxnComplete() {
 
-Checkpointer.prototype.updateSource = function (checkpoint) {
-  var self = this;
-  if (this.readOnlySource) {
-    return Promise.resolve(true);
-  }
-  return updateCheckpoint(this.src, this.id, checkpoint, this.returnValue)
-    .catch(function (err) {
-      var isForbidden = typeof err.status === 'number' &&
-        Math.floor(err.status / 100) === 4;
-      if (isForbidden) {
-        self.readOnlySource = true;
-        return true;
+      function finish() {
+        opts.complete(null, {
+          results: results,
+          last_seq: lastSeq
+        });
       }
-      throw err;
-    });
-};
 
-Checkpointer.prototype.getCheckpoint = function () {
-  var self = this;
-  return self.target.get(self.id).then(function (targetDoc) {
-    return self.src.get(self.id).then(function (sourceDoc) {
-      if (collate(targetDoc.last_seq, sourceDoc.last_seq) === 0) {
-        return sourceDoc.last_seq;
-      }
-      return 0;
-    }, function (err) {
-      if (err.status === 404 && targetDoc.last_seq) {
-        return self.src.put({
-          _id: self.id,
-          last_seq: 0
-        }).then(function () {
-          return 0;
-        }, function (err) {
-          if (err.status === 401) {
-            self.readOnlySource = true;
-            return targetDoc.last_seq;
-          }
-          return 0;
-        });
+      if (!opts.continuous && opts.attachments) {
+        // cannot guarantee that postProcessing was already done,
+        // so do it again
+        postProcessAttachments(results).then(finish);
+      } else {
+        finish();
       }
-      throw err;
-    });
-  }).catch(function (err) {
-    if (err.status !== 404) {
-      throw err;
     }
-    return 0;
-  });
-};
-
-module.exports = Checkpointer;
-
-},{"./deps/explain404":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js","./deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js","pouchdb-collate":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collate/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/constructor.js":[function(require,module,exports){
-(function (process,global){
-/*globals cordova */
-"use strict";
-
-var Adapter = require('./adapter');
-var utils = require('./utils');
-var TaskQueue = require('./taskqueue');
-var Promise = utils.Promise;
-
-function defaultCallback(err) {
-  if (err && global.debug) {
-    console.error(err);
-  }
-}
+  };
 
-utils.inherits(PouchDB, Adapter);
-function PouchDB(name, opts, callback) {
+  api._close = function (callback) {
+    if (idb === null) {
+      return callback(errors.error(errors.NOT_OPEN));
+    }
 
-  if (!(this instanceof PouchDB)) {
-    return new PouchDB(name, opts, callback);
-  }
-  var self = this;
-  if (typeof opts === 'function' || typeof opts === 'undefined') {
-    callback = opts;
-    opts = {};
-  }
+    // https://developer.mozilla.org/en-US/docs/IndexedDB/IDBDatabase#close
+    // "Returns immediately and closes the connection in a separate thread..."
+    idb.close();
+    delete cachedDBs[dbName];
+    idb = null;
+    callback();
+  };
 
-  if (name && typeof name === 'object') {
-    opts = name;
-    name = undefined;
-  }
-  if (typeof callback === 'undefined') {
-    callback = defaultCallback;
-  }
-  name = name || opts.name;
-  opts = opts ? utils.clone(opts) : {};
-  // if name was specified via opts, ignore for the sake of dependentDbs
-  delete opts.name;
-  this.__opts = opts;
-  var oldCB = callback;
-  self.auto_compaction = opts.auto_compaction;
-  self.prefix = PouchDB.prefix;
-  Adapter.call(self);
-  self.taskqueue = new TaskQueue();
-  var promise = new Promise(function (fulfill, reject) {
-    callback = function (err, resp) {
-      if (err) {
-        return reject(err);
+  api._getRevisionTree = function (docId, callback) {
+    var txnResult = openTransactionSafely(idb, [DOC_STORE], 'readonly');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    var txn = txnResult.txn;
+    var req = txn.objectStore(DOC_STORE).get(docId);
+    req.onsuccess = function (event) {
+      var doc = decodeMetadata(event.target.result);
+      if (!doc) {
+        callback(errors.error(errors.MISSING_DOC));
+      } else {
+        callback(null, doc.rev_tree);
       }
-      delete resp.then;
-      fulfill(resp);
     };
-  
-    opts = utils.clone(opts);
-    var originalName = opts.name || name;
-    var backend, error;
-    (function () {
-      try {
-
-        if (typeof originalName !== 'string') {
-          error = new Error('Missing/invalid DB name');
-          error.code = 400;
-          throw error;
-        }
-
-        backend = PouchDB.parseAdapter(originalName, opts);
-        
-        opts.originalName = originalName;
-        opts.name = backend.name;
-        if (opts.prefix && backend.adapter !== 'http' &&
-            backend.adapter !== 'https') {
-          opts.name = opts.prefix + opts.name;
-        }
-        opts.adapter = opts.adapter || backend.adapter;
-        self._adapter = opts.adapter;
-        self._db_name = originalName;
-        if (!PouchDB.adapters[opts.adapter]) {
-          error = new Error('Adapter is missing');
-          error.code = 404;
-          throw error;
-        }
+  };
 
-        if (!PouchDB.adapters[opts.adapter].valid()) {
-          error = new Error('Invalid Adapter');
-          error.code = 404;
-          throw error;
-        }
-      } catch (err) {
-        self.taskqueue.fail(err);
-        self.changes = utils.toPromise(function (opts) {
-          if (opts.complete) {
-            opts.complete(err);
-          }
-        });
-      }
-    }());
-    if (error) {
-      return reject(error); // constructor error, see above
+  // This function removes revisions of document docId
+  // which are listed in revs and sets this document
+  // revision to to rev_tree
+  api._doCompaction = function (docId, revs, callback) {
+    var stores = [
+      DOC_STORE,
+      BY_SEQ_STORE,
+      ATTACH_STORE,
+      ATTACH_AND_SEQ_STORE
+    ];
+    var txnResult = openTransactionSafely(idb, stores, 'readwrite');
+    if (txnResult.error) {
+      return callback(txnResult.error);
     }
-    self.adapter = opts.adapter;
+    var txn = txnResult.txn;
 
-    // needs access to PouchDB;
-    self.replicate = {};
+    var docStore = txn.objectStore(DOC_STORE);
 
-    self.replicate.from = function (url, opts, callback) {
-      return self.constructor.replicate(url, self, opts, callback);
+    docStore.get(docId).onsuccess = function (event) {
+      var metadata = decodeMetadata(event.target.result);
+      merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
+                                                         revHash, ctx, opts) {
+        var rev = pos + '-' + revHash;
+        if (revs.indexOf(rev) !== -1) {
+          opts.status = 'missing';
+        }
+      });
+      compactRevs(revs, docId, txn);
+      var winningRev = metadata.winningRev;
+      var deleted = metadata.deleted;
+      txn.objectStore(DOC_STORE).put(
+        encodeMetadata(metadata, winningRev, deleted));
     };
-
-    self.replicate.to = function (url, opts, callback) {
-      return self.constructor.replicate(self, url, opts, callback);
+    txn.onerror = idbError(callback);
+    txn.oncomplete = function () {
+      utils.call(callback);
     };
+  };
 
-    self.sync = function (dbName, opts, callback) {
-      return self.constructor.sync(self, dbName, opts, callback);
-    };
 
-    self.replicate.sync = self.sync;
+  api._getLocal = function (id, callback) {
+    var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readonly');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    var tx = txnResult.txn;
+    var req = tx.objectStore(LOCAL_STORE).get(id);
 
-    PouchDB.adapters[opts.adapter].call(self, opts, function (err) {
-      if (err) {
-        if (callback) {
-          self.taskqueue.fail(err);
-          callback(err);
-        }
-        return;
-      }
-      function destructionListener() {
-        PouchDB.emit('destroyed', opts.originalName);
-        //so we don't have to sift through all dbnames
-        PouchDB.emit(opts.originalName, 'destroyed');
-        self.removeListener('destroyed', destructionListener);
+    req.onerror = idbError(callback);
+    req.onsuccess = function (e) {
+      var doc = e.target.result;
+      if (!doc) {
+        callback(errors.error(errors.MISSING_DOC));
+      } else {
+        delete doc['_doc_id_rev']; // for backwards compat
+        callback(null, doc);
       }
-      self.on('destroyed', destructionListener);
-      self.emit('created', self);
-      PouchDB.emit('created', opts.originalName);
-      self.taskqueue.ready(self);
-      callback(null, self);
-    });
+    };
+  };
 
-    if (opts.skipSetup) {
-      self.taskqueue.ready(self);
-      process.nextTick(function () {
-        callback(null, self);
-      });
+  api._putLocal = function (doc, opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
     }
-
-    if (utils.isCordova()) {
-      //to inform websql adapter that we can use api
-      cordova.fireWindowEvent(opts.name + "_pouch", {});
+    delete doc._revisions; // ignore this, trust the rev
+    var oldRev = doc._rev;
+    var id = doc._id;
+    if (!oldRev) {
+      doc._rev = '0-1';
+    } else {
+      doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
     }
-  });
-  promise.then(function (resp) {
-    oldCB(null, resp);
-  }, oldCB);
-  self.then = promise.then.bind(promise);
-  self.catch = promise.catch.bind(promise);
-}
-
-PouchDB.debug = require('debug');
-
-module.exports = PouchDB;
-
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./adapter":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapter.js","./taskqueue":"/Users/richard/src/beagle/node_modules/pouchdb/lib/taskqueue.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js":[function(require,module,exports){
-(function (process){
-"use strict";
-
-var request = require('request');
-
-var buffer = require('./buffer');
-var errors = require('./errors');
-var utils = require('../utils');
-
-function ajax(options, adapterCallback) {
 
-  var requestCompleted = false;
-  var callback = utils.getArguments(function (args) {
-    if (requestCompleted) {
-      return;
+    var tx = opts.ctx;
+    var ret;
+    if (!tx) {
+      var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');
+      if (txnResult.error) {
+        return callback(txnResult.error);
+      }
+      tx = txnResult.txn;
+      tx.onerror = idbError(callback);
+      tx.oncomplete = function () {
+        if (ret) {
+          callback(null, ret);
+        }
+      };
     }
-    adapterCallback.apply(this, args);
-    requestCompleted = true;
-  });
-
-  if (typeof options === "function") {
-    callback = options;
-    options = {};
-  }
-
-  options = utils.clone(options);
 
-  var defaultOptions = {
-    method : "GET",
-    headers: {},
-    json: true,
-    processData: true,
-    timeout: 10000,
-    cache: false
+    var oStore = tx.objectStore(LOCAL_STORE);
+    var req;
+    if (oldRev) {
+      req = oStore.get(id);
+      req.onsuccess = function (e) {
+        var oldDoc = e.target.result;
+        if (!oldDoc || oldDoc._rev !== oldRev) {
+          callback(errors.error(errors.REV_CONFLICT));
+        } else { // update
+          var req = oStore.put(doc);
+          req.onsuccess = function () {
+            ret = {ok: true, id: doc._id, rev: doc._rev};
+            if (opts.ctx) { // return immediately
+              callback(null, ret);
+            }
+          };
+        }
+      };
+    } else { // new doc
+      req = oStore.add(doc);
+      req.onerror = function (e) {
+        // constraint error, already exists
+        callback(errors.error(errors.REV_CONFLICT));
+        e.preventDefault(); // avoid transaction abort
+        e.stopPropagation(); // avoid transaction onerror
+      };
+      req.onsuccess = function () {
+        ret = {ok: true, id: doc._id, rev: doc._rev};
+        if (opts.ctx) { // return immediately
+          callback(null, ret);
+        }
+      };
+    }
   };
 
-  options = utils.extend(true, defaultOptions, options);
-
+  api._removeLocal = function (doc, callback) {
+    var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');
+    if (txnResult.error) {
+      return callback(txnResult.error);
+    }
+    var tx = txnResult.txn;
+    var ret;
+    tx.oncomplete = function () {
+      if (ret) {
+        callback(null, ret);
+      }
+    };
+    var id = doc._id;
+    var oStore = tx.objectStore(LOCAL_STORE);
+    var req = oStore.get(id);
 
-  function onSuccess(obj, resp, cb) {
-    if (!options.binary && !options.json && options.processData &&
-      typeof obj !== 'string') {
-      obj = JSON.stringify(obj);
-    } else if (!options.binary && options.json && typeof obj === 'string') {
-      try {
-        obj = JSON.parse(obj);
-      } catch (e) {
-        // Probably a malformed JSON from server
-        return cb(e);
+    req.onerror = idbError(callback);
+    req.onsuccess = function (e) {
+      var oldDoc = e.target.result;
+      if (!oldDoc || oldDoc._rev !== doc._rev) {
+        callback(errors.error(errors.MISSING_DOC));
+      } else {
+        oStore.delete(id);
+        ret = {ok: true, id: id, rev: '0-0'};
       }
-    }
-    if (Array.isArray(obj)) {
-      obj = obj.map(function (v) {
-        if (v.error || v.missing) {
-          return errors.generateErrorFromResponse(v);
-        } else {
-          return v;
-        }
-      });
-    }
-    cb(null, obj, resp);
-  }
+    };
+  };
 
-  function onError(err, cb) {
-    var errParsed, errObj;
-    if (err.code && err.status) {
-      var err2 = new Error(err.message || err.code);
-      err2.status = err.status;
-      return cb(err2);
-    }
-    try {
-      errParsed = JSON.parse(err.responseText);
-      //would prefer not to have a try/catch clause
-      errObj = errors.generateErrorFromResponse(errParsed);
-    } catch (e) {
-      errObj = errors.generateErrorFromResponse(err);
+  api._destroy = function (callback) {
+    IdbPouch.Changes.removeAllListeners(dbName);
+
+    //Close open request for "dbName" database to fix ie delay.
+    if (IdbPouch.openReqList[dbName] && IdbPouch.openReqList[dbName].result) {
+      IdbPouch.openReqList[dbName].result.close();
+      delete cachedDBs[dbName];
     }
-    cb(errObj);
-  }
+    var req = indexedDB.deleteDatabase(dbName);
 
+    req.onsuccess = function () {
+      //Remove open request from the list.
+      if (IdbPouch.openReqList[dbName]) {
+        IdbPouch.openReqList[dbName] = null;
+      }
+      if (utils.hasLocalStorage() && (dbName in localStorage)) {
+        delete localStorage[dbName];
+      }
+      callback(null, { 'ok': true });
+    };
 
-  if (options.json) {
-    if (!options.binary) {
-      options.headers.Accept = 'application/json';
-    }
-    options.headers['Content-Type'] = options.headers['Content-Type'] ||
-      'application/json';
-  }
+    req.onerror = idbError(callback);
+  };
 
-  if (options.binary) {
-    options.encoding = null;
-    options.json = false;
-  }
+  var cached = cachedDBs[dbName];
 
-  if (!options.processData) {
-    options.json = false;
+  if (cached) {
+    idb = cached.idb;
+    api._meta = cached.global;
+    process.nextTick(function () {
+      callback(null, api);
+    });
+    return;
   }
 
-  function defaultBody(data) {
-    if (process.browser) {
-      return '';
-    }
-    return new buffer('', 'binary');
+  var req = indexedDB.open(dbName, ADAPTER_VERSION);
+
+  if (!('openReqList' in IdbPouch)) {
+    IdbPouch.openReqList = {};
   }
+  IdbPouch.openReqList[dbName] = req;
 
-  return request(options, function (err, response, body) {
-    if (err) {
-      err.status = response ? response.statusCode : 400;
-      return onError(err, callback);
+  req.onupgradeneeded = function (e) {
+    var db = e.target.result;
+    if (e.oldVersion < 1) {
+      return createSchema(db); // new db, initial schema
     }
+    // do migrations
 
-    var error;
-    var content_type = response.headers && response.headers['content-type'];
-    var data = body || defaultBody();
+    var txn = e.currentTarget.transaction;
+    // these migrations have to be done in this function, before
+    // control is returned to the event loop, because IndexedDB
 
-    // CouchDB doesn't always return the right content-type for JSON data, so
-    // we check for ^{ and }$ (ignoring leading/trailing whitespace)
-    if (!options.binary && (options.json || !options.processData) &&
-        typeof data !== 'object' &&
-        (/json/.test(content_type) ||
-         (/^[\s]*\{/.test(data) && /\}[\s]*$/.test(data)))) {
-      data = JSON.parse(data);
+    if (e.oldVersion < 3) {
+      createLocalStoreSchema(db); // v2 -> v3
     }
-
-    if (response.statusCode >= 200 && response.statusCode < 300) {
-      onSuccess(data, response, callback);
-    } else {
-      if (options.binary) {
-        data = JSON.parse(data.toString());
-      }
-      error = errors.generateErrorFromResponse(data);
-      error.status = response.statusCode;
-      callback(error);
+    if (e.oldVersion < 4) {
+      addAttachAndSeqStore(db); // v3 -> v4
     }
-  });
-}
 
-module.exports = ajax;
+    var migrations = [
+      addDeletedOrLocalIndex, // v1 -> v2
+      migrateLocalStore,      // v2 -> v3
+      migrateAttsAndSeqs,     // v3 -> v4
+      migrateMetadata         // v4 -> v5
+    ];
 
-}).call(this,require('_process'))
-},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","./errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","request":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/request-browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js":[function(require,module,exports){
-(function (global){
-"use strict";
+    var i = e.oldVersion;
 
-//Abstracts constructing a Blob object, so it also works in older
-//browsers that don't support the native Blob constructor. (i.e.
-//old QtWebKit versions, at least).
-function createBlob(parts, properties) {
-  parts = parts || [];
-  properties = properties || {};
-  try {
-    return new Blob(parts, properties);
-  } catch (e) {
-    if (e.name !== "TypeError") {
-      throw e;
-    }
-    var BlobBuilder = global.BlobBuilder ||
-                      global.MSBlobBuilder ||
-                      global.MozBlobBuilder ||
-                      global.WebKitBlobBuilder;
-    var builder = new BlobBuilder();
-    for (var i = 0; i < parts.length; i += 1) {
-      builder.append(parts[i]);
+    function next() {
+      var migration = migrations[i - 1];
+      i++;
+      if (migration) {
+        migration(txn, next);
+      }
     }
-    return builder.getBlob(properties.type);
-  }
-}
 
-module.exports = createBlob;
+    next();
+  };
 
+  req.onsuccess = function (e) {
 
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js":[function(require,module,exports){
-// hey guess what, we don't need this in the browser
-module.exports = {};
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js":[function(require,module,exports){
-"use strict";
+    idb = e.target.result;
 
-var inherits = require('inherits');
-inherits(PouchError, Error);
+    idb.onversionchange = function () {
+      idb.close();
+      delete cachedDBs[dbName];
+    };
+    idb.onabort = function () {
+      idb.close();
+      delete cachedDBs[dbName];
+    };
 
-function PouchError(opts) {
-  Error.call(opts.reason);
-  this.status = opts.status;
-  this.name = opts.error;
-  this.message = opts.reason;
-  this.error = true;
-}
+    var txn = idb.transaction([
+        META_STORE,
+        DETECT_BLOB_SUPPORT_STORE,
+        DOC_STORE
+      ], 'readwrite');
 
-PouchError.prototype.toString = function () {
-  return JSON.stringify({
-    status: this.status,
-    name: this.name,
-    message: this.message
-  });
-};
+    var req = txn.objectStore(META_STORE).get(META_STORE);
 
-exports.UNAUTHORIZED = new PouchError({
-  status: 401,
-  error: 'unauthorized',
-  reason: "Name or password is incorrect."
-});
+    var blobSupport = null;
+    var docCount = null;
+    var instanceId = null;
 
-exports.MISSING_BULK_DOCS = new PouchError({
-  status: 400,
-  error: 'bad_request',
-  reason: "Missing JSON list of 'docs'"
-});
+    req.onsuccess = function (e) {
 
-exports.MISSING_DOC = new PouchError({
-  status: 404,
-  error: 'not_found',
-  reason: 'missing'
-});
+      var checkSetupComplete = function () {
+        if (blobSupport === null || docCount === null ||
+            instanceId === null) {
+          return;
+        } else {
+          api._meta = {
+            name: dbName,
+            instanceId: instanceId,
+            blobSupport: blobSupport,
+            docCount: docCount
+          };
 
-exports.REV_CONFLICT = new PouchError({
-  status: 409,
-  error: 'conflict',
-  reason: 'Document update conflict'
-});
+          cachedDBs[dbName] = {
+            idb: idb,
+            global: api._meta
+          };
+          callback(null, api);
+        }
+      };
 
-exports.INVALID_ID = new PouchError({
-  status: 400,
-  error: 'invalid_id',
-  reason: '_id field must contain a string'
-});
+      //
+      // fetch/store the id
+      //
 
-exports.MISSING_ID = new PouchError({
-  status: 412,
-  error: 'missing_id',
-  reason: '_id is required for puts'
-});
+      var meta = e.target.result || {id: META_STORE};
+      if (dbName  + '_id' in meta) {
+        instanceId = meta[dbName + '_id'];
+        checkSetupComplete();
+      } else {
+        instanceId = utils.uuid();
+        meta[dbName + '_id'] = instanceId;
+        txn.objectStore(META_STORE).put(meta).onsuccess = function () {
+          checkSetupComplete();
+        };
+      }
 
-exports.RESERVED_ID = new PouchError({
-  status: 400,
-  error: 'bad_request',
-  reason: 'Only reserved document ids may start with underscore.'
-});
+      //
+      // check blob support
+      //
 
-exports.NOT_OPEN = new PouchError({
-  status: 412,
-  error: 'precondition_failed',
-  reason: 'Database not open'
-});
+      if (!blobSupportPromise) {
+        // make sure blob support is only checked once
+        blobSupportPromise = checkBlobSupport(txn, idb);
+      }
 
-exports.UNKNOWN_ERROR = new PouchError({
-  status: 500,
-  error: 'unknown_error',
-  reason: 'Database encountered an unknown error'
-});
+      blobSupportPromise.then(function (val) {
+        blobSupport = val;
+        checkSetupComplete();
+      });
 
-exports.BAD_ARG = new PouchError({
-  status: 500,
-  error: 'badarg',
-  reason: 'Some query argument is invalid'
-});
+      //
+      // count docs
+      //
 
-exports.INVALID_REQUEST = new PouchError({
-  status: 400,
-  error: 'invalid_request',
-  reason: 'Request was invalid'
-});
+      var index = txn.objectStore(DOC_STORE).index('deletedOrLocal');
+      index.count(IDBKeyRange.only('0')).onsuccess = function (e) {
+        docCount = e.target.result;
+        checkSetupComplete();
+      };
 
-exports.QUERY_PARSE_ERROR = new PouchError({
-  status: 400,
-  error: 'query_parse_error',
-  reason: 'Some query parameter is invalid'
-});
+    };
+  };
 
-exports.DOC_VALIDATION = new PouchError({
-  status: 500,
-  error: 'doc_validation',
-  reason: 'Bad special document member'
-});
+  req.onerror = idbError(callback);
 
-exports.BAD_REQUEST = new PouchError({
-  status: 400,
-  error: 'bad_request',
-  reason: 'Something wrong with the request'
-});
+}
 
-exports.NOT_AN_OBJECT = new PouchError({
-  status: 400,
-  error: 'bad_request',
-  reason: 'Document must be a JSON object'
-});
+IdbPouch.valid = function () {
+  // Issue #2533, we finally gave up on doing bug
+  // detection instead of browser sniffing. Safari brought us
+  // to our knees.
+  var isSafari = typeof openDatabase !== 'undefined' &&
+    /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) &&
+    !/Chrome/.test(navigator.userAgent) &&
+    !/BlackBerry/.test(navigator.platform);
 
-exports.DB_MISSING = new PouchError({
-  status: 404,
-  error: 'not_found',
-  reason: 'Database not found'
-});
+  // some outdated implementations of IDB that appear on Samsung
+  // and HTC Android devices <4.4 are missing IDBKeyRange
+  return !isSafari && typeof indexedDB !== 'undefined' &&
+    typeof IDBKeyRange !== 'undefined';
+};
 
-exports.IDB_ERROR = new PouchError({
-  status: 500,
-  error: 'indexed_db_went_bad',
-  reason: 'unknown'
-});
+IdbPouch.Changes = new utils.Changes();
 
-exports.WSQ_ERROR = new PouchError({
-  status: 500,
-  error: 'web_sql_went_bad',
-  reason: 'unknown'
-});
+module.exports = IdbPouch;
 
-exports.LDB_ERROR = new PouchError({
-  status: 500,
-  error: 'levelDB_went_went_bad',
-  reason: 'unknown'
-});
+}).call(this,require('_process'))
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./idb-all-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-all-docs.js","./idb-blob-support":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-blob-support.js","./idb-bulk-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-bulk-docs.js","./idb-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-constants.js","./idb-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb-utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-bulk-docs.js":[function(require,module,exports){
+'use strict';
 
-exports.FORBIDDEN = new PouchError({
-  status: 403,
-  error: 'forbidden',
-  reason: 'Forbidden by design doc validate_doc_update function'
-});
+var utils = require('../../utils');
+var errors = require('../../deps/errors');
 
-exports.INVALID_REV = new PouchError({
-  status: 400,
-  error: 'bad_request',
-  reason: 'Invalid rev format'
-});
+var websqlUtils = require('./websql-utils');
+var websqlConstants = require('./websql-constants');
 
-exports.FILE_EXISTS = new PouchError({
-  status: 412,
-  error: 'file_exists',
-  reason: 'The database could not be created, the file already exists.'
-});
+var DOC_STORE = websqlConstants.DOC_STORE;
+var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
+var ATTACH_STORE = websqlConstants.ATTACH_STORE;
+var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
 
-exports.MISSING_STUB = new PouchError({
-  status: 412,
-  error: 'missing_stub'
-});
+var select = websqlUtils.select;
+var stringifyDoc = websqlUtils.stringifyDoc;
+var compactRevs = websqlUtils.compactRevs;
+var unknownError = websqlUtils.unknownError;
 
-exports.error = function (error, reason, name) {
-  function CustomPouchError(reason) {
-    // inherit error properties from our parent error manually
-    // so as to allow proper JSON parsing.
-    /* jshint ignore:start */
-    for (var p in error) {
-      if (typeof error[p] !== 'function') {
-        this[p] = error[p];
-      }
-    }
-    /* jshint ignore:end */
-    if (name !== undefined) {
-      this.name = name;
-    }
-    if (reason !== undefined) {
-      this.reason = reason;
-    }
-  }
-  CustomPouchError.prototype = PouchError.prototype;
-  return new CustomPouchError(reason);
-};
+function websqlBulkDocs(req, opts, api, db, Changes, callback) {
+  var newEdits = opts.new_edits;
+  var userDocs = req.docs;
 
-// Find one of the errors defined above based on the value
-// of the specified property.
-// If reason is provided prefer the error matching that reason.
-// This is for differentiating between errors with the same name and status,
-// eg, bad_request.
-exports.getErrorTypeByProp = function (prop, value, reason) {
-  var errors = exports;
-  var keys = Object.keys(errors).filter(function (key) {
-    var error = errors[key];
-    return typeof error !== 'function' && error[prop] === value;
+  // Parse the docs, give them a sequence number for the result
+  var docInfos = userDocs.map(function (doc) {
+    if (doc._id && utils.isLocalId(doc._id)) {
+      return doc;
+    }
+    var newDoc = utils.parseDoc(doc, newEdits);
+    return newDoc;
   });
-  var key = reason && keys.filter(function (key) {
-        var error = errors[key];
-        return error.message === reason;
-      })[0] || keys[0];
-  return (key) ? errors[key] : null;
-};
-
-exports.generateErrorFromResponse = function (res) {
-  var error, errName, errType, errMsg, errReason;
-  var errors = exports;
 
-  errName = (res.error === true && typeof res.name === 'string') ?
-              res.name :
-              res.error;
-  errReason = res.reason;
-  errType = errors.getErrorTypeByProp('name', errName, errReason);
+  var docInfoErrors = docInfos.filter(function (docInfo) {
+    return docInfo.error;
+  });
+  if (docInfoErrors.length) {
+    return callback(docInfoErrors[0]);
+  }
 
-  if (res.missing ||
-      errReason === 'missing' ||
-      errReason === 'deleted' ||
-      errName === 'not_found') {
-    errType = errors.MISSING_DOC;
-  } else if (errName === 'doc_validation') {
-    // doc validation needs special treatment since
-    // res.reason depends on the validation error.
-    // see utils.js
-    errType = errors.DOC_VALIDATION;
-    errMsg = errReason;
-  } else if (errName === 'bad_request' && errType.message !== errReason) {
-    // if bad_request error already found based on reason don't override.
+  var tx;
+  var results = new Array(docInfos.length);
+  var fetchedDocs = new utils.Map();
 
-    // attachment errors.
-    if (errReason.indexOf('unknown stub attachment') === 0) {
-      errType = errors.MISSING_STUB;
-      errMsg = errReason;
-    } else {
-      errType = errors.BAD_REQUEST;
+  var preconditionErrored;
+  function complete() {
+    if (preconditionErrored) {
+      return callback(preconditionErrored);
     }
+    Changes.notify(api._name);
+    api._docCount = -1; // invalidate
+    callback(null, results);
   }
 
-  // fallback to error by statys or unknown error.
-  if (!errType) {
-    errType = errors.getErrorTypeByProp('status', res.status, errReason) ||
-                errors.UNKNOWN_ERROR;
+  function verifyAttachment(digest, callback) {
+    var sql = 'SELECT count(*) as cnt FROM ' + ATTACH_STORE +
+      ' WHERE digest=?';
+    tx.executeSql(sql, [digest], function (tx, result) {
+      if (result.rows.item(0).cnt === 0) {
+        var err = errors.error(errors.MISSING_STUB,
+          'unknown stub attachment with digest ' +
+          digest);
+        callback(err);
+      } else {
+        callback();
+      }
+    });
   }
 
-  error = errors.error(errType, errReason, errName);
-
-  // Keep custom message.
-  if (errMsg) {
-    error.message = errMsg;
-  }
+  function verifyAttachments(finish) {
+    var digests = [];
+    docInfos.forEach(function (docInfo) {
+      if (docInfo.data && docInfo.data._attachments) {
+        Object.keys(docInfo.data._attachments).forEach(function (filename) {
+          var att = docInfo.data._attachments[filename];
+          if (att.stub) {
+            digests.push(att.digest);
+          }
+        });
+      }
+    });
+    if (!digests.length) {
+      return finish();
+    }
+    var numDone = 0;
+    var err;
 
-  // Keep helpful response data in our error messages.
-  if (res.id) {
-    error.id = res.id;
-  }
-  if (res.status) {
-    error.status = res.status;
-  }
-  if (res.statusText) {
-    error.name = res.statusText;
-  }
-  if (res.missing) {
-    error.missing = res.missing;
+    function checkDone() {
+      if (++numDone === digests.length) {
+        finish(err);
+      }
+    }
+    digests.forEach(function (digest) {
+      verifyAttachment(digest, function (attErr) {
+        if (attErr && !err) {
+          err = attErr;
+        }
+        checkDone();
+      });
+    });
   }
 
-  return error;
-};
+  function writeDoc(docInfo, winningRev, winningRevIsDeleted, newRevIsDeleted,
+                    isUpdate, delta, resultsIdx, callback) {
 
-},{"inherits":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/inherits/inherits_browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js":[function(require,module,exports){
-(function (process,global){
-'use strict';
+    function finish() {
+      var data = docInfo.data;
+      var deletedInt = newRevIsDeleted ? 1 : 0;
 
-// designed to give info to browser users, who are disturbed
-// when they see 404s in the console
-function explain404(str) {
-  if (process.browser && 'console' in global && 'info' in console) {
-    console.info('The above 404 is totally normal. ' + str);
-  }
-}
+      var id = data._id;
+      var rev = data._rev;
+      var json = stringifyDoc(data);
+      var sql = 'INSERT INTO ' + BY_SEQ_STORE +
+        ' (doc_id, rev, json, deleted) VALUES (?, ?, ?, ?);';
+      var sqlArgs = [id, rev, json, deletedInt];
 
-module.exports = explain404;
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/md5.js":[function(require,module,exports){
-(function (process,global){
-'use strict';
+      // map seqs to attachment digests, which
+      // we will need later during compaction
+      function insertAttachmentMappings(seq, callback) {
+        var attsAdded = 0;
+        var attsToAdd = Object.keys(data._attachments || {});
 
-var crypto = require('crypto');
-var Md5 = require('spark-md5');
-var setImmediateShim = global.setImmediate || global.setTimeout;
-var MD5_CHUNK_SIZE = 32768;
+        if (!attsToAdd.length) {
+          return callback();
+        }
+        function checkDone() {
+          if (++attsAdded === attsToAdd.length) {
+            callback();
+          }
+          return false; // ack handling a constraint error
+        }
+        function add(att) {
+          var sql = 'INSERT INTO ' + ATTACH_AND_SEQ_STORE +
+            ' (digest, seq) VALUES (?,?)';
+          var sqlArgs = [data._attachments[att].digest, seq];
+          tx.executeSql(sql, sqlArgs, checkDone, checkDone);
+          // second callback is for a constaint error, which we ignore
+          // because this docid/rev has already been associated with
+          // the digest (e.g. when new_edits == false)
+        }
+        for (var i = 0; i < attsToAdd.length; i++) {
+          add(attsToAdd[i]); // do in parallel
+        }
+      }
 
-// convert a 64-bit int to a binary string
-function intToString(int) {
-  var bytes = [
-    (int & 0xff),
-    ((int >>> 8) & 0xff),
-    ((int >>> 16) & 0xff),
-    ((int >>> 24) & 0xff)
-  ];
-  return bytes.map(function (byte) {
-    return String.fromCharCode(byte);
-  }).join('');
-}
+      tx.executeSql(sql, sqlArgs, function (tx, result) {
+        var seq = result.insertId;
+        insertAttachmentMappings(seq, function () {
+          dataWritten(tx, seq);
+        });
+      }, function () {
+        // constraint error, recover by updating instead (see #1638)
+        var fetchSql = select('seq', BY_SEQ_STORE, null,
+          'doc_id=? AND rev=?');
+        tx.executeSql(fetchSql, [id, rev], function (tx, res) {
+          var seq = res.rows.item(0).seq;
+          var sql = 'UPDATE ' + BY_SEQ_STORE +
+            ' SET json=?, deleted=? WHERE doc_id=? AND rev=?;';
+          var sqlArgs = [json, deletedInt, id, rev];
+          tx.executeSql(sql, sqlArgs, function (tx) {
+            insertAttachmentMappings(seq, function () {
+              dataWritten(tx, seq);
+            });
+          });
+        });
+        return false; // ack that we've handled the error
+      });
+    }
 
-// convert an array of 64-bit ints into
-// a base64-encoded string
-function rawToBase64(raw) {
-  var res = '';
-  for (var i = 0; i < raw.length; i++) {
-    res += intToString(raw[i]);
-  }
-  return btoa(res);
-}
+    function collectResults(attachmentErr) {
+      if (!err) {
+        if (attachmentErr) {
+          err = attachmentErr;
+          callback(err);
+        } else if (recv === attachments.length) {
+          finish();
+        }
+      }
+    }
 
-function appendBuffer(buffer, data, start, end) {
-  if (start > 0 || end < data.byteLength) {
-    // only create a subarray if we really need to
-    data = new Uint8Array(data, start,
-      Math.min(end, data.byteLength) - start);
-  }
-  buffer.append(data);
-}
+    var err = null;
+    var recv = 0;
 
-function appendString(buffer, data, start, end) {
-  if (start > 0 || end < data.length) {
-    // only create a substring if we really need to
-    data = data.substring(start, end);
-  }
-  buffer.appendBinary(data);
-}
+    docInfo.data._id = docInfo.metadata.id;
+    docInfo.data._rev = docInfo.metadata.rev;
+    var attachments = Object.keys(docInfo.data._attachments || {});
 
-module.exports = function (data, callback) {
-  if (!process.browser) {
-    var base64 = crypto.createHash('md5').update(data).digest('base64');
-    callback(null, base64);
-    return;
-  }
-  var inputIsString = typeof data === 'string';
-  var len = inputIsString ? data.length : data.byteLength;
-  var chunkSize = Math.min(MD5_CHUNK_SIZE, len);
-  var chunks = Math.ceil(len / chunkSize);
-  var currentChunk = 0;
-  var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();
 
-  var append = inputIsString ? appendString : appendBuffer;
+    if (newRevIsDeleted) {
+      docInfo.data._deleted = true;
+    }
 
-  function loadNextChunk() {
-    var start = currentChunk * chunkSize;
-    var end = start + chunkSize;
-    currentChunk++;
-    if (currentChunk < chunks) {
-      append(buffer, data, start, end);
-      setImmediateShim(loadNextChunk);
-    } else {
-      append(buffer, data, start, end);
-      var raw = buffer.end(true);
-      var base64 = rawToBase64(raw);
-      callback(null, base64);
-      buffer.destroy();
+    function attachmentSaved(err) {
+      recv++;
+      collectResults(err);
     }
-  }
-  loadNextChunk();
-};
 
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","crypto":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","spark-md5":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-doc.js":[function(require,module,exports){
-'use strict';
+    attachments.forEach(function (key) {
+      var att = docInfo.data._attachments[key];
+      if (!att.stub) {
+        var data = att.data;
+        delete att.data;
+        var digest = att.digest;
+        saveAttachment(digest, data, attachmentSaved);
+      } else {
+        recv++;
+        collectResults();
+      }
+    });
 
-var errors = require('./errors');
-var uuid = require('./uuid');
+    if (!attachments.length) {
+      finish();
+    }
 
-function toObject(array) {
-  return array.reduce(function (obj, item) {
-    obj[item] = true;
-    return obj;
-  }, {});
-}
-// List of top level reserved words for doc
-var reservedWords = toObject([
-  '_id',
-  '_rev',
-  '_attachments',
-  '_deleted',
-  '_revisions',
-  '_revs_info',
-  '_conflicts',
-  '_deleted_conflicts',
-  '_local_seq',
-  '_rev_tree',
-  //replication documents
-  '_replication_id',
-  '_replication_state',
-  '_replication_state_time',
-  '_replication_state_reason',
-  '_replication_stats',
-  // Specific to Couchbase Sync Gateway
-  '_removed'
-]);
+    function autoCompact() {
+      if (!isUpdate || !api.auto_compaction) {
+        return; // nothing to do
+      }
+      var id = docInfo.metadata.id;
+      var revsToDelete = utils.compactTree(docInfo.metadata);
+      compactRevs(revsToDelete, id, tx);
+    }
 
-// List of reserved words that should end up the document
-var dataWords = toObject([
-  '_attachments',
-  //replication documents
-  '_replication_id',
-  '_replication_state',
-  '_replication_state_time',
-  '_replication_state_reason',
-  '_replication_stats'
-]);
+    function dataWritten(tx, seq) {
+      autoCompact();
+      docInfo.metadata.seq = seq;
+      delete docInfo.metadata.rev;
 
-// Determine id an ID is valid
-//   - invalid IDs begin with an underescore that does not begin '_design' or
-//     '_local'
-//   - any other string value is a valid id
-// Returns the specific error object for each case
-exports.invalidIdError = function (id) {
-  var err;
-  if (!id) {
-    err = errors.error(errors.MISSING_ID);
-  } else if (typeof id !== 'string') {
-    err = errors.error(errors.INVALID_ID);
-  } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
-    err = errors.error(errors.RESERVED_ID);
-  }
-  if (err) {
-    throw err;
+      var sql = isUpdate ?
+      'UPDATE ' + DOC_STORE +
+      ' SET json=?, max_seq=?, winningseq=' +
+      '(SELECT seq FROM ' + BY_SEQ_STORE +
+      ' WHERE doc_id=' + DOC_STORE + '.id AND rev=?) WHERE id=?'
+        : 'INSERT INTO ' + DOC_STORE +
+      ' (id, winningseq, max_seq, json) VALUES (?,?,?,?);';
+      var metadataStr = utils.safeJsonStringify(docInfo.metadata);
+      var id = docInfo.metadata.id;
+      var params = isUpdate ?
+        [metadataStr, seq, winningRev, id] :
+        [id, seq, seq, metadataStr];
+      tx.executeSql(sql, params, function () {
+        results[resultsIdx] = {
+          ok: true,
+          id: docInfo.metadata.id,
+          rev: winningRev
+        };
+        fetchedDocs.set(id, docInfo.metadata);
+        callback();
+      });
+    }
   }
-};
 
-function parseRevisionInfo(rev) {
-  if (!/^\d+\-./.test(rev)) {
-    return errors.error(errors.INVALID_REV);
+  function processDocs() {
+    utils.processDocs(docInfos, api, fetchedDocs,
+      tx, results, writeDoc, opts);
   }
-  var idx = rev.indexOf('-');
-  var left = rev.substring(0, idx);
-  var right = rev.substring(idx + 1);
-  return {
-    prefix: parseInt(left, 10),
-    id: right
-  };
-}
 
-function makeRevTreeFromRevisions(revisions, opts) {
-  var pos = revisions.start - revisions.ids.length + 1;
+  function fetchExistingDocs(callback) {
+    if (!docInfos.length) {
+      return callback();
+    }
 
-  var revisionIds = revisions.ids;
-  var ids = [revisionIds[0], opts, []];
+    var numFetched = 0;
 
-  for (var i = 1, len = revisionIds.length; i < len; i++) {
-    ids = [revisionIds[i], {status: 'missing'}, [ids]];
+    function checkDone() {
+      if (++numFetched === docInfos.length) {
+        callback();
+      }
+    }
+
+    docInfos.forEach(function (docInfo) {
+      if (docInfo._id && utils.isLocalId(docInfo._id)) {
+        return checkDone(); // skip local docs
+      }
+      var id = docInfo.metadata.id;
+      tx.executeSql('SELECT json FROM ' + DOC_STORE +
+      ' WHERE id = ?', [id], function (tx, result) {
+        if (result.rows.length) {
+          var metadata = utils.safeJsonParse(result.rows.item(0).json);
+          fetchedDocs.set(id, metadata);
+        }
+        checkDone();
+      });
+    });
   }
 
-  return [{
-    pos: pos,
-    ids: ids
-  }];
+  function saveAttachment(digest, data, callback) {
+    var sql = 'SELECT digest FROM ' + ATTACH_STORE + ' WHERE digest=?';
+    tx.executeSql(sql, [digest], function (tx, result) {
+      if (result.rows.length) { // attachment already exists
+        return callback();
+      }
+      // we could just insert before selecting and catch the error,
+      // but my hunch is that it's cheaper not to serialize the blob
+      // from JS to C if we don't have to (TODO: confirm this)
+      sql = 'INSERT INTO ' + ATTACH_STORE +
+      ' (digest, body, escaped) VALUES (?,?,1)';
+      tx.executeSql(sql, [digest, websqlUtils.escapeBlob(data)], function () {
+        callback();
+      }, function () {
+        // ignore constaint errors, means it already exists
+        callback();
+        return false; // ack we handled the error
+      });
+    });
+  }
+
+  utils.preprocessAttachments(docInfos, 'binary', function (err) {
+    if (err) {
+      return callback(err);
+    }
+    db.transaction(function (txn) {
+      tx = txn;
+      verifyAttachments(function (err) {
+        if (err) {
+          preconditionErrored = err;
+        } else {
+          fetchExistingDocs(processDocs);
+        }
+      });
+    }, unknownError(callback), complete);
+  });
 }
 
-// Preprocess documents, parse their revisions, assign an id and a
-// revision for new writes that are missing them, etc
-exports.parseDoc = function (doc, newEdits) {
+module.exports = websqlBulkDocs;
 
-  var nRevNum;
-  var newRevId;
-  var revInfo;
-  var opts = {status: 'available'};
-  if (doc._deleted) {
-    opts.deleted = true;
-  }
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js","./websql-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js":[function(require,module,exports){
+'use strict';
 
-  if (newEdits) {
-    if (!doc._id) {
-      doc._id = uuid();
-    }
-    newRevId = uuid(32, 16).toLowerCase();
-    if (doc._rev) {
-      revInfo = parseRevisionInfo(doc._rev);
-      if (revInfo.error) {
-        return revInfo;
-      }
-      doc._rev_tree = [{
-        pos: revInfo.prefix,
-        ids: [revInfo.id, {status: 'missing'}, [[newRevId, opts, []]]]
-      }];
-      nRevNum = revInfo.prefix + 1;
-    } else {
-      doc._rev_tree = [{
-        pos: 1,
-        ids : [newRevId, opts, []]
-      }];
-      nRevNum = 1;
-    }
-  } else {
-    if (doc._revisions) {
-      doc._rev_tree = makeRevTreeFromRevisions(doc._revisions, opts);
-      nRevNum = doc._revisions.start;
-      newRevId = doc._revisions.ids[0];
-    }
-    if (!doc._rev_tree) {
-      revInfo = parseRevisionInfo(doc._rev);
-      if (revInfo.error) {
-        return revInfo;
-      }
-      nRevNum = revInfo.prefix;
-      newRevId = revInfo.id;
-      doc._rev_tree = [{
-        pos: nRevNum,
-        ids: [newRevId, opts, []]
-      }];
-    }
-  }
+function quote(str) {
+  return "'" + str + "'";
+}
 
-  exports.invalidIdError(doc._id);
+exports.ADAPTER_VERSION = 7; // used to manage migrations
+
+// The object stores created for each database
+// DOC_STORE stores the document meta data, its revision history and state
+exports.DOC_STORE = quote('document-store');
+// BY_SEQ_STORE stores a particular version of a document, keyed by its
+// sequence id
+exports.BY_SEQ_STORE = quote('by-sequence');
+// Where we store attachments
+exports.ATTACH_STORE = quote('attach-store');
+exports.LOCAL_STORE = quote('local-store');
+exports.META_STORE = quote('metadata-store');
+// where we store many-to-many relations between attachment
+// digests and seqs
+exports.ATTACH_AND_SEQ_STORE = quote('attach-seq-store');
 
-  doc._rev = nRevNum + '-' + newRevId;
 
-  var result = {metadata : {}, data : {}};
-  for (var key in doc) {
-    if (doc.hasOwnProperty(key)) {
-      var specialKey = key[0] === '_';
-      if (specialKey && !reservedWords[key]) {
-        var error = errors.error(errors.DOC_VALIDATION, key);
-        error.message = errors.DOC_VALIDATION.message + ': ' + key;
-        throw error;
-      } else if (specialKey && !dataWords[key]) {
-        result.metadata[key.slice(1)] = doc[key];
-      } else {
-        result.data[key] = doc[key];
-      }
-    }
-  }
-  return result;
-};
-},{"./errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./uuid":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-hex.js":[function(require,module,exports){
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js":[function(require,module,exports){
 'use strict';
 
-//
-// Parsing hex strings. Yeah.
-//
-// So basically we need this because of a bug in WebSQL:
+var utils = require('../../utils');
+var errors = require('../../deps/errors');
+
+var websqlConstants = require('./websql-constants');
+
+var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
+var ATTACH_STORE = websqlConstants.ATTACH_STORE;
+var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
+
+// escapeBlob and unescapeBlob are workarounds for a websql bug:
 // https://code.google.com/p/chromium/issues/detail?id=422690
 // https://bugs.webkit.org/show_bug.cgi?id=137637
-//
-// UTF-8 and UTF-16 are provided as separate functions
-// for meager performance improvements
-//
-
-function decodeUtf8(str) {
-  return decodeURIComponent(window.escape(str));
+// The goal is to never actually insert the \u0000 character
+// in the database.
+function escapeBlob(str) {
+  return str
+    .replace(/\u0002/g, '\u0002\u0002')
+    .replace(/\u0001/g, '\u0001\u0002')
+    .replace(/\u0000/g, '\u0001\u0001');
 }
 
-function hexToInt(charCode) {
-  // '0'-'9' is 48-57
-  // 'A'-'F' is 65-70
-  // SQLite will only give us uppercase hex
-  return charCode < 65 ? (charCode - 48) : (charCode - 55);
+function unescapeBlob(str) {
+  return str
+    .replace(/\u0001\u0001/g, '\u0000')
+    .replace(/\u0001\u0002/g, '\u0001')
+    .replace(/\u0002\u0002/g, '\u0002');
 }
 
+function stringifyDoc(doc) {
+  // don't bother storing the id/rev. it uses lots of space,
+  // in persistent map/reduce especially
+  delete doc._id;
+  delete doc._rev;
+  return JSON.stringify(doc);
+}
 
-// Example:
-// pragma encoding=utf8;
-// select hex('A');
-// returns '41'
-function parseHexUtf8(str, start, end) {
-  var result = '';
-  while (start < end) {
-    result += String.fromCharCode(
-      (hexToInt(str.charCodeAt(start++)) << 4) |
-        hexToInt(str.charCodeAt(start++)));
-  }
-  return result;
+function unstringifyDoc(doc, id, rev) {
+  doc = JSON.parse(doc);
+  doc._id = id;
+  doc._rev = rev;
+  return doc;
 }
 
-// Example:
-// pragma encoding=utf16;
-// select hex('A');
-// returns '4100'
-// notice that the 00 comes after the 41 (i.e. it's swizzled)
-function parseHexUtf16(str, start, end) {
-  var result = '';
-  while (start < end) {
-    // UTF-16, so swizzle the bytes
-    result += String.fromCharCode(
-      (hexToInt(str.charCodeAt(start + 2)) << 12) |
-        (hexToInt(str.charCodeAt(start + 3)) << 8) |
-        (hexToInt(str.charCodeAt(start)) << 4) |
-        hexToInt(str.charCodeAt(start + 1)));
-    start += 4;
+// question mark groups IN queries, e.g. 3 -> '(?,?,?)'
+function qMarks(num) {
+  var s = '(';
+  while (num--) {
+    s += '?';
+    if (num) {
+      s += ',';
+    }
   }
-  return result;
+  return s + ')';
 }
 
-function parseHexString(str, encoding) {
-  if (encoding === 'UTF-8') {
-    return decodeUtf8(parseHexUtf8(str, 0, str.length));
-  } else {
-    return parseHexUtf16(str, 0, str.length);
-  }
+function select(selector, table, joiner, where, orderBy) {
+  return 'SELECT ' + selector + ' FROM ' +
+    (typeof table === 'string' ? table : table.join(' JOIN ')) +
+    (joiner ? (' ON ' + joiner) : '') +
+    (where ? (' WHERE ' +
+    (typeof where === 'string' ? where : where.join(' AND '))) : '') +
+    (orderBy ? (' ORDER BY ' + orderBy) : '');
 }
 
-module.exports = parseHexString;
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-uri.js":[function(require,module,exports){
-'use strict';
+function compactRevs(revs, docId, tx) {
 
-// originally parseUri 1.2.2, now patched by us
-// (c) Steven Levithan <stevenlevithan.com>
-// MIT License
-var options = {
-  strictMode: false,
-  key: ["source", "protocol", "authority", "userInfo", "user", "password",
-    "host", "port", "relative", "path", "directory", "file", "query",
-    "anchor"],
-  q:   {
-    name:   "queryKey",
-    parser: /(?:^|&)([^&=]*)=?([^&]*)/g
-  },
-  parser: {
-    /* jshint maxlen: false */
-    strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
-    loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+  if (!revs.length) {
+    return;
   }
-};
-function parseUri(str) {
-  var o = options;
-  var m = o.parser[o.strictMode ? "strict" : "loose"].exec(str);
-  var uri = {};
-  var i = 14;
 
-  while (i--) {
-    var key = o.key[i];
-    var value = m[i] || "";
-    var encoded = ['user', 'password'].indexOf(key) !== -1;
-    uri[key] = encoded ? decodeURIComponent(value) : value;
+  var numDone = 0;
+  var seqs = [];
+
+  function checkDone() {
+    if (++numDone === revs.length) { // done
+      deleteOrphans();
+    }
   }
 
-  uri[o.q.name] = {};
-  uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
-    if ($1) {
-      uri[o.q.name][$1] = $2;
+  function deleteOrphans() {
+    // find orphaned attachment digests
+
+    if (!seqs.length) {
+      return;
     }
-  });
 
-  return uri;
-}
+    var sql = 'SELECT DISTINCT digest AS digest FROM ' +
+      ATTACH_AND_SEQ_STORE + ' WHERE seq IN ' + qMarks(seqs.length);
 
+    tx.executeSql(sql, seqs, function (tx, res) {
 
-module.exports = parseUri;
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js":[function(require,module,exports){
-'use strict';
+      var digestsToCheck = [];
+      for (var i = 0; i < res.rows.length; i++) {
+        digestsToCheck.push(res.rows.item(i).digest);
+      }
+      if (!digestsToCheck.length) {
+        return;
+      }
 
-if (typeof Promise === 'function') {
-  module.exports = Promise;
-} else {
-  module.exports = require('bluebird');
-}
-},{"bluebird":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/request-browser.js":[function(require,module,exports){
-/* global fetch */
-/* global Headers */
-'use strict';
+      var sql = 'DELETE FROM ' + ATTACH_AND_SEQ_STORE +
+        ' WHERE seq IN (' +
+        seqs.map(function () { return '?'; }).join(',') +
+        ')';
+      tx.executeSql(sql, seqs, function (tx) {
 
-var createBlob = require('./blob.js');
-var utils = require('../utils');
+        var sql = 'SELECT digest FROM ' + ATTACH_AND_SEQ_STORE +
+          ' WHERE digest IN (' +
+          digestsToCheck.map(function () { return '?'; }).join(',') +
+          ')';
+        tx.executeSql(sql, digestsToCheck, function (tx, res) {
+          var nonOrphanedDigests = new utils.Set();
+          for (var i = 0; i < res.rows.length; i++) {
+            nonOrphanedDigests.add(res.rows.item(i).digest);
+          }
+          digestsToCheck.forEach(function (digest) {
+            if (nonOrphanedDigests.has(digest)) {
+              return;
+            }
+            tx.executeSql(
+              'DELETE FROM ' + ATTACH_AND_SEQ_STORE + ' WHERE digest=?',
+              [digest]);
+            tx.executeSql(
+              'DELETE FROM ' + ATTACH_STORE + ' WHERE digest=?', [digest]);
+          });
+        });
+      });
+    });
+  }
 
-function wrappedFetch() {
-  var wrappedPromise = {};
+  // update by-seq and attach stores in parallel
+  revs.forEach(function (rev) {
+    var sql = 'SELECT seq FROM ' + BY_SEQ_STORE +
+      ' WHERE doc_id=? AND rev=?';
 
-  var promise = new utils.Promise(function(resolve, reject) {
-    wrappedPromise.resolve = resolve;
-    wrappedPromise.reject = reject;
+    tx.executeSql(sql, [docId, rev], function (tx, res) {
+      if (!res.rows.length) { // already deleted
+        return checkDone();
+      }
+      var seq = res.rows.item(0).seq;
+      seqs.push(seq);
+
+      tx.executeSql(
+        'DELETE FROM ' + BY_SEQ_STORE + ' WHERE seq=?', [seq], checkDone);
+    });
   });
+}
 
-  var args = new Array(arguments.length);
+function unknownError(callback) {
+  return function (event) {
+    // event may actually be a SQLError object, so report is as such
+    var errorNameMatch = event && event.constructor.toString()
+        .match(/function ([^\(]+)/);
+    var errorName = (errorNameMatch && errorNameMatch[1]) || event.type;
+    var errorReason = event.target || event.message;
+    callback(errors.error(errors.WSQ_ERROR, errorReason, errorName));
+  };
+}
 
-  for (var i = 0; i < args.length; i++) {
-    args[i] = arguments[i];
+function getSize(opts) {
+  if ('size' in opts) {
+    // triggers immediate popup in iOS, fixes #2347
+    // e.g. 5000001 asks for 5 MB, 10000001 asks for 10 MB,
+    return opts.size * 1000000;
   }
+  // In iOS, doesn't matter as long as it's <= 5000000.
+  // Except that if you request too much, our tests fail
+  // because of the native "do you accept?" popup.
+  // In Android <=4.3, this value is actually used as an
+  // honest-to-god ceiling for data, so we need to
+  // set it to a decently high number.
+  var isAndroid = /Android/.test(window.navigator.userAgent);
+  return isAndroid ? 5000000 : 1; // in PhantomJS, if you use 0 it will crash
+}
 
-  wrappedPromise.then = promise.then.bind(promise);
-  wrappedPromise.catch = promise.catch.bind(promise);
-  wrappedPromise.promise = promise;
-
-  fetch.apply(null, args).then(function(response) {
-    wrappedPromise.resolve(response);
-  }, function(error) {
-    wrappedPromise.reject(error);
-  }).catch(function(error) {
-    wrappedPromise.catch(error);
-  });
+function createOpenDBFunction() {
+  if (typeof sqlitePlugin !== 'undefined') {
+    // The SQLite Plugin started deviating pretty heavily from the
+    // standard openDatabase() function, as they started adding more features.
+    // It's better to just use their "new" format and pass in a big ol'
+    // options object.
+    return sqlitePlugin.openDatabase.bind(sqlitePlugin);
+  }
 
-  return wrappedPromise;
+  if (typeof openDatabase !== 'undefined') {
+    return function openDB(opts) {
+      // Traditional WebSQL API
+      return openDatabase(opts.name, opts.version, opts.description, opts.size);
+    };
+  }
 }
 
-function fetchRequest(options, callback) {
-  var wrappedPromise, timer, fetchResponse;
+var cachedDatabases = {};
 
-  var headers = new Headers();
+function openDB(opts) {
 
-  var fetchOptions = {
-    method: options.method,
-    credentials: 'include',
-    headers: headers
-  };
+  var openDBFunction = createOpenDBFunction();
 
-  if (options.json) {
-    headers.set('Accept', 'application/json');
-    headers.set('Content-Type', options.headers['Content-Type'] ||
-      'application/json');
+  var db = cachedDatabases[opts.name];
+  if (!db) {
+    db = cachedDatabases[opts.name] = openDBFunction(opts);
+    db._sqlitePlugin = typeof sqlitePlugin !== 'undefined';
   }
+  return db;
+}
 
-  if (options.body && (options.body instanceof Blob)) {
-    utils.readAsBinaryString(options.body, function(binary) {
-      fetchOptions.body = utils.fixBinary(binary);
-    });
-  } else if (options.body &&
-             options.processData &&
-             typeof options.body !== 'string') {
-    fetchOptions.body = JSON.stringify(options.body);
-  } else if ('body' in options) {
-    fetchOptions.body = options.body;
-  } else {
-    fetchOptions.body = null;
-  }
+function valid() {
+  // SQLitePlugin leaks this global object, which we can use
+  // to detect if it's installed or not. The benefit is that it's
+  // declared immediately, before the 'deviceready' event has fired.
+  return typeof openDatabase !== 'undefined' ||
+    typeof SQLitePlugin !== 'undefined';
+}
 
-  Object.keys(options.headers).forEach(function(key) {
-    if (options.headers.hasOwnProperty(key)) {
-      headers.set(key, options.headers[key]);
-    }
-  });
+module.exports = {
+  escapeBlob: escapeBlob,
+  unescapeBlob: unescapeBlob,
+  stringifyDoc: stringifyDoc,
+  unstringifyDoc: unstringifyDoc,
+  qMarks: qMarks,
+  select: select,
+  compactRevs: compactRevs,
+  unknownError: unknownError,
+  getSize: getSize,
+  openDB: openDB,
+  valid: valid
+};
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql.js":[function(require,module,exports){
+'use strict';
 
-  wrappedPromise = wrappedFetch(options.url, fetchOptions);
+var utils = require('../../utils');
+var merge = require('../../merge');
+var errors = require('../../deps/errors');
+var parseHexString = require('../../deps/parse-hex');
 
-  if (options.timeout > 0) {
-    timer = setTimeout(function() {
-      wrappedPromise.reject(new Error('Load timeout for resource: ' +
-        options.url));
-    }, options.timeout);
-  }
+var websqlConstants = require('./websql-constants');
+var websqlUtils = require('./websql-utils');
+var websqlBulkDocs = require('./websql-bulk-docs');
 
-  wrappedPromise.promise.then(function(response) {
-    var result;
+var ADAPTER_VERSION = websqlConstants.ADAPTER_VERSION;
+var DOC_STORE = websqlConstants.DOC_STORE;
+var BY_SEQ_STORE = websqlConstants.BY_SEQ_STORE;
+var ATTACH_STORE = websqlConstants.ATTACH_STORE;
+var LOCAL_STORE = websqlConstants.LOCAL_STORE;
+var META_STORE = websqlConstants.META_STORE;
+var ATTACH_AND_SEQ_STORE = websqlConstants.ATTACH_AND_SEQ_STORE;
 
-    fetchResponse = response;
+var qMarks = websqlUtils.qMarks;
+var stringifyDoc = websqlUtils.stringifyDoc;
+var unstringifyDoc = websqlUtils.unstringifyDoc;
+var select = websqlUtils.select;
+var compactRevs = websqlUtils.compactRevs;
+var unknownError = websqlUtils.unknownError;
+var getSize = websqlUtils.getSize;
+var openDB = websqlUtils.openDB;
 
-    if (options.timeout > 0) {
-      clearTimeout(timer);
-    }
+function fetchAttachmentsIfNecessary(doc, opts, api, txn, cb) {
+  var attachments = Object.keys(doc._attachments || {});
+  if (!attachments.length) {
+    return cb && cb();
+  }
+  var numDone = 0;
 
-    if (response.status >= 200 && response.status < 300) {
-      return options.binary ? response.blob() : response.text();
+  function checkDone() {
+    if (++numDone === attachments.length && cb) {
+      cb();
     }
+  }
 
-    return result.json();
-  }).then(function(result) {
-    if (fetchResponse.status >= 200 && fetchResponse.status < 300) {
-      callback(null, fetchResponse, result);
+  function fetchAttachment(doc, att) {
+    var attObj = doc._attachments[att];
+    var attOpts = {encode: true, ctx: txn};
+    api._getAttachment(attObj, attOpts, function (_, base64) {
+      doc._attachments[att] = utils.extend(
+        utils.pick(attObj, ['digest', 'content_type']),
+        { data: base64 }
+      );
+      checkDone();
+    });
+  }
+
+  attachments.forEach(function (att) {
+    if (opts.attachments && opts.include_docs) {
+      fetchAttachment(doc, att);
     } else {
-      callback(result, fetchResponse);
+      doc._attachments[att].stub = true;
+      checkDone();
     }
-  }).catch(function(error) {
-    callback(error, fetchResponse);
   });
-
-  return {abort: wrappedPromise.reject};
 }
 
-function xhRequest(options, callback) {
+var POUCH_VERSION = 1;
 
-  var xhr, timer, hasUpload;
+// these indexes cover the ground for most allDocs queries
+var BY_SEQ_STORE_DELETED_INDEX_SQL =
+  'CREATE INDEX IF NOT EXISTS \'by-seq-deleted-idx\' ON ' +
+  BY_SEQ_STORE + ' (seq, deleted)';
+var BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL =
+  'CREATE UNIQUE INDEX IF NOT EXISTS \'by-seq-doc-id-rev\' ON ' +
+    BY_SEQ_STORE + ' (doc_id, rev)';
+var DOC_STORE_WINNINGSEQ_INDEX_SQL =
+  'CREATE INDEX IF NOT EXISTS \'doc-winningseq-idx\' ON ' +
+  DOC_STORE + ' (winningseq)';
+var ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL =
+  'CREATE INDEX IF NOT EXISTS \'attach-seq-seq-idx\' ON ' +
+    ATTACH_AND_SEQ_STORE + ' (seq)';
+var ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL =
+  'CREATE UNIQUE INDEX IF NOT EXISTS \'attach-seq-digest-idx\' ON ' +
+    ATTACH_AND_SEQ_STORE + ' (digest, seq)';
 
-  var abortReq = function () {
-    xhr.abort();
-  };
+var DOC_STORE_AND_BY_SEQ_JOINER = BY_SEQ_STORE +
+  '.seq = ' + DOC_STORE + '.winningseq';
 
-  if (options.xhr) {
-    xhr = new options.xhr();
-  } else {
-    xhr = new XMLHttpRequest();
-  }
+var SELECT_DOCS = BY_SEQ_STORE + '.seq AS seq, ' +
+  BY_SEQ_STORE + '.deleted AS deleted, ' +
+  BY_SEQ_STORE + '.json AS data, ' +
+  BY_SEQ_STORE + '.rev AS rev, ' +
+  DOC_STORE + '.json AS metadata';
 
-  // cache-buster, specifically designed to work around IE's aggressive caching
-  // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
-  if (options.method === 'GET' && !options.cache) {
-    var hasArgs = options.url.indexOf('?') !== -1;
-    options.url += (hasArgs ? '&' : '?') + '_nonce=' + Date.now();
-  }
+function WebSqlPouch(opts, callback) {
+  var api = this;
+  var instanceId = null;
+  var size = getSize(opts);
+  var idRequests = [];
+  var encoding;
 
-  xhr.open(options.method, options.url);
-  xhr.withCredentials = true;
+  api._docCount = -1; // cache sqlite count(*) for performance
+  api._name = opts.name;
 
-  if (options.method === 'GET') {
-    delete options.headers['Content-Type'];
-  } else if (options.json) {
-    options.headers.Accept = 'application/json';
-    options.headers['Content-Type'] = options.headers['Content-Type'] ||
-      'application/json';
-    if (options.body &&
-        options.processData &&
-        typeof options.body !== "string") {
-      options.body = JSON.stringify(options.body);
-    }
+  var db = openDB({
+    name: api._name,
+    version: POUCH_VERSION,
+    description: api._name,
+    size: size,
+    location: opts.location,
+    createFromLocation: opts.createFromLocation
+  });
+  if (!db) {
+    return callback(errors.error(errors.UNKNOWN_ERROR));
+  } else if (typeof db.readTransaction !== 'function') {
+    // doesn't exist in sqlite plugin
+    db.readTransaction = db.transaction;
   }
 
-  if (options.binary) {
-    xhr.responseType = 'arraybuffer';
+  function dbCreated() {
+    // note the db name in case the browser upgrades to idb
+    if (utils.hasLocalStorage()) {
+      window.localStorage['_pouch__websqldb_' + api._name] = true;
+    }
+    callback(null, api);
   }
 
-  if (!('body' in options)) {
-    options.body = null;
-  }
+  // In this migration, we added the 'deleted' and 'local' columns to the
+  // by-seq and doc store tables.
+  // To preserve existing user data, we re-process all the existing JSON
+  // and add these values.
+  // Called migration2 because it corresponds to adapter version (db_version) #2
+  function runMigration2(tx, callback) {
+    // index used for the join in the allDocs query
+    tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
 
-  for (var key in options.headers) {
-    if (options.headers.hasOwnProperty(key)) {
-      xhr.setRequestHeader(key, options.headers[key]);
-    }
-  }
+    tx.executeSql('ALTER TABLE ' + BY_SEQ_STORE +
+      ' ADD COLUMN deleted TINYINT(1) DEFAULT 0', [], function () {
+      tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
+      tx.executeSql('ALTER TABLE ' + DOC_STORE +
+        ' ADD COLUMN local TINYINT(1) DEFAULT 0', [], function () {
+        tx.executeSql('CREATE INDEX IF NOT EXISTS \'doc-store-local-idx\' ON ' +
+          DOC_STORE + ' (local, id)');
 
-  if (options.timeout > 0) {
-    timer = setTimeout(abortReq, options.timeout);
-    xhr.onprogress = function () {
-      clearTimeout(timer);
-      timer = setTimeout(abortReq, options.timeout);
-    };
-    if (typeof hasUpload === 'undefined') {
-      // IE throws an error if you try to access it directly
-      hasUpload = Object.keys(xhr).indexOf('upload') !== -1 &&
-                  typeof xhr.upload !== 'undefined';
-    }
-    if (hasUpload) { // does not exist in ie9
-      xhr.upload.onprogress = xhr.onprogress;
-    }
+        var sql = 'SELECT ' + DOC_STORE + '.winningseq AS seq, ' + DOC_STORE +
+          '.json AS metadata FROM ' + BY_SEQ_STORE + ' JOIN ' + DOC_STORE +
+          ' ON ' + BY_SEQ_STORE + '.seq = ' + DOC_STORE + '.winningseq';
+
+        tx.executeSql(sql, [], function (tx, result) {
+
+          var deleted = [];
+          var local = [];
+
+          for (var i = 0; i < result.rows.length; i++) {
+            var item = result.rows.item(i);
+            var seq = item.seq;
+            var metadata = JSON.parse(item.metadata);
+            if (utils.isDeleted(metadata)) {
+              deleted.push(seq);
+            }
+            if (utils.isLocalId(metadata.id)) {
+              local.push(metadata.id);
+            }
+          }
+          tx.executeSql('UPDATE ' + DOC_STORE + 'SET local = 1 WHERE id IN ' +
+            qMarks(local.length), local, function () {
+            tx.executeSql('UPDATE ' + BY_SEQ_STORE +
+              ' SET deleted = 1 WHERE seq IN ' +
+              qMarks(deleted.length), deleted, callback);
+          });
+        });
+      });
+    });
   }
 
-  xhr.onreadystatechange = function () {
-    if (xhr.readyState !== 4) {
-      return;
-    }
+  // in this migration, we make all the local docs unversioned
+  function runMigration3(tx, callback) {
+    var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
+      ' (id UNIQUE, rev, json)';
+    tx.executeSql(local, [], function () {
+      var sql = 'SELECT ' + DOC_STORE + '.id AS id, ' +
+        BY_SEQ_STORE + '.json AS data ' +
+        'FROM ' + BY_SEQ_STORE + ' JOIN ' +
+        DOC_STORE + ' ON ' + BY_SEQ_STORE + '.seq = ' +
+        DOC_STORE + '.winningseq WHERE local = 1';
+      tx.executeSql(sql, [], function (tx, res) {
+        var rows = [];
+        for (var i = 0; i < res.rows.length; i++) {
+          rows.push(res.rows.item(i));
+        }
+        function doNext() {
+          if (!rows.length) {
+            return callback(tx);
+          }
+          var row = rows.shift();
+          var rev = JSON.parse(row.data)._rev;
+          tx.executeSql('INSERT INTO ' + LOCAL_STORE +
+              ' (id, rev, json) VALUES (?,?,?)',
+              [row.id, rev, row.data], function (tx) {
+            tx.executeSql('DELETE FROM ' + DOC_STORE + ' WHERE id=?',
+                [row.id], function (tx) {
+              tx.executeSql('DELETE FROM ' + BY_SEQ_STORE + ' WHERE seq=?',
+                  [row.seq], function () {
+                doNext();
+              });
+            });
+          });
+        }
+        doNext();
+      });
+    });
+  }
 
-    var response = {
-      statusCode: xhr.status
-    };
+  // in this migration, we remove doc_id_rev and just use rev
+  function runMigration4(tx, callback) {
 
-    if (xhr.status >= 200 && xhr.status < 300) {
-      var data;
-      if (options.binary) {
-        data = createBlob([xhr.response || ''], {
-          type: xhr.getResponseHeader('Content-Type')
+    function updateRows(rows) {
+      function doNext() {
+        if (!rows.length) {
+          return callback(tx);
+        }
+        var row = rows.shift();
+        var doc_id_rev = parseHexString(row.hex, encoding);
+        var idx = doc_id_rev.lastIndexOf('::');
+        var doc_id = doc_id_rev.substring(0, idx);
+        var rev = doc_id_rev.substring(idx + 2);
+        var sql = 'UPDATE ' + BY_SEQ_STORE +
+          ' SET doc_id=?, rev=? WHERE doc_id_rev=?';
+        tx.executeSql(sql, [doc_id, rev, doc_id_rev], function () {
+          doNext();
         });
-      } else {
-        data = xhr.responseText;
       }
-      callback(null, response, data);
-    } else {
-      var err = {};
-      try {
-        err = JSON.parse(xhr.response);
-      } catch(e) {}
-      callback(err, response);
+      doNext();
     }
-  };
 
-  if (options.body && (options.body instanceof Blob)) {
-    utils.readAsBinaryString(options.body, function (binary) {
-      xhr.send(utils.fixBinary(binary));
+    var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN doc_id';
+    tx.executeSql(sql, [], function (tx) {
+      var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN rev';
+      tx.executeSql(sql, [], function (tx) {
+        tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL, [], function (tx) {
+          var sql = 'SELECT hex(doc_id_rev) as hex FROM ' + BY_SEQ_STORE;
+          tx.executeSql(sql, [], function (tx, res) {
+            var rows = [];
+            for (var i = 0; i < res.rows.length; i++) {
+              rows.push(res.rows.item(i));
+            }
+            updateRows(rows);
+          });
+        });
+      });
     });
-  } else {
-    xhr.send(options.body);
   }
 
-  return {abort: abortReq};
-}
-
-module.exports = function(options, callback) {
-  if (typeof XMLHttpRequest === 'undefined' && !options.xhr) {
-    return fetchRequest(options, callback);
-  } else {
-    return xhRequest(options, callback);
-  }
-};
+  // in this migration, we add the attach_and_seq table
+  // for issue #2818
+  function runMigration5(tx, callback) {
 
-},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./blob.js":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/upsert.js":[function(require,module,exports){
-'use strict';
+    function migrateAttsAndSeqs(tx) {
+      // need to actually populate the table. this is the expensive part,
+      // so as an optimization, check first that this database even
+      // contains attachments
+      var sql = 'SELECT COUNT(*) AS cnt FROM ' + ATTACH_STORE;
+      tx.executeSql(sql, [], function (tx, res) {
+        var count = res.rows.item(0).cnt;
+        if (!count) {
+          return callback(tx);
+        }
 
-var upsert = require('pouchdb-upsert').upsert;
+        var offset = 0;
+        var pageSize = 10;
+        function nextPage() {
+          var sql = select(
+            SELECT_DOCS + ', ' + DOC_STORE + '.id AS id',
+            [DOC_STORE, BY_SEQ_STORE],
+            DOC_STORE_AND_BY_SEQ_JOINER,
+            null,
+            DOC_STORE + '.id '
+          );
+          sql += ' LIMIT ' + pageSize + ' OFFSET ' + offset;
+          offset += pageSize;
+          tx.executeSql(sql, [], function (tx, res) {
+            if (!res.rows.length) {
+              return callback(tx);
+            }
+            var digestSeqs = {};
+            function addDigestSeq(digest, seq) {
+              // uniq digest/seq pairs, just in case there are dups
+              var seqs = digestSeqs[digest] = (digestSeqs[digest] || []);
+              if (seqs.indexOf(seq) === -1) {
+                seqs.push(seq);
+              }
+            }
+            for (var i = 0; i < res.rows.length; i++) {
+              var row = res.rows.item(i);
+              var doc = unstringifyDoc(row.data, row.id, row.rev);
+              var atts = Object.keys(doc._attachments || {});
+              for (var j = 0; j < atts.length; j++) {
+                var att = doc._attachments[atts[j]];
+                addDigestSeq(att.digest, row.seq);
+              }
+            }
+            var digestSeqPairs = [];
+            Object.keys(digestSeqs).forEach(function (digest) {
+              var seqs = digestSeqs[digest];
+              seqs.forEach(function (seq) {
+                digestSeqPairs.push([digest, seq]);
+              });
+            });
+            if (!digestSeqPairs.length) {
+              return nextPage();
+            }
+            var numDone = 0;
+            digestSeqPairs.forEach(function (pair) {
+              var sql = 'INSERT INTO ' + ATTACH_AND_SEQ_STORE +
+                ' (digest, seq) VALUES (?,?)';
+              tx.executeSql(sql, pair, function () {
+                if (++numDone === digestSeqPairs.length) {
+                  nextPage();
+                }
+              });
+            });
+          });
+        }
+        nextPage();
+      });
+    }
 
-module.exports = function (db, doc, diffFun, cb) {
-  return upsert.call(db, doc, diffFun, cb);
-};
+    var attachAndRev = 'CREATE TABLE IF NOT EXISTS ' +
+      ATTACH_AND_SEQ_STORE + ' (digest, seq INTEGER)';
+    tx.executeSql(attachAndRev, [], function (tx) {
+      tx.executeSql(
+        ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL, [], function (tx) {
+          tx.executeSql(
+            ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL, [],
+            migrateAttsAndSeqs);
+        });
+    });
+  }
 
-},{"pouchdb-upsert":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-upsert/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js":[function(require,module,exports){
-arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js"][0].apply(exports,arguments)
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalFilter.js":[function(require,module,exports){
-'use strict';
+  // in this migration, we use escapeBlob() and unescapeBlob()
+  // instead of reading out the binary as HEX, which is slow
+  function runMigration6(tx, callback) {
+    var sql = 'ALTER TABLE ' + ATTACH_STORE +
+      ' ADD COLUMN escaped TINYINT(1) DEFAULT 0';
+    tx.executeSql(sql, [], callback);
+  }
 
-module.exports = evalFilter;
-function evalFilter(input) {
-  /*jshint evil: true */
-  return eval([
-    '(function () { return ',
-    input,
-    ' })()'
-  ].join(''));
-}
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalView.js":[function(require,module,exports){
-'use strict';
+  // issue #3136, in this migration we need a "latest seq" as well
+  // as the "winning seq" in the doc store
+  function runMigration7(tx, callback) {
+    var sql = 'ALTER TABLE ' + DOC_STORE +
+      ' ADD COLUMN max_seq INTEGER';
+    tx.executeSql(sql, [], function (tx) {
+      var sql = 'UPDATE ' + DOC_STORE + ' SET max_seq=(SELECT MAX(seq) FROM ' +
+        BY_SEQ_STORE + ' WHERE doc_id=id)';
+      tx.executeSql(sql, [], function (tx) {
+        // add unique index after filling, else we'll get a constraint
+        // error when we do the ALTER TABLE
+        var sql =
+          'CREATE UNIQUE INDEX IF NOT EXISTS \'doc-max-seq-idx\' ON ' +
+          DOC_STORE + ' (max_seq)';
+        tx.executeSql(sql, [], callback);
+      });
+    });
+  }
 
-module.exports = evalView;
-function evalView(input) {
-  /*jshint evil: true */
-  return eval([
-    '(function () {',
-    '  return function (doc) {',
-    '    var emitted = false;',
-    '    var emit = function (a, b) {',
-    '      emitted = true;',
-    '    };',
-    '    var view = ' + input + ';',
-    '    view(doc);',
-    '    if (emitted) {',
-    '      return true;',
-    '    }',
-    '  }',
-    '})()'
-  ].join('\n'));
-}
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/index.js":[function(require,module,exports){
-(function (process){
-"use strict";
+  function checkEncoding(tx, cb) {
+    // UTF-8 on chrome/android, UTF-16 on safari < 7.1
+    tx.executeSql('SELECT HEX("a") AS hex', [], function (tx, res) {
+        var hex = res.rows.item(0).hex;
+        encoding = hex.length === 2 ? 'UTF-8' : 'UTF-16';
+        cb();
+      }
+    );
+  }
 
-var PouchDB = require('./setup');
+  function onGetInstanceId() {
+    while (idRequests.length > 0) {
+      var idCallback = idRequests.pop();
+      idCallback(null, instanceId);
+    }
+  }
 
-module.exports = PouchDB;
+  function onGetVersion(tx, dbVersion) {
+    if (dbVersion === 0) {
+      // initial schema
 
-PouchDB.ajax = require('./deps/ajax');
-PouchDB.utils = require('./utils');
-PouchDB.Errors = require('./deps/errors');
-PouchDB.replicate = require('./replicate').replicate;
-PouchDB.sync = require('./sync');
-PouchDB.version = require('./version');
-var httpAdapter = require('./adapters/http/http');
-PouchDB.adapter('http', httpAdapter);
-PouchDB.adapter('https', httpAdapter);
+      var meta = 'CREATE TABLE IF NOT EXISTS ' + META_STORE +
+        ' (dbid, db_version INTEGER)';
+      var attach = 'CREATE TABLE IF NOT EXISTS ' + ATTACH_STORE +
+        ' (digest UNIQUE, escaped TINYINT(1), body BLOB)';
+      var attachAndRev = 'CREATE TABLE IF NOT EXISTS ' +
+        ATTACH_AND_SEQ_STORE + ' (digest, seq INTEGER)';
+      // TODO: migrate winningseq to INTEGER
+      var doc = 'CREATE TABLE IF NOT EXISTS ' + DOC_STORE +
+        ' (id unique, json, winningseq, max_seq INTEGER UNIQUE)';
+      var seq = 'CREATE TABLE IF NOT EXISTS ' + BY_SEQ_STORE +
+        ' (seq INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, ' +
+        'json, deleted TINYINT(1), doc_id, rev)';
+      var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
+        ' (id UNIQUE, rev, json)';
 
-PouchDB.adapter('idb', require('./adapters/idb/idb'), true);
-PouchDB.adapter('websql', require('./adapters/websql/websql'), true);
-PouchDB.plugin(require('pouchdb-mapreduce'));
+      // creates
+      tx.executeSql(attach);
+      tx.executeSql(local);
+      tx.executeSql(attachAndRev, [], function () {
+        tx.executeSql(ATTACH_AND_SEQ_STORE_SEQ_INDEX_SQL);
+        tx.executeSql(ATTACH_AND_SEQ_STORE_ATTACH_INDEX_SQL);
+      });
+      tx.executeSql(doc, [], function () {
+        tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
+        tx.executeSql(seq, [], function () {
+          tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
+          tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL);
+          tx.executeSql(meta, [], function () {
+            // mark the db version, and new dbid
+            var initSeq = 'INSERT INTO ' + META_STORE +
+              ' (db_version, dbid) VALUES (?,?)';
+            instanceId = utils.uuid();
+            var initSeqArgs = [ADAPTER_VERSION, instanceId];
+            tx.executeSql(initSeq, initSeqArgs, function () {
+              onGetInstanceId();
+            });
+          });
+        });
+      });
+    } else { // version > 0
 
-if (!process.browser) {
-  var ldbAdapter = require('./adapters/leveldb/leveldb');
-  PouchDB.adapter('leveldb', ldbAdapter, true);
-}
+      var setupDone = function () {
+        var migrated = dbVersion < ADAPTER_VERSION;
+        if (migrated) {
+          // update the db version within this transaction
+          tx.executeSql('UPDATE ' + META_STORE + ' SET db_version = ' +
+            ADAPTER_VERSION);
+        }
+        // notify db.id() callers
+        var sql = 'SELECT dbid FROM ' + META_STORE;
+        tx.executeSql(sql, [], function (tx, result) {
+          instanceId = result.rows.item(0).dbid;
+          onGetInstanceId();
+        });
+      };
 
-}).call(this,require('_process'))
-},{"./adapters/http/http":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/http/http.js","./adapters/idb/idb":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb.js","./adapters/leveldb/leveldb":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","./adapters/websql/websql":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql.js","./deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./replicate":"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js","./setup":"/Users/richard/src/beagle/node_modules/pouchdb/lib/setup.js","./sync":"/Users/richard/src/beagle/node_modules/pouchdb/lib/sync.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./version":"/Users/richard/src/beagle/node_modules/pouchdb/lib/version-browser.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","pouchdb-mapreduce":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-mapreduce/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js":[function(require,module,exports){
-'use strict';
-var extend = require('pouchdb-extend');
+      // would love to use promises here, but then websql
+      // ends the transaction early
+      var tasks = [
+        runMigration2,
+        runMigration3,
+        runMigration4,
+        runMigration5,
+        runMigration6,
+        runMigration7,
+        setupDone
+      ];
 
+      // run each migration sequentially
+      var i = dbVersion;
+      var nextMigration = function (tx) {
+        tasks[i - 1](tx, nextMigration);
+        i++;
+      };
+      nextMigration(tx);
+    }
+  }
 
-// for a better overview of what this is doing, read:
-// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
-//
-// But for a quick intro, CouchDB uses a revision tree to store a documents
-// history, A -> B -> C, when a document has conflicts, that is a branch in the
-// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
-//
-// KeyTree = [Path ... ]
-// Path = {pos: position_from_root, ids: Tree}
-// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
+  function setup() {
+    db.transaction(function (tx) {
+      // first check the encoding
+      checkEncoding(tx, function () {
+        // then get the version
+        fetchVersion(tx);
+      });
+    }, unknownError(callback), dbCreated);
+  }
 
-// classic binary search
-function binarySearch(arr, item, comparator) {
-  var low = 0;
-  var high = arr.length;
-  var mid;
-  while (low < high) {
-    mid = (low + high) >>> 1;
-    if (comparator(arr[mid], item) < 0) {
-      low = mid + 1;
-    } else {
-      high = mid;
-    }
+  function fetchVersion(tx) {
+    var sql = 'SELECT sql FROM sqlite_master WHERE tbl_name = ' + META_STORE;
+    tx.executeSql(sql, [], function (tx, result) {
+      if (!result.rows.length) {
+        // database hasn't even been created yet (version 0)
+        onGetVersion(tx, 0);
+      } else if (!/db_version/.test(result.rows.item(0).sql)) {
+        // table was created, but without the new db_version column,
+        // so add it.
+        tx.executeSql('ALTER TABLE ' + META_STORE +
+          ' ADD COLUMN db_version INTEGER', [], function () {
+          // before version 2, this column didn't even exist
+          onGetVersion(tx, 1);
+        });
+      } else { // column exists, we can safely get it
+        tx.executeSql('SELECT db_version FROM ' + META_STORE,
+          [], function (tx, result) {
+          var dbVersion = result.rows.item(0).db_version;
+          onGetVersion(tx, dbVersion);
+        });
+      }
+    });
   }
-  return low;
-}
 
-// assuming the arr is sorted, insert the item in the proper place
-function insertSorted(arr, item, comparator) {
-  var idx = binarySearch(arr, item, comparator);
-  arr.splice(idx, 0, item);
-}
+  if (utils.isCordova()) {
+    //to wait until custom api is made in pouch.adapters before doing setup
+    window.addEventListener(api._name + '_pouch', function cordova_init() {
+      window.removeEventListener(api._name + '_pouch', cordova_init, false);
+      setup();
+    }, false);
+  } else {
+    setup();
+  }
 
-// Turn a path as a flat array into a tree with a single branch
-function pathToTree(path) {
-  var doc = path.shift();
-  var root = [doc.id, doc.opts, []];
-  var leaf = root;
-  var nleaf;
+  api.type = function () {
+    return 'websql';
+  };
 
-  while (path.length) {
-    doc = path.shift();
-    nleaf = [doc.id, doc.opts, []];
-    leaf[2].push(nleaf);
-    leaf = nleaf;
-  }
-  return root;
-}
+  api._id = utils.toPromise(function (callback) {
+    callback(null, instanceId);
+  });
 
-// compare the IDs of two trees
-function compareTree(a, b) {
-  return a[0] < b[0] ? -1 : 1;
-}
+  api._info = function (callback) {
+    db.readTransaction(function (tx) {
+      countDocs(tx, function (docCount) {
+        var sql = 'SELECT MAX(seq) AS seq FROM ' + BY_SEQ_STORE;
+        tx.executeSql(sql, [], function (tx, res) {
+          var updateSeq = res.rows.item(0).seq || 0;
+          callback(null, {
+            doc_count: docCount,
+            update_seq: updateSeq,
+            // for debugging
+            sqlite_plugin: db._sqlitePlugin,
+            websql_encoding: encoding
+          });
+        });
+      });
+    }, unknownError(callback));
+  };
 
-// Merge two trees together
-// The roots of tree1 and tree2 must be the same revision
-function mergeTree(in_tree1, in_tree2) {
-  var queue = [{tree1: in_tree1, tree2: in_tree2}];
-  var conflicts = false;
-  while (queue.length > 0) {
-    var item = queue.pop();
-    var tree1 = item.tree1;
-    var tree2 = item.tree2;
+  api._bulkDocs = function (req, opts, callback) {
+    websqlBulkDocs(req, opts, api, db, WebSqlPouch.Changes, callback);
+  };
 
-    if (tree1[1].status || tree2[1].status) {
-      tree1[1].status =
-        (tree1[1].status ===  'available' ||
-         tree2[1].status === 'available') ? 'available' : 'missing';
+  api._get = function (id, opts, callback) {
+    opts = utils.clone(opts);
+    var doc;
+    var metadata;
+    var err;
+    if (!opts.ctx) {
+      db.readTransaction(function (txn) {
+        opts.ctx = txn;
+        api._get(id, opts, callback);
+      });
+      return;
     }
+    var tx = opts.ctx;
 
-    for (var i = 0; i < tree2[2].length; i++) {
-      if (!tree1[2][0]) {
-        conflicts = 'new_leaf';
-        tree1[2][0] = tree2[2][i];
-        continue;
-      }
+    function finish() {
+      callback(err, {doc: doc, metadata: metadata, ctx: tx});
+    }
 
-      var merged = false;
-      for (var j = 0; j < tree1[2].length; j++) {
-        if (tree1[2][j][0] === tree2[2][i][0]) {
-          queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
-          merged = true;
-        }
+    var sql;
+    var sqlArgs;
+    if (opts.rev) {
+      sql = select(
+        SELECT_DOCS,
+        [DOC_STORE, BY_SEQ_STORE],
+        DOC_STORE + '.id=' + BY_SEQ_STORE + '.doc_id',
+        [BY_SEQ_STORE + '.doc_id=?', BY_SEQ_STORE + '.rev=?']);
+      sqlArgs = [id, opts.rev];
+    } else {
+      sql = select(
+        SELECT_DOCS,
+        [DOC_STORE, BY_SEQ_STORE],
+        DOC_STORE_AND_BY_SEQ_JOINER,
+        DOC_STORE + '.id=?');
+      sqlArgs = [id];
+    }
+    tx.executeSql(sql, sqlArgs, function (a, results) {
+      if (!results.rows.length) {
+        err = errors.error(errors.MISSING_DOC, 'missing');
+        return finish();
       }
-      if (!merged) {
-        conflicts = 'new_branch';
-        insertSorted(tree1[2], tree2[2][i], compareTree);
+      var item = results.rows.item(0);
+      metadata = utils.safeJsonParse(item.metadata);
+      if (item.deleted && !opts.rev) {
+        err = errors.error(errors.MISSING_DOC, 'deleted');
+        return finish();
       }
+      doc = unstringifyDoc(item.data, metadata.id, item.rev);
+      finish();
+    });
+  };
+
+  function countDocs(tx, callback) {
+
+    if (api._docCount !== -1) {
+      return callback(api._docCount);
     }
-  }
-  return {conflicts: conflicts, tree: in_tree1};
-}
 
-function doMerge(tree, path, dontExpand) {
-  var restree = [];
-  var conflicts = false;
-  var merged = false;
-  var res;
+    // count the total rows
+    var sql = select(
+      'COUNT(' + DOC_STORE + '.id) AS \'num\'',
+      [DOC_STORE, BY_SEQ_STORE],
+      DOC_STORE_AND_BY_SEQ_JOINER,
+      BY_SEQ_STORE + '.deleted=0');
 
-  if (!tree.length) {
-    return {tree: [path], conflicts: 'new_leaf'};
+    tx.executeSql(sql, [], function (tx, result) {
+      api._docCount = result.rows.item(0).num;
+      callback(api._docCount);
+    });
   }
 
-  tree.forEach(function (branch) {
-    if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
-      // Paths start at the same position and have the same root, so they need
-      // merged
-      res = mergeTree(branch.ids, path.ids);
-      restree.push({pos: branch.pos, ids: res.tree});
-      conflicts = conflicts || res.conflicts;
-      merged = true;
-    } else if (dontExpand !== true) {
-      // The paths start at a different position, take the earliest path and
-      // traverse up until it as at the same point from root as the path we
-      // want to merge.  If the keys match we return the longer path with the
-      // other merged After stemming we dont want to expand the trees
+  api._allDocs = function (opts, callback) {
+    var results = [];
+    var totalRows;
 
-      var t1 = branch.pos < path.pos ? branch : path;
-      var t2 = branch.pos < path.pos ? path : branch;
-      var diff = t2.pos - t1.pos;
+    var start = 'startkey' in opts ? opts.startkey : false;
+    var end = 'endkey' in opts ? opts.endkey : false;
+    var key = 'key' in opts ? opts.key : false;
+    var descending = 'descending' in opts ? opts.descending : false;
+    var limit = 'limit' in opts ? opts.limit : -1;
+    var offset = 'skip' in opts ? opts.skip : 0;
+    var inclusiveEnd = opts.inclusive_end !== false;
 
-      var candidateParents = [];
+    var sqlArgs = [];
+    var criteria = [];
 
-      var trees = [];
-      trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
-      while (trees.length > 0) {
-        var item = trees.pop();
-        if (item.diff === 0) {
-          if (item.ids[0] === t2.ids[0]) {
-            candidateParents.push(item);
-          }
-          continue;
-        }
-        if (!item.ids) {
-          continue;
+    if (key !== false) {
+      criteria.push(DOC_STORE + '.id = ?');
+      sqlArgs.push(key);
+    } else if (start !== false || end !== false) {
+      if (start !== false) {
+        criteria.push(DOC_STORE + '.id ' + (descending ? '<=' : '>=') + ' ?');
+        sqlArgs.push(start);
+      }
+      if (end !== false) {
+        var comparator = descending ? '>' : '<';
+        if (inclusiveEnd) {
+          comparator += '=';
         }
-        /*jshint loopfunc:true */
-        item.ids[2].forEach(function (el, idx) {
-          trees.push(
-            {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
-        });
+        criteria.push(DOC_STORE + '.id ' + comparator + ' ?');
+        sqlArgs.push(end);
       }
-
-      var el = candidateParents[0];
-
-      if (!el) {
-        restree.push(branch);
-      } else {
-        res = mergeTree(el.ids, t2.ids);
-        el.parent[2][el.parentIdx] = res.tree;
-        restree.push({pos: t1.pos, ids: t1.ids});
-        conflicts = conflicts || res.conflicts;
-        merged = true;
+      if (key !== false) {
+        criteria.push(DOC_STORE + '.id = ?');
+        sqlArgs.push(key);
       }
-    } else {
-      restree.push(branch);
     }
-  });
 
-  // We didnt find
-  if (!merged) {
-    restree.push(path);
-  }
+    if (opts.deleted !== 'ok') {
+      // report deleted if keys are specified
+      criteria.push(BY_SEQ_STORE + '.deleted = 0');
+    }
 
-  restree.sort(function (a, b) {
-    return a.pos - b.pos;
-  });
+    db.readTransaction(function (tx) {
 
-  return {
-    tree: restree,
-    conflicts: conflicts || 'internal_node'
-  };
-}
+      // first count up the total rows
+      countDocs(tx, function (count) {
+        totalRows = count;
 
-// To ensure we dont grow the revision tree infinitely, we stem old revisions
-function stem(tree, depth) {
-  // First we break out the tree into a complete list of root to leaf paths,
-  // we cut off the start of the path and generate a new set of flat trees
-  var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
-    var stemmed = path.ids.slice(-depth);
-    return {
-      pos: path.pos + (path.ids.length - stemmed.length),
-      ids: pathToTree(stemmed)
-    };
-  });
-  // Then we remerge all those flat trees together, ensuring that we dont
-  // connect trees that would go beyond the depth limit
-  return stemmedPaths.reduce(function (prev, current) {
-    return doMerge(prev, current, true).tree;
-  }, [stemmedPaths.shift()]);
-}
+        if (limit === 0) {
+          return;
+        }
 
-var PouchMerge = {};
+        // then actually fetch the documents
+        var sql = select(
+          SELECT_DOCS,
+          [DOC_STORE, BY_SEQ_STORE],
+          DOC_STORE_AND_BY_SEQ_JOINER,
+          criteria,
+          DOC_STORE + '.id ' + (descending ? 'DESC' : 'ASC')
+          );
+        sql += ' LIMIT ' + limit + ' OFFSET ' + offset;
 
-PouchMerge.merge = function (tree, path, depth) {
-  // Ugh, nicer way to not modify arguments in place?
-  tree = extend(true, [], tree);
-  path = extend(true, {}, path);
-  var newTree = doMerge(tree, path);
-  return {
-    tree: stem(newTree.tree, depth),
-    conflicts: newTree.conflicts
+        tx.executeSql(sql, sqlArgs, function (tx, result) {
+          for (var i = 0, l = result.rows.length; i < l; i++) {
+            var item = result.rows.item(i);
+            var metadata = utils.safeJsonParse(item.metadata);
+            var id = metadata.id;
+            var data = unstringifyDoc(item.data, id, item.rev);
+            var winningRev = data._rev;
+            var doc = {
+              id: id,
+              key: id,
+              value: {rev: winningRev}
+            };
+            if (opts.include_docs) {
+              doc.doc = data;
+              doc.doc._rev = winningRev;
+              if (opts.conflicts) {
+                doc.doc._conflicts = merge.collectConflicts(metadata);
+              }
+              fetchAttachmentsIfNecessary(doc.doc, opts, api, tx);
+            }
+            if (item.deleted) {
+              if (opts.deleted === 'ok') {
+                doc.value.deleted = true;
+                doc.doc = null;
+              } else {
+                continue;
+              }
+            }
+            results.push(doc);
+          }
+        });
+      });
+    }, unknownError(callback), function () {
+      callback(null, {
+        total_rows: totalRows,
+        offset: opts.skip,
+        rows: results
+      });
+    });
   };
-};
-
-// We fetch all leafs of the revision tree, and sort them based on tree length
-// and whether they were deleted, undeleted documents with the longest revision
-// tree (most edits) win
-// The final sort algorithm is slightly documented in a sidebar here:
-// http://guide.couchdb.org/draft/conflicts.html
-PouchMerge.winningRev = function (metadata) {
-  var leafs = [];
-  PouchMerge.traverseRevTree(metadata.rev_tree,
-                              function (isLeaf, pos, id, something, opts) {
-    if (isLeaf) {
-      leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
-    }
-  });
-  leafs.sort(function (a, b) {
-    if (a.deleted !== b.deleted) {
-      return a.deleted > b.deleted ? 1 : -1;
-    }
-    if (a.pos !== b.pos) {
-      return b.pos - a.pos;
-    }
-    return a.id < b.id ? 1 : -1;
-  });
-
-  return leafs[0].pos + '-' + leafs[0].id;
-};
 
-// Pretty much all below can be combined into a higher order function to
-// traverse revisions
-// The return value from the callback will be passed as context to all
-// children of that node
-PouchMerge.traverseRevTree = function (revs, callback) {
-  var toVisit = revs.slice();
+  api._changes = function (opts) {
+    opts = utils.clone(opts);
 
-  var node;
-  while ((node = toVisit.pop())) {
-    var pos = node.pos;
-    var tree = node.ids;
-    var branches = tree[2];
-    var newCtx =
-      callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
-    for (var i = 0, len = branches.length; i < len; i++) {
-      toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
+    if (opts.continuous) {
+      var id = api._name + ':' + utils.uuid();
+      WebSqlPouch.Changes.addListener(api._name, id, api, opts);
+      WebSqlPouch.Changes.notify(api._name);
+      return {
+        cancel: function () {
+          WebSqlPouch.Changes.removeListener(api._name, id);
+        }
+      };
     }
-  }
-};
 
-PouchMerge.collectLeaves = function (revs) {
-  var leaves = [];
-  PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
-    if (isLeaf) {
-      leaves.push({rev: pos + "-" + id, pos: pos, opts: opts});
-    }
-  });
-  leaves.sort(function (a, b) {
-    return b.pos - a.pos;
-  });
-  leaves.forEach(function (leaf) { delete leaf.pos; });
-  return leaves;
-};
+    var descending = opts.descending;
 
-// returns revs of all conflicts that is leaves such that
-// 1. are not deleted and
-// 2. are different than winning revision
-PouchMerge.collectConflicts = function (metadata) {
-  var win = PouchMerge.winningRev(metadata);
-  var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
-  var conflicts = [];
-  leaves.forEach(function (leaf) {
-    if (leaf.rev !== win && !leaf.opts.deleted) {
-      conflicts.push(leaf.rev);
-    }
-  });
-  return conflicts;
-};
+    // Ignore the `since` parameter when `descending` is true
+    opts.since = opts.since && !descending ? opts.since : 0;
 
-PouchMerge.rootToLeaf = function (tree) {
-  var paths = [];
-  PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
-    history = history ? history.slice(0) : [];
-    history.push({id: id, opts: opts});
-    if (isLeaf) {
-      var rootPos = pos + 1 - history.length;
-      paths.unshift({pos: rootPos, ids: history});
+    var limit = 'limit' in opts ? opts.limit : -1;
+    if (limit === 0) {
+      limit = 1; // per CouchDB _changes spec
     }
-    return history;
-  });
-  return paths;
-};
-
-
-module.exports = PouchMerge;
 
-},{"pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-extend/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js":[function(require,module,exports){
-'use strict';
-
-var utils = require('./utils');
-var EE = require('events').EventEmitter;
-var Checkpointer = require('./checkpointer');
+    var returnDocs;
+    if ('returnDocs' in opts) {
+      returnDocs = opts.returnDocs;
+    } else {
+      returnDocs = true;
+    }
+    var results = [];
+    var numResults = 0;
 
-var MAX_SIMULTANEOUS_REVS = 50;
-var RETRY_DEFAULT = false;
+    function fetchChanges() {
 
-function randomNumber(min, max) {
-  min = parseInt(min, 10);
-  max = parseInt(max, 10);
-  if (min !== min) {
-    min = 0;
-  }
-  if (max !== max || max <= min) {
-    max = (min || 1) << 1; //doubling
-  } else {
-    max = max + 1;
-  }
-  var ratio = Math.random();
-  var range = max - min;
+      var selectStmt =
+        DOC_STORE + '.json AS metadata, ' +
+        DOC_STORE + '.max_seq AS maxSeq, ' +
+        BY_SEQ_STORE + '.json AS winningDoc, ' +
+        BY_SEQ_STORE + '.rev AS winningRev ';
 
-  return ~~(range * ratio + min); // ~~ coerces to an int, but fast.
-}
+      var from = DOC_STORE + ' JOIN ' + BY_SEQ_STORE;
 
-function defaultBackOff(min) {
-  var max = 0;
-  if (!min) {
-    max = 2000;
-  }
-  return randomNumber(min, max);
-}
+      var joiner = DOC_STORE + '.id=' + BY_SEQ_STORE + '.doc_id' +
+        ' AND ' + DOC_STORE + '.winningseq=' + BY_SEQ_STORE + '.seq';
 
-function backOff(repId, src, target, opts, returnValue, result, error) {
-  if (opts.retry === false) {
-    returnValue.emit('error', error);
-    returnValue.removeAllListeners();
-    return;
-  }
-  opts.default_back_off = opts.default_back_off || 0;
-  opts.retries = opts.retries || 0;
-  if (typeof opts.back_off_function !== 'function') {
-    opts.back_off_function = defaultBackOff;
-  }
-  opts.retries++;
-  if (opts.max_retries && opts.retries > opts.max_retries) {
-    returnValue.emit('error', new Error('tried ' +
-      opts.retries + ' times but replication failed'));
-    returnValue.removeAllListeners();
-    return;
-  }
-  returnValue.emit('requestError', error);
-  if (returnValue.state === 'active') {
-    returnValue.emit('paused', error);
-    returnValue.state = 'stopped';
-    returnValue.once('active', function () {
-      opts.current_back_off = opts.default_back_off;
-    });
-  }
+      var criteria = ['maxSeq > ?'];
+      var sqlArgs = [opts.since];
 
-  opts.current_back_off = opts.current_back_off || opts.default_back_off;
-  opts.current_back_off = opts.back_off_function(opts.current_back_off);
-  setTimeout(function () {
-    replicate(repId, src, target, opts, returnValue);
-  }, opts.current_back_off);
-}
+      if (opts.doc_ids) {
+        criteria.push(DOC_STORE + '.id IN ' + qMarks(opts.doc_ids.length));
+        sqlArgs = sqlArgs.concat(opts.doc_ids);
+      }
 
-// We create a basic promise so the caller can cancel the replication possibly
-// before we have actually started listening to changes etc
-utils.inherits(Replication, EE);
-function Replication() {
-  EE.call(this);
-  this.cancelled = false;
-  this.state = 'pending';
-  var self = this;
-  var promise = new utils.Promise(function (fulfill, reject) {
-    self.once('complete', fulfill);
-    self.once('error', reject);
-  });
-  self.then = function (resolve, reject) {
-    return promise.then(resolve, reject);
-  };
-  self.catch = function (reject) {
-    return promise.catch(reject);
-  };
-  // As we allow error handling via "error" event as well,
-  // put a stub in here so that rejecting never throws UnhandledError.
-  self.catch(function () {});
-}
+      var orderBy = 'maxSeq ' + (descending ? 'DESC' : 'ASC');
 
-Replication.prototype.cancel = function () {
-  this.cancelled = true;
-  this.state = 'cancelled';
-  this.emit('cancel');
-};
+      var sql = select(selectStmt, from, joiner, criteria, orderBy);
 
-Replication.prototype.ready = function (src, target) {
-  var self = this;
-  function onDestroy() {
-    self.cancel();
-  }
-  src.once('destroyed', onDestroy);
-  target.once('destroyed', onDestroy);
-  function cleanup() {
-    src.removeListener('destroyed', onDestroy);
-    target.removeListener('destroyed', onDestroy);
-  }
-  this.then(cleanup, cleanup);
-};
+      var filter = utils.filterChange(opts);
+      if (!opts.view && !opts.filter) {
+        // we can just limit in the query
+        sql += ' LIMIT ' + limit;
+      }
 
+      var lastSeq = opts.since || 0;
+      db.readTransaction(function (tx) {
+        tx.executeSql(sql, sqlArgs, function (tx, result) {
+          function reportChange(change) {
+            return function () {
+              opts.onChange(change);
+            };
+          }
+          for (var i = 0, l = result.rows.length; i < l; i++) {
+            var item = result.rows.item(i);
+            var metadata = utils.safeJsonParse(item.metadata);
+            lastSeq = item.maxSeq;
 
-// TODO: check CouchDB's replication id generation
-// Generate a unique id particular to this replication
-function genReplicationId(src, target, opts) {
-  var filterFun = opts.filter ? opts.filter.toString() : '';
-  return src.id().then(function (src_id) {
-    return target.id().then(function (target_id) {
-      var queryData = src_id + target_id + filterFun +
-        JSON.stringify(opts.query_params) + opts.doc_ids;
-      return utils.MD5(queryData).then(function (md5) {
-        // can't use straight-up md5 alphabet, because
-        // the char '/' is interpreted as being for attachments,
-        // and + is also not url-safe
-        md5 = md5.replace(/\//g, '.').replace(/\+/g, '_');
-        return '_local/' + md5;
+            var doc = unstringifyDoc(item.winningDoc, metadata.id,
+              item.winningRev);
+            var change = opts.processChange(doc, metadata, opts);
+            change.seq = item.maxSeq;
+            if (filter(change)) {
+              numResults++;
+              if (returnDocs) {
+                results.push(change);
+              }
+              // process the attachment immediately
+              // for the benefit of live listeners
+              if (opts.attachments && opts.include_docs) {
+                fetchAttachmentsIfNecessary(doc, opts, api, tx,
+                  reportChange(change));
+              } else {
+                reportChange(change)();
+              }
+            }
+            if (numResults === limit) {
+              break;
+            }
+          }
+        });
+      }, unknownError(opts.complete), function () {
+        if (!opts.continuous) {
+          opts.complete(null, {
+            results: results,
+            last_seq: lastSeq
+          });
+        }
       });
-    });
-  });
-}
+    }
 
-function replicate(repId, src, target, opts, returnValue, result) {
-  var batches = [];               // list of batches to be processed
-  var currentBatch;               // the batch currently being processed
-  var pendingBatch = {
-    seq: 0,
-    changes: [],
-    docs: []
-  }; // next batch, not yet ready to be processed
-  var writingCheckpoint = false;  // true while checkpoint is being written
-  var changesCompleted = false;   // true when all changes received
-  var replicationCompleted = false; // true when replication has completed
-  var last_seq = 0;
-  var continuous = opts.continuous || opts.live || false;
-  var batch_size = opts.batch_size || 100;
-  var batches_limit = opts.batches_limit || 10;
-  var changesPending = false;     // true while src.changes is running
-  var doc_ids = opts.doc_ids;
-  var state = {
-    cancelled: false
+    fetchChanges();
   };
-  var checkpointer = new Checkpointer(src, target, repId, state);
-  var allErrors = [];
-  var changedDocs = [];
 
-  result = result || {
-    ok: true,
-    start_time: new Date(),
-    docs_read: 0,
-    docs_written: 0,
-    doc_write_failures: 0,
-    errors: []
+  api._close = function (callback) {
+    //WebSQL databases do not need to be closed
+    callback();
   };
 
-  var changesOpts = {};
-  returnValue.ready(src, target);
-
-  function writeDocs() {
-    if (currentBatch.docs.length === 0) {
-      return;
-    }
-    var docs = currentBatch.docs;
-    return target.bulkDocs({docs: docs, new_edits: false}).then(function (res) {
-      if (state.cancelled) {
-        completeReplication();
-        throw new Error('cancelled');
+  api._getAttachment = function (attachment, opts, callback) {
+    var res;
+    var tx = opts.ctx;
+    var digest = attachment.digest;
+    var type = attachment.content_type;
+    var sql = 'SELECT escaped, ' +
+      'CASE WHEN escaped = 1 THEN body ELSE HEX(body) END AS body FROM ' +
+      ATTACH_STORE + ' WHERE digest=?';
+    tx.executeSql(sql, [digest], function (tx, result) {
+      // websql has a bug where \u0000 causes early truncation in strings
+      // and blobs. to work around this, we used to use the hex() function,
+      // but that's not performant. after migration 6, we remove \u0000
+      // and add it back in afterwards
+      var item = result.rows.item(0);
+      var data = item.escaped ? websqlUtils.unescapeBlob(item.body) :
+        parseHexString(item.body, encoding);
+      if (opts.encode) {
+        res = btoa(data);
+      } else {
+        data = utils.fixBinary(data);
+        res = utils.createBlob([data], {type: type});
       }
-      var errors = [];
-      var errorsById = {};
-      res.forEach(function (res) {
-        if (res.error) {
-          result.doc_write_failures++;
-          errors.push(res);
-          errorsById[res.id] = res;
-        }
-      });
-      allErrors = allErrors.concat(errors);
-      result.docs_written += currentBatch.docs.length - errors.length;
-      var non403s = errors.filter(function (error) {
-        return error.name !== 'unauthorized' && error.name !== 'forbidden';
-      });
+      callback(null, res);
+    });
+  };
 
-      changedDocs = [];
-      docs.forEach(function(doc) {
-        var error = errorsById[doc._id];
-        if (error) {
-          returnValue.emit('denied', utils.clone(error));
+  api._getRevisionTree = function (docId, callback) {
+    db.readTransaction(function (tx) {
+      var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
+      tx.executeSql(sql, [docId], function (tx, result) {
+        if (!result.rows.length) {
+          callback(errors.error(errors.MISSING_DOC));
         } else {
-          changedDocs.push(doc);
+          var data = utils.safeJsonParse(result.rows.item(0).metadata);
+          callback(null, data.rev_tree);
         }
       });
-
-      if (non403s.length > 0) {
-        var error = new Error('bulkDocs error');
-        error.other_errors = errors;
-        abortReplication('target.bulkDocs failed to write docs', error);
-        throw new Error('bulkWrite partial failure');
-      }
-    }, function (err) {
-      result.doc_write_failures += docs.length;
-      throw err;
     });
-  }
+  };
 
-  function processDiffDoc(id) {
-    var diffs = currentBatch.diffs;
-    var allMissing = diffs[id].missing;
-    // avoid url too long error by batching
-    var missingBatches = [];
-    for (var i = 0; i < allMissing.length; i += MAX_SIMULTANEOUS_REVS) {
-      missingBatches.push(allMissing.slice(i, Math.min(allMissing.length,
-        i + MAX_SIMULTANEOUS_REVS)));
+  api._doCompaction = function (docId, revs, callback) {
+    if (!revs.length) {
+      return callback();
     }
+    db.transaction(function (tx) {
 
-    return utils.Promise.all(missingBatches.map(function (missing) {
-      var opts = {
-        revs: true,
-        open_revs: missing,
-        attachments: true
-      };
-      return src.get(id, opts).then(function (docs) {
-        docs.forEach(function (doc) {
-          if (state.cancelled) {
-            return completeReplication();
-          }
-          if (doc.ok) {
-            result.docs_read++;
-            currentBatch.pendingRevs++;
-            currentBatch.docs.push(doc.ok);
+      // update doc store
+      var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
+      tx.executeSql(sql, [docId], function (tx, result) {
+        var metadata = utils.safeJsonParse(result.rows.item(0).metadata);
+        merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
+                                                           revHash, ctx, opts) {
+          var rev = pos + '-' + revHash;
+          if (revs.indexOf(rev) !== -1) {
+            opts.status = 'missing';
           }
         });
-        delete diffs[id];
-      });
-    }));
-  }
 
-  function getAllDocs() {
-    var diffKeys = Object.keys(currentBatch.diffs);
-    return utils.Promise.all(diffKeys.map(processDiffDoc));
-  }
+        var sql = 'UPDATE ' + DOC_STORE + ' SET json = ? WHERE id = ?';
+        tx.executeSql(sql, [utils.safeJsonStringify(metadata), docId]);
+      });
 
+      compactRevs(revs, docId, tx);
+    }, unknownError(callback), function () {
+      callback();
+    });
+  };
 
-  function getRevisionOneDocs() {
-    // filter out the generation 1 docs and get them
-    // leaving the non-generation one docs to be got otherwise
-    var ids = Object.keys(currentBatch.diffs).filter(function (id) {
-      var missing = currentBatch.diffs[id].missing;
-      return missing.length === 1 && missing[0].slice(0, 2) === '1-';
+  api._getLocal = function (id, callback) {
+    db.readTransaction(function (tx) {
+      var sql = 'SELECT json, rev FROM ' + LOCAL_STORE + ' WHERE id=?';
+      tx.executeSql(sql, [id], function (tx, res) {
+        if (res.rows.length) {
+          var item = res.rows.item(0);
+          var doc = unstringifyDoc(item.json, id, item.rev);
+          callback(null, doc);
+        } else {
+          callback(errors.error(errors.MISSING_DOC));
+        }
+      });
     });
-    if (!ids.length) { // nothing to fetch
-      return utils.Promise.resolve();
+  };
+
+  api._putLocal = function (doc, opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
     }
-    return src.allDocs({
-      keys: ids,
-      include_docs: true
-    }).then(function (res) {
-      if (state.cancelled) {
-        completeReplication();
-        throw (new Error('cancelled'));
+    delete doc._revisions; // ignore this, trust the rev
+    var oldRev = doc._rev;
+    var id = doc._id;
+    var newRev;
+    if (!oldRev) {
+      newRev = doc._rev = '0-1';
+    } else {
+      newRev = doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+    }
+    var json = stringifyDoc(doc);
+
+    var ret;
+    function putLocal(tx) {
+      var sql;
+      var values;
+      if (oldRev) {
+        sql = 'UPDATE ' + LOCAL_STORE + ' SET rev=?, json=? ' +
+          'WHERE id=? AND rev=?';
+        values = [newRev, json, id, oldRev];
+      } else {
+        sql = 'INSERT INTO ' + LOCAL_STORE + ' (id, rev, json) VALUES (?,?,?)';
+        values = [id, newRev, json];
       }
-      res.rows.forEach(function (row) {
-        if (row.doc && !row.deleted &&
-          row.value.rev.slice(0, 2) === '1-' && (
-            !row.doc._attachments ||
-            Object.keys(row.doc._attachments).length === 0
-          )
-        ) {
-          result.docs_read++;
-          currentBatch.pendingRevs++;
-          currentBatch.docs.push(row.doc);
-          delete currentBatch.diffs[row.id];
+      tx.executeSql(sql, values, function (tx, res) {
+        if (res.rowsAffected) {
+          ret = {ok: true, id: id, rev: newRev};
+          if (opts.ctx) { // return immediately
+            callback(null, ret);
+          }
+        } else {
+          callback(errors.error(errors.REV_CONFLICT));
         }
+      }, function () {
+        callback(errors.error(errors.REV_CONFLICT));
+        return false; // ack that we handled the error
       });
-    });
-  }
+    }
 
-  function getDocs() {
-    return getRevisionOneDocs().then(getAllDocs);
-  }
+    if (opts.ctx) {
+      putLocal(opts.ctx);
+    } else {
+      db.transaction(function (tx) {
+        putLocal(tx);
+      }, unknownError(callback), function () {
+        if (ret) {
+          callback(null, ret);
+        }
+      });
+    }
+  };
 
-  function finishBatch() {
-    writingCheckpoint = true;
-    return checkpointer.writeCheckpoint(currentBatch.seq).then(function () {
-      writingCheckpoint = false;
-      if (state.cancelled) {
-        completeReplication();
-        throw new Error('cancelled');
+  api._removeLocal = function (doc, callback) {
+    var ret;
+    db.transaction(function (tx) {
+      var sql = 'DELETE FROM ' + LOCAL_STORE + ' WHERE id=? AND rev=?';
+      var params = [doc._id, doc._rev];
+      tx.executeSql(sql, params, function (tx, res) {
+        if (!res.rowsAffected) {
+          return callback(errors.error(errors.MISSING_DOC));
+        }
+        ret = {ok: true, id: doc._id, rev: '0-0'};
+      });
+    }, unknownError(callback), function () {
+      if (ret) {
+        callback(null, ret);
       }
-      result.last_seq = last_seq = currentBatch.seq;
-      var outResult = utils.clone(result);
-      outResult.docs = changedDocs;
-      returnValue.emit('change', outResult);
-      currentBatch = undefined;
-      getChanges();
-    }).catch(function (err) {
-      writingCheckpoint = false;
-      abortReplication('writeCheckpoint completed with error', err);
-      throw err;
     });
-  }
+  };
 
-  function getDiffs() {
-    var diff = {};
-    currentBatch.changes.forEach(function (change) {
-      // Couchbase Sync Gateway emits these, but we can ignore them
-      if (change.id === "_user/") {
-        return;
-      }
-      diff[change.id] = change.changes.map(function (x) {
-        return x.rev;
+  api._destroy = function (callback) {
+    WebSqlPouch.Changes.removeAllListeners(api._name);
+    db.transaction(function (tx) {
+      var stores = [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE, META_STORE,
+        LOCAL_STORE, ATTACH_AND_SEQ_STORE];
+      stores.forEach(function (store) {
+        tx.executeSql('DROP TABLE IF EXISTS ' + store, []);
       });
-    });
-    return target.revsDiff(diff).then(function (diffs) {
-      if (state.cancelled) {
-        completeReplication();
-        throw new Error('cancelled');
+    }, unknownError(callback), function () {
+      if (utils.hasLocalStorage()) {
+        delete window.localStorage['_pouch__websqldb_' + api._name];
+        delete window.localStorage[api._name];
       }
-      // currentBatch.diffs elements are deleted as the documents are written
-      currentBatch.diffs = diffs;
-      currentBatch.pendingRevs = 0;
+      callback(null, {'ok': true});
     });
-  }
+  };
+}
 
-  function startNextBatch() {
-    if (state.cancelled || currentBatch) {
-      return;
-    }
-    if (batches.length === 0) {
-      processPendingBatch(true);
-      return;
-    }
-    currentBatch = batches.shift();
-    getDiffs()
-      .then(getDocs)
-      .then(writeDocs)
-      .then(finishBatch)
-      .then(startNextBatch)
-      .catch(function (err) {
-        abortReplication('batch processing terminated with error', err);
-      });
-  }
+WebSqlPouch.valid = websqlUtils.valid;
 
+WebSqlPouch.Changes = new utils.Changes();
 
-  function processPendingBatch(immediate) {
-    if (pendingBatch.changes.length === 0) {
-      if (batches.length === 0 && !currentBatch) {
-        if ((continuous && changesOpts.live) || changesCompleted) {
-          returnValue.state = 'pending';
-          returnValue.emit('paused');
-          returnValue.emit('uptodate', result);
-        }
-        if (changesCompleted) {
-          completeReplication();
-        }
-      }
-      return;
-    }
-    if (
-      immediate ||
-      changesCompleted ||
-      pendingBatch.changes.length >= batch_size
-    ) {
-      batches.push(pendingBatch);
-      pendingBatch = {
-        seq: 0,
-        changes: [],
-        docs: []
-      };
-      if (returnValue.state === 'pending' || returnValue.state === 'stopped') {
-        returnValue.state = 'active';
-        returnValue.emit('active');
-      }
-      startNextBatch();
-    }
-  }
+module.exports = WebSqlPouch;
 
+},{"../../deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","../../deps/parse-hex":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-hex.js","../../merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","../../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./websql-bulk-docs":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-bulk-docs.js","./websql-constants":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-constants.js","./websql-utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql-utils.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/changes.js":[function(require,module,exports){
+'use strict';
+var utils = require('./utils');
+var merge = require('./merge');
+var errors = require('./deps/errors');
+var EE = require('events').EventEmitter;
+var evalFilter = require('./evalFilter');
+var evalView = require('./evalView');
+module.exports = Changes;
+utils.inherits(Changes, EE);
 
-  function abortReplication(reason, err) {
-    if (replicationCompleted) {
-      return;
-    }
-    if (!err.message) {
-      err.message = reason;
+function Changes(db, opts, callback) {
+  EE.call(this);
+  var self = this;
+  this.db = db;
+  opts = opts ? utils.clone(opts) : {};
+  var oldComplete = callback || opts.complete || function () {};
+  var complete = opts.complete = utils.once(function (err, resp) {
+    if (err) {
+      self.emit('error', err);
+    } else {
+      self.emit('complete', resp);
     }
-    result.ok = false;
-    result.status = 'aborting';
-    result.errors.push(err);
-    allErrors = allErrors.concat(err);
-    batches = [];
-    pendingBatch = {
-      seq: 0,
-      changes: [],
-      docs: []
-    };
-    completeReplication();
+    self.removeAllListeners();
+    db.removeListener('destroyed', onDestroy);
+  });
+  if (oldComplete) {
+    self.on('complete', function (resp) {
+      oldComplete(null, resp);
+    });
+    self.on('error', function (err) {
+      oldComplete(err);
+    });
   }
+  var oldOnChange = opts.onChange;
+  if (oldOnChange) {
+    self.on('change', oldOnChange);
+  }
+  function onDestroy() {
+    self.cancel();
+  }
+  db.once('destroyed', onDestroy);
 
-
-  function completeReplication() {
-    if (replicationCompleted) {
+  opts.onChange = function (change) {
+    if (opts.isCancelled) {
       return;
     }
-    if (state.cancelled) {
-      result.status = 'cancelled';
-      if (writingCheckpoint) {
-        return;
-      }
+    self.emit('change', change);
+    if (self.startSeq && self.startSeq <= change.seq) {
+      self.emit('uptodate');
+      self.startSeq = false;
     }
-    result.status = result.status || 'complete';
-    result.end_time = new Date();
-    result.last_seq = last_seq;
-    replicationCompleted = state.cancelled = true;
-    var non403s = allErrors.filter(function (error) {
-      return error.name !== 'unauthorized' && error.name !== 'forbidden';
-    });
-    if (non403s.length > 0) {
-      var error = allErrors.pop();
-      if (allErrors.length > 0) {
-        error.other_errors = allErrors;
-      }
-      error.result = result;
-      backOff(repId, src, target, opts, returnValue, result, error);
+    if (change.deleted) {
+      self.emit('delete', change);
+    } else if (change.changes.length === 1 &&
+      change.changes[0].rev.slice(0, 2) === '1-') {
+      self.emit('create', change);
     } else {
-      result.errors = allErrors;
-      returnValue.emit('complete', result);
-      returnValue.removeAllListeners();
+      self.emit('update', change);
     }
-  }
-
+  };
 
-  function onChange(change) {
-    if (state.cancelled) {
-      return completeReplication();
-    }
-    var filter = utils.filterChange(opts)(change);
-    if (!filter) {
-      return;
-    }
-    if (
-      pendingBatch.changes.length === 0 &&
-      batches.length === 0 &&
-      !currentBatch
-    ) {
-      returnValue.emit('outofdate', result);
+  var promise = new utils.Promise(function (fulfill, reject) {
+    opts.complete = function (err, res) {
+      if (err) {
+        reject(err);
+      } else {
+        fulfill(res);
+      }
+    };
+  });
+  self.once('cancel', function () {
+    if (oldOnChange) {
+      self.removeListener('change', oldOnChange);
     }
-    pendingBatch.seq = change.seq;
-    pendingBatch.changes.push(change);
-    processPendingBatch(batches.length === 0);
-  }
+    opts.complete(null, {status: 'cancelled'});
+  });
+  this.then = promise.then.bind(promise);
+  this['catch'] = promise['catch'].bind(promise);
+  this.then(function (result) {
+    complete(null, result);
+  }, complete);
 
 
-  function onChangesComplete(changes) {
-    changesPending = false;
-    if (state.cancelled) {
-      return completeReplication();
-    }
 
-    // if no results were returned then we're done,
-    // else fetch more
-    if (changes.results.length > 0) {
-      changesOpts.since = changes.last_seq;
-      getChanges();
-    } else {
-      if (continuous) {
-        changesOpts.live = true;
-        getChanges();
+  if (!db.taskqueue.isReady) {
+    db.taskqueue.addTask(function () {
+      if (self.isCancelled) {
+        self.emit('cancel');
       } else {
-        changesCompleted = true;
+        self.doChanges(opts);
       }
-    }
-    processPendingBatch(true);
+    });
+  } else {
+    self.doChanges(opts);
   }
+}
+Changes.prototype.cancel = function () {
+  this.isCancelled = true;
+  if (this.db.taskqueue.isReady) {
+    this.emit('cancel');
+  }
+};
+function processChange(doc, metadata, opts) {
+  var changeList = [{rev: doc._rev}];
+  if (opts.style === 'all_docs') {
+    changeList = merge.collectLeaves(metadata.rev_tree)
+    .map(function (x) { return {rev: x.rev}; });
+  }
+  var change = {
+    id: metadata.id,
+    changes: changeList,
+    doc: doc
+  };
 
-
-  function onChangesError(err) {
-    changesPending = false;
-    if (state.cancelled) {
-      return completeReplication();
+  if (utils.isDeleted(metadata, doc._rev)) {
+    change.deleted = true;
+  }
+  if (opts.conflicts) {
+    change.doc._conflicts = merge.collectConflicts(metadata);
+    if (!change.doc._conflicts.length) {
+      delete change.doc._conflicts;
     }
-    abortReplication('changes rejected', err);
   }
+  return change;
+}
 
+Changes.prototype.doChanges = function (opts) {
+  var self = this;
+  var callback = opts.complete;
 
-  function getChanges() {
-    if (!(
-      !changesPending &&
-      !changesCompleted &&
-      batches.length < batches_limit
-    )) {
-      return;
-    }
-    changesPending = true;
-    function abortChanges() {
-      changes.cancel();
-    }
-    function removeListener() {
-      returnValue.removeListener('cancel', abortChanges);
-    }
-    returnValue.once('cancel', abortChanges);
-    var changes = src.changes(changesOpts)
-    .on('change', onChange);
-    changes.then(removeListener, removeListener);
-    changes.then(onChangesComplete)
-    .catch(onChangesError);
+  opts = utils.clone(opts);
+  if ('live' in opts && !('continuous' in opts)) {
+    opts.continuous = opts.live;
   }
+  opts.processChange = processChange;
 
-
-  function startChanges() {
-    checkpointer.getCheckpoint().then(function (checkpoint) {
-      last_seq = checkpoint;
-      changesOpts = {
-        since: last_seq,
-        limit: batch_size,
-        batch_size: batch_size,
-        style: 'all_docs',
-        doc_ids: doc_ids,
-        returnDocs: true // required so we know when we're done
-      };
-      if (opts.filter) {
-        if (typeof opts.filter !== 'string') {
-          // required for the client-side filter in onChange
-          changesOpts.include_docs = true;
-        } else { // ddoc filter
-          changesOpts.filter = opts.filter;
-        }
-      }
-      if (opts.query_params) {
-        changesOpts.query_params = opts.query_params;
+  if (opts.since === 'latest') {
+    opts.since = 'now';
+  }
+  if (!opts.since) {
+    opts.since = 0;
+  }
+  if (opts.since === 'now') {
+    this.db.info().then(function (info) {
+      if (self.isCancelled) {
+        callback(null, {status: 'cancelled'});
+        return;
       }
-      if (opts.view) {
-        changesOpts.view = opts.view;
+      opts.since = info.update_seq;
+      self.doChanges(opts);
+    }, callback);
+    return;
+  }
+
+  if (opts.continuous && opts.since !== 'now') {
+    this.db.info().then(function (info) {
+      self.startSeq = info.update_seq;
+    }, function (err) {
+      if (err.id === 'idbNull') {
+        //db closed before this returned
+        //thats ok
+        return;
       }
-      getChanges();
-    }).catch(function (err) {
-      abortReplication('getCheckpoint rejected with ', err);
+      throw err;
     });
   }
 
-  if (returnValue.cancelled) { // cancelled immediately
-    completeReplication();
-    return;
+  if (this.db.type() !== 'http' &&
+      opts.filter && typeof opts.filter === 'string' &&
+      !opts.doc_ids) {
+    return this.filterChanges(opts);
   }
 
-  returnValue.once('cancel', completeReplication);
-
-  if (typeof opts.onChange === 'function') {
-    returnValue.on('change', opts.onChange);
+  if (!('descending' in opts)) {
+    opts.descending = false;
   }
 
-  if (typeof opts.complete === 'function') {
-    returnValue.once('error', opts.complete);
-    returnValue.once('complete', function (result) {
-      opts.complete(null, result);
+  // 0 and 1 should return 1 document
+  opts.limit = opts.limit === 0 ? 1 : opts.limit;
+  opts.complete = callback;
+  var newPromise = this.db._changes(opts);
+  if (newPromise && typeof newPromise.cancel === 'function') {
+    var cancel = self.cancel;
+    self.cancel = utils.getArguments(function (args) {
+      newPromise.cancel();
+      cancel.apply(this, args);
     });
   }
+};
 
-  if (typeof opts.since === 'undefined') {
-    startChanges();
-  } else {
-    writingCheckpoint = true;
-    checkpointer.writeCheckpoint(opts.since).then(function () {
-      writingCheckpoint = false;
-      if (state.cancelled) {
-        completeReplication();
+Changes.prototype.filterChanges = function (opts) {
+  var self = this;
+  var callback = opts.complete;
+  if (opts.filter === '_view') {
+    if (!opts.view || typeof opts.view !== 'string') {
+      var err = errors.error(errors.BAD_REQUEST,
+                             '`view` filter parameter is not provided.');
+      callback(err);
+      return;
+    }
+    // fetch a view from a design doc, make it behave like a filter
+    var viewName = opts.view.split('/');
+    this.db.get('_design/' + viewName[0], function (err, ddoc) {
+      if (self.isCancelled) {
+        callback(null, {status: 'cancelled'});
         return;
       }
-      last_seq = opts.since;
-      startChanges();
-    }).catch(function (err) {
-      writingCheckpoint = false;
-      abortReplication('writeCheckpoint completed with error', err);
-      throw err;
+      if (err) {
+        callback(errors.generateErrorFromResponse(err));
+        return;
+      }
+      if (ddoc && ddoc.views && ddoc.views[viewName[1]]) {
+        
+        var filter = evalView(ddoc.views[viewName[1]].map);
+        opts.filter = filter;
+        self.doChanges(opts);
+        return;
+      }
+      var msg = ddoc.views ? 'missing json key: ' + viewName[1] :
+        'missing json key: views';
+      if (!err) {
+        err = errors.error(errors.MISSING_DOC, msg);
+      }
+      callback(err);
+      return;
     });
-  }
-}
-
-exports.toPouch = toPouch;
-function toPouch(db, opts) {
-  var PouchConstructor = opts.PouchConstructor;
-  if (typeof db === 'string') {
-    return new PouchConstructor(db, opts);
-  } else if (db.then) {
-    return db;
   } else {
-    return utils.Promise.resolve(db);
+    // fetch a filter from a design doc
+    var filterName = opts.filter.split('/');
+    this.db.get('_design/' + filterName[0], function (err, ddoc) {
+      if (self.isCancelled) {
+        callback(null, {status: 'cancelled'});
+        return;
+      }
+      if (err) {
+        callback(errors.generateErrorFromResponse(err));
+        return;
+      }
+      if (ddoc && ddoc.filters && ddoc.filters[filterName[1]]) {
+        var filter = evalFilter(ddoc.filters[filterName[1]]);
+        opts.filter = filter;
+        self.doChanges(opts);
+        return;
+      } else {
+        var msg = (ddoc && ddoc.filters) ? 'missing json key: ' + filterName[1]
+          : 'missing json key: filters';
+        if (!err) {
+          err = errors.error(errors.MISSING_DOC, msg);
+        }
+        callback(err);
+        return;
+      }
+    });
   }
-}
+};
+},{"./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./evalFilter":"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalFilter.js","./evalView":"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalView.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/checkpointer.js":[function(require,module,exports){
+'use strict';
 
+var Promise = require('./deps/promise');
+var explain404 = require('./deps/explain404');
+var pouchCollate = require('pouchdb-collate');
+var collate = pouchCollate.collate;
 
-exports.replicate = replicateWrapper;
-function replicateWrapper(src, target, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  if (typeof opts === 'undefined') {
-    opts = {};
-  }
-  if (!opts.complete) {
-    opts.complete = callback || function () {};
-  }
-  opts = utils.clone(opts);
-  opts.continuous = opts.continuous || opts.live;
-  opts.retry = ('retry' in opts) ? opts.retry : RETRY_DEFAULT;
-  /*jshint validthis:true */
-  opts.PouchConstructor = opts.PouchConstructor || this;
-  var replicateRet = new Replication(opts);
-  toPouch(src, opts).then(function (src) {
-    return toPouch(target, opts).then(function (target) {
-      return genReplicationId(src, target, opts).then(function (repId) {
-        replicate(repId, src, target, opts, replicateRet);
-      });
+function updateCheckpoint(db, id, checkpoint, returnValue) {
+  return db.get(id).catch(function (err) {
+    if (err.status === 404) {
+      if (db.type() === 'http') {
+        explain404(
+          'PouchDB is just checking if a remote checkpoint exists.');
+      }
+      return {_id: id};
+    }
+    throw err;
+  }).then(function (doc) {
+    if (returnValue.cancelled) {
+      return;
+    }
+    doc.last_seq = checkpoint;
+    return db.put(doc).catch(function (err) {
+      if (err.status === 409) {
+        // retry; someone is trying to write a checkpoint simultaneously
+        return updateCheckpoint(db, id, checkpoint, returnValue);
+      }
+      throw err;
     });
-  }).catch(function (err) {
-    replicateRet.emit('error', err);
-    opts.complete(err);
   });
-  return replicateRet;
 }
 
-},{"./checkpointer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/checkpointer.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/setup.js":[function(require,module,exports){
-"use strict";
-
-var PouchDB = require("./constructor");
-var utils = require('./utils');
-var EventEmitter = require('events').EventEmitter;
-PouchDB.adapters = {};
-PouchDB.preferredAdapters = [];
-
-PouchDB.prefix = '_pouch_';
+function Checkpointer(src, target, id, returnValue) {
+  this.src = src;
+  this.target = target;
+  this.id = id;
+  this.returnValue = returnValue;
+}
 
-var eventEmitter = new EventEmitter();
+Checkpointer.prototype.writeCheckpoint = function (checkpoint) {
+  var self = this;
+  return this.updateTarget(checkpoint).then(function () {
+    return self.updateSource(checkpoint);
+  });
+};
 
-var eventEmitterMethods = [
-  'on',
-  'addListener',
-  'emit',
-  'listeners',
-  'once',
-  'removeAllListeners',
-  'removeListener',
-  'setMaxListeners'
-];
+Checkpointer.prototype.updateTarget = function (checkpoint) {
+  return updateCheckpoint(this.target, this.id, checkpoint, this.returnValue);
+};
 
-eventEmitterMethods.forEach(function (method) {
-  PouchDB[method] = eventEmitter[method].bind(eventEmitter);
-});
-PouchDB.setMaxListeners(0);
-PouchDB.parseAdapter = function (name, opts) {
-  var match = name.match(/([a-z\-]*):\/\/(.*)/);
-  var adapter, adapterName;
-  if (match) {
-    // the http adapter expects the fully qualified name
-    name = /http(s?)/.test(match[1]) ? match[1] + '://' + match[2] : match[2];
-    adapter = match[1];
-    if (!PouchDB.adapters[adapter].valid()) {
-      throw 'Invalid adapter';
-    }
-    return {name: name, adapter: match[1]};
+Checkpointer.prototype.updateSource = function (checkpoint) {
+  var self = this;
+  if (this.readOnlySource) {
+    return Promise.resolve(true);
   }
+  return updateCheckpoint(this.src, this.id, checkpoint, this.returnValue)
+    .catch(function (err) {
+      var isForbidden = typeof err.status === 'number' &&
+        Math.floor(err.status / 100) === 4;
+      if (isForbidden) {
+        self.readOnlySource = true;
+        return true;
+      }
+      throw err;
+    });
+};
 
-  // check for browsers that have been upgraded from websql-only to websql+idb
-  var skipIdb = 'idb' in PouchDB.adapters && 'websql' in PouchDB.adapters &&
-    utils.hasLocalStorage() &&
-    localStorage['_pouch__websqldb_' + PouchDB.prefix + name];
-
-
-  if (opts.adapter) {
-    adapterName = opts.adapter;
-  } else if (typeof opts !== 'undefined' && opts.db) {
-    adapterName = 'leveldb';
-  } else { // automatically determine adapter
-    for (var i = 0; i < PouchDB.preferredAdapters.length; ++i) {
-      adapterName = PouchDB.preferredAdapters[i];
-      if (adapterName in PouchDB.adapters) {
-        if (skipIdb && adapterName === 'idb') {
-          // log it, because this can be confusing during development
-          console.log('PouchDB is downgrading "' + name + '" to WebSQL to' +
-            ' avoid data loss, because it was already opened with WebSQL.');
-          continue; // keep using websql to avoid user data loss
-        }
-        break;
+Checkpointer.prototype.getCheckpoint = function () {
+  var self = this;
+  return self.target.get(self.id).then(function (targetDoc) {
+    return self.src.get(self.id).then(function (sourceDoc) {
+      if (collate(targetDoc.last_seq, sourceDoc.last_seq) === 0) {
+        return sourceDoc.last_seq;
+      }
+      return 0;
+    }, function (err) {
+      if (err.status === 404 && targetDoc.last_seq) {
+        return self.src.put({
+          _id: self.id,
+          last_seq: 0
+        }).then(function () {
+          return 0;
+        }, function (err) {
+          if (err.status === 401) {
+            self.readOnlySource = true;
+            return targetDoc.last_seq;
+          }
+          return 0;
+        });
       }
+      throw err;
+    });
+  }).catch(function (err) {
+    if (err.status !== 404) {
+      throw err;
     }
-  }
+    return 0;
+  });
+};
 
-  adapter = PouchDB.adapters[adapterName];
+module.exports = Checkpointer;
 
-  // if adapter is invalid, then an error will be thrown later
-  var usePrefix = (adapter && 'use_prefix' in adapter) ?
-      adapter.use_prefix : true;
+},{"./deps/explain404":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js","./deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js","pouchdb-collate":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collate/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/constructor.js":[function(require,module,exports){
+(function (process,global){
+/*globals cordova */
+"use strict";
 
-  return {
-    name: usePrefix ? (PouchDB.prefix + name) : name,
-    adapter: adapterName
-  };
-};
+var Adapter = require('./adapter');
+var utils = require('./utils');
+var TaskQueue = require('./taskqueue');
+var Promise = utils.Promise;
 
-PouchDB.destroy = utils.toPromise(function (name, opts, callback) {
-  console.log('PouchDB.destroy() is deprecated and will be removed. ' +
-              'Please use db.destroy() instead.');
+function defaultCallback(err) {
+  if (err && global.debug) {
+    console.error(err);
+  }
+}
+
+utils.inherits(PouchDB, Adapter);
+function PouchDB(name, opts, callback) {
 
+  if (!(this instanceof PouchDB)) {
+    return new PouchDB(name, opts, callback);
+  }
+  var self = this;
   if (typeof opts === 'function' || typeof opts === 'undefined') {
     callback = opts;
     opts = {};
   }
+
   if (name && typeof name === 'object') {
     opts = name;
     name = undefined;
   }
+  if (typeof callback === 'undefined') {
+    callback = defaultCallback;
+  }
+  name = name || opts.name;
+  opts = opts ? utils.clone(opts) : {};
+  // if name was specified via opts, ignore for the sake of dependentDbs
+  delete opts.name;
+  this.__opts = opts;
+  var oldCB = callback;
+  self.auto_compaction = opts.auto_compaction;
+  self.prefix = PouchDB.prefix;
+  Adapter.call(self);
+  self.taskqueue = new TaskQueue();
+  var promise = new Promise(function (fulfill, reject) {
+    callback = function (err, resp) {
+      if (err) {
+        return reject(err);
+      }
+      delete resp.then;
+      fulfill(resp);
+    };
+  
+    opts = utils.clone(opts);
+    var originalName = opts.name || name;
+    var backend, error;
+    (function () {
+      try {
 
-  new PouchDB(name, opts, function (err, db) {
-    if (err) {
-      return callback(err);
-    }
-    db.destroy(callback);
-  });
-});
+        if (typeof originalName !== 'string') {
+          error = new Error('Missing/invalid DB name');
+          error.code = 400;
+          throw error;
+        }
 
-PouchDB.adapter = function (id, obj, addToPreferredAdapters) {
-  if (obj.valid()) {
-    PouchDB.adapters[id] = obj;
-    if (addToPreferredAdapters) {
-      PouchDB.preferredAdapters.push(id);
+        backend = PouchDB.parseAdapter(originalName, opts);
+        
+        opts.originalName = originalName;
+        opts.name = backend.name;
+        if (opts.prefix && backend.adapter !== 'http' &&
+            backend.adapter !== 'https') {
+          opts.name = opts.prefix + opts.name;
+        }
+        opts.adapter = opts.adapter || backend.adapter;
+        self._adapter = opts.adapter;
+        self._db_name = originalName;
+        if (!PouchDB.adapters[opts.adapter]) {
+          error = new Error('Adapter is missing');
+          error.code = 404;
+          throw error;
+        }
+
+        if (!PouchDB.adapters[opts.adapter].valid()) {
+          error = new Error('Invalid Adapter');
+          error.code = 404;
+          throw error;
+        }
+      } catch (err) {
+        self.taskqueue.fail(err);
+        self.changes = utils.toPromise(function (opts) {
+          if (opts.complete) {
+            opts.complete(err);
+          }
+        });
+      }
+    }());
+    if (error) {
+      return reject(error); // constructor error, see above
     }
-  }
-};
+    self.adapter = opts.adapter;
 
-PouchDB.plugin = function (obj) {
-  Object.keys(obj).forEach(function (id) {
-    PouchDB.prototype[id] = obj[id];
-  });
-};
+    // needs access to PouchDB;
+    self.replicate = {};
 
-PouchDB.defaults = function (defaultOpts) {
-  function PouchAlt(name, opts, callback) {
-    if (typeof opts === 'function' || typeof opts === 'undefined') {
-      callback = opts;
-      opts = {};
-    }
-    if (name && typeof name === 'object') {
-      opts = name;
-      name = undefined;
-    }
+    self.replicate.from = function (url, opts, callback) {
+      return self.constructor.replicate(url, self, opts, callback);
+    };
 
-    opts = utils.extend(true, {}, defaultOpts, opts);
-    PouchDB.call(this, name, opts, callback);
-  }
+    self.replicate.to = function (url, opts, callback) {
+      return self.constructor.replicate(self, url, opts, callback);
+    };
 
-  utils.inherits(PouchAlt, PouchDB);
+    self.sync = function (dbName, opts, callback) {
+      return self.constructor.sync(self, dbName, opts, callback);
+    };
 
-  PouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
-    if (typeof opts === 'function' || typeof opts === 'undefined') {
-      callback = opts;
-      opts = {};
-    }
+    self.replicate.sync = self.sync;
 
-    if (name && typeof name === 'object') {
-      opts = name;
-      name = undefined;
-    }
-    opts = utils.extend(true, {}, defaultOpts, opts);
-    return PouchDB.destroy(name, opts, callback);
-  });
+    PouchDB.adapters[opts.adapter].call(self, opts, function (err) {
+      if (err) {
+        if (callback) {
+          self.taskqueue.fail(err);
+          callback(err);
+        }
+        return;
+      }
+      function destructionListener() {
+        PouchDB.emit('destroyed', opts.originalName);
+        //so we don't have to sift through all dbnames
+        PouchDB.emit(opts.originalName, 'destroyed');
+        self.removeListener('destroyed', destructionListener);
+      }
+      self.on('destroyed', destructionListener);
+      self.emit('created', self);
+      PouchDB.emit('created', opts.originalName);
+      self.taskqueue.ready(self);
+      callback(null, self);
+    });
 
-  eventEmitterMethods.forEach(function (method) {
-    PouchAlt[method] = eventEmitter[method].bind(eventEmitter);
-  });
-  PouchAlt.setMaxListeners(0);
+    if (opts.skipSetup) {
+      self.taskqueue.ready(self);
+      process.nextTick(function () {
+        callback(null, self);
+      });
+    }
 
-  PouchAlt.preferredAdapters = PouchDB.preferredAdapters.slice();
-  Object.keys(PouchDB).forEach(function (key) {
-    if (!(key in PouchAlt)) {
-      PouchAlt[key] = PouchDB[key];
+    if (utils.isCordova()) {
+      //to inform websql adapter that we can use api
+      cordova.fireWindowEvent(opts.name + "_pouch", {});
     }
   });
+  promise.then(function (resp) {
+    oldCB(null, resp);
+  }, oldCB);
+  self.then = promise.then.bind(promise);
+  self.catch = promise.catch.bind(promise);
+}
 
-  return PouchAlt;
-};
+PouchDB.debug = require('debug');
 
 module.exports = PouchDB;
 
-},{"./constructor":"/Users/richard/src/beagle/node_modules/pouchdb/lib/constructor.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/sync.js":[function(require,module,exports){
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./adapter":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapter.js","./taskqueue":"/Users/richard/src/beagle/node_modules/pouchdb/lib/taskqueue.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/ajax.js"][0].apply(exports,arguments)
+},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","./errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","request":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/request-browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/blob.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/buffer-browser.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/errors.js"][0].apply(exports,arguments)
+},{"inherits":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/inherits/inherits_browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/explain404.js"][0].apply(exports,arguments)
+},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/md5.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/md5.js"][0].apply(exports,arguments)
+},{"_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","crypto":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","spark-md5":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-doc.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-doc.js"][0].apply(exports,arguments)
+},{"./errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./uuid":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-hex.js":[function(require,module,exports){
 'use strict';
 
-var utils = require('./utils');
-var replication = require('./replicate');
-var replicate = replication.replicate;
-var EE = require('events').EventEmitter;
+//
+// Parsing hex strings. Yeah.
+//
+// So basically we need this because of a bug in WebSQL:
+// https://code.google.com/p/chromium/issues/detail?id=422690
+// https://bugs.webkit.org/show_bug.cgi?id=137637
+//
+// UTF-8 and UTF-16 are provided as separate functions
+// for meager performance improvements
+//
 
-utils.inherits(Sync, EE);
-module.exports = sync;
-function sync(src, target, opts, callback) {
-  if (typeof opts === 'function') {
-    callback = opts;
-    opts = {};
-  }
-  if (typeof opts === 'undefined') {
-    opts = {};
-  }
-  opts = utils.clone(opts);
-  /*jshint validthis:true */
-  opts.PouchConstructor = opts.PouchConstructor || this;
-  src = replication.toPouch(src, opts);
-  target = replication.toPouch(target, opts);
-  return new Sync(src, target, opts, callback);
+function decodeUtf8(str) {
+  return decodeURIComponent(window.escape(str));
 }
 
-function Sync(src, target, opts, callback) {
-  var self = this;
-  this.canceled = false;
-
-  var onChange, complete;
-  if ('onChange' in opts) {
-    onChange = opts.onChange;
-    delete opts.onChange;
-  }
-  if (typeof callback === 'function' && !opts.complete) {
-    complete = callback;
-  } else if ('complete' in opts) {
-    complete = opts.complete;
-    delete opts.complete;
-  }
+function hexToInt(charCode) {
+  // '0'-'9' is 48-57
+  // 'A'-'F' is 65-70
+  // SQLite will only give us uppercase hex
+  return charCode < 65 ? (charCode - 48) : (charCode - 55);
+}
 
-  this.push = replicate(src, target, opts);
-  this.pull = replicate(target, src, opts);
 
-  var emittedCancel = false;
-  function onCancel(data) {
-    if (!emittedCancel) {
-      emittedCancel = true;
-      self.emit('cancel', data);
-    }
-  }
-  function pullChange(change) {
-    self.emit('change', {
-      direction: 'pull',
-      change: change
-    });
-  }
-  function pushChange(change) {
-    self.emit('change', {
-      direction: 'push',
-      change: change
-    });
-  }
-  function pushDenied(doc) {
-    self.emit('denied', {
-      direction: 'push',
-      doc: doc
-    });
-  }
-  function pullDenied(doc) {
-    self.emit('denied', {
-      direction: 'pull',
-      doc: doc
-    });
+// Example:
+// pragma encoding=utf8;
+// select hex('A');
+// returns '41'
+function parseHexUtf8(str, start, end) {
+  var result = '';
+  while (start < end) {
+    result += String.fromCharCode(
+      (hexToInt(str.charCodeAt(start++)) << 4) |
+        hexToInt(str.charCodeAt(start++)));
   }
+  return result;
+}
 
-  var listeners = {};
-  var removed = {};
-
-  function removeAll(type) { // type is 'push' or 'pull'
-    return function (event, func) {
-      var isChange = event === 'change' &&
-        (func === pullChange || func === pushChange);
-      var isCancel = event === 'cancel' && func === onCancel;
-      var isOtherEvent = event in listeners && func === listeners[event];
-
-      if (isChange || isCancel || isOtherEvent) {
-        if (!(event in removed)) {
-          removed[event] = {};
-        }
-        removed[event][type] = true;
-        if (Object.keys(removed[event]).length === 2) {
-          // both push and pull have asked to be removed
-          self.removeAllListeners(event);
-        }
-      }
-    };
+// Example:
+// pragma encoding=utf16;
+// select hex('A');
+// returns '4100'
+// notice that the 00 comes after the 41 (i.e. it's swizzled)
+function parseHexUtf16(str, start, end) {
+  var result = '';
+  while (start < end) {
+    // UTF-16, so swizzle the bytes
+    result += String.fromCharCode(
+      (hexToInt(str.charCodeAt(start + 2)) << 12) |
+        (hexToInt(str.charCodeAt(start + 3)) << 8) |
+        (hexToInt(str.charCodeAt(start)) << 4) |
+        hexToInt(str.charCodeAt(start + 1)));
+    start += 4;
   }
+  return result;
+}
 
-  if (opts.live) {
-    this.push.on('complete', self.pull.cancel.bind(self.pull));
-    this.pull.on('complete', self.push.cancel.bind(self.push));
+function parseHexString(str, encoding) {
+  if (encoding === 'UTF-8') {
+    return decodeUtf8(parseHexUtf8(str, 0, str.length));
+  } else {
+    return parseHexUtf16(str, 0, str.length);
   }
+}
 
-  this.on('newListener', function (event) {
-    if (event === 'change') {
-      self.pull.on('change', pullChange);
-      self.push.on('change', pushChange);
-    } else if (event === 'denied') {
-      self.pull.on('denied', pullDenied);
-      self.push.on('denied', pushDenied);
-    } else if (event === 'cancel') {
-      self.pull.on('cancel', onCancel);
-      self.push.on('cancel', onCancel);
-    } else if (event !== 'error' &&
-      event !== 'removeListener' &&
-      event !== 'complete' && !(event in listeners)) {
-      listeners[event] = function (e) {
-        self.emit(event, e);
-      };
-      self.pull.on(event, listeners[event]);
-      self.push.on(event, listeners[event]);
-    }
-  });
-
-  this.on('removeListener', function (event) {
-    if (event === 'change') {
-      self.pull.removeListener('change', pullChange);
-      self.push.removeListener('change', pushChange);
-    } else if (event === 'cancel') {
-      self.pull.removeListener('cancel', onCancel);
-      self.push.removeListener('cancel', onCancel);
-    } else if (event in listeners) {
-      if (typeof listeners[event] === 'function') {
-        self.pull.removeListener(event, listeners[event]);
-        self.push.removeListener(event, listeners[event]);
-        delete listeners[event];
-      }
-    }
-  });
-
-  this.pull.on('removeListener', removeAll('pull'));
-  this.push.on('removeListener', removeAll('push'));
-
-  var promise = utils.Promise.all([
-    this.push,
-    this.pull
-  ]).then(function (resp) {
-    var out = {
-      push: resp[0],
-      pull: resp[1]
-    };
-    self.emit('complete', out);
-    if (complete) {
-      complete(null, out);
-    }
-    self.removeAllListeners();
-    return out;
-  }, function (err) {
-    self.cancel();
-    self.emit('error', err);
-    if (complete) {
-      complete(err);
-    }
-    self.removeAllListeners();
-    throw err;
-  });
-
-  this.then = function (success, err) {
-    return promise.then(success, err);
-  };
+module.exports = parseHexString;
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-uri.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/parse-uri.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/promise.js"][0].apply(exports,arguments)
+},{"bluebird":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/request-browser.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/deps/request-browser.js"][0].apply(exports,arguments)
+},{"../utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./blob.js":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/upsert.js":[function(require,module,exports){
+'use strict';
 
-  this.catch = function (err) {
-    return promise.catch(err);
-  };
-}
+var upsert = require('pouchdb-upsert').upsert;
 
-Sync.prototype.cancel = function () {
-  if (!this.canceled) {
-    this.canceled = true;
-    this.push.cancel();
-    this.pull.cancel();
-  }
+module.exports = function (db, doc, diffFun, cb) {
+  return upsert.call(db, doc, diffFun, cb);
 };
 
-},{"./replicate":"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/taskqueue.js":[function(require,module,exports){
+},{"pouchdb-upsert":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-upsert/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/lib/uuid.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalFilter.js":[function(require,module,exports){
 'use strict';
 
-module.exports = TaskQueue;
-
-function TaskQueue() {
-  this.isReady = false;
-  this.failed = false;
-  this.queue = [];
+module.exports = evalFilter;
+function evalFilter(input) {
+  /*jshint evil: true */
+  return eval([
+    '(function () { return ',
+    input,
+    ' })()'
+  ].join(''));
 }
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/evalView.js":[function(require,module,exports){
+'use strict';
 
-TaskQueue.prototype.execute = function () {
-  var d, func;
-  if (this.failed) {
-    while ((d = this.queue.shift())) {
-      if (typeof d === 'function') {
-        d(this.failed);
-        continue;
-      }
-      func = d.parameters[d.parameters.length - 1];
-      if (typeof func === 'function') {
-        func(this.failed);
-      } else if (d.name === 'changes' && typeof func.complete === 'function') {
-        func.complete(this.failed);
-      }
-    }
-  } else if (this.isReady) {
-    while ((d = this.queue.shift())) {
-
-      if (typeof d === 'function') {
-        d();
-      } else {
-        d.task = this.db[d.name].apply(this.db, d.parameters);
-      }
-    }
-  }
-};
+module.exports = evalView;
+function evalView(input) {
+  /*jshint evil: true */
+  return eval([
+    '(function () {',
+    '  return function (doc) {',
+    '    var emitted = false;',
+    '    var emit = function (a, b) {',
+    '      emitted = true;',
+    '    };',
+    '    var view = ' + input + ';',
+    '    view(doc);',
+    '    if (emitted) {',
+    '      return true;',
+    '    }',
+    '  }',
+    '})()'
+  ].join('\n'));
+}
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/index.js":[function(require,module,exports){
+(function (process){
+"use strict";
 
-TaskQueue.prototype.fail = function (err) {
-  this.failed = err;
-  this.execute();
-};
+var PouchDB = require('./setup');
 
-TaskQueue.prototype.ready = function (db) {
-  if (this.failed) {
-    return false;
-  } else if (arguments.length === 0) {
-    return this.isReady;
-  }
-  this.isReady = db ? true: false;
-  this.db = db;
-  this.execute();
-};
+module.exports = PouchDB;
 
-TaskQueue.prototype.addTask = function (name, parameters) {
-  if (typeof name === 'function') {
-    this.queue.push(name);
-    if (this.failed) {
-      this.execute();
-    }
-  } else {
-    var task = { name: name, parameters: parameters };
-    this.queue.push(task);
-    if (this.failed) {
-      this.execute();
-    }
-    return task;
-  }
-};
+PouchDB.ajax = require('./deps/ajax');
+PouchDB.utils = require('./utils');
+PouchDB.Errors = require('./deps/errors');
+PouchDB.replicate = require('./replicate').replicate;
+PouchDB.sync = require('./sync');
+PouchDB.version = require('./version');
+var httpAdapter = require('./adapters/http/http');
+PouchDB.adapter('http', httpAdapter);
+PouchDB.adapter('https', httpAdapter);
 
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js":[function(require,module,exports){
-(function (process){
-/*jshint strict: false */
-/*global chrome */
-var merge = require('./merge');
-exports.extend = require('pouchdb-extend');
-exports.ajax = require('./deps/ajax');
-exports.createBlob = require('./deps/blob');
-exports.uuid = require('./deps/uuid');
-exports.getArguments = require('argsarray');
-var buffer = require('./deps/buffer');
-var errors = require('./deps/errors');
-var EventEmitter = require('events').EventEmitter;
-var collections = require('pouchdb-collections');
-exports.Map = collections.Map;
-exports.Set = collections.Set;
-var parseDoc = require('./deps/parse-doc');
+PouchDB.adapter('idb', require('./adapters/idb/idb'), true);
+PouchDB.adapter('websql', require('./adapters/websql/websql'), true);
+PouchDB.plugin(require('pouchdb-mapreduce'));
 
-var Promise = require('./deps/promise');
-exports.Promise = Promise;
+if (!process.browser) {
+  var ldbAdapter = require('./adapters/leveldb/leveldb');
+  PouchDB.adapter('leveldb', ldbAdapter, true);
+}
 
-exports.lastIndexOf = function (str, char) {
-  for (var i = str.length - 1; i >= 0; i--) {
-    if (str.charAt(i) === char) {
-      return i;
-    }
-  }
-  return -1;
-};
+}).call(this,require('_process'))
+},{"./adapters/http/http":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/http/http.js","./adapters/idb/idb":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/idb/idb.js","./adapters/leveldb/leveldb":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","./adapters/websql/websql":"/Users/richard/src/beagle/node_modules/pouchdb/lib/adapters/websql/websql.js","./deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./replicate":"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js","./setup":"/Users/richard/src/beagle/node_modules/pouchdb/lib/setup.js","./sync":"/Users/richard/src/beagle/node_modules/pouchdb/lib/sync.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","./version":"/Users/richard/src/beagle/node_modules/pouchdb/lib/version-browser.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","pouchdb-mapreduce":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-mapreduce/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/merge.js"][0].apply(exports,arguments)
+},{"pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-extend/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js":[function(require,module,exports){
+'use strict';
 
-exports.clone = function (obj) {
-  return exports.extend(true, {}, obj);
-};
+var utils = require('./utils');
+var EE = require('events').EventEmitter;
+var Checkpointer = require('./checkpointer');
 
-// like underscore/lodash _.pick()
-exports.pick = function (obj, arr) {
-  var res = {};
-  for (var i = 0, len = arr.length; i < len; i++) {
-    var prop = arr[i];
-    res[prop] = obj[prop];
+var MAX_SIMULTANEOUS_REVS = 50;
+var RETRY_DEFAULT = false;
+
+function randomNumber(min, max) {
+  min = parseInt(min, 10);
+  max = parseInt(max, 10);
+  if (min !== min) {
+    min = 0;
   }
-  return res;
-};
+  if (max !== max || max <= min) {
+    max = (min || 1) << 1; //doubling
+  } else {
+    max = max + 1;
+  }
+  var ratio = Math.random();
+  var range = max - min;
 
-exports.inherits = require('inherits');
+  return ~~(range * ratio + min); // ~~ coerces to an int, but fast.
+}
 
-function isChromeApp() {
-  return (typeof chrome !== "undefined" &&
-          typeof chrome.storage !== "undefined" &&
-          typeof chrome.storage.local !== "undefined");
+function defaultBackOff(min) {
+  var max = 0;
+  if (!min) {
+    max = 2000;
+  }
+  return randomNumber(min, max);
 }
 
-// Pretty dumb name for a function, just wraps callback calls so we dont
-// to if (callback) callback() everywhere
-exports.call = exports.getArguments(function (args) {
-  if (!args.length) {
+function backOff(repId, src, target, opts, returnValue, result, error) {
+  if (opts.retry === false) {
+    returnValue.emit('error', error);
+    returnValue.removeAllListeners();
     return;
   }
-  var fun = args.shift();
-  if (typeof fun === 'function') {
-    fun.apply(this, args);
+  opts.default_back_off = opts.default_back_off || 0;
+  opts.retries = opts.retries || 0;
+  if (typeof opts.back_off_function !== 'function') {
+    opts.back_off_function = defaultBackOff;
   }
-});
-
-exports.isLocalId = function (id) {
-  return (/^_local/).test(id);
-};
-
-// check if a specific revision of a doc has been deleted
-//  - metadata: the metadata object from the doc store
-//  - rev: (optional) the revision to check. defaults to winning revision
-exports.isDeleted = function (metadata, rev) {
-  if (!rev) {
-    rev = merge.winningRev(metadata);
+  opts.retries++;
+  if (opts.max_retries && opts.retries > opts.max_retries) {
+    returnValue.emit('error', new Error('tried ' +
+      opts.retries + ' times but replication failed'));
+    returnValue.removeAllListeners();
+    return;
   }
-  var dashIndex = rev.indexOf('-');
-  if (dashIndex !== -1) {
-    rev = rev.substring(dashIndex + 1);
+  returnValue.emit('requestError', error);
+  if (returnValue.state === 'active') {
+    returnValue.emit('paused', error);
+    returnValue.state = 'stopped';
+    returnValue.once('active', function () {
+      opts.current_back_off = opts.default_back_off;
+    });
   }
-  var deleted = false;
-  merge.traverseRevTree(metadata.rev_tree,
-  function (isLeaf, pos, id, acc, opts) {
-    if (id === rev) {
-      deleted = !!opts.deleted;
-    }
-  });
 
-  return deleted;
-};
+  opts.current_back_off = opts.current_back_off || opts.default_back_off;
+  opts.current_back_off = opts.back_off_function(opts.current_back_off);
+  setTimeout(function () {
+    replicate(repId, src, target, opts, returnValue);
+  }, opts.current_back_off);
+}
 
-exports.revExists = function (metadata, rev) {
-  var found = false;
-  merge.traverseRevTree(metadata.rev_tree, function (leaf, pos, id) {
-    if ((pos + '-' + id) === rev) {
-      found = true;
-    }
+// We create a basic promise so the caller can cancel the replication possibly
+// before we have actually started listening to changes etc
+utils.inherits(Replication, EE);
+function Replication() {
+  EE.call(this);
+  this.cancelled = false;
+  this.state = 'pending';
+  var self = this;
+  var promise = new utils.Promise(function (fulfill, reject) {
+    self.once('complete', fulfill);
+    self.once('error', reject);
   });
-  return found;
-};
-
-exports.filterChange = function filterChange(opts) {
-  var req = {};
-  var hasFilter = opts.filter && typeof opts.filter === 'function';
-  req.query = opts.query_params;
-
-  return function filter(change) {
-    if (!change.doc) {
-      // CSG sends events on the changes feed that don't have documents,
-      // this hack makes a whole lot of existing code robust.
-      change.doc = {};
-    }
-    if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
-      return false;
-    }
-    if (!opts.include_docs) {
-      delete change.doc;
-    } else if (!opts.attachments) {
-      for (var att in change.doc._attachments) {
-        if (change.doc._attachments.hasOwnProperty(att)) {
-          change.doc._attachments[att].stub = true;
-        }
-      }
-    }
-    return true;
+  self.then = function (resolve, reject) {
+    return promise.then(resolve, reject);
   };
-};
-
-exports.parseDoc = parseDoc.parseDoc;
-exports.invalidIdError = parseDoc.invalidIdError;
+  self.catch = function (reject) {
+    return promise.catch(reject);
+  };
+  // As we allow error handling via "error" event as well,
+  // put a stub in here so that rejecting never throws UnhandledError.
+  self.catch(function () {});
+}
 
-exports.isCordova = function () {
-  return (typeof cordova !== "undefined" ||
-          typeof PhoneGap !== "undefined" ||
-          typeof phonegap !== "undefined");
+Replication.prototype.cancel = function () {
+  this.cancelled = true;
+  this.state = 'cancelled';
+  this.emit('cancel');
 };
 
-exports.hasLocalStorage = function () {
-  if (isChromeApp()) {
-    return false;
-  }
-  try {
-    return localStorage;
-  } catch (e) {
-    return false;
-  }
-};
-exports.Changes = Changes;
-exports.inherits(Changes, EventEmitter);
-function Changes() {
-  if (!(this instanceof Changes)) {
-    return new Changes();
-  }
+Replication.prototype.ready = function (src, target) {
   var self = this;
-  EventEmitter.call(this);
-  this.isChrome = isChromeApp();
-  this.listeners = {};
-  this.hasLocal = false;
-  if (!this.isChrome) {
-    this.hasLocal = exports.hasLocalStorage();
+  function onDestroy() {
+    self.cancel();
   }
-  if (this.isChrome) {
-    chrome.storage.onChanged.addListener(function (e) {
-      // make sure it's event addressed to us
-      if (e.db_name != null) {
-        //object only has oldValue, newValue members
-        self.emit(e.dbName.newValue);
-      }
-    });
-  } else if (this.hasLocal) {
-    if (typeof addEventListener !== 'undefined') {
-      addEventListener("storage", function (e) {
-        self.emit(e.key);
-      });
-    } else { // old IE
-      window.attachEvent("storage", function (e) {
-        self.emit(e.key);
-      });
-    }
+  src.once('destroyed', onDestroy);
+  target.once('destroyed', onDestroy);
+  function cleanup() {
+    src.removeListener('destroyed', onDestroy);
+    target.removeListener('destroyed', onDestroy);
   }
+  this.then(cleanup, cleanup);
+};
+
 
+// TODO: check CouchDB's replication id generation
+// Generate a unique id particular to this replication
+function genReplicationId(src, target, opts) {
+  var filterFun = opts.filter ? opts.filter.toString() : '';
+  return src.id().then(function (src_id) {
+    return target.id().then(function (target_id) {
+      var queryData = src_id + target_id + filterFun +
+        JSON.stringify(opts.query_params) + opts.doc_ids;
+      return utils.MD5(queryData).then(function (md5) {
+        // can't use straight-up md5 alphabet, because
+        // the char '/' is interpreted as being for attachments,
+        // and + is also not url-safe
+        md5 = md5.replace(/\//g, '.').replace(/\+/g, '_');
+        return '_local/' + md5;
+      });
+    });
+  });
 }
-Changes.prototype.addListener = function (dbName, id, db, opts) {
-  if (this.listeners[id]) {
-    return;
-  }
-  var self = this;
-  var inprogress = false;
-  function eventFunction() {
-    if (!self.listeners[id]) {
-      return;
-    }
-    if (inprogress) {
-      inprogress = 'waiting';
+
+function replicate(repId, src, target, opts, returnValue, result) {
+  var batches = [];               // list of batches to be processed
+  var currentBatch;               // the batch currently being processed
+  var pendingBatch = {
+    seq: 0,
+    changes: [],
+    docs: []
+  }; // next batch, not yet ready to be processed
+  var writingCheckpoint = false;  // true while checkpoint is being written
+  var changesCompleted = false;   // true when all changes received
+  var replicationCompleted = false; // true when replication has completed
+  var last_seq = 0;
+  var continuous = opts.continuous || opts.live || false;
+  var batch_size = opts.batch_size || 100;
+  var batches_limit = opts.batches_limit || 10;
+  var changesPending = false;     // true while src.changes is running
+  var doc_ids = opts.doc_ids;
+  var state = {
+    cancelled: false
+  };
+  var checkpointer = new Checkpointer(src, target, repId, state);
+  var allErrors = [];
+  var changedDocs = [];
+
+  result = result || {
+    ok: true,
+    start_time: new Date(),
+    docs_read: 0,
+    docs_written: 0,
+    doc_write_failures: 0,
+    errors: []
+  };
+
+  var changesOpts = {};
+  returnValue.ready(src, target);
+
+  function writeDocs() {
+    if (currentBatch.docs.length === 0) {
       return;
     }
-    inprogress = true;
-    db.changes({
-      style: opts.style,
-      include_docs: opts.include_docs,
-      attachments: opts.attachments,
-      conflicts: opts.conflicts,
-      continuous: false,
-      descending: false,
-      filter: opts.filter,
-      doc_ids: opts.doc_ids,
-      view: opts.view,
-      since: opts.since,
-      query_params: opts.query_params
-    }).on('change', function (c) {
-      if (c.seq > opts.since && !opts.cancelled) {
-        opts.since = c.seq;
-        exports.call(opts.onChange, c);
+    var docs = currentBatch.docs;
+    return target.bulkDocs({docs: docs, new_edits: false}).then(function (res) {
+      if (state.cancelled) {
+        completeReplication();
+        throw new Error('cancelled');
       }
-    }).on('complete', function () {
-      if (inprogress === 'waiting') {
-        process.nextTick(function () {
-          self.notify(dbName);
-        });
+      var errors = [];
+      var errorsById = {};
+      res.forEach(function (res) {
+        if (res.error) {
+          result.doc_write_failures++;
+          errors.push(res);
+          errorsById[res.id] = res;
+        }
+      });
+      allErrors = allErrors.concat(errors);
+      result.docs_written += currentBatch.docs.length - errors.length;
+      var non403s = errors.filter(function (error) {
+        return error.name !== 'unauthorized' && error.name !== 'forbidden';
+      });
+
+      changedDocs = [];
+      docs.forEach(function(doc) {
+        var error = errorsById[doc._id];
+        if (error) {
+          returnValue.emit('denied', utils.clone(error));
+        } else {
+          changedDocs.push(doc);
+        }
+      });
+
+      if (non403s.length > 0) {
+        var error = new Error('bulkDocs error');
+        error.other_errors = errors;
+        abortReplication('target.bulkDocs failed to write docs', error);
+        throw new Error('bulkWrite partial failure');
       }
-      inprogress = false;
-    }).on('error', function () {
-      inprogress = false;
+    }, function (err) {
+      result.doc_write_failures += docs.length;
+      throw err;
     });
   }
-  this.listeners[id] = eventFunction;
-  this.on(dbName, eventFunction);
-};
 
-Changes.prototype.removeListener = function (dbName, id) {
-  if (!(id in this.listeners)) {
-    return;
-  }
-  EventEmitter.prototype.removeListener.call(this, dbName,
-    this.listeners[id]);
-};
+  function processDiffDoc(id) {
+    var diffs = currentBatch.diffs;
+    var allMissing = diffs[id].missing;
+    // avoid url too long error by batching
+    var missingBatches = [];
+    for (var i = 0; i < allMissing.length; i += MAX_SIMULTANEOUS_REVS) {
+      missingBatches.push(allMissing.slice(i, Math.min(allMissing.length,
+        i + MAX_SIMULTANEOUS_REVS)));
+    }
 
+    return utils.Promise.all(missingBatches.map(function (missing) {
+      var opts = {
+        revs: true,
+        open_revs: missing,
+        attachments: true
+      };
+      return src.get(id, opts).then(function (docs) {
+        docs.forEach(function (doc) {
+          if (state.cancelled) {
+            return completeReplication();
+          }
+          if (doc.ok) {
+            result.docs_read++;
+            currentBatch.pendingRevs++;
+            currentBatch.docs.push(doc.ok);
+          }
+        });
+        delete diffs[id];
+      });
+    }));
+  }
 
-Changes.prototype.notifyLocalWindows = function (dbName) {
-  //do a useless change on a storage thing
-  //in order to get other windows's listeners to activate
-  if (this.isChrome) {
-    chrome.storage.local.set({dbName: dbName});
-  } else if (this.hasLocal) {
-    localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
+  function getAllDocs() {
+    var diffKeys = Object.keys(currentBatch.diffs);
+    return utils.Promise.all(diffKeys.map(processDiffDoc));
   }
-};
 
-Changes.prototype.notify = function (dbName) {
-  this.emit(dbName);
-  this.notifyLocalWindows(dbName);
-};
 
-if (typeof atob === 'function') {
-  exports.atob = function (str) {
-    return atob(str);
-  };
-} else {
-  exports.atob = function (str) {
-    var base64 = new buffer(str, 'base64');
-    // Node.js will just skip the characters it can't encode instead of
-    // throwing and exception
-    if (base64.toString('base64') !== str) {
-      throw ("Cannot base64 encode full string");
+  function getRevisionOneDocs() {
+    // filter out the generation 1 docs and get them
+    // leaving the non-generation one docs to be got otherwise
+    var ids = Object.keys(currentBatch.diffs).filter(function (id) {
+      var missing = currentBatch.diffs[id].missing;
+      return missing.length === 1 && missing[0].slice(0, 2) === '1-';
+    });
+    if (!ids.length) { // nothing to fetch
+      return utils.Promise.resolve();
     }
-    return base64.toString('binary');
-  };
-}
+    return src.allDocs({
+      keys: ids,
+      include_docs: true
+    }).then(function (res) {
+      if (state.cancelled) {
+        completeReplication();
+        throw (new Error('cancelled'));
+      }
+      res.rows.forEach(function (row) {
+        if (row.doc && !row.deleted &&
+          row.value.rev.slice(0, 2) === '1-' && (
+            !row.doc._attachments ||
+            Object.keys(row.doc._attachments).length === 0
+          )
+        ) {
+          result.docs_read++;
+          currentBatch.pendingRevs++;
+          currentBatch.docs.push(row.doc);
+          delete currentBatch.diffs[row.id];
+        }
+      });
+    });
+  }
 
-if (typeof btoa === 'function') {
-  exports.btoa = function (str) {
-    return btoa(str);
-  };
-} else {
-  exports.btoa = function (str) {
-    return new buffer(str, 'binary').toString('base64');
-  };
-}
+  function getDocs() {
+    return getRevisionOneDocs().then(getAllDocs);
+  }
 
-// From http://stackoverflow.com/questions/14967647/ (continues on next line)
-// encode-decode-image-with-base64-breaks-image (2013-04-21)
-exports.fixBinary = function (bin) {
-  if (!process.browser) {
-    // don't need to do this in Node
-    return bin;
+  function finishBatch() {
+    writingCheckpoint = true;
+    return checkpointer.writeCheckpoint(currentBatch.seq).then(function () {
+      writingCheckpoint = false;
+      if (state.cancelled) {
+        completeReplication();
+        throw new Error('cancelled');
+      }
+      result.last_seq = last_seq = currentBatch.seq;
+      var outResult = utils.clone(result);
+      outResult.docs = changedDocs;
+      returnValue.emit('change', outResult);
+      currentBatch = undefined;
+      getChanges();
+    }).catch(function (err) {
+      writingCheckpoint = false;
+      abortReplication('writeCheckpoint completed with error', err);
+      throw err;
+    });
   }
 
-  var length = bin.length;
-  var buf = new ArrayBuffer(length);
-  var arr = new Uint8Array(buf);
-  for (var i = 0; i < length; i++) {
-    arr[i] = bin.charCodeAt(i);
+  function getDiffs() {
+    var diff = {};
+    currentBatch.changes.forEach(function (change) {
+      // Couchbase Sync Gateway emits these, but we can ignore them
+      if (change.id === "_user/") {
+        return;
+      }
+      diff[change.id] = change.changes.map(function (x) {
+        return x.rev;
+      });
+    });
+    return target.revsDiff(diff).then(function (diffs) {
+      if (state.cancelled) {
+        completeReplication();
+        throw new Error('cancelled');
+      }
+      // currentBatch.diffs elements are deleted as the documents are written
+      currentBatch.diffs = diffs;
+      currentBatch.pendingRevs = 0;
+    });
   }
-  return buf;
-};
 
-// shim for browsers that don't support it
-exports.readAsBinaryString = function (blob, callback) {
-  var reader = new FileReader();
-  var hasBinaryString = typeof reader.readAsBinaryString === 'function';
-  reader.onloadend = function (e) {
-    var result = e.target.result || '';
-    if (hasBinaryString) {
-      return callback(result);
+  function startNextBatch() {
+    if (state.cancelled || currentBatch) {
+      return;
     }
-    callback(exports.arrayBufferToBinaryString(result));
-  };
-  if (hasBinaryString) {
-    reader.readAsBinaryString(blob);
-  } else {
-    reader.readAsArrayBuffer(blob);
+    if (batches.length === 0) {
+      processPendingBatch(true);
+      return;
+    }
+    currentBatch = batches.shift();
+    getDiffs()
+      .then(getDocs)
+      .then(writeDocs)
+      .then(finishBatch)
+      .then(startNextBatch)
+      .catch(function (err) {
+        abortReplication('batch processing terminated with error', err);
+      });
   }
-};
 
-// simplified API. universal browser support is assumed
-exports.readAsArrayBuffer = function (blob, callback) {
-  var reader = new FileReader();
-  reader.onloadend = function (e) {
-    var result = e.target.result || new ArrayBuffer(0);
-    callback(result);
-  };
-  reader.readAsArrayBuffer(blob);
-};
 
-exports.once = function (fun) {
-  var called = false;
-  return exports.getArguments(function (args) {
-    if (called) {
-      throw new Error('once called  more than once');
-    } else {
-      called = true;
-      fun.apply(this, args);
+  function processPendingBatch(immediate) {
+    if (pendingBatch.changes.length === 0) {
+      if (batches.length === 0 && !currentBatch) {
+        if ((continuous && changesOpts.live) || changesCompleted) {
+          returnValue.state = 'pending';
+          returnValue.emit('paused');
+          returnValue.emit('uptodate', result);
+        }
+        if (changesCompleted) {
+          completeReplication();
+        }
+      }
+      return;
     }
-  });
-};
-
-exports.toPromise = function (func) {
-  //create the function we will be returning
-  return exports.getArguments(function (args) {
-    var self = this;
-    var tempCB =
-      (typeof args[args.length - 1] === 'function') ? args.pop() : false;
-    // if the last argument is a function, assume its a callback
-    var usedCB;
-    if (tempCB) {
-      // if it was a callback, create a new callback which calls it,
-      // but do so async so we don't trap any errors
-      usedCB = function (err, resp) {
-        process.nextTick(function () {
-          tempCB(err, resp);
-        });
+    if (
+      immediate ||
+      changesCompleted ||
+      pendingBatch.changes.length >= batch_size
+    ) {
+      batches.push(pendingBatch);
+      pendingBatch = {
+        seq: 0,
+        changes: [],
+        docs: []
       };
-    }
-    var promise = new Promise(function (fulfill, reject) {
-      var resp;
-      try {
-        var callback = exports.once(function (err, mesg) {
-          if (err) {
-            reject(err);
-          } else {
-            fulfill(mesg);
-          }
-        });
-        // create a callback for this invocation
-        // apply the function in the orig context
-        args.push(callback);
-        resp = func.apply(self, args);
-        if (resp && typeof resp.then === 'function') {
-          fulfill(resp);
-        }
-      } catch (e) {
-        reject(e);
+      if (returnValue.state === 'pending' || returnValue.state === 'stopped') {
+        returnValue.state = 'active';
+        returnValue.emit('active');
       }
-    });
-    // if there is a callback, call it back
-    if (usedCB) {
-      promise.then(function (result) {
-        usedCB(null, result);
-      }, usedCB);
+      startNextBatch();
     }
-    promise.cancel = function () {
-      return this;
-    };
-    return promise;
-  });
-};
+  }
 
-exports.adapterFun = function (name, callback) {
-  var log = require('debug')('pouchdb:api');
 
-  function logApiCall(self, name, args) {
-    if (!log.enabled) {
+  function abortReplication(reason, err) {
+    if (replicationCompleted) {
       return;
     }
-    var logArgs = [self._db_name, name];
-    for (var i = 0; i < args.length - 1; i++) {
-      logArgs.push(args[i]);
+    if (!err.message) {
+      err.message = reason;
     }
-    log.apply(null, logArgs);
-
-    // override the callback itself to log the response
-    var origCallback = args[args.length - 1];
-    args[args.length - 1] = function (err, res) {
-      var responseArgs = [self._db_name, name];
-      responseArgs = responseArgs.concat(
-        err ? ['error', err] : ['success', res]
-      );
-      log.apply(null, responseArgs);
-      origCallback(err, res);
+    result.ok = false;
+    result.status = 'aborting';
+    result.errors.push(err);
+    allErrors = allErrors.concat(err);
+    batches = [];
+    pendingBatch = {
+      seq: 0,
+      changes: [],
+      docs: []
     };
+    completeReplication();
   }
 
 
-  return exports.toPromise(exports.getArguments(function (args) {
-    if (this._closed) {
-      return Promise.reject(new Error('database is closed'));
+  function completeReplication() {
+    if (replicationCompleted) {
+      return;
     }
-    var self = this;
-    logApiCall(self, name, args);
-    if (!this.taskqueue.isReady) {
-      return new Promise(function (fulfill, reject) {
-        self.taskqueue.addTask(function (failed) {
-          if (failed) {
-            reject(failed);
-          } else {
-            fulfill(self[name].apply(self, args));
-          }
-        });
-      });
+    if (state.cancelled) {
+      result.status = 'cancelled';
+      if (writingCheckpoint) {
+        return;
+      }
+    }
+    result.status = result.status || 'complete';
+    result.end_time = new Date();
+    result.last_seq = last_seq;
+    replicationCompleted = state.cancelled = true;
+    var non403s = allErrors.filter(function (error) {
+      return error.name !== 'unauthorized' && error.name !== 'forbidden';
+    });
+    if (non403s.length > 0) {
+      var error = allErrors.pop();
+      if (allErrors.length > 0) {
+        error.other_errors = allErrors;
+      }
+      error.result = result;
+      backOff(repId, src, target, opts, returnValue, result, error);
+    } else {
+      result.errors = allErrors;
+      returnValue.emit('complete', result);
+      returnValue.removeAllListeners();
     }
-    return callback.apply(this, args);
-  }));
-};
-
-//Can't find original post, but this is close
-//http://stackoverflow.com/questions/6965107/ (continues on next line)
-//converting-between-strings-and-arraybuffers
-exports.arrayBufferToBinaryString = function (buffer) {
-  var binary = "";
-  var bytes = new Uint8Array(buffer);
-  var length = bytes.byteLength;
-  for (var i = 0; i < length; i++) {
-    binary += String.fromCharCode(bytes[i]);
   }
-  return binary;
-};
-
-exports.cancellableFun = function (fun, self, opts) {
 
-  opts = opts ? exports.clone(true, {}, opts) : {};
 
-  var emitter = new EventEmitter();
-  var oldComplete = opts.complete || function () { };
-  var complete = opts.complete = exports.once(function (err, resp) {
-    if (err) {
-      oldComplete(err);
-    } else {
-      emitter.emit('end', resp);
-      oldComplete(null, resp);
+  function onChange(change) {
+    if (state.cancelled) {
+      return completeReplication();
     }
-    emitter.removeAllListeners();
-  });
-  var oldOnChange = opts.onChange || function () {};
-  var lastChange = 0;
-  self.on('destroyed', function () {
-    emitter.removeAllListeners();
-  });
-  opts.onChange = function (change) {
-    oldOnChange(change);
-    if (change.seq <= lastChange) {
+    var filter = utils.filterChange(opts)(change);
+    if (!filter) {
       return;
     }
-    lastChange = change.seq;
-    emitter.emit('change', change);
-    if (change.deleted) {
-      emitter.emit('delete', change);
-    } else if (change.changes.length === 1 &&
-      change.changes[0].rev.slice(0, 1) === '1-') {
-      emitter.emit('create', change);
-    } else {
-      emitter.emit('update', change);
+    if (
+      pendingBatch.changes.length === 0 &&
+      batches.length === 0 &&
+      !currentBatch
+    ) {
+      returnValue.emit('outofdate', result);
     }
-  };
-  var promise = new Promise(function (fulfill, reject) {
-    opts.complete = function (err, res) {
-      if (err) {
-        reject(err);
-      } else {
-        fulfill(res);
-      }
-    };
-  });
+    pendingBatch.seq = change.seq;
+    pendingBatch.changes.push(change);
+    processPendingBatch(batches.length === 0);
+  }
 
-  promise.then(function (result) {
-    complete(null, result);
-  }, complete);
 
-  // this needs to be overwridden by caller, dont fire complete until
-  // the task is ready
-  promise.cancel = function () {
-    promise.isCancelled = true;
-    if (self.taskqueue.isReady) {
-      opts.complete(null, {status: 'cancelled'});
+  function onChangesComplete(changes) {
+    changesPending = false;
+    if (state.cancelled) {
+      return completeReplication();
     }
-  };
 
-  if (!self.taskqueue.isReady) {
-    self.taskqueue.addTask(function () {
-      if (promise.isCancelled) {
-        opts.complete(null, {status: 'cancelled'});
+    // if no results were returned then we're done,
+    // else fetch more
+    if (changes.results.length > 0) {
+      changesOpts.since = changes.last_seq;
+      getChanges();
+    } else {
+      if (continuous) {
+        changesOpts.live = true;
+        getChanges();
       } else {
-        fun(self, opts, promise);
+        changesCompleted = true;
       }
-    });
-  } else {
-    fun(self, opts, promise);
-  }
-  promise.on = emitter.on.bind(emitter);
-  promise.once = emitter.once.bind(emitter);
-  promise.addListener = emitter.addListener.bind(emitter);
-  promise.removeListener = emitter.removeListener.bind(emitter);
-  promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
-  promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
-  promise.listeners = emitter.listeners.bind(emitter);
-  promise.emit = emitter.emit.bind(emitter);
-  return promise;
-};
-
-exports.MD5 = exports.toPromise(require('./deps/md5'));
-
-exports.explain404 = require('./deps/explain404');
-
-exports.info = function (str) {
-  if (typeof console !== 'undefined' && 'info' in console) {
-    console.info(str);
-  }
-};
-
-exports.parseUri = require('./deps/parse-uri');
-
-exports.compare = function (left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-};
-
-exports.updateDoc = function updateDoc(prev, docInfo, results,
-                                       i, cb, writeDoc, newEdits) {
-
-  if (exports.revExists(prev, docInfo.metadata.rev)) {
-    results[i] = docInfo;
-    return cb();
+    }
+    processPendingBatch(true);
   }
 
-  // TODO: some of these can be pre-calculated, but it's safer to just
-  // call merge.winningRev() and exports.isDeleted() all over again
-  var previousWinningRev = merge.winningRev(prev);
-  var previouslyDeleted = exports.isDeleted(prev, previousWinningRev);
-  var deleted = exports.isDeleted(docInfo.metadata);
-  var isRoot = /^1-/.test(docInfo.metadata.rev);
 
-  if (previouslyDeleted && !deleted && newEdits && isRoot) {
-    var newDoc = docInfo.data;
-    newDoc._rev = previousWinningRev;
-    newDoc._id = docInfo.metadata.id;
-    docInfo = exports.parseDoc(newDoc, newEdits);
+  function onChangesError(err) {
+    changesPending = false;
+    if (state.cancelled) {
+      return completeReplication();
+    }
+    abortReplication('changes rejected', err);
   }
 
-  var merged = merge.merge(prev.rev_tree, docInfo.metadata.rev_tree[0], 1000);
-
-  var inConflict = newEdits && (((previouslyDeleted && deleted) ||
-    (!previouslyDeleted && merged.conflicts !== 'new_leaf') ||
-    (previouslyDeleted && !deleted && merged.conflicts === 'new_branch')));
-
-  if (inConflict) {
-    var err = errors.error(errors.REV_CONFLICT);
-    results[i] = err;
-    return cb();
-  }
 
-  var newRev = docInfo.metadata.rev;
-  docInfo.metadata.rev_tree = merged.tree;
-  if (prev.rev_map) {
-    docInfo.metadata.rev_map = prev.rev_map; // used by leveldb
+  function getChanges() {
+    if (!(
+      !changesPending &&
+      !changesCompleted &&
+      batches.length < batches_limit
+    )) {
+      return;
+    }
+    changesPending = true;
+    function abortChanges() {
+      changes.cancel();
+    }
+    function removeListener() {
+      returnValue.removeListener('cancel', abortChanges);
+    }
+    returnValue.once('cancel', abortChanges);
+    var changes = src.changes(changesOpts)
+    .on('change', onChange);
+    changes.then(removeListener, removeListener);
+    changes.then(onChangesComplete)
+    .catch(onChangesError);
   }
 
-  // recalculate
-  var winningRev = merge.winningRev(docInfo.metadata);
-  var winningRevIsDeleted = exports.isDeleted(docInfo.metadata, winningRev);
-
-  // calculate the total number of documents that were added/removed,
-  // from the perspective of total_rows/doc_count
-  var delta = (previouslyDeleted === winningRevIsDeleted) ? 0 :
-      previouslyDeleted < winningRevIsDeleted ? -1 : 1;
-
-  var newRevIsDeleted = exports.isDeleted(docInfo.metadata, newRev);
-
-  writeDoc(docInfo, winningRev, winningRevIsDeleted, newRevIsDeleted,
-    true, delta, i, cb);
-};
 
-exports.processDocs = function processDocs(docInfos, api, fetchedDocs,
-                                           tx, results, writeDoc, opts,
-                                           overallCallback) {
+  function startChanges() {
+    checkpointer.getCheckpoint().then(function (checkpoint) {
+      last_seq = checkpoint;
+      changesOpts = {
+        since: last_seq,
+        limit: batch_size,
+        batch_size: batch_size,
+        style: 'all_docs',
+        doc_ids: doc_ids,
+        returnDocs: true // required so we know when we're done
+      };
+      if (opts.filter) {
+        if (typeof opts.filter !== 'string') {
+          // required for the client-side filter in onChange
+          changesOpts.include_docs = true;
+        } else { // ddoc filter
+          changesOpts.filter = opts.filter;
+        }
+      }
+      if (opts.query_params) {
+        changesOpts.query_params = opts.query_params;
+      }
+      if (opts.view) {
+        changesOpts.view = opts.view;
+      }
+      getChanges();
+    }).catch(function (err) {
+      abortReplication('getCheckpoint rejected with ', err);
+    });
+  }
 
-  if (!docInfos.length) {
+  if (returnValue.cancelled) { // cancelled immediately
+    completeReplication();
     return;
   }
 
-  function insertDoc(docInfo, resultsIdx, callback) {
-    // Cant insert new deleted documents
-    var winningRev = merge.winningRev(docInfo.metadata);
-    var deleted = exports.isDeleted(docInfo.metadata, winningRev);
-    if ('was_delete' in opts && deleted) {
-      results[resultsIdx] = errors.error(errors.MISSING_DOC, 'deleted');
-      return callback();
-    }
-
-    var delta = deleted ? 0 : 1;
+  returnValue.once('cancel', completeReplication);
 
-    writeDoc(docInfo, winningRev, deleted, deleted, false,
-      delta, resultsIdx, callback);
+  if (typeof opts.onChange === 'function') {
+    returnValue.on('change', opts.onChange);
   }
 
-  var newEdits = opts.new_edits;
-  var idsToDocs = new exports.Map();
-
-  var docsDone = 0;
-  var docsToDo = docInfos.length;
+  if (typeof opts.complete === 'function') {
+    returnValue.once('error', opts.complete);
+    returnValue.once('complete', function (result) {
+      opts.complete(null, result);
+    });
+  }
 
-  function checkAllDocsDone() {
-    if (++docsDone === docsToDo && overallCallback) {
-      overallCallback();
-    }
+  if (typeof opts.since === 'undefined') {
+    startChanges();
+  } else {
+    writingCheckpoint = true;
+    checkpointer.writeCheckpoint(opts.since).then(function () {
+      writingCheckpoint = false;
+      if (state.cancelled) {
+        completeReplication();
+        return;
+      }
+      last_seq = opts.since;
+      startChanges();
+    }).catch(function (err) {
+      writingCheckpoint = false;
+      abortReplication('writeCheckpoint completed with error', err);
+      throw err;
+    });
   }
+}
 
-  docInfos.forEach(function (currentDoc, resultsIdx) {
+exports.toPouch = toPouch;
+function toPouch(db, opts) {
+  var PouchConstructor = opts.PouchConstructor;
+  if (typeof db === 'string') {
+    return new PouchConstructor(db, opts);
+  } else if (db.then) {
+    return db;
+  } else {
+    return utils.Promise.resolve(db);
+  }
+}
 
-    if (currentDoc._id && exports.isLocalId(currentDoc._id)) {
-      api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
-        currentDoc, {ctx: tx}, function (err) {
-          if (err) {
-            results[resultsIdx] = err;
-          } else {
-            results[resultsIdx] = {ok: true};
-          }
-          checkAllDocsDone();
-        });
-      return;
-    }
 
-    var id = currentDoc.metadata.id;
-    if (idsToDocs.has(id)) {
-      docsToDo--; // duplicate
-      idsToDocs.get(id).push([currentDoc, resultsIdx]);
-    } else {
-      idsToDocs.set(id, [[currentDoc, resultsIdx]]);
-    }
+exports.replicate = replicateWrapper;
+function replicateWrapper(src, target, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  if (typeof opts === 'undefined') {
+    opts = {};
+  }
+  if (!opts.complete) {
+    opts.complete = callback || function () {};
+  }
+  opts = utils.clone(opts);
+  opts.continuous = opts.continuous || opts.live;
+  opts.retry = ('retry' in opts) ? opts.retry : RETRY_DEFAULT;
+  /*jshint validthis:true */
+  opts.PouchConstructor = opts.PouchConstructor || this;
+  var replicateRet = new Replication(opts);
+  toPouch(src, opts).then(function (src) {
+    return toPouch(target, opts).then(function (target) {
+      return genReplicationId(src, target, opts).then(function (repId) {
+        replicate(repId, src, target, opts, replicateRet);
+      });
+    });
+  }).catch(function (err) {
+    replicateRet.emit('error', err);
+    opts.complete(err);
   });
+  return replicateRet;
+}
 
-  // in the case of new_edits, the user can provide multiple docs
-  // with the same id. these need to be processed sequentially
-  idsToDocs.forEach(function (docs, id) {
-    var numDone = 0;
-
-    function docWritten() {
-      if (++numDone < docs.length) {
-        nextDoc();
-      } else {
-        checkAllDocsDone();
-      }
-    }
-    function nextDoc() {
-      var value = docs[numDone];
-      var currentDoc = value[0];
-      var resultsIdx = value[1];
+},{"./checkpointer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/checkpointer.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/setup.js":[function(require,module,exports){
+"use strict";
 
-      if (fetchedDocs.has(id)) {
-        exports.updateDoc(fetchedDocs.get(id), currentDoc, results,
-          resultsIdx, docWritten, writeDoc, newEdits);
-      } else {
-        insertDoc(currentDoc, resultsIdx, docWritten);
-      }
-    }
-    nextDoc();
-  });
-};
+var PouchDB = require("./constructor");
+var utils = require('./utils');
+var EventEmitter = require('events').EventEmitter;
+PouchDB.adapters = {};
+PouchDB.preferredAdapters = [];
 
-exports.preprocessAttachments = function preprocessAttachments(
-    docInfos, blobType, callback) {
+PouchDB.prefix = '_pouch_';
 
-  if (!docInfos.length) {
-    return callback();
-  }
+var eventEmitter = new EventEmitter();
 
-  var docv = 0;
+var eventEmitterMethods = [
+  'on',
+  'addListener',
+  'emit',
+  'listeners',
+  'once',
+  'removeAllListeners',
+  'removeListener',
+  'setMaxListeners'
+];
 
-  function parseBase64(data) {
-    try {
-      return exports.atob(data);
-    } catch (e) {
-      var err = errors.error(errors.BAD_ARG,
-                             'Attachments need to be base64 encoded');
-      return {error: err};
+eventEmitterMethods.forEach(function (method) {
+  PouchDB[method] = eventEmitter[method].bind(eventEmitter);
+});
+PouchDB.setMaxListeners(0);
+PouchDB.parseAdapter = function (name, opts) {
+  var match = name.match(/([a-z\-]*):\/\/(.*)/);
+  var adapter, adapterName;
+  if (match) {
+    // the http adapter expects the fully qualified name
+    name = /http(s?)/.test(match[1]) ? match[1] + '://' + match[2] : match[2];
+    adapter = match[1];
+    if (!PouchDB.adapters[adapter].valid()) {
+      throw 'Invalid adapter';
     }
+    return {name: name, adapter: match[1]};
   }
 
-  function preprocessAttachment(att, callback) {
-    if (att.stub) {
-      return callback();
-    }
-    if (typeof att.data === 'string') {
-      // input is a base64 string
+  // check for browsers that have been upgraded from websql-only to websql+idb
+  var skipIdb = 'idb' in PouchDB.adapters && 'websql' in PouchDB.adapters &&
+    utils.hasLocalStorage() &&
+    localStorage['_pouch__websqldb_' + PouchDB.prefix + name];
 
-      var asBinary = parseBase64(att.data);
-      if (asBinary.error) {
-        return callback(asBinary.error);
-      }
 
-      att.length = asBinary.length;
-      if (blobType === 'blob') {
-        att.data = exports.createBlob([exports.fixBinary(asBinary)],
-          {type: att.content_type});
-      } else if (blobType === 'base64') {
-        att.data = exports.btoa(asBinary);
-      } else { // binary
-        att.data = asBinary;
-      }
-      exports.MD5(asBinary).then(function (result) {
-        att.digest = 'md5-' + result;
-        callback();
-      });
-    } else { // input is a blob
-      exports.readAsArrayBuffer(att.data, function (buff) {
-        if (blobType === 'binary') {
-          att.data = exports.arrayBufferToBinaryString(buff);
-        } else if (blobType === 'base64') {
-          att.data = exports.btoa(exports.arrayBufferToBinaryString(buff));
+  if (opts.adapter) {
+    adapterName = opts.adapter;
+  } else if (typeof opts !== 'undefined' && opts.db) {
+    adapterName = 'leveldb';
+  } else { // automatically determine adapter
+    for (var i = 0; i < PouchDB.preferredAdapters.length; ++i) {
+      adapterName = PouchDB.preferredAdapters[i];
+      if (adapterName in PouchDB.adapters) {
+        if (skipIdb && adapterName === 'idb') {
+          // log it, because this can be confusing during development
+          console.log('PouchDB is downgrading "' + name + '" to WebSQL to' +
+            ' avoid data loss, because it was already opened with WebSQL.');
+          continue; // keep using websql to avoid user data loss
         }
-        exports.MD5(buff).then(function (result) {
-          att.digest = 'md5-' + result;
-          att.length = buff.byteLength;
-          callback();
-        });
-      });
+        break;
+      }
     }
   }
 
-  var overallErr;
+  adapter = PouchDB.adapters[adapterName];
 
-  docInfos.forEach(function (docInfo) {
-    var attachments = docInfo.data && docInfo.data._attachments ?
-      Object.keys(docInfo.data._attachments) : [];
-    var recv = 0;
+  // if adapter is invalid, then an error will be thrown later
+  var usePrefix = (adapter && 'use_prefix' in adapter) ?
+      adapter.use_prefix : true;
 
-    if (!attachments.length) {
-      return done();
-    }
+  return {
+    name: usePrefix ? (PouchDB.prefix + name) : name,
+    adapter: adapterName
+  };
+};
 
-    function processedAttachment(err) {
-      overallErr = err;
-      recv++;
-      if (recv === attachments.length) {
-        done();
-      }
-    }
+PouchDB.destroy = utils.toPromise(function (name, opts, callback) {
+  console.log('PouchDB.destroy() is deprecated and will be removed. ' +
+              'Please use db.destroy() instead.');
 
-    for (var key in docInfo.data._attachments) {
-      if (docInfo.data._attachments.hasOwnProperty(key)) {
-        preprocessAttachment(docInfo.data._attachments[key],
-          processedAttachment);
-      }
+  if (typeof opts === 'function' || typeof opts === 'undefined') {
+    callback = opts;
+    opts = {};
+  }
+  if (name && typeof name === 'object') {
+    opts = name;
+    name = undefined;
+  }
+
+  new PouchDB(name, opts, function (err, db) {
+    if (err) {
+      return callback(err);
     }
+    db.destroy(callback);
   });
+});
 
-  function done() {
-    docv++;
-    if (docInfos.length === docv) {
-      if (overallErr) {
-        callback(overallErr);
-      } else {
-        callback();
-      }
+PouchDB.adapter = function (id, obj, addToPreferredAdapters) {
+  if (obj.valid()) {
+    PouchDB.adapters[id] = obj;
+    if (addToPreferredAdapters) {
+      PouchDB.preferredAdapters.push(id);
     }
   }
 };
 
-// compact a tree by marking its non-leafs as missing,
-// and return a list of revs to delete
-exports.compactTree = function compactTree(metadata) {
-  var revs = [];
-  merge.traverseRevTree(metadata.rev_tree, function (isLeaf, pos,
-                                                     revHash, ctx, opts) {
-    if (opts.status === 'available' && !isLeaf) {
-      revs.push(pos + '-' + revHash);
-      opts.status = 'missing';
-    }
+PouchDB.plugin = function (obj) {
+  Object.keys(obj).forEach(function (id) {
+    PouchDB.prototype[id] = obj[id];
   });
-  return revs;
 };
 
-var vuvuzela = require('vuvuzela');
+PouchDB.defaults = function (defaultOpts) {
+  function PouchAlt(name, opts, callback) {
+    if (typeof opts === 'function' || typeof opts === 'undefined') {
+      callback = opts;
+      opts = {};
+    }
+    if (name && typeof name === 'object') {
+      opts = name;
+      name = undefined;
+    }
 
-exports.safeJsonParse = function safeJsonParse(str) {
-  try {
-    return JSON.parse(str);
-  } catch (e) {
-    return vuvuzela.parse(str);
+    opts = utils.extend(true, {}, defaultOpts, opts);
+    PouchDB.call(this, name, opts, callback);
   }
-};
 
-exports.safeJsonStringify = function safeJsonStringify(json) {
-  try {
-    return JSON.stringify(json);
-  } catch (e) {
-    return vuvuzela.stringify(json);
-  }
-};
+  utils.inherits(PouchAlt, PouchDB);
 
-}).call(this,require('_process'))
-},{"./deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js","./deps/blob":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js","./deps/buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./deps/explain404":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js","./deps/md5":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/md5.js","./deps/parse-doc":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-doc.js","./deps/parse-uri":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-uri.js","./deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js","./deps/uuid":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","argsarray":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/argsarray/index.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js","inherits":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/inherits/inherits_browser.js","pouchdb-collections":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collections/index.js","pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-extend/index.js","vuvuzela":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/vuvuzela/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/version-browser.js":[function(require,module,exports){
-module.exports = "3.5.0";
+  PouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
+    if (typeof opts === 'function' || typeof opts === 'undefined') {
+      callback = opts;
+      opts = {};
+    }
 
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/argsarray/index.js":[function(require,module,exports){
-'use strict';
+    if (name && typeof name === 'object') {
+      opts = name;
+      name = undefined;
+    }
+    opts = utils.extend(true, {}, defaultOpts, opts);
+    return PouchDB.destroy(name, opts, callback);
+  });
 
-module.exports = argsArray;
+  eventEmitterMethods.forEach(function (method) {
+    PouchAlt[method] = eventEmitter[method].bind(eventEmitter);
+  });
+  PouchAlt.setMaxListeners(0);
 
-function argsArray(fun) {
-  return function () {
-    var len = arguments.length;
-    if (len) {
-      var args = [];
-      var i = -1;
-      while (++i < len) {
-        args[i] = arguments[i];
-      }
-      return fun.call(this, args);
-    } else {
-      return fun.call(this, []);
+  PouchAlt.preferredAdapters = PouchDB.preferredAdapters.slice();
+  Object.keys(PouchDB).forEach(function (key) {
+    if (!(key in PouchAlt)) {
+      PouchAlt[key] = PouchDB[key];
     }
-  };
-}
-},{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js":[function(require,module,exports){
-
-/**
- * This is the web browser implementation of `debug()`.
- *
- * Expose `debug()` as the module.
- */
+  });
 
-exports = module.exports = require('./debug');
-exports.log = log;
-exports.formatArgs = formatArgs;
-exports.save = save;
-exports.load = load;
-exports.useColors = useColors;
-exports.storage = 'undefined' != typeof chrome
-               && 'undefined' != typeof chrome.storage
-                  ? chrome.storage.local
-                  : localstorage();
+  return PouchAlt;
+};
 
-/**
- * Colors.
- */
+module.exports = PouchDB;
 
-exports.colors = [
-  'lightseagreen',
-  'forestgreen',
-  'goldenrod',
-  'dodgerblue',
-  'darkorchid',
-  'crimson'
-];
+},{"./constructor":"/Users/richard/src/beagle/node_modules/pouchdb/lib/constructor.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/sync.js":[function(require,module,exports){
+'use strict';
 
-/**
- * Currently only WebKit-based Web Inspectors, Firefox >= v31,
- * and the Firebug extension (any Firefox version) are known
- * to support "%c" CSS customizations.
- *
- * TODO: add a `localStorage` variable to explicitly enable/disable colors
- */
+var utils = require('./utils');
+var replication = require('./replicate');
+var replicate = replication.replicate;
+var EE = require('events').EventEmitter;
 
-function useColors() {
-  // is webkit? http://stackoverflow.com/a/16459606/376773
-  return ('WebkitAppearance' in document.documentElement.style) ||
-    // is firebug? http://stackoverflow.com/a/398120/376773
-    (window.console && (console.firebug || (console.exception && console.table))) ||
-    // is firefox >= v31?
-    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-    (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31);
+utils.inherits(Sync, EE);
+module.exports = sync;
+function sync(src, target, opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  if (typeof opts === 'undefined') {
+    opts = {};
+  }
+  opts = utils.clone(opts);
+  /*jshint validthis:true */
+  opts.PouchConstructor = opts.PouchConstructor || this;
+  src = replication.toPouch(src, opts);
+  target = replication.toPouch(target, opts);
+  return new Sync(src, target, opts, callback);
 }
 
-/**
- * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
- */
+function Sync(src, target, opts, callback) {
+  var self = this;
+  this.canceled = false;
 
-exports.formatters.j = function(v) {
-  return JSON.stringify(v);
-};
+  var onChange, complete;
+  if ('onChange' in opts) {
+    onChange = opts.onChange;
+    delete opts.onChange;
+  }
+  if (typeof callback === 'function' && !opts.complete) {
+    complete = callback;
+  } else if ('complete' in opts) {
+    complete = opts.complete;
+    delete opts.complete;
+  }
 
+  this.push = replicate(src, target, opts);
+  this.pull = replicate(target, src, opts);
 
-/**
- * Colorize log arguments if enabled.
- *
- * @api public
- */
+  var emittedCancel = false;
+  function onCancel(data) {
+    if (!emittedCancel) {
+      emittedCancel = true;
+      self.emit('cancel', data);
+    }
+  }
+  function pullChange(change) {
+    self.emit('change', {
+      direction: 'pull',
+      change: change
+    });
+  }
+  function pushChange(change) {
+    self.emit('change', {
+      direction: 'push',
+      change: change
+    });
+  }
+  function pushDenied(doc) {
+    self.emit('denied', {
+      direction: 'push',
+      doc: doc
+    });
+  }
+  function pullDenied(doc) {
+    self.emit('denied', {
+      direction: 'pull',
+      doc: doc
+    });
+  }
 
-function formatArgs() {
-  var args = arguments;
-  var useColors = this.useColors;
+  var listeners = {};
+  var removed = {};
 
-  args[0] = (useColors ? '%c' : '')
-    + this.namespace
-    + (useColors ? ' %c' : ' ')
-    + args[0]
-    + (useColors ? '%c ' : ' ')
-    + '+' + exports.humanize(this.diff);
+  function removeAll(type) { // type is 'push' or 'pull'
+    return function (event, func) {
+      var isChange = event === 'change' &&
+        (func === pullChange || func === pushChange);
+      var isCancel = event === 'cancel' && func === onCancel;
+      var isOtherEvent = event in listeners && func === listeners[event];
 
-  if (!useColors) return args;
+      if (isChange || isCancel || isOtherEvent) {
+        if (!(event in removed)) {
+          removed[event] = {};
+        }
+        removed[event][type] = true;
+        if (Object.keys(removed[event]).length === 2) {
+          // both push and pull have asked to be removed
+          self.removeAllListeners(event);
+        }
+      }
+    };
+  }
 
-  var c = 'color: ' + this.color;
-  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));
+  if (opts.live) {
+    this.push.on('complete', self.pull.cancel.bind(self.pull));
+    this.pull.on('complete', self.push.cancel.bind(self.push));
+  }
 
-  // the final "%c" is somewhat tricky, because there could be other
-  // arguments passed either before or after the %c, so we need to
-  // figure out the correct index to insert the CSS into
-  var index = 0;
-  var lastC = 0;
-  args[0].replace(/%[a-z%]/g, function(match) {
-    if ('%%' === match) return;
-    index++;
-    if ('%c' === match) {
-      // we only are interested in the *last* %c
-      // (the user may have provided their own)
-      lastC = index;
+  this.on('newListener', function (event) {
+    if (event === 'change') {
+      self.pull.on('change', pullChange);
+      self.push.on('change', pushChange);
+    } else if (event === 'denied') {
+      self.pull.on('denied', pullDenied);
+      self.push.on('denied', pushDenied);
+    } else if (event === 'cancel') {
+      self.pull.on('cancel', onCancel);
+      self.push.on('cancel', onCancel);
+    } else if (event !== 'error' &&
+      event !== 'removeListener' &&
+      event !== 'complete' && !(event in listeners)) {
+      listeners[event] = function (e) {
+        self.emit(event, e);
+      };
+      self.pull.on(event, listeners[event]);
+      self.push.on(event, listeners[event]);
     }
   });
 
-  args.splice(lastC, 0, c);
-  return args;
-}
-
-/**
- * Invokes `console.log()` when available.
- * No-op when `console.log` is not a "function".
- *
- * @api public
- */
-
-function log() {
-  // this hackery is required for IE8/9, where
-  // the `console.log` function doesn't have 'apply'
-  return 'object' === typeof console
-    && console.log
-    && Function.prototype.apply.call(console.log, console, arguments);
-}
+  this.on('removeListener', function (event) {
+    if (event === 'change') {
+      self.pull.removeListener('change', pullChange);
+      self.push.removeListener('change', pushChange);
+    } else if (event === 'cancel') {
+      self.pull.removeListener('cancel', onCancel);
+      self.push.removeListener('cancel', onCancel);
+    } else if (event in listeners) {
+      if (typeof listeners[event] === 'function') {
+        self.pull.removeListener(event, listeners[event]);
+        self.push.removeListener(event, listeners[event]);
+        delete listeners[event];
+      }
+    }
+  });
 
-/**
- * Save `namespaces`.
- *
- * @param {String} namespaces
- * @api private
- */
+  this.pull.on('removeListener', removeAll('pull'));
+  this.push.on('removeListener', removeAll('push'));
 
-function save(namespaces) {
-  try {
-    if (null == namespaces) {
-      exports.storage.removeItem('debug');
-    } else {
-      exports.storage.debug = namespaces;
+  var promise = utils.Promise.all([
+    this.push,
+    this.pull
+  ]).then(function (resp) {
+    var out = {
+      push: resp[0],
+      pull: resp[1]
+    };
+    self.emit('complete', out);
+    if (complete) {
+      complete(null, out);
     }
-  } catch(e) {}
-}
+    self.removeAllListeners();
+    return out;
+  }, function (err) {
+    self.cancel();
+    self.emit('error', err);
+    if (complete) {
+      complete(err);
+    }
+    self.removeAllListeners();
+    throw err;
+  });
 
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
+  this.then = function (success, err) {
+    return promise.then(success, err);
+  };
 
-function load() {
-  var r;
-  try {
-    r = exports.storage.debug;
-  } catch(e) {}
-  return r;
+  this.catch = function (err) {
+    return promise.catch(err);
+  };
 }
 
-/**
- * Enable namespaces listed in `localStorage.debug` initially.
- */
+Sync.prototype.cancel = function () {
+  if (!this.canceled) {
+    this.canceled = true;
+    this.push.cancel();
+    this.pull.cancel();
+  }
+};
 
-exports.enable(load());
+},{"./replicate":"/Users/richard/src/beagle/node_modules/pouchdb/lib/replicate.js","./utils":"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/taskqueue.js":[function(require,module,exports){
+'use strict';
 
-/**
- * Localstorage attempts to return the localstorage.
- *
- * This is necessary because safari throws
- * when a user disables cookies/localstorage
- * and you attempt to access it.
- *
- * @return {LocalStorage}
- * @api private
- */
+module.exports = TaskQueue;
 
-function localstorage(){
-  try {
-    return window.localStorage;
-  } catch (e) {}
+function TaskQueue() {
+  this.isReady = false;
+  this.failed = false;
+  this.queue = [];
 }
 
-},{"./debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/debug.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/debug.js":[function(require,module,exports){
-arguments[4]["/Users/richard/src/beagle/node_modules/nodemailer-mailgun-transport/node_modules/mailgun-js/node_modules/debug/debug.js"][0].apply(exports,arguments)
-},{"ms":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js":[function(require,module,exports){
-/**
- * Helpers.
- */
-
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var y = d * 365.25;
-
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} options
- * @return {String|Number}
- * @api public
- */
+TaskQueue.prototype.execute = function () {
+  var d, func;
+  if (this.failed) {
+    while ((d = this.queue.shift())) {
+      if (typeof d === 'function') {
+        d(this.failed);
+        continue;
+      }
+      func = d.parameters[d.parameters.length - 1];
+      if (typeof func === 'function') {
+        func(this.failed);
+      } else if (d.name === 'changes' && typeof func.complete === 'function') {
+        func.complete(this.failed);
+      }
+    }
+  } else if (this.isReady) {
+    while ((d = this.queue.shift())) {
 
-module.exports = function(val, options){
-  options = options || {};
-  if ('string' == typeof val) return parse(val);
-  return options.long
-    ? long(val)
-    : short(val);
+      if (typeof d === 'function') {
+        d();
+      } else {
+        d.task = this.db[d.name].apply(this.db, d.parameters);
+      }
+    }
+  }
 };
 
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
+TaskQueue.prototype.fail = function (err) {
+  this.failed = err;
+  this.execute();
+};
 
-function parse(str) {
-  str = '' + str;
-  if (str.length > 10000) return;
-  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
-  if (!match) return;
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
+TaskQueue.prototype.ready = function (db) {
+  if (this.failed) {
+    return false;
+  } else if (arguments.length === 0) {
+    return this.isReady;
   }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function short(ms) {
-  if (ms >= d) return Math.round(ms / d) + 'd';
-  if (ms >= h) return Math.round(ms / h) + 'h';
-  if (ms >= m) return Math.round(ms / m) + 'm';
-  if (ms >= s) return Math.round(ms / s) + 's';
-  return ms + 'ms';
-}
-
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function long(ms) {
-  return plural(ms, d, 'day')
-    || plural(ms, h, 'hour')
-    || plural(ms, m, 'minute')
-    || plural(ms, s, 'second')
-    || ms + ' ms';
-}
+  this.isReady = db ? true: false;
+  this.db = db;
+  this.execute();
+};
 
-/**
- * Pluralization helper.
- */
+TaskQueue.prototype.addTask = function (name, parameters) {
+  if (typeof name === 'function') {
+    this.queue.push(name);
+    if (this.failed) {
+      this.execute();
+    }
+  } else {
+    var task = { name: name, parameters: parameters };
+    this.queue.push(task);
+    if (this.failed) {
+      this.execute();
+    }
+    return task;
+  }
+};
 
-function plural(ms, n, name) {
-  if (ms < n) return;
-  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
-  return Math.ceil(ms / n) + ' ' + name + 's';
-}
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/utils.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/lib/utils.js"][0].apply(exports,arguments)
+},{"./deps/ajax":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/ajax.js","./deps/blob":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/blob.js","./deps/buffer":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/buffer-browser.js","./deps/errors":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/errors.js","./deps/explain404":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/explain404.js","./deps/md5":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/md5.js","./deps/parse-doc":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-doc.js","./deps/parse-uri":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/parse-uri.js","./deps/promise":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/promise.js","./deps/uuid":"/Users/richard/src/beagle/node_modules/pouchdb/lib/deps/uuid.js","./merge":"/Users/richard/src/beagle/node_modules/pouchdb/lib/merge.js","_process":"/Users/richard/src/beagle/node_modules/browserify/node_modules/process/browser.js","argsarray":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/argsarray/index.js","debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js","events":"/Users/richard/src/beagle/node_modules/browserify/node_modules/events/events.js","inherits":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/inherits/inherits_browser.js","pouchdb-collections":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collections/index.js","pouchdb-extend":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-extend/index.js","vuvuzela":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/vuvuzela/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/lib/version-browser.js":[function(require,module,exports){
+module.exports = "3.5.0";
 
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/argsarray/index.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/argsarray/index.js"][0].apply(exports,arguments)
+},{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/browser.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/browser.js"][0].apply(exports,arguments)
+},{"./debug":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/debug.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/debug.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/nodemailer-mailgun-transport/node_modules/mailgun-js/node_modules/debug/debug.js"][0].apply(exports,arguments)
+},{"ms":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/debug/node_modules/ms/index.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/inherits/inherits_browser.js":[function(require,module,exports){
 arguments[4]["/Users/richard/src/beagle/node_modules/beagle-altmetrics/node_modules/accum-transform/node_modules/through2/node_modules/readable-stream/node_modules/inherits/inherits_browser.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js":[function(require,module,exports){
-'use strict';
-
-module.exports = INTERNAL;
-
-function INTERNAL() {}
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/INTERNAL.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/all.js":[function(require,module,exports){
-'use strict';
-var Promise = require('./promise');
-var reject = require('./reject');
-var resolve = require('./resolve');
-var INTERNAL = require('./INTERNAL');
-var handlers = require('./handlers');
-module.exports = all;
-function all(iterable) {
-  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
-    return reject(new TypeError('must be an array'));
-  }
-
-  var len = iterable.length;
-  var called = false;
-  if (!len) {
-    return resolve([]);
-  }
-
-  var values = new Array(len);
-  var resolved = 0;
-  var i = -1;
-  var promise = new Promise(INTERNAL);
-  
-  while (++i < len) {
-    allResolver(iterable[i], i);
-  }
-  return promise;
-  function allResolver(value, i) {
-    resolve(value).then(resolveFromAll, function (error) {
-      if (!called) {
-        called = true;
-        handlers.reject(promise, error);
-      }
-    });
-    function resolveFromAll(outValue) {
-      values[i] = outValue;
-      if (++resolved === len & !called) {
-        called = true;
-        handlers.resolve(promise, values);
-      }
-    }
-  }
-}
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/all.js"][0].apply(exports,arguments)
 },{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js":[function(require,module,exports){
 'use strict';
 var tryCatch = require('./tryCatch');
@@ -197182,132 +198464,58 @@ QueueItem.prototype.otherCallFulfilled = function (value) {
   unwrap(this.promise, this.onFulfilled, value);
 };
 QueueItem.prototype.callRejected = function (value) {
-  handlers.reject(this.promise, value);
-};
-QueueItem.prototype.otherCallRejected = function (value) {
-  unwrap(this.promise, this.onRejected, value);
-};
-},{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./unwrap":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/unwrap.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/race.js":[function(require,module,exports){
-'use strict';
-var Promise = require('./promise');
-var reject = require('./reject');
-var resolve = require('./resolve');
-var INTERNAL = require('./INTERNAL');
-var handlers = require('./handlers');
-module.exports = race;
-function race(iterable) {
-  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
-    return reject(new TypeError('must be an array'));
-  }
-
-  var len = iterable.length;
-  var called = false;
-  if (!len) {
-    return resolve([]);
-  }
-
-  var resolved = 0;
-  var i = -1;
-  var promise = new Promise(INTERNAL);
-  
-  while (++i < len) {
-    resolver(iterable[i]);
-  }
-  return promise;
-  function resolver(value) {
-    resolve(value).then(function (response) {
-      if (!called) {
-        called = true;
-        handlers.resolve(promise, response);
-      }
-    }, function (error) {
-      if (!called) {
-        called = true;
-        handlers.reject(promise, error);
-      }
-    });
-  }
-}
-},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/reject.js":[function(require,module,exports){
-'use strict';
-
-var Promise = require('./promise');
-var INTERNAL = require('./INTERNAL');
-var handlers = require('./handlers');
-module.exports = reject;
-
-function reject(reason) {
-	var promise = new Promise(INTERNAL);
-	return handlers.reject(promise, reason);
-}
-},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolve.js":[function(require,module,exports){
-'use strict';
-
-var Promise = require('./promise');
-var INTERNAL = require('./INTERNAL');
-var handlers = require('./handlers');
-module.exports = resolve;
-
-var FALSE = handlers.resolve(new Promise(INTERNAL), false);
-var NULL = handlers.resolve(new Promise(INTERNAL), null);
-var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
-var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
-var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
-
-function resolve(value) {
-  if (value) {
-    if (value instanceof Promise) {
-      return value;
-    }
-    return handlers.resolve(new Promise(INTERNAL), value);
-  }
-  var valueType = typeof value;
-  switch (valueType) {
-    case 'boolean':
-      return FALSE;
-    case 'undefined':
-      return UNDEFINED;
-    case 'object':
-      return NULL;
-    case 'number':
-      return ZERO;
-    case 'string':
-      return EMPTYSTRING;
-  }
-}
-},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolveThenable.js":[function(require,module,exports){
+  handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+  unwrap(this.promise, this.onRejected, value);
+};
+},{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./unwrap":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/unwrap.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/race.js":[function(require,module,exports){
 'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
 var handlers = require('./handlers');
-var tryCatch = require('./tryCatch');
-function safelyResolveThenable(self, thenable) {
-  // Either fulfill, reject or reject with error
-  var called = false;
-  function onError(value) {
-    if (called) {
-      return;
-    }
-    called = true;
-    handlers.reject(self, value);
+module.exports = race;
+function race(iterable) {
+  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+    return reject(new TypeError('must be an array'));
   }
 
-  function onSuccess(value) {
-    if (called) {
-      return;
-    }
-    called = true;
-    handlers.resolve(self, value);
+  var len = iterable.length;
+  var called = false;
+  if (!len) {
+    return resolve([]);
   }
 
-  function tryToUnwrap() {
-    thenable(onSuccess, onError);
-  }
+  var resolved = 0;
+  var i = -1;
+  var promise = new Promise(INTERNAL);
   
-  var result = tryCatch(tryToUnwrap);
-  if (result.status === 'error') {
-    onError(result.value);
+  while (++i < len) {
+    resolver(iterable[i]);
+  }
+  return promise;
+  function resolver(value) {
+    resolve(value).then(function (response) {
+      if (!called) {
+        called = true;
+        handlers.resolve(promise, response);
+      }
+    }, function (error) {
+      if (!called) {
+        called = true;
+        handlers.reject(promise, error);
+      }
+    });
   }
 }
-exports.safely = safelyResolveThenable;
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js","./reject":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/reject.js","./resolve":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolve.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/reject.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/reject.js"][0].apply(exports,arguments)
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolve.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolve.js"][0].apply(exports,arguments)
+},{"./INTERNAL":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/INTERNAL.js","./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./promise":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/promise.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/resolveThenable.js":[function(require,module,exports){
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/resolveThenable.js"][0].apply(exports,arguments)
 },{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","./tryCatch":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/tryCatch.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/states.js":[function(require,module,exports){
 // Lazy man's symbols for states
 
@@ -197315,43 +198523,9 @@ exports.REJECTED = ['REJECTED'];
 exports.FULFILLED = ['FULFILLED'];
 exports.PENDING = ['PENDING'];
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/tryCatch.js":[function(require,module,exports){
-'use strict';
-
-module.exports = tryCatch;
-
-function tryCatch(func, value) {
-  var out = {};
-  try {
-    out.value = func(value);
-    out.status = 'success';
-  } catch (e) {
-    out.status = 'error';
-    out.value = e;
-  }
-  return out;
-}
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/tryCatch.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/unwrap.js":[function(require,module,exports){
-'use strict';
-
-var immediate = require('immediate');
-var handlers = require('./handlers');
-module.exports = unwrap;
-
-function unwrap(promise, func, value) {
-  immediate(function () {
-    var returnValue;
-    try {
-      returnValue = func(value);
-    } catch (e) {
-      return handlers.reject(promise, e);
-    }
-    if (returnValue === promise) {
-      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
-    } else {
-      handlers.resolve(promise, returnValue);
-    }
-  });
-}
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/lib/unwrap.js"][0].apply(exports,arguments)
 },{"./handlers":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/handlers.js","immediate":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/index.js":[function(require,module,exports){
 'use strict';
 var types = [
@@ -197411,89 +198585,13 @@ function immediate(task) {
   }
 }
 },{"./messageChannel":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/messageChannel.js","./mutation.js":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/mutation.js","./nextTick":"/Users/richard/src/beagle/node_modules/browserify/node_modules/browser-resolve/empty.js","./stateChange":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/stateChange.js","./timeout":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/timeout.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/messageChannel.js":[function(require,module,exports){
-(function (global){
-'use strict';
-
-exports.test = function () {
-  if (global.setImmediate) {
-    // we can only get here in IE10
-    // which doesn't handel postMessage well
-    return false;
-  }
-  return typeof global.MessageChannel !== 'undefined';
-};
-
-exports.install = function (func) {
-  var channel = new global.MessageChannel();
-  channel.port1.onmessage = func;
-  return function () {
-    channel.port2.postMessage(0);
-  };
-};
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/messageChannel.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/mutation.js":[function(require,module,exports){
-(function (global){
-'use strict';
-//based off rsvp https://github.com/tildeio/rsvp.js
-//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
-//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
-
-var Mutation = global.MutationObserver || global.WebKitMutationObserver;
-
-exports.test = function () {
-  return Mutation;
-};
-
-exports.install = function (handle) {
-  var called = 0;
-  var observer = new Mutation(handle);
-  var element = global.document.createTextNode('');
-  observer.observe(element, {
-    characterData: true
-  });
-  return function () {
-    element.data = (called = ++called % 2);
-  };
-};
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/mutation.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/stateChange.js":[function(require,module,exports){
-(function (global){
-'use strict';
-
-exports.test = function () {
-  return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
-};
-
-exports.install = function (handle) {
-  return function () {
-
-    // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
-    // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
-    var scriptEl = global.document.createElement('script');
-    scriptEl.onreadystatechange = function () {
-      handle();
-
-      scriptEl.onreadystatechange = null;
-      scriptEl.parentNode.removeChild(scriptEl);
-      scriptEl = null;
-    };
-    global.document.documentElement.appendChild(scriptEl);
-
-    return handle;
-  };
-};
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/stateChange.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/node_modules/immediate/lib/timeout.js":[function(require,module,exports){
-'use strict';
-exports.test = function () {
-  return true;
-};
-
-exports.install = function (t) {
-  return function () {
-    setTimeout(t, 0);
-  };
-};
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/lie/node_modules/immediate/lib/timeout.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collate/lib/index.js":[function(require,module,exports){
 'use strict';
 
@@ -197921,77 +199019,7 @@ exports.intToDecimalForm = function (int) {
   return result;
 };
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-collections/index.js":[function(require,module,exports){
-'use strict';
-exports.Map = LazyMap; // TODO: use ES6 map
-exports.Set = LazySet; // TODO: use ES6 set
-// based on https://github.com/montagejs/collections
-function LazyMap() {
-  this.store = {};
-}
-LazyMap.prototype.mangle = function (key) {
-  if (typeof key !== "string") {
-    throw new TypeError("key must be a string but Got " + key);
-  }
-  return '$' + key;
-};
-LazyMap.prototype.unmangle = function (key) {
-  return key.substring(1);
-};
-LazyMap.prototype.get = function (key) {
-  var mangled = this.mangle(key);
-  if (mangled in this.store) {
-    return this.store[mangled];
-  } else {
-    return void 0;
-  }
-};
-LazyMap.prototype.set = function (key, value) {
-  var mangled = this.mangle(key);
-  this.store[mangled] = value;
-  return true;
-};
-LazyMap.prototype.has = function (key) {
-  var mangled = this.mangle(key);
-  return mangled in this.store;
-};
-LazyMap.prototype.delete = function (key) {
-  var mangled = this.mangle(key);
-  if (mangled in this.store) {
-    delete this.store[mangled];
-    return true;
-  }
-  return false;
-};
-LazyMap.prototype.forEach = function (cb) {
-  var self = this;
-  var keys = Object.keys(self.store);
-  keys.forEach(function (key) {
-    var value = self.store[key];
-    key = self.unmangle(key);
-    cb(value, key);
-  });
-};
-
-function LazySet(array) {
-  this.store = new LazyMap();
-
-  // init with an array
-  if (array && Array.isArray(array)) {
-    for (var i = 0, len = array.length; i < len; i++) {
-      this.add(array[i]);
-    }
-  }
-}
-LazySet.prototype.add = function (key) {
-  return this.store.set(key, true);
-};
-LazySet.prototype.has = function (key) {
-  return this.store.has(key);
-};
-LazySet.prototype.delete = function (key) {
-  return this.store.delete(key);
-};
-
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/pouchdb-collections/index.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-extend/index.js":[function(require,module,exports){
 arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb-extend/index.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/pouchdb-mapreduce/create-view.js":[function(require,module,exports){
@@ -199205,781 +200233,9 @@ if (typeof window !== 'undefined' && window.PouchDB) {
 
 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
 },{"lie":"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/lie/lib/index.js"}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js":[function(require,module,exports){
-/*jshint bitwise:false*/
-/*global unescape*/
-
-(function (factory) {
-    if (typeof exports === 'object') {
-        // Node/CommonJS
-        module.exports = factory();
-    } else if (typeof define === 'function' && define.amd) {
-        // AMD
-        define(factory);
-    } else {
-        // Browser globals (with support for web workers)
-        var glob;
-        try {
-            glob = window;
-        } catch (e) {
-            glob = self;
-        }
-
-        glob.SparkMD5 = factory();
-    }
-}(function (undefined) {
-
-    'use strict';
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    /*
-     * Fastest md5 implementation around (JKM md5)
-     * Credits: Joseph Myers
-     *
-     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
-     * @see http://jsperf.com/md5-shootout/7
-     */
-
-    /* this function is much faster,
-      so if possible we use it. Some IEs
-      are the only ones I know of that
-      need the idiotic second function,
-      generated by an if clause.  */
-    var add32 = function (a, b) {
-        return (a + b) & 0xFFFFFFFF;
-    },
-
-    cmn = function (q, a, b, x, s, t) {
-        a = add32(add32(a, q), add32(x, t));
-        return add32((a << s) | (a >>> (32 - s)), b);
-    },
-
-    ff = function (a, b, c, d, x, s, t) {
-        return cmn((b & c) | ((~b) & d), a, b, x, s, t);
-    },
-
-    gg = function (a, b, c, d, x, s, t) {
-        return cmn((b & d) | (c & (~d)), a, b, x, s, t);
-    },
-
-    hh = function (a, b, c, d, x, s, t) {
-        return cmn(b ^ c ^ d, a, b, x, s, t);
-    },
-
-    ii = function (a, b, c, d, x, s, t) {
-        return cmn(c ^ (b | (~d)), a, b, x, s, t);
-    },
-
-    md5cycle = function (x, k) {
-        var a = x[0],
-            b = x[1],
-            c = x[2],
-            d = x[3];
-
-        a = ff(a, b, c, d, k[0], 7, -680876936);
-        d = ff(d, a, b, c, k[1], 12, -389564586);
-        c = ff(c, d, a, b, k[2], 17, 606105819);
-        b = ff(b, c, d, a, k[3], 22, -1044525330);
-        a = ff(a, b, c, d, k[4], 7, -176418897);
-        d = ff(d, a, b, c, k[5], 12, 1200080426);
-        c = ff(c, d, a, b, k[6], 17, -1473231341);
-        b = ff(b, c, d, a, k[7], 22, -45705983);
-        a = ff(a, b, c, d, k[8], 7, 1770035416);
-        d = ff(d, a, b, c, k[9], 12, -1958414417);
-        c = ff(c, d, a, b, k[10], 17, -42063);
-        b = ff(b, c, d, a, k[11], 22, -1990404162);
-        a = ff(a, b, c, d, k[12], 7, 1804603682);
-        d = ff(d, a, b, c, k[13], 12, -40341101);
-        c = ff(c, d, a, b, k[14], 17, -1502002290);
-        b = ff(b, c, d, a, k[15], 22, 1236535329);
-
-        a = gg(a, b, c, d, k[1], 5, -165796510);
-        d = gg(d, a, b, c, k[6], 9, -1069501632);
-        c = gg(c, d, a, b, k[11], 14, 643717713);
-        b = gg(b, c, d, a, k[0], 20, -373897302);
-        a = gg(a, b, c, d, k[5], 5, -701558691);
-        d = gg(d, a, b, c, k[10], 9, 38016083);
-        c = gg(c, d, a, b, k[15], 14, -660478335);
-        b = gg(b, c, d, a, k[4], 20, -405537848);
-        a = gg(a, b, c, d, k[9], 5, 568446438);
-        d = gg(d, a, b, c, k[14], 9, -1019803690);
-        c = gg(c, d, a, b, k[3], 14, -187363961);
-        b = gg(b, c, d, a, k[8], 20, 1163531501);
-        a = gg(a, b, c, d, k[13], 5, -1444681467);
-        d = gg(d, a, b, c, k[2], 9, -51403784);
-        c = gg(c, d, a, b, k[7], 14, 1735328473);
-        b = gg(b, c, d, a, k[12], 20, -1926607734);
-
-        a = hh(a, b, c, d, k[5], 4, -378558);
-        d = hh(d, a, b, c, k[8], 11, -2022574463);
-        c = hh(c, d, a, b, k[11], 16, 1839030562);
-        b = hh(b, c, d, a, k[14], 23, -35309556);
-        a = hh(a, b, c, d, k[1], 4, -1530992060);
-        d = hh(d, a, b, c, k[4], 11, 1272893353);
-        c = hh(c, d, a, b, k[7], 16, -155497632);
-        b = hh(b, c, d, a, k[10], 23, -1094730640);
-        a = hh(a, b, c, d, k[13], 4, 681279174);
-        d = hh(d, a, b, c, k[0], 11, -358537222);
-        c = hh(c, d, a, b, k[3], 16, -722521979);
-        b = hh(b, c, d, a, k[6], 23, 76029189);
-        a = hh(a, b, c, d, k[9], 4, -640364487);
-        d = hh(d, a, b, c, k[12], 11, -421815835);
-        c = hh(c, d, a, b, k[15], 16, 530742520);
-        b = hh(b, c, d, a, k[2], 23, -995338651);
-
-        a = ii(a, b, c, d, k[0], 6, -198630844);
-        d = ii(d, a, b, c, k[7], 10, 1126891415);
-        c = ii(c, d, a, b, k[14], 15, -1416354905);
-        b = ii(b, c, d, a, k[5], 21, -57434055);
-        a = ii(a, b, c, d, k[12], 6, 1700485571);
-        d = ii(d, a, b, c, k[3], 10, -1894986606);
-        c = ii(c, d, a, b, k[10], 15, -1051523);
-        b = ii(b, c, d, a, k[1], 21, -2054922799);
-        a = ii(a, b, c, d, k[8], 6, 1873313359);
-        d = ii(d, a, b, c, k[15], 10, -30611744);
-        c = ii(c, d, a, b, k[6], 15, -1560198380);
-        b = ii(b, c, d, a, k[13], 21, 1309151649);
-        a = ii(a, b, c, d, k[4], 6, -145523070);
-        d = ii(d, a, b, c, k[11], 10, -1120210379);
-        c = ii(c, d, a, b, k[2], 15, 718787259);
-        b = ii(b, c, d, a, k[9], 21, -343485551);
-
-        x[0] = add32(a, x[0]);
-        x[1] = add32(b, x[1]);
-        x[2] = add32(c, x[2]);
-        x[3] = add32(d, x[3]);
-    },
-
-    /* there needs to be support for Unicode here,
-       * unless we pretend that we can redefine the MD-5
-       * algorithm for multi-byte characters (perhaps
-       * by adding every four 16-bit characters and
-       * shortening the sum to 32 bits). Otherwise
-       * I suggest performing MD-5 as if every character
-       * was two bytes--e.g., 0040 0025 = @%--but then
-       * how will an ordinary MD-5 sum be matched?
-       * There is no way to standardize text to something
-       * like UTF-8 before transformation; speed cost is
-       * utterly prohibitive. The JavaScript standard
-       * itself needs to look at this: it should start
-       * providing access to strings as preformed UTF-8
-       * 8-bit unsigned value arrays.
-       */
-    md5blk = function (s) {
-        var md5blks = [],
-            i; /* Andy King said do it this way. */
-
-        for (i = 0; i < 64; i += 4) {
-            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
-        }
-        return md5blks;
-    },
-
-    md5blk_array = function (a) {
-        var md5blks = [],
-            i; /* Andy King said do it this way. */
-
-        for (i = 0; i < 64; i += 4) {
-            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
-        }
-        return md5blks;
-    },
-
-    md51 = function (s) {
-        var n = s.length,
-            state = [1732584193, -271733879, -1732584194, 271733878],
-            i,
-            length,
-            tail,
-            tmp,
-            lo,
-            hi;
-
-        for (i = 64; i <= n; i += 64) {
-            md5cycle(state, md5blk(s.substring(i - 64, i)));
-        }
-        s = s.substring(i - 64);
-        length = s.length;
-        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
-        }
-        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
-        if (i > 55) {
-            md5cycle(state, tail);
-            for (i = 0; i < 16; i += 1) {
-                tail[i] = 0;
-            }
-        }
-
-        // Beware that the final length might not fit in 32 bits so we take care of that
-        tmp = n * 8;
-        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
-        lo = parseInt(tmp[2], 16);
-        hi = parseInt(tmp[1], 16) || 0;
-
-        tail[14] = lo;
-        tail[15] = hi;
-
-        md5cycle(state, tail);
-        return state;
-    },
-
-    md51_array = function (a) {
-        var n = a.length,
-            state = [1732584193, -271733879, -1732584194, 271733878],
-            i,
-            length,
-            tail,
-            tmp,
-            lo,
-            hi;
-
-        for (i = 64; i <= n; i += 64) {
-            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
-        }
-
-        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
-        // containing the last element of the parent array if the sub array specified starts
-        // beyond the length of the parent array - weird.
-        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
-        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
-
-        length = a.length;
-        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= a[i] << ((i % 4) << 3);
-        }
-
-        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
-        if (i > 55) {
-            md5cycle(state, tail);
-            for (i = 0; i < 16; i += 1) {
-                tail[i] = 0;
-            }
-        }
-
-        // Beware that the final length might not fit in 32 bits so we take care of that
-        tmp = n * 8;
-        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
-        lo = parseInt(tmp[2], 16);
-        hi = parseInt(tmp[1], 16) || 0;
-
-        tail[14] = lo;
-        tail[15] = hi;
-
-        md5cycle(state, tail);
-
-        return state;
-    },
-
-    hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
-
-    rhex = function (n) {
-        var s = '',
-            j;
-        for (j = 0; j < 4; j += 1) {
-            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
-        }
-        return s;
-    },
-
-    hex = function (x) {
-        var i;
-        for (i = 0; i < x.length; i += 1) {
-            x[i] = rhex(x[i]);
-        }
-        return x.join('');
-    },
-
-    md5 = function (s) {
-        return hex(md51(s));
-    },
-
-
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    /**
-     * SparkMD5 OOP implementation.
-     *
-     * Use this class to perform an incremental md5, otherwise use the
-     * static methods instead.
-     */
-    SparkMD5 = function () {
-        // call reset to init the instance
-        this.reset();
-    };
-
-
-    // In some cases the fast add32 function cannot be used..
-    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
-        add32 = function (x, y) {
-            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
-                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
-            return (msw << 16) | (lsw & 0xFFFF);
-        };
-    }
-
-
-    /**
-     * Appends a string.
-     * A conversion will be applied if an utf8 string is detected.
-     *
-     * @param {String} str The string to be appended
-     *
-     * @return {SparkMD5} The instance itself
-     */
-    SparkMD5.prototype.append = function (str) {
-        // converts the string to utf8 bytes if necessary
-        if (/[\u0080-\uFFFF]/.test(str)) {
-            str = unescape(encodeURIComponent(str));
-        }
-
-        // then append as binary
-        this.appendBinary(str);
-
-        return this;
-    };
-
-    /**
-     * Appends a binary string.
-     *
-     * @param {String} contents The binary string to be appended
-     *
-     * @return {SparkMD5} The instance itself
-     */
-    SparkMD5.prototype.appendBinary = function (contents) {
-        this._buff += contents;
-        this._length += contents.length;
-
-        var length = this._buff.length,
-            i;
-
-        for (i = 64; i <= length; i += 64) {
-            md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
-        }
-
-        this._buff = this._buff.substr(i - 64);
-
-        return this;
-    };
-
-    /**
-     * Finishes the incremental computation, reseting the internal state and
-     * returning the result.
-     * Use the raw parameter to obtain the raw result instead of the hex one.
-     *
-     * @param {Boolean} raw True to get the raw result, false to get the hex result
-     *
-     * @return {String|Array} The result
-     */
-    SparkMD5.prototype.end = function (raw) {
-        var buff = this._buff,
-            length = buff.length,
-            i,
-            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            ret;
-
-        for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
-        }
-
-        this._finish(tail, length);
-        ret = !!raw ? this._state : hex(this._state);
-
-        this.reset();
-
-        return ret;
-    };
-
-    /**
-     * Finish the final calculation based on the tail.
-     *
-     * @param {Array}  tail   The tail (will be modified)
-     * @param {Number} length The length of the remaining buffer
-     */
-    SparkMD5.prototype._finish = function (tail, length) {
-        var i = length,
-            tmp,
-            lo,
-            hi;
-
-        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
-        if (i > 55) {
-            md5cycle(this._state, tail);
-            for (i = 0; i < 16; i += 1) {
-                tail[i] = 0;
-            }
-        }
-
-        // Do the final computation based on the tail and length
-        // Beware that the final length may not fit in 32 bits so we take care of that
-        tmp = this._length * 8;
-        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
-        lo = parseInt(tmp[2], 16);
-        hi = parseInt(tmp[1], 16) || 0;
-
-        tail[14] = lo;
-        tail[15] = hi;
-        md5cycle(this._state, tail);
-    };
-
-    /**
-     * Resets the internal state of the computation.
-     *
-     * @return {SparkMD5} The instance itself
-     */
-    SparkMD5.prototype.reset = function () {
-        this._buff = "";
-        this._length = 0;
-        this._state = [1732584193, -271733879, -1732584194, 271733878];
-
-        return this;
-    };
-
-    /**
-     * Releases memory used by the incremental buffer and other aditional
-     * resources. If you plan to use the instance again, use reset instead.
-     */
-    SparkMD5.prototype.destroy = function () {
-        delete this._state;
-        delete this._buff;
-        delete this._length;
-    };
-
-
-    /**
-     * Performs the md5 hash on a string.
-     * A conversion will be applied if utf8 string is detected.
-     *
-     * @param {String}  str The string
-     * @param {Boolean} raw True to get the raw result, false to get the hex result
-     *
-     * @return {String|Array} The result
-     */
-    SparkMD5.hash = function (str, raw) {
-        // converts the string to utf8 bytes if necessary
-        if (/[\u0080-\uFFFF]/.test(str)) {
-            str = unescape(encodeURIComponent(str));
-        }
-
-        var hash = md51(str);
-
-        return !!raw ? hash : hex(hash);
-    };
-
-    /**
-     * Performs the md5 hash on a binary string.
-     *
-     * @param {String}  content The binary string
-     * @param {Boolean} raw     True to get the raw result, false to get the hex result
-     *
-     * @return {String|Array} The result
-     */
-    SparkMD5.hashBinary = function (content, raw) {
-        var hash = md51(content);
-
-        return !!raw ? hash : hex(hash);
-    };
-
-    /**
-     * SparkMD5 OOP implementation for array buffers.
-     *
-     * Use this class to perform an incremental md5 ONLY for array buffers.
-     */
-    SparkMD5.ArrayBuffer = function () {
-        // call reset to init the instance
-        this.reset();
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    /**
-     * Appends an array buffer.
-     *
-     * @param {ArrayBuffer} arr The array to be appended
-     *
-     * @return {SparkMD5.ArrayBuffer} The instance itself
-     */
-    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
-        // TODO: we could avoid the concatenation here but the algorithm would be more complex
-        //       if you find yourself needing extra performance, please make a PR.
-        var buff = this._concatArrayBuffer(this._buff, arr),
-            length = buff.length,
-            i;
-
-        this._length += arr.byteLength;
-
-        for (i = 64; i <= length; i += 64) {
-            md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
-        }
-
-        // Avoids IE10 weirdness (documented above)
-        this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
-
-        return this;
-    };
-
-    /**
-     * Finishes the incremental computation, reseting the internal state and
-     * returning the result.
-     * Use the raw parameter to obtain the raw result instead of the hex one.
-     *
-     * @param {Boolean} raw True to get the raw result, false to get the hex result
-     *
-     * @return {String|Array} The result
-     */
-    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
-        var buff = this._buff,
-            length = buff.length,
-            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            i,
-            ret;
-
-        for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
-        }
-
-        this._finish(tail, length);
-        ret = !!raw ? this._state : hex(this._state);
-
-        this.reset();
-
-        return ret;
-    };
-
-    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
-
-    /**
-     * Resets the internal state of the computation.
-     *
-     * @return {SparkMD5.ArrayBuffer} The instance itself
-     */
-    SparkMD5.ArrayBuffer.prototype.reset = function () {
-        this._buff = new Uint8Array(0);
-        this._length = 0;
-        this._state = [1732584193, -271733879, -1732584194, 271733878];
-
-        return this;
-    };
-
-    /**
-     * Releases memory used by the incremental buffer and other aditional
-     * resources. If you plan to use the instance again, use reset instead.
-     */
-    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
-
-    /**
-     * Concats two array buffers, returning a new one.
-     *
-     * @param  {ArrayBuffer} first  The first array buffer
-     * @param  {ArrayBuffer} second The second array buffer
-     *
-     * @return {ArrayBuffer} The new array buffer
-     */
-    SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
-        var firstLength = first.length,
-            result = new Uint8Array(firstLength + second.byteLength);
-
-        result.set(first);
-        result.set(new Uint8Array(second), firstLength);
-
-        return result;
-    };
-
-    /**
-     * Performs the md5 hash on an array buffer.
-     *
-     * @param {ArrayBuffer} arr The array buffer
-     * @param {Boolean}     raw True to get the raw result, false to get the hex result
-     *
-     * @return {String|Array} The result
-     */
-    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
-        var hash = md51_array(new Uint8Array(arr));
-
-        return !!raw ? hash : hex(hash);
-    };
-
-    return SparkMD5;
-}));
-
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/spark-md5/spark-md5.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/pouchdb/node_modules/vuvuzela/index.js":[function(require,module,exports){
-'use strict';
-
-/**
- * Stringify/parse functions that don't operate
- * recursively, so they avoid call stack exceeded
- * errors.
- */
-exports.stringify = function stringify(input) {
-  var queue = [];
-  queue.push({obj: input});
-
-  var res = '';
-  var next, obj, prefix, val, i, arrayPrefix, keys, k, key, value, objPrefix;
-  while ((next = queue.pop())) {
-    obj = next.obj;
-    prefix = next.prefix || '';
-    val = next.val || '';
-    res += prefix;
-    if (val) {
-      res += val;
-    } else if (typeof obj !== 'object') {
-      res += typeof obj === 'undefined' ? null : JSON.stringify(obj);
-    } else if (obj === null) {
-      res += 'null';
-    } else if (Array.isArray(obj)) {
-      queue.push({val: ']'});
-      for (i = obj.length - 1; i >= 0; i--) {
-        arrayPrefix = i === 0 ? '' : ',';
-        queue.push({obj: obj[i], prefix: arrayPrefix});
-      }
-      queue.push({val: '['});
-    } else { // object
-      keys = [];
-      for (k in obj) {
-        if (obj.hasOwnProperty(k)) {
-          keys.push(k);
-        }
-      }
-      queue.push({val: '}'});
-      for (i = keys.length - 1; i >= 0; i--) {
-        key = keys[i];
-        value = obj[key];
-        objPrefix = (i > 0 ? ',' : '');
-        objPrefix += JSON.stringify(key) + ':';
-        queue.push({obj: value, prefix: objPrefix});
-      }
-      queue.push({val: '{'});
-    }
-  }
-  return res;
-};
-
-// Convenience function for the parse function.
-// This pop function is basically copied from
-// pouchCollate.parseIndexableString
-function pop(obj, stack, metaStack) {
-  var lastMetaElement = metaStack[metaStack.length - 1];
-  if (obj === lastMetaElement.element) {
-    // popping a meta-element, e.g. an object whose value is another object
-    metaStack.pop();
-    lastMetaElement = metaStack[metaStack.length - 1];
-  }
-  var element = lastMetaElement.element;
-  var lastElementIndex = lastMetaElement.index;
-  if (Array.isArray(element)) {
-    element.push(obj);
-  } else if (lastElementIndex === stack.length - 2) { // obj with key+value
-    var key = stack.pop();
-    element[key] = obj;
-  } else {
-    stack.push(obj); // obj with key only
-  }
-}
-
-exports.parse = function (str) {
-  var stack = [];
-  var metaStack = []; // stack for arrays and objects
-  var i = 0;
-  var collationIndex,parsedNum,numChar;
-  var parsedString,lastCh,numConsecutiveSlashes,ch;
-  var arrayElement, objElement;
-  while (true) {
-    collationIndex = str[i++];
-    if (collationIndex === '}' ||
-        collationIndex === ']' ||
-        typeof collationIndex === 'undefined') {
-      if (stack.length === 1) {
-        return stack.pop();
-      } else {
-        pop(stack.pop(), stack, metaStack);
-        continue;
-      }
-    }
-    switch (collationIndex) {
-      case ' ':
-      case '\t':
-      case '\n':
-      case ':':
-      case ',':
-        break;
-      case 'n':
-        i += 3; // 'ull'
-        pop(null, stack, metaStack);
-        break;
-      case 't':
-        i += 3; // 'rue'
-        pop(true, stack, metaStack);
-        break;
-      case 'f':
-        i += 4; // 'alse'
-        pop(false, stack, metaStack);
-        break;
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-      case '-':
-        parsedNum = '';
-        i--;
-        while (true) {
-          numChar = str[i++];
-          if (/[\d\.\-e\+]/.test(numChar)) {
-            parsedNum += numChar;
-          } else {
-            i--;
-            break;
-          }
-        }
-        pop(parseFloat(parsedNum), stack, metaStack);
-        break;
-      case '"':
-        parsedString = '';
-        lastCh = void 0;
-        numConsecutiveSlashes = 0;
-        while (true) {
-          ch = str[i++];
-          if (ch !== '"' || (lastCh === '\\' &&
-              numConsecutiveSlashes % 2 === 1)) {
-            parsedString += ch;
-            lastCh = ch;
-            if (lastCh === '\\') {
-              numConsecutiveSlashes++;
-            } else {
-              numConsecutiveSlashes = 0;
-            }
-          } else {
-            break;
-          }
-        }
-        pop(JSON.parse('"' + parsedString + '"'), stack, metaStack);
-        break;
-      case '[':
-        arrayElement = { element: [], index: stack.length };
-        stack.push(arrayElement.element);
-        metaStack.push(arrayElement);
-        break;
-      case '{':
-        objElement = { element: {}, index: stack.length };
-        stack.push(objElement.element);
-        metaStack.push(objElement);
-        break;
-      default:
-        throw new Error(
-          'unexpectedly reached end of input: ' + collationIndex);
-    }
-  }
-};
-
+arguments[4]["/Users/richard/src/beagle/node_modules/pouchdb-authentication/node_modules/pouchdb/node_modules/vuvuzela/index.js"][0].apply(exports,arguments)
 },{}],"/Users/richard/src/beagle/node_modules/protocol-parser/index.js":[function(require,module,exports){
 "use strict()";