diff --git a/hash_object.js b/hash_object.js
new file mode 100644
index 0000000..04ca816
--- /dev/null
+++ b/hash_object.js
@@ -0,0 +1,50 @@
+var crypto = require('crypto')
+
+module.exports = function(object, algo){
+  var string = canonicalJSON(object)
+  if (algo === 'djb2'){
+    return djb2(string).toString(36)
+  } else {
+    return crypto.createHash(algo || 'sha1').update(string).digest('base64')
+  }
+}
+
+function djb2(str) {
+  var hash = 5381
+  for (i = 0; i < str.length; i++) {
+    char = str.charCodeAt(i)
+    hash = ((hash << 5) + hash) + char
+  }
+  return hash
+}
+
+function canonicalJSON(object){
+  if (object == null){
+    return 'null'
+  }
+  
+  var object = object.valueOf()
+  
+  if (object instanceof Array){
+    var result = "["
+    
+    object.forEach(function(value, i){
+      if (i > 0) result += ','
+      result += canonicalJSON(value)
+    })
+    
+    return result + ']'
+  } else if (object instanceof Object){
+    var result = "{"
+    
+    Object.keys(object).sort().forEach(function(key, i){
+      var value = object[key]
+      if (i > 0) result += ','
+      result += JSON.stringify(key) + ':' + canonicalJSON(value)
+    })
+    
+    return result + '}'
+  } else {
+    return JSON.stringify(object)
+  }
+}
\ No newline at end of file
diff --git a/index.js b/index.js
index 757f6de..d5f1051 100644
--- a/index.js
+++ b/index.js
@@ -1,15 +1,14 @@
 var JsonContext = require('json-context')
-var LevelMap = require('level-map')
-
-var checkFilter = require('json-filter')
-
+var SubLevel  = require('level-sublevel')
+var MatchMap = require('./match_map')
 var TimeoutMap = require('./timeout-map')
+var EventEmitter = require("events").EventEmitter
 
+var checkFilter = require('json-filter')
 var async = require('async')
 
-var EventEmitter = require("events").EventEmitter
 
-module.exports = function(db, options){
+module.exports = function(levelDB, options){
 
   var rootOptions = options || {}
 
@@ -25,87 +24,108 @@ module.exports = function(db, options){
     rootOptions.timestamps = true
   }
 
-  LevelMap(db)
-  db.queue.delay = 100
+  var db = SubLevel(levelDB)
+  var metaDB = db.sublevel('meta')
+  var matchDb = MatchMap(db, rootOptions.matchers)
 
-  var contextDB = new EventEmitter()
-  contextDB.db = db
+  var self = new EventEmitter()
+  self.db = db
 
-  var matcherLookup = {}
-  var matcherParamLookup = {}
-  var views = {}
+  matchDb.on('reindex', function(){
+    self.emit('reindex')
+  })
 
   // incrementing values
   var currentIncementValue = 0
   if (rootOptions.incrementingKey){
-    db.get('\xFFincrement~' + rootOptions.incrementingKey, function(err, val){
+    metaDB.get('increment!' + rootOptions.incrementingKey, function(err, val){
       currentIncementValue = parseInt(val, 10) || 0
     })
   }
   function incrementKey(){
     currentIncementValue += 1
-    db.put('\xFFincrement~' + rootOptions.incrementingKey, currentIncementValue)
+    metaDB.put('increment!' + rootOptions.incrementingKey, currentIncementValue)
     return currentIncementValue
   }
 
   function getObjectKey(object){
+    if (!checkValid(object[rootOptions.primaryKey])){
+      throw new Error("id can't contain '!' or '~")
+    }
     if (rootOptions.incrementingKey){
       var ref = parseInt(object[rootOptions.incrementingKey])
-      return padNumber(ref, 10) + ':' + object[rootOptions.primaryKey]
+      return padNumber(ref, 10) + '!' + object[rootOptions.primaryKey]
     } else {
-      return padNumber(0, 10) + ':' + object[rootOptions.primaryKey]
+      return padNumber(0, 10) + '!' + object[rootOptions.primaryKey]
     }
   }
 
-  rootOptions.matchers.forEach(function(matcher){
-    var paramifiedMatch = paramify(matcher.match)
-    var map = getMapFromMatcher(matcher.ref, paramifiedMatch)
-    db.map.add(map)
-    matcherParamLookup[matcher.ref] = paramifiedMatch.params
-    matcherLookup[matcher.ref] = matcher
-    views[matcher.ref] = map
-  })
+  function checkValid(key){
+    return !~key.indexOf('~') && !~key.indexOf('!') && !~key.indexOf('\xFF') && !~key.indexOf('\0')
+  }
+
+  self.applyChange = function(object, changeInfo, cb){
+    self.applyChanges([object], changeInfo, cb)
+    return object
+  }
+
+  // batch version
+  self.applyChanges = function(objects, changeInfo, cb){
+
+    if (typeof changeInfo === 'function'){
+      cb = changeInfo
+      changeInfo = {}
+    }
 
-  contextDB.applyChange = function(object, changeInfo){
     changeInfo = changeInfo || {}
-    if (changeInfo.source !== contextDB){
+    if (changeInfo.source !== self){
 
-      if (rootOptions.incrementingKey){
-        if (!object[rootOptions.incrementingKey]){
-          object[rootOptions.incrementingKey] = incrementKey()
-        }
-      }
+      try{
 
-      if (rootOptions.timestamps){
-        object.updated_at = Date.now()
-        object.created_at = object.created_at || Date.now()
-        if (object._deleted){
-          object.deleted_at = Date.now()
-        }
-      }
+        var changes = objects.map(function(object){
+          if (rootOptions.incrementingKey){
+            if (!object[rootOptions.incrementingKey]){
+              object[rootOptions.incrementingKey] = incrementKey()
+            }
+          }
+
+          if (rootOptions.timestamps){
+            object.updated_at = Date.now()
+            object.created_at = object.created_at || Date.now()
+            if (object._deleted){
+              object.deleted_at = Date.now()
+            }
+          }
+
+          var key = getObjectKey(object)
+          if (object._deleted){
+            deleted.set(key, object)
+          }
 
-      var key = getObjectKey(object)
+          return {type: 'put', key: key, value: object}
+        })
 
-      if (object._deleted){
-        deleted.set(key, object)
+        db.batch(changes, cb)
+
+      } catch (ex){
+        cb&&cb(ex)
       }
 
-      db.put(key, object)
-      return object
     }
   }
 
-  contextDB.generate = function(options, callback){
+  self.generate = function(options, callback){
 
     var data = options.data || {}
     var matcherRefs = options.matcherRefs || []
 
     try {
-      var matchers = matcherRefs.map(function(ref){ 
-        if (!matcherLookup[ref]){
+      var matchers = matcherRefs.map(function(ref){
+        var matcher = matchDb.lookupMatcher(ref)
+        if (!matcher){
           throw new Error('No matcher called ' + ref)
         }
-        return matcherLookup[ref]
+        return matcher
       })
     } catch (ex){
       return callback(ex)
@@ -125,124 +145,92 @@ module.exports = function(db, options){
       context.removeAllListeners()
     }
 
+    context.getChanges = function(cb){
+      var result = []
+      async.eachSeries(context.matchers, function(matcher, next){
+        matchDb.createMatchStream(matcher.ref, context, {tail: false}).on('data', function(data){
+          result.push(data.value)
+        }).on('end', next).on('error', next)
+      }, function(err){
+        if (err) return cb&&cb(err)
+        cb&&cb(null, result)
+      })
+    }
+
     context.emitChangesSince = function(timestamp){
 
       if (rootOptions.timestamps){
 
         context.matchers.forEach(function(matcher){
 
-          if (matcher.collection){
-
-            matcherStream(matcher.ref, context, {tail: false}).on('data', function(data){
-              if (!data.updated_at || data.updated_at > timestamp){
-                context.emit('change', data.value, {
-                  matcher: matcher, 
-                  source: contextDB,
-                  verfiedChange: true,
-                  time: data.updated_at || Date.now()
-                })
-              }
-            })
-
-            deletedStream(matcher.ref, context, timestamp, {tail: false}).on('data', function(data){
+          matchDb.createMatchStream(matcher.ref, context, {tail: false}).on('data', function(data){
+            if (!data.updated_at || data.updated_at > timestamp){
               context.emit('change', data.value, {
-                source: contextDB, 
-                action: 'remove', 
-                verifiedChange: true,
-                matcher: matcher,
-                time: data.deleted_at || Date.now()
+                matcher: matcher, 
+                source: self,
+                verfiedChange: true,
+                time: data.updated_at || Date.now()
               })
+            }
+          })
+
+          matchDb.createMatchStream(matcher.ref, context, {tail: false, deletedSince: timestamp}).on('data', function(data){
+            context.emit('change', data.value, {
+              source: self, 
+              action: 'remove', 
+              verifiedChange: true,
+              matcher: matcher,
+              time: data.deleted_at || Date.now()
             })
-
-          }
+          })
         })
       }
     }
 
     async.eachSeries(matchers, function(matcher, next){
-      streams.push(matcherStream(matcher.ref, context).on('data', function(data){
-        var key = data.key[data.key.length-1]
-        var object = data.value || deleted.get(key)
+      streams.push(matchDb.createMatchStream(matcher.ref, context).on('data', function(data){
+        var object = data.value
+        if (!object){
+          var split = data.key.split('~')
+          object = deleted.get(split[split.length-1])
+        }
 
         if (object){
           var time = object._deleted ? object.deleted_at : object.updated_at
-          context.pushChange(object, {matcher: matcher, source: contextDB, verifiedChange: true, time: time})
+          context.pushChange(object, {matcher: matcher, source: self, verifiedChange: true, time: time})
         }
-        
+              
       }).once('sync', function(){
         next()
       }))
 
     }, function(err){ if(err)return callback&&callback(err)
       process.nextTick(function(){
-        context.on('change', contextDB.applyChange)
-        callback(null, context)
+        context.on('change', self.applyChange)
+        context.emit('sync')
+        callback&&callback(null, context)
       })
     })
-  }
 
-  function matcherStream(matcherRef, context, options){
-    var params = getParamsFrom(matcherParamLookup[matcherRef], context)
-    return db.map.view(mergeClone(options, {name: matcherRef, start: params.concat('')}))
+    return context
   }
 
-  function deletedStream(matcherRef, context, since, options){
-    var params = getParamsFrom(matcherParamLookup[matcherRef], context).concat('DEL')
-    var startParams = params.concat(alphaKey(since), '')
-    var endParams = params.concat(alphaKey(Date.now()+100), '')
+  self.getByMatcher = function(matcherRef, params, cb){
+    // should replace with QueryContext
+    var context = JsonContext({data: params, dataFilters: dataFilters})
+    var result = []
 
-    return db.map.view(mergeClone(options, {name: matcherRef, start: startParams, end: endParams}))
+    matchDb.createMatchStream(matcherRef, context, {tail: false}).on('data', function(data){
+      result.push(data.value)
+    }).on('end', function(){
+      cb(null, result)
+    }).on('error', cb)
   }
 
-  return contextDB
+  self.forceIndex = matchDb.forceIndex
 
-}
+  return self
 
-function isParam(object){
-  return object instanceof Object && object.$query
-}
-
-function getParamsFrom(params, context){
-  return params.map(function(param){
-    return context.get(param.query)
-  })
-}
-
-function paramify(match){
-  var params = []
-  var ensure = {}
-
-  Object.keys(match).sort().forEach(function(key){
-    var value = match[key]
-    if (isParam(value)){
-      params.push({key: key, query: value.$query})
-    } else {
-      ensure[key] = value
-    }
-  })
-
-  return {
-    params: params,
-    ensure: ensure
-  }
-}
-
-function getMapFromMatcher(name, paramifiedMatch){
-  return {
-    name: name,
-    map: function(key, value, emit){
-      if (Object.keys(paramifiedMatch.ensure).length === 0 || checkFilter(value, paramifiedMatch.ensure, {match: 'filter'})){
-        var newKey = paramifiedMatch.params.map(function(param){
-          return value[param.key] || null
-        })
-        if (value._deleted){
-          newKey.push('DEL')
-          newKey.push(alphaKey(value.deleted_at || Date.now(), 8))
-        }
-        emit(newKey, value)
-      }
-    }
-  }
 }
 
 function padNumber(number, pad) {
@@ -250,14 +238,6 @@ function padNumber(number, pad) {
   return number < N ? ("" + (N + number)).slice(1) : "" + number
 }
 
-function alphaKey(number, pad) {
-  var N = Math.pow(36, pad);
-  return number < N ? ((N + number).toString(36)).slice(1) : "" + number.toString(36)
-}
-function parseAlphaKey(string){
-  return parseInt(string, 36)
-}
-
 function mergeClone(){
   var result = {}
   for (var i=0;i<arguments.length;i++){
diff --git a/match_map.js b/match_map.js
new file mode 100644
index 0000000..d562148
--- /dev/null
+++ b/match_map.js
@@ -0,0 +1,160 @@
+var Trigger = require('level-trigger')
+var checkFilter = require('json-filter')
+var hashObject = require('./hash_object')
+
+var LiveStream = require('level-live-stream')
+
+module.exports = function(db, matchers){
+  var self = db.sublevel('match-map')
+  var matcher = db.sublevel('matched')
+
+  db.matchMap = self
+
+  // extract params
+  var matcherLookup = {}
+  var matcherParams = {}
+  var matcherHashes = {}
+
+  matchers.forEach(function(matcher){
+    matcherLookup[matcher.ref] = matcher
+    matcherParams[matcher.ref] = paramify(matcher.match)
+    matcherHashes[matcher.ref] = hashObject(matcher.match, 'djb2')
+  })
+
+  // map trigger
+  var matchTrigger = Trigger(db, 'match', function(id, done){    
+    matcher.get('o~' + id, function(err, oldKeys){
+      oldKeys = oldKeys || []
+      var newKeys = []
+
+      db.get(id, function(err, value){
+        var batch = []
+
+        matchers.forEach(function(matcher){
+          var paramifiedMatch = matcherParams[matcher.ref]
+          if (checkMatch(value, paramifiedMatch.ensure)){
+            var paramHash = paramHashForObject(value, paramifiedMatch.params)
+            var key = matcherHashes[matcher.ref] + '~' + paramHash + '~'
+            if (value._deleted && !value._tombstone){
+              key += 'd~' + alphaKey(value.deleted_at || Date.now(), 8) + '~'
+            } else {
+              key += 'c~'
+            }
+            key += id
+            batch.push({key: key, value: value, type: 'put'})
+            newKeys.push(key)
+          }
+        })
+
+        oldKeys.forEach(function (k) {
+          if(!~newKeys.indexOf(k)) batch.push({key: k, type: 'del'})
+        })
+
+        batch.push({
+          key: 'o~' + id,
+          value: newKeys,
+          type: 'put',
+          prefix: matcher
+        })
+
+        self.batch(batch, done)
+      })
+    })
+  })
+
+  // check for reindex
+  matcher.get('matcher-hashes', function(err, value){
+    var currentHashes = Object.keys(matcherHashes).map(function(key){
+      return matcherHashes[key]
+    }).sort()
+  
+    if (!value || value.join('~') !== currentHashes.join('~')){
+      process.nextTick(function(){
+        self.forceIndex()
+        matcher.put('matcher-hashes', currentHashes)
+      })
+    }
+  })
+
+  self.forceIndex = function (){
+    matchTrigger.start()
+    self.emit('reindex')
+    return self
+  }
+
+  self.lookupMatcher = function (ref){
+    return matcherLookup[ref]
+  }
+
+  self.createMatchStream = function(matcherRef, context, opts){
+    if (typeof matcherRef !== 'string') throw new Error('must specify matcherRef')
+    opts = opts || {}
+    opts.start = matcherHashes[matcherRef] + '~'
+    if (context) {
+      opts.start += paramHashForContext(context, matcherParams[matcherRef].params) + '~'
+    }
+    if (opts.deletedSince){
+      opts.start += 'd~' + alphaKey(opts.deletedSince, 8) + '~'
+      opts.end = opts.start + 'd~~'
+    } else {
+      opts.start += 'c~'
+      opts.end = opts.start + '~'
+    }
+    return LiveStream(self, opts)
+  }
+
+  return self
+}
+
+function checkMatch(object, ensure){
+  return !Object.keys(ensure).length || checkFilter(object, ensure, {match: 'filter'})
+}
+
+function paramHashForObject(object, params){
+  var objectToHash = Object.keys(params).reduce(function(result, key){
+    result[key] = object[key]
+    return result
+  }, {})
+  return hashObject(objectToHash)
+}
+
+function paramHashForContext(context, params){
+  var objectToHash = Object.keys(params).reduce(function(result, key){
+    result[key] = context.get(params[key])
+    return result
+  }, {})
+  return hashObject(objectToHash)
+}
+
+function alphaKey(number, pad) {
+  var N = Math.pow(36, pad);
+  return number < N ? ((N + number).toString(36)).slice(1) : "" + number.toString(36)
+}
+function parseAlphaKey(string){
+  return parseInt(string, 36)
+}
+
+
+function paramify(match){
+  var params = {}
+  var ensure = {}
+
+  Object.keys(match).forEach(function(key){
+    var value = match[key]
+    if (isParam(value)){
+      params[key] = value.$query
+    } else {
+      ensure[key] = value
+    }
+  })
+
+  return {
+    params: params,
+    ensure: ensure
+  }
+}
+
+
+function isParam(object){
+  return object instanceof Object && object.$query
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 200f0b8..cb5ad50 100644
--- a/package.json
+++ b/package.json
@@ -13,10 +13,12 @@
   "dependencies": {
     "json-filter": "*",
     "json-context": "~0.2.0",
-    "level-map": "~0.1.2"
+    "level-sublevel": "~4.0.2",
+    "level-live-stream": "~1.1.2",
+    "level-trigger": "~1.1.0"
   },
   "peerDependencies": {
-    "levelup": "~0.6.1"
+    "levelup": "~0.6.2"
   },
   "keywords": [
     "realtime",
@@ -29,4 +31,4 @@
   ],
   "author": "Matt McKegg",
   "license": "MIT"
-}
\ No newline at end of file
+}
diff --git a/test/datasource.js b/test/datasource.js
index 7c56870..5469a1d 100644
--- a/test/datasource.js
+++ b/test/datasource.js
@@ -49,14 +49,14 @@ rimraf(testPath, function(){
       description: "Item 2"
     }
 
-    contextDB.applyChange(site1)
-    contextDB.applyChange(site2)
-
-    setTimeout(function(){
+    contextDB.applyChanges([site1, site2], function(){
       contextDB.generate({
         data: {site_id: site1.id},
         matcherRefs: ['site', 'items']
       }, function(err, datasource){
+
+        if (err) throw err
+
         t.deepEqual(datasource.data.site, site1, "check return site 1 matches applied")
         datasource.on('change', function(object, changeInfo){
           t.deepEqual(datasource.data.items[0], item1, "check item 1 emitted after context created")
@@ -74,7 +74,7 @@ rimraf(testPath, function(){
         })
         contextDB.applyChange(item2)
       })
-    }, 110)
+    })
 
   })
 
@@ -95,11 +95,8 @@ rimraf(testPath, function(){
       description: "Item 2"
     }
 
-    contextDB.applyChange(site)
-    contextDB.applyChange(item1)
-    contextDB.applyChange(item2)
+    contextDB.applyChanges([site, item1, item2], function(){
 
-    setTimeout(function(){
       contextDB.generate({
         data: {site_id: site.id},
         matcherRefs: ['site', 'items']
@@ -137,9 +134,9 @@ rimraf(testPath, function(){
           datasource1.pushChange(changedItem1, {verifiedChange: true})
           datasource2.pushChange(changedItem2, {verifiedChange: true})
         })
-
       })
-    }, 110)
+
+    })
   })
 
   test("Changes since", function(t){
@@ -160,11 +157,7 @@ rimraf(testPath, function(){
       description: "Item 2"
     }
 
-    contextDB.applyChange(site)
-    contextDB.applyChange(item1)
-    contextDB.applyChange(item2)
-
-    setTimeout(function(){
+    contextDB.applyChanges([site, item1, item2], function(){
 
       contextDB.generate({
         data: {site_id: site.id},
@@ -184,12 +177,7 @@ rimraf(testPath, function(){
           description: "New Item 3"
         }
 
-        contextDB.applyChange(changedItem1)
-        contextDB.applyChange(deletedItem2)
-        contextDB.applyChange(newItem3)
-
-        setTimeout(function(){
-
+        contextDB.applyChanges([changedItem1, deletedItem2, newItem3], function(){
           t.deepEqual(offlineDatasource.data, {
             site: site,
             site_id: site.id,
@@ -209,12 +197,12 @@ rimraf(testPath, function(){
               site_id: site.id,
               items: [changedItem1, newItem3]
             }, "check changes from past made")
-          }, 100)
-
-        }, 110)
+          }, 50)
+        })
 
       })
-    }, 110)
+
+    })
 
   })
 
diff --git a/test/reindex.js b/test/reindex.js
new file mode 100644
index 0000000..6666a5d
--- /dev/null
+++ b/test/reindex.js
@@ -0,0 +1,116 @@
+var test = require('tap').test
+var LevelDB = require('levelup')
+var ContextDB = require('../')
+var JsonContext = require('json-context')
+var rimraf = require('rimraf')
+
+var testPath = __dirname + '/test-db'
+rimraf(testPath, function(){
+
+  test('database reindex when matchers change', function(t){
+
+    t.plan(4)
+
+    var site = {id: 'site-1', type: 'site', name: "test 1234"}
+
+    var inaccessibleObject = {id: 'something', type: 'thing', name: "test 4567", site_id: site.id}
+
+
+    var originalMatchers = [
+      { ref: 'site', 
+        item: 'site', 
+        match: {
+          type: 'site',
+          id: {$query: 'site_id'}
+        }
+      }
+    ]
+
+    var db = LevelDB(testPath, {
+      encoding: 'json'
+    }, function(){
+      var contextDB = ContextDB(db, {
+        matchers: originalMatchers
+      })
+
+      contextDB.applyChanges([site, inaccessibleObject], function(){
+        contextDB.generate({
+          data: {site_id: site.id},
+          matcherRefs: ['site']
+        }, function(err, datasource){
+          t.deepEqual(datasource.data, {site_id: site.id, site: site}, "only first item matched")
+          datasource.destroy()
+          db.close(secondDatabase)
+        })
+      })
+
+    })
+
+    var changedMatchers = [
+      { ref: 'changed-site', 
+        item: 'changedSite', 
+        match: {
+          type: 'site',
+          id: {$query: 'site_id'}
+        }
+      }, {
+        ref: 'now-accessible',
+        item: 'accessible',
+        match: {
+          type: 'thing',
+          site_id: {$query: 'site_id'}
+        }
+      }
+    ]
+
+    function secondDatabase(){
+
+      var db = LevelDB(testPath, {
+        encoding: 'json'
+      }, function(){
+        var contextDB = ContextDB(db, {
+          matchers: changedMatchers
+        })
+
+        contextDB.on('reindex', function(){
+          t.ok(true, 'reindex event emitted')
+        })
+
+        contextDB.generate({
+          data: {site_id: site.id},
+          matcherRefs: ['changed-site', 'now-accessible']
+        }, function(err, datasource){
+
+          if (err) throw err
+
+          t.deepEqual(datasource.data, {site_id: site.id, changedSite: site, accessible: inaccessibleObject}, "item was reindexed, and second item now matched")
+          datasource.destroy()
+          db.close(thirdDatabase)
+        })
+      })
+    }
+
+    function thirdDatabase(){
+
+      var db = LevelDB(testPath, {
+        encoding: 'json'
+      })
+
+      var contextDB = ContextDB(db, {
+        matchers: changedMatchers
+      })
+
+      contextDB.on('reindex', function(){
+        throw new Error('should not reindex')
+      })
+
+      setTimeout(function(){
+        t.ok(true, 'reload database with same matchers didn\'t cause reindex')
+      }, 40)
+    }
+
+  })
+
+
+
+})
\ No newline at end of file