diff --git a/.gitignore b/.gitignore
index 8758413..aa673e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-go/bin
+bin
 node_modules
 public/bundle.*
 tmp
diff --git a/Makefile b/Makefile
index ff687a8..1c0fd6b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,24 +1,42 @@
 SHELL := /bin/bash -euo pipefail
-export PATH := go/bin:node_modules/.bin:$(V23_ROOT)/release/go/bin:$(V23_ROOT)/roadmap/go/bin:$(V23_ROOT)/third_party/cout/node/bin:$(PATH)
+export PATH := node_modules/.bin:$(V23_ROOT)/release/go/bin:$(V23_ROOT)/roadmap/go/bin:$(V23_ROOT)/third_party/cout/node/bin:$(PATH)
 
+# Default browserify options: use sourcemaps.
+BROWSERIFY_OPTS := --debug
+# Names that should not be mangled by minification.
+RESERVED_NAMES := 'context,ctx,callback,cb,$$stream,serverCall'
+# Don't mangle RESERVED_NAMES, and screw ie8.
+MANGLE_OPTS := --mangle [--except $(RESERVED_NAMES) --screw_ie8]
+# Don't remove unused variables from function arguments, which could mess up
+# signatures. Also don't evaulate constant expressions, since we rely on them to
+# conditionally require modules only in node.
+COMPRESS_OPTS := --compress [--no-unused --no-evaluate]
+# Workaround for Browserify opening too many files: increase the limit on file
+# descriptors.
+# https://github.com/substack/node-browserify/issues/431
+INCREASE_FILE_DESC = ulimit -S -n 2560
+
+# Browserify and extract sourcemap, but do not minify.
 define BROWSERIFY
 	mkdir -p $(dir $2)
-	browserify $1 -d -o $2
+	$(INCREASE_FILE_DESC); \
+	browserify $1 $(BROWSERIFY_OPTS) | exorcist $2.map > $2
 endef
 
+# Browserify, minify, and extract sourcemap.
 define BROWSERIFY_MIN
 	mkdir -p $(dir $2)
-	browserify $1 -d -p [minifyify --map $(notdir $2).map --output $2.map] -o $2
+	$(INCREASE_FILE_DESC); \
+	browserify $1 $(BROWSERIFY_OPTS) --g [uglifyify $(MANGLE_OPTS) $(COMPRESS_OPTS)] | exorcist $2.map > $2
 endef
 
 .DELETE_ON_ERROR:
 
-go/bin: $(shell find $(V23_ROOT) -name "*.go")
+bin: $(shell find $(V23_ROOT) -name "*.go")
 	v23 go build -a -o $@/principal v.io/x/ref/cmd/principal
-	v23 go build -a -tags wspr -o $@/servicerunner v.io/x/ref/cmd/servicerunner
 	v23 go build -a -o $@/syncbased v.io/syncbase/x/ref/services/syncbase/syncbased
 
-node_modules: package.json
+node_modules: package.json $(shell find $(V23_ROOT)/roadmap/javascript/syncbase)
 	npm prune
 	npm install
 	touch $@
@@ -26,8 +44,14 @@
 	rm -rf ./node_modules/{vanadium,syncbase}
 	cd "$(V23_ROOT)/release/javascript/core" && npm link
 	npm link vanadium
+	rm -rf ./node_modules/syncbase
 	cd "$(V23_ROOT)/roadmap/javascript/syncbase" && npm link
 	npm link syncbase
+# Delete syncbase's copy of the vanadium module. If we don't do this, then two
+# copies of vanadium will get bundled, and unfortunately vanadium contains some
+# singletons, which break if there is more than one copy of the module.
+# See https://github.com/vanadium/issues/issues/155
+	rm -rf ./node_modules/syncbase/node_modules/vanadium
 	touch node_modules
 
 public/bundle.min.js: browser/index.js $(shell find browser) node_modules
@@ -38,17 +62,15 @@
 endif
 
 .PHONY: build
-build: go/bin node_modules public/bundle.min.js
+build: bin node_modules public/bundle.min.js
 
 .PHONY: serve
-serve: export PATH := test:$(PATH)
 serve: build
-	node ./node_modules/vanadium/test/integration/runner.js --services=start-syncbased.sh -- \
 	npm start
 
 .PHONY: clean
 clean:
-	rm -rf go/bin node_modules public/bundle.min.js
+	rm -rf bin node_modules public/bundle.min.js
 
 .PHONY: lint
 lint:
diff --git a/README.md b/README.md
index 9c6b6f2..9ae3f96 100644
--- a/README.md
+++ b/README.md
@@ -10,3 +10,29 @@
 
     $V23_ROOT/release/go/bin/namespace glob -v23.namespace.root=V23_NAMESPACE -v23.credentials=V23_CREDENTIALS "test/*"
     $V23_ROOT/release/go/bin/vrpc signature -v23.namespace.root=V23_NAMESPACE -v23.credentials=V23_CREDENTIALS "test/syncbased/todos"
+
+## Notes
+
+- problem was that the extension defaults to prod mounttable and assumes
+  blessings minted by prod identity server, but local mount table and syncbased
+  run with local credentials and do not include dev.v.io in trusted roots.
+
+- one solution is to configure the extension with local identityd,
+  identitydBlessingUrl, and namespaceRoot, but this requires running Chrome as
+  follows and manually editing the Chrome extension options on each restart.
+
+  /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --ignore-certificate-errors --user-data-dir=/tmp/foo
+
+- to avoid manually editing options, we could build the Chrome extension as part
+  of "make serve" - that's what our tests do. ew.
+
+- alternatively, we can include dev.v.io in our local mount table and
+  syncbased's trusted root sets, and have their "root dirs" allow access to
+  anyone. secure b/c these services are only accessible on localhost. for this
+  to work, we'd need to configure the webapp to talk to the local mount table.
+
+- even simpler, we could bypass mount table completely and have the webapp talk
+  directly to local syncbased. in addition, instead of overriding the trusted
+  root set, we can run the local syncbased with a dev.v.io blessing by using
+  seekblessings. (both here and above, all extension opts are left untouched,
+  and dev.v.io blessings are used.)
diff --git a/browser/collection.js b/browser/collection.js
index a819839..f237c29 100644
--- a/browser/collection.js
+++ b/browser/collection.js
@@ -1,3 +1,5 @@
+// Defines the Collection interface, a subset of the MongoDB collection API.
+
 'use strict';
 
 var EventEmitter = require('events').EventEmitter;
@@ -6,11 +8,11 @@
 inherits(Collection, EventEmitter);
 module.exports = Collection;
 
+// Collection interface. Collections emit 'change' events.
 function Collection() {
   EventEmitter.call(this);
 }
 
-// Collection interface, with most methods stubbed out.
 Collection.prototype.find = function(q, opts, cb) {
   throw new Error('not implemented');
 };
@@ -26,13 +28,3 @@
 Collection.prototype.update = function(q, opts, cb) {
   throw new Error('not implemented');
 };
-
-Collection.prototype.findOne = function(q, opts, cb) {
-  this.find(q, opts, function(err, all) {
-    if (err) return cb(err);
-    if (all.length > 0) {
-      return cb(null, all[0]);
-    }
-    return cb();
-  });
-};
diff --git a/browser/collection_dispatcher.js b/browser/collection_dispatcher.js
new file mode 100644
index 0000000..86be565
--- /dev/null
+++ b/browser/collection_dispatcher.js
@@ -0,0 +1,72 @@
+// Collection-based implementation of Dispatcher.
+
+'use strict';
+
+var _ = require('lodash');
+var inherits = require('util').inherits;
+
+var Collection = require('./collection');
+var Dispatcher = require('./dispatcher');
+
+inherits(CollectionDispatcher, Dispatcher);
+module.exports = CollectionDispatcher;
+
+function noop() {}
+
+function CollectionDispatcher(lists, todos) {
+  Dispatcher.call(this);
+  console.assert(lists instanceof Collection);
+  console.assert(todos instanceof Collection);
+  this.lists_ = lists;
+  this.todos_ = todos;
+}
+
+CollectionDispatcher.prototype.getLists = function(cb) {
+  this.lists_.find({}, {sort: {name: 1}}, cb);
+};
+
+CollectionDispatcher.prototype.getTodos = function(listId, cb) {
+  this.todos_.find({listId: listId}, {sort: {timestamp: 1}}, cb);
+};
+
+CollectionDispatcher.prototype.addList = function(list, cb) {
+  this.lists_.insert(list, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.editListName = function(listId, name, cb) {
+  this.lists_.update(listId, {$set: {name: name}}, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.addTodo = function(listId, todo, cb) {
+  todo = _.assign({}, todo, {listId: listId});
+  this.todos_.insert(todo, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.removeTodo = function(todoId, cb) {
+  this.todos_.remove(todoId, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.editTodoText = function(todoId, text, cb) {
+  this.todos_.update(todoId, {$set: {text: text}}, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.markTodoDone = function(todoId, done, cb) {
+  this.todos_.update(todoId, {$set: {done: done}}, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.addTag = function(todoId, tag, cb) {
+  this.todos_.update(todoId, {$addToSet: {tags: tag}}, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.removeTag = function(todoId, tag, cb) {
+  this.todos_.update(todoId, {$pull: {tags: tag}}, this.maybeEmit_(cb));
+};
+
+CollectionDispatcher.prototype.maybeEmit_ = function(cb) {
+  var that = this;
+  cb = cb || noop;
+  return function(err) {
+    cb.apply(null, arguments);
+    if (!err) that.emit('change');
+  };
+};
diff --git a/browser/defaults.js b/browser/defaults.js
index 001d722..4dd3ba7 100644
--- a/browser/defaults.js
+++ b/browser/defaults.js
@@ -3,10 +3,12 @@
 var async = require('async');
 var syncbase = require('syncbase');
 
-var Memstore = require('./memstore');
-var Syncbase = require('./syncbase');
+var CollectionDispatcher = require('./collection_dispatcher');
+var MemCollection = require('./mem_collection');
+var SyncbaseDispatcher = require('./syncbase_dispatcher');
 
-var SYNCBASE_NAME = 'test/syncbased';
+//var SYNCBASE_NAME = 'test/syncbased';
+var SYNCBASE_NAME = '/localhost:8200';
 
 // Copied from meteor/todos/server/bootstrap.js.
 var data = [
@@ -46,85 +48,70 @@
   }
 ];
 
-function initData(lists, todos, cb) {
+function initData(disp, cb) {
   var timestamp = Date.now();
   async.each(data, function(list, cb) {
-    lists.insert({name: list.name}, function(err, listId) {
+    disp.addList({name: list.name}, function(err, listId) {
       if (err) return cb(err);
       async.each(list.contents, function(info, cb) {
         timestamp += 1;  // ensure unique timestamp
-        todos.insert({
-          listId: listId,
+        disp.addTodo(listId, {
           text: info[0],
+          tags: info.slice(1),
           done: false,
-          timestamp: timestamp,
-          tags: info.slice(1)
+          timestamp: timestamp
         }, cb);
       }, cb);
     });
   }, cb);
 }
 
-function appExists(ctx, service, name, cb) {
-  service.listApps(ctx, function(err, names) {
+function newCtx(rt, timeout) {
+  timeout = timeout || 5000;
+  return rt.getContext().withTimeout(timeout);
+}
+
+function appExists(rt, service, name, cb) {
+  service.listApps(newCtx(rt), function(err, names) {
     if (err) return cb(err);
     return cb(null, names.indexOf(name) >= 0);
   });
 }
 
-exports.initCollections = function(ctx, engine, cb) {
-  function doInitData(lists, todos, cb) {
-    initData(lists, todos, function(err) {
-      if (err) return cb(err);
-      return cb(null, {
-        lists: lists,
-        todos: todos
-      });
-    });
-  }
-
-  switch (engine) {
-  case 'syncbase':
+exports.initDispatcher = function(rt, engine, cb) {
+  if (engine === 'syncbase') {
     var service = syncbase.newService(SYNCBASE_NAME);
-    appExists(ctx, service, 'todos', function(err, exists) {
+    appExists(rt, service, 'todos', function(err, exists) {
       if (err) return cb(err);
       var app = service.app('todos'), db = app.noSqlDatabase('db');
-      var lists = new Syncbase(db, 'lists');
-      var todos = new Syncbase(db, 'todos');
+      var disp = new SyncbaseDispatcher(rt, db);
       if (exists) {
         console.log('app exists; assuming everything has been initialized');
-        return cb(null, {
-          lists: lists,
-          todos: todos
-        });
+        return cb(null, disp);
       }
       console.log('app does not exist; initializing everything');
-      app.create(ctx, {}, function(err) {
-        console.log('app.create done');
-        // TODO(sadovsky): This fails with "No usable servers found". Chat with
-        // Nick to determine optimal setup for development and debugging.
+      app.create(newCtx(rt), {}, function(err) {
         if (err) return cb(err);
-        var db = app.noSqlDatabase('db');
-        db.create(ctx, {}, function(err) {
+        db.create(newCtx(rt), {}, function(err) {
           if (err) return cb(err);
-          async.each(['lists', 'todos'], function(name, cb) {
-            db.createTable(ctx, name, {}, cb);
-          }, function(err) {
+          db.createTable(newCtx(rt), 'tb', {}, function(err) {
             if (err) return cb(err);
-            var lists = new Syncbase(db, 'lists');
-            var todos = new Syncbase(db, 'todos');
-            doInitData(lists, todos, cb);
+            initData(disp, function(err) {
+              if (err) return cb(err);
+              return cb(null, disp);
+            });
           });
         });
       });
     });
-    break;
-  case 'memstore':
-    var lists = new Memstore('lists');
-    var todos = new Memstore('todos');
-    doInitData(lists, todos, cb);
-    break;
-  default:
+  } else if (engine === 'memstore') {
+    var lists = new MemCollection('lists'), todos = new MemCollection('todos');
+    var disp = new CollectionDispatcher(lists, todos);
+    initData(disp, function(err) {
+      if (err) return cb(err);
+      return cb(null, disp);
+    });
+  } else {
     throw new Error('unknown engine: ' + engine);
   }
 };
diff --git a/browser/dispatcher.js b/browser/dispatcher.js
index a9d6f15..3c109f1 100644
--- a/browser/dispatcher.js
+++ b/browser/dispatcher.js
@@ -1,49 +1,58 @@
-// Note, our Dispatcher combines the following React Flux concepts: Actions,
-// Dispatcher, and Stores.
+// Defines the Dispatcher interface. Loosely inspired by React Flux.
 
 'use strict';
 
+var EventEmitter = require('events').EventEmitter;
+var inherits = require('util').inherits;
+
+inherits(Dispatcher, EventEmitter);
 module.exports = Dispatcher;
 
-function Dispatcher(lists, todos) {
-  this.lists_ = lists;
-  this.todos_ = todos;
+// Dispatcher interface. Dispatchers emit 'change' events.
+function Dispatcher() {
+  EventEmitter.call(this);
 }
 
-function noop() {}
+// Returns lists with _id.
+Dispatcher.prototype.getLists = function(cb) {
+  throw new Error('not implemented');
+};
 
-// Note, we pass noop as the callback everywhere since our app handles all
-// updates by watching for changes.
-// TODO(sadovsky): Pass a callback and handle errors.
-Dispatcher.prototype = {
-  addList: function(name) {
-    return this.lists_.insert({name: name}, noop);
-  },
-  editListName: function(listId, name) {
-    this.lists_.update(listId, {$set: {name: name}}, noop);
-  },
-  addTodo: function(listId, text, tags) {
-    return this.todos_.insert({
-      listId: listId,
-      text: text,
-      done: false,
-      timestamp: (new Date()).getTime(),
-      tags: tags
-    }, noop);
-  },
-  removeTodo: function(todoId) {
-    this.todos_.remove(todoId, noop);
-  },
-  editTodoText: function(todoId, text) {
-    this.todos_.update(todoId, {$set: {text: text}}, noop);
-  },
-  markTodoDone: function(todoId, done) {
-    this.todos_.update(todoId, {$set: {done: done}}, noop);
-  },
-  addTag: function(todoId, tag) {
-    this.todos_.update(todoId, {$addToSet: {tags: tag}}, noop);
-  },
-  removeTag: function(todoId, tag) {
-    this.todos_.update(todoId, {$pull: {tags: tag}}, noop);
-  }
+// Returns todos with _id and tags.
+Dispatcher.prototype.getTodos = function(listId, cb) {
+  throw new Error('not implemented');
+};
+
+// The given list must not have _id.
+Dispatcher.prototype.addList = function(list, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.editListName = function(listId, name, cb) {
+  throw new Error('not implemented');
+};
+
+// The given todo must not have _id, but may have tags.
+Dispatcher.prototype.addTodo = function(listId, todo, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.removeTodo = function(todoId, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.editTodoText = function(todoId, text, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.markTodoDone = function(todoId, done, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.addTag = function(todoId, tag, cb) {
+  throw new Error('not implemented');
+};
+
+Dispatcher.prototype.removeTag = function(todoId, tag, cb) {
+  throw new Error('not implemented');
 };
diff --git a/browser/index.js b/browser/index.js
index 1f04fcd..eedafb4 100644
--- a/browser/index.js
+++ b/browser/index.js
@@ -11,14 +11,12 @@
 var vanadium = require('vanadium');
 
 var defaults = require('./defaults');
-var Dispatcher = require('./dispatcher');
 var h = require('./util').h;
 
 ////////////////////////////////////////
 // Global state
 
-var cLists, cTodos;  // collections
-var disp;  // dispatcher
+var disp;  // type Dispatcher
 
 ////////////////////////////////////////
 // Helpers
@@ -126,6 +124,8 @@
             ev.target.parentNode.style.opacity = 0;
             // Wait for CSS animation to finish.
             window.setTimeout(function() {
+              // TODO(sadovsky): If no other todos have the removed tag, set
+              // tagFilter to null.
               disp.removeTag(that.props.todoId, tag);
             }, 300);
           }
@@ -232,8 +232,12 @@
         placeholder: 'New item'
       }, okCancelEvents({
         ok: function(value, ev) {
-          var tags = tagFilter ? [tagFilter] : [];
-          disp.addTodo(that.props.listId, value, tags);
+          disp.addTodo(that.props.listId, {
+            text: value,
+            tags: tagFilter ? [tagFilter] : [],
+            done: false,
+            timestamp: Date.now()
+          });
           ev.target.value = '';
         }
       })))));
@@ -313,8 +317,9 @@
         placeholder: 'New list'
       }, okCancelEvents({
         ok: function(value, ev) {
-          var id = disp.addList(value);
-          that.props.setListId(id);
+          disp.addList({name: value}, function(err, listId) {
+            that.props.setListId(listId);
+          });
           ev.target.value = '';
         }
       })))));
@@ -333,14 +338,14 @@
       tagFilter: null  // current tag
     };
   },
-  fetchLists_: function(cb) {
-    return cLists.find({}, {sort: {name: 1}}, cb);
+  getLists_: function(cb) {
+    disp.getLists(cb);
   },
-  fetchTodos_: function(listId, cb) {
+  getTodos_: function(listId, cb) {
     if (listId === null) {
       return cb();
     }
-    return cTodos.find({listId: listId}, {sort: {timestamp: 1}}, cb);
+    disp.getTodos(listId, cb);
   },
   updateURL: function() {
     var router = this.props.router, listId = this.state.listId;
@@ -349,26 +354,27 @@
   componentDidMount: function() {
     var that = this;
 
-    cLists.on('change', function() {
-      that.fetchLists_(function(err, lists) {
+    // TODO(sadovsky): Only update what's needed based on what changed.
+    disp.on('change', function() {
+      that.getLists_(function(err, lists) {
         if (err) throw err;
-        that.setState({lists: lists});
-      });
-    });
-    cTodos.on('change', function() {
-      that.fetchTodos_(that.state.listId, function(err, todos) {
-        if (err) throw err;
-        that.setState({todos: todos});
+        that.getTodos_(that.state.listId, function(err, todos) {
+          if (err) throw err;
+          that.setState({
+            lists: lists,
+            todos: todos
+          });
+        });
       });
     });
 
-    that.fetchLists_(function(err, lists) {
+    that.getLists_(function(err, lists) {
       if (err) throw err;
       var listId = that.state.listId;
       if (listId === null && lists.length > 0) {
         listId = lists[0]._id;
       }
-      that.fetchTodos_(listId, function(err, todos) {
+      that.getTodos_(listId, function(err, todos) {
         if (err) throw err;
         that.setState({
           lists: lists,
@@ -402,7 +408,8 @@
         listId: this.state.listId,
         setListId: function(listId) {
           if (listId !== that.state.listId) {
-            that.fetchTodos_(listId, function(err, todos) {
+            // TODO(sadovsky): Get todos as a separate async step?
+            that.getTodos_(listId, function(err, todos) {
               if (err) throw err;
               that.setState({
                 todos: todos,
@@ -430,11 +437,9 @@
 vanadium.init(vanadiumConfig, function(err, rt) {
   if (err) throw err;
   var engine = u.query.engine || 'memstore';
-  defaults.initCollections(rt.getContext(), engine, function(err, cxs) {
+  defaults.initDispatcher(rt, engine, function(err, resDisp) {
     if (err) throw err;
-    cLists = cxs.lists;
-    cTodos = cxs.todos;
-    disp = new Dispatcher(cLists, cTodos);
+    disp = resDisp;
 
     var Router = Backbone.Router.extend({
       routes: {
diff --git a/browser/memstore.js b/browser/mem_collection.js
similarity index 76%
rename from browser/memstore.js
rename to browser/mem_collection.js
index 8be3a82..51b8f6f 100644
--- a/browser/memstore.js
+++ b/browser/mem_collection.js
@@ -1,4 +1,5 @@
-// TODO(sadovsky): Use minimongo?
+// In-memory implementation of Collection.
+// TODO(sadovsky): Replace with nedb NPM module.
 
 'use strict';
 
@@ -7,17 +8,20 @@
 
 var Collection = require('./collection');
 
-inherits(Memstore, Collection);
-module.exports = Memstore;
+inherits(MemCollection, Collection);
+module.exports = MemCollection;
 
-function Memstore(name) {
+function MemCollection(name) {
   Collection.call(this);
   this.name_ = name;
   this.vals_ = [];
 }
 
-Memstore.prototype.find = function(q, opts, cb) {
+function noop() {}
+
+MemCollection.prototype.find = function(q, opts, cb) {
   var that = this;
+  cb = cb || noop;
   q = this.normalize_(q);
   var res = _.filter(this.vals_, function(v) {
     return that.matches_(v, q);
@@ -33,16 +37,18 @@
   return cb(null, _.cloneDeep(res));
 };
 
-Memstore.prototype.insert = function(v, cb) {
-  console.assert(!_.has(v, '_id'));
+MemCollection.prototype.insert = function(v, cb) {
+  cb = cb || noop;
+  console.assert(!v._id);
   v = _.assign({}, v, {_id: this.vals_.length});
   this.vals_.push(v);
   this.emit('change');
   return cb(null, v._id);
 };
 
-Memstore.prototype.remove = function(q, cb) {
+MemCollection.prototype.remove = function(q, cb) {
   var that = this;
+  cb = cb || noop;
   q = this.normalize_(q);
   this.vals_ = _.filter(this.vals_, function(v) {
     return !that.matches_(v, q);
@@ -51,8 +57,9 @@
   return cb();
 };
 
-Memstore.prototype.update = function(q, opts, cb) {
+MemCollection.prototype.update = function(q, opts, cb) {
   var that = this;
+  cb = cb || noop;
   q = this.normalize_(q);
   var vals = _.filter(this.vals_, function(v) {
     return that.matches_(v, q);
@@ -86,14 +93,14 @@
   return cb();
 };
 
-Memstore.prototype.normalize_ = function(q) {
+MemCollection.prototype.normalize_ = function(q) {
   if (_.isObject(q)) {
     return q;
   }
   return {_id: q};
 };
 
-Memstore.prototype.matches_ = function(v, q) {
+MemCollection.prototype.matches_ = function(v, q) {
   var keys = _.keys(q);
   for (var i = 0; i < keys.length; i++) {
     var key = keys[i];
diff --git a/browser/syncbase.js b/browser/syncbase.js
deleted file mode 100644
index f82a401..0000000
--- a/browser/syncbase.js
+++ /dev/null
@@ -1,36 +0,0 @@
-// Syncbase wrapper that implements the Collection API.
-
-// TODO(sadovsky): Implement.
-
-'use strict';
-
-var inherits = require('util').inherits;
-
-var Collection = require('./collection');
-
-inherits(Syncbase, Collection);
-module.exports = Syncbase;
-
-// TODO(sadovsky): Watch store for change events. (Necessary if we want to
-// immediately display synced data.)
-
-function Syncbase(db, tableName) {
-  Collection.call(this);
-  this.table_ = db.table(tableName);
-}
-
-Syncbase.prototype.find = function(q, opts, cb) {
-  throw new Error('not implemented');
-};
-
-Syncbase.prototype.insert = function(v, cb) {
-  throw new Error('not implemented');
-};
-
-Syncbase.prototype.remove = function(q, cb) {
-  throw new Error('not implemented');
-};
-
-Syncbase.prototype.update = function(q, opts, cb) {
-  throw new Error('not implemented');
-};
diff --git a/browser/syncbase_dispatcher.js b/browser/syncbase_dispatcher.js
new file mode 100644
index 0000000..6914caa
--- /dev/null
+++ b/browser/syncbase_dispatcher.js
@@ -0,0 +1,235 @@
+// Syncbase-based implementation of Dispatcher.
+//
+// Schema design doc (a bit outdated):
+// https://docs.google.com/document/d/1GtBk75QmjSorUW6T6BATCoiS_LTqOrGksgqjqJ1Hiow/edit#
+//
+// NOTE: Currently, list and todo order are not preserved. We should make the
+// app always order these lexicographically.
+
+'use strict';
+
+var _ = require('lodash');
+var async = require('async');
+var inherits = require('util').inherits;
+var nodeUuid = require('node-uuid');
+
+var syncbase = require('syncbase');
+var nosql = syncbase.nosql;
+
+var Dispatcher = require('./Dispatcher');
+
+inherits(SyncbaseDispatcher, Dispatcher);
+module.exports = SyncbaseDispatcher;
+
+function SyncbaseDispatcher(rt, db) {
+  Dispatcher.call(this);
+  this.rt_ = rt;
+  this.db_ = db;
+  this.tb_ = db.table('tb');
+}
+
+////////////////////////////////////////
+// Helpers
+
+function noop() {}
+
+var SEP = '.';  // separator for key parts
+
+function join() {
+  // TODO(sadovsky): Switch to using naming.join() once Syncbase allows slashes
+  // in row keys.
+  var args = Array.prototype.slice.call(arguments);
+  return args.join(SEP);
+}
+
+function uuid() {
+  return nodeUuid.v4();
+}
+
+function newListKey() {
+  return uuid();
+}
+
+function newTodoKey(listId) {
+  return join(listId, 'todos', uuid());
+}
+
+function tagKey(todoId, tag) {
+  return join(todoId, 'tags', tag);
+}
+
+function marshal(x) {
+  return JSON.stringify(x);
+}
+
+function unmarshal(x) {
+  return JSON.parse(x);
+}
+
+////////////////////////////////////////
+// SyncbaseDispatcher impl
+
+// TODO(sadovsky): Switch to storing VDL values (instead of JSON) and use a
+// query to get all values of a particular type.
+SyncbaseDispatcher.prototype.getLists = function(cb) {
+  this.getRows_(function(err, rows) {
+    if (err) return cb(err);
+    var lists = [];
+    _.forEach(rows, function(row) {
+      if (row.key.indexOf(SEP) >= 0) {
+        return;
+      }
+      lists.push(_.assign({}, unmarshal(row.value), {_id: row.key}));
+    });
+    return cb(null, lists);
+  });
+};
+
+SyncbaseDispatcher.prototype.getTodos = function(listId, cb) {
+  this.getRows_(function(err, rows) {
+    if (err) return cb(err);
+    var todos = [];
+    var todo = {};
+    _.forEach(rows, function(row) {
+      var parts = row.key.split(SEP);
+      if (parts.length < 2 || parts[0] !== listId) {
+        return;
+      } else if (parts.length === 3) {  // next todo
+        if (todo._id) {
+          todos.push(todo);
+        }
+        todo = _.assign({}, unmarshal(row.value), {_id: row.key});
+      } else if (parts.length === 5) {  // tag for current todo
+        if (!todo.tags) {
+          todo.tags = [];
+        }
+        todo.tags.push(parts[4]);  // push tag name
+      } else {
+        throw new Error('bad key: ' + row.key);
+      }
+    });
+    return cb(null, todos);
+  });
+};
+
+SyncbaseDispatcher.prototype.addList = function(list, cb) {
+  console.assert(!list._id);
+  var listId = newListKey();
+  var v = marshal(list);
+  this.tb_.put(this.newCtx_(), listId, v, this.maybeEmit_(function(err) {
+    if (err) return cb(err);
+    return cb(null, listId);
+  }));
+};
+
+SyncbaseDispatcher.prototype.editListName = function(listId, name, cb) {
+  this.update_(listId, function(list) {
+    return _.assign(list, {name: name});
+  }, cb);
+};
+
+SyncbaseDispatcher.prototype.addTodo = function(listId, todo, cb) {
+  var that = this;
+  console.assert(!todo._id);
+  var tags = todo.tags;
+  delete todo.tags;
+  var todoId = newTodoKey(listId);
+  var v = marshal(todo);
+  // Write todo and tags in a batch.
+  var opts = new nosql.BatchOptions();
+  nosql.runInBatch(this.newCtx_(), this.db_, opts, function(db, cb) {
+    // NOTE: Dealing with tables is awkward given that batches and syncgroups
+    // are database-level. Maybe we should just get rid of tables. Doing so
+    // would solve other problems as well, e.g. the API inconsistency for
+    // creating databases vs. tables.
+    var tb = db.table('tb');
+    tb.put(that.newCtx_(), todoId, v, function(err) {
+      if (err) return cb(err);
+      async.each(tags, function(tag, cb) {
+        that.addTagInternal_(tb, todoId, tag, cb);
+      }, cb);
+    });
+  }, this.maybeEmit_(cb));
+};
+
+SyncbaseDispatcher.prototype.removeTodo = function(todoId, cb) {
+  this.tb_.row(todoId).delete(this.newCtx_(), this.maybeEmit_(cb));
+};
+
+SyncbaseDispatcher.prototype.editTodoText = function(todoId, text, cb) {
+  this.update_(todoId, function(todo) {
+    return _.assign(todo, {text: text});
+  }, cb);
+};
+
+SyncbaseDispatcher.prototype.markTodoDone = function(todoId, done, cb) {
+  this.update_(todoId, function(todo) {
+    return _.assign(todo, {done: done});
+  }, cb);
+};
+
+SyncbaseDispatcher.prototype.addTag = function(todoId, tag, cb) {
+  this.addTagInternal_(this.tb_, todoId, tag, this.maybeEmit_(cb));
+};
+
+SyncbaseDispatcher.prototype.removeTag = function(todoId, tag, cb) {
+  // NOTE: Table.delete is awkward (it takes a range), so instead we use
+  // Row.delete. It would be nice for Table.delete to operate on a single row
+  // and have a separate Table.deleteRowRange.
+  this.tb_.row(tagKey(todoId, tag)).delete(this.newCtx_(), this.maybeEmit_(cb));
+};
+
+// TODO(sadovsky): Watch for changes on Syncbase itself so that we can detect
+// when data arrives via sync, and drop this method.
+SyncbaseDispatcher.prototype.maybeEmit_ = function(cb) {
+  var that = this;
+  cb = cb || noop;
+  return function(err) {
+    cb.apply(null, arguments);
+    if (!err) that.emit('change');
+  };
+};
+
+// Returns a new Vanadium context object with a timeout.
+SyncbaseDispatcher.prototype.newCtx_ = function(timeout) {
+  timeout = timeout || 5000;
+  return this.rt_.getContext().withTimeout(timeout);
+};
+
+// Writes the given tag into the given table.
+SyncbaseDispatcher.prototype.addTagInternal_ = function(tb, todoId, tag, cb) {
+  // NOTE: Syncbase currently disallows whitespace in keys, so as a quick hack
+  // we drop all whitespace before storing tags.
+  tag = tag.replace(/\s+/g, '');
+  tb.put(this.newCtx_(), tagKey(todoId, tag), null, cb);
+};
+
+// Returns all rows in the table.
+SyncbaseDispatcher.prototype.getRows_ = function(cb) {
+  var rows = [], streamErr = null;
+  var range = nosql.rowrange.prefix('');
+  this.tb_.scan(this.newCtx_(), range, function(err) {
+    if (err) return cb(err);
+    if (streamErr) return cb(streamErr);
+    cb(null, rows);
+  }).on('data', function(row) {
+    rows.push(row);
+  }).on('error', function(err) {
+    streamErr = streamErr || err.error;
+  });
+};
+
+// Performs a read-modify-write on key, applying updateFn to the value.
+// Takes care of value marshalling and unmarshalling.
+SyncbaseDispatcher.prototype.update_ = function(key, updateFn, cb) {
+  var that = this;
+  var opts = new nosql.BatchOptions();
+  nosql.runInBatch(this.newCtx_(), this.db_, opts, function(db, cb) {
+    var tb = db.table('tb');
+    tb.get(that.newCtx_(), key, function(err, value) {
+      if (err) return cb(err);
+      var newValue = marshal(updateFn(unmarshal(value)));
+      tb.put(that.newCtx_(), key, newValue, cb);
+    });
+  }, this.maybeEmit_(cb));
+};
diff --git a/package.json b/package.json
index 4e22922..a48c127 100644
--- a/package.json
+++ b/package.json
@@ -16,12 +16,14 @@
     "async": "^1.2.1",
     "express": "^4.12.4",
     "lodash": "^3.9.3",
+    "node-uuid": "^1.4.3",
     "react": "^0.13.3"
   },
   "devDependencies": {
     "browserify": "^10.2.3",
     "browserify-shim": "^3.8.8",
     "jshint": "^2.8.0",
-    "minifyify": "^7.0.0"
+    "exorcist": "~0.4.0",
+    "uglifyify": "~3.0.1"
   }
 }
diff --git a/start_syncbased.sh b/start_syncbased.sh
new file mode 100755
index 0000000..c806ac7
--- /dev/null
+++ b/start_syncbased.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+# Copyright 2015 The Vanadium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# Expects credentials in /tmp/creds, generated as follows:
+# make build
+# ./bin/principal seekblessings --v23.credentials tmp/creds
+
+./bin/syncbased --root-dir=tmp/sbroot --v23.tcp.address=localhost:8200 --v23.credentials=tmp/creds --v=3 --alsologtostderr=true --v23.permissions.literal='{"Admin":{"In":["..."]},"Write":{"In":["..."]},"Read":{"In":["..."]},"Resolve":{"In":["..."]},"Debug":{"In":["..."]}}'
diff --git a/test/start-syncbased.sh b/test/start-syncbased.sh
deleted file mode 100755
index d6c2e11..0000000
--- a/test/start-syncbased.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-# Copyright 2015 The Vanadium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-# Start syncbased and mount in the mounttable.
-
-# TODO(nlacasse): This file is needed because the javascript service-runner
-# does not allow flags or arguments to the executables it starts.  We should
-# fix service-runner to allow flags/arguments, and then have it start syncbased
-# directly with the appropriate flags.  Then we can delete this file.
-
-syncbased -v=1 --name test/syncbased --engine memstore