diff --git a/lib/Syncbase/Batch.swift b/lib/Syncbase/Batch.swift
new file mode 100644
index 0000000..6640b7d
--- /dev/null
+++ b/lib/Syncbase/Batch.swift
@@ -0,0 +1,50 @@
+// 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.
+
+import Foundation
+
+internal class BatchHandle {
+}
+
+public enum Batch {
+  public typealias BatchCompletionHandler = SyncbaseError? -> Void
+  public typealias Operation = Void -> BatchCompletionHandler
+
+  /**
+   Runs the given batch operation, managing retries and BatchDatabase's commit() and abort()s.
+
+   - Parameter db:      database on which the batch operation is to be performed
+   - Parameter opts:    batch configuration
+   - Parameter op:      batch operation
+   - Parameter completionHandler:      future result called when runInBatch finishes
+   */
+  public static func runInBatch(db: Database, opts: BatchOptions, op: Operation, completionHandler: BatchCompletionHandler) {
+    preconditionFailure("stub")
+  }
+}
+
+public struct BatchOptions {
+  /// Arbitrary string, typically used to describe the intent behind a batch.
+  /// Hints are surfaced to clients during conflict resolution.
+  /// TODO(sadovsky): Use "any" here?
+  public let hint: String? = nil
+
+  /// ReadOnly specifies whether the batch should allow writes.
+  /// If ReadOnly is set to true, Abort() should be used to release any resources
+  /// associated with this batch (though it is not strictly required), and
+  /// Commit() will always fail.
+  public let readOnly: Bool = false
+}
+
+public protocol BatchDatabase: DatabaseHandle {
+  /// Commit persists the pending changes to the database.
+  /// If the batch is readonly, Commit() will fail with ErrReadOnlyBatch; Abort()
+  /// should be used instead.
+  func commit() throws
+
+  /// Abort notifies the server that any pending changes can be discarded.
+  /// It is not strictly required, but it may allow the server to release locks
+  /// or other resources sooner than if it was not called.
+  func abort() throws
+}
diff --git a/lib/Syncbase/Blob.swift b/lib/Syncbase/Blob.swift
new file mode 100644
index 0000000..9562fe2
--- /dev/null
+++ b/lib/Syncbase/Blob.swift
@@ -0,0 +1,135 @@
+// 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.
+
+import Foundation
+
+/// BlobRef is a reference to a blob.
+public typealias BlobRef = String
+
+public enum BlobDevType: Int {
+  /// Blobs migrate toward servers, which store them.  (example: server in cloud)
+  case BlobDevTypeServer = 0
+  /// Ordinary devices (example: laptop)
+  case BlobDevTypeNormal = 1
+  /// Blobs migrate from leaves, which have less storage (examples: a camera, phone)
+  case BlobDevTypeLeaf = 2
+}
+
+let kNullBlobRef = BlobRef("")
+
+/// Blob is the interface for a Blob in the store.
+public protocol Blob {
+  /// Ref returns Syncbase's BlobRef for this blob.
+  func ref() -> BlobRef
+
+  /// Put appends the byte stream to the blob.
+  func put() throws -> BlobWriter
+
+  /// Commit marks the blob as immutable.
+  func commit() throws
+
+  /// Size returns the count of bytes written as part of the blob
+  /// (committed or uncommitted).
+  func size() throws -> Int64
+
+  /// Delete locally deletes the blob (committed or uncommitted).
+  func delete() throws
+
+  /// Get returns the byte stream from a committed blob starting at offset.
+  func get(offset: Int64) throws -> BlobReader
+
+  /// Fetch initiates fetching a blob if not locally found. priority
+  /// controls the network priority of the blob. Higher priority blobs are
+  /// fetched before the lower priority ones. However an ongoing blob
+  /// transfer is not interrupted. Status updates are streamed back to the
+  /// client as fetch is in progress.
+  func fetch(priority: UInt64) throws -> BlobStatus
+
+  /// Pin locally pins the blob so that it is not evicted.
+  func pin() throws
+
+  /// Unpin locally unpins the blob so that it can be evicted if needed.
+  func unpin() throws
+
+  /// Keep locally caches the blob with the specified rank. Lower
+  /// ranked blobs are more eagerly evicted.
+  func keep(rank: UInt64) throws
+}
+
+/// BlobWriter is an interface for putting a blob.
+public protocol BlobWriter {
+  /// Send places the bytes given by the client onto the output
+  /// stream. Returns throwss encountered while sending. Blocks if there is
+  /// no buffer space.
+  func Send(data: NSData) throws
+
+  /// Close indicates that no more bytes will be sent.
+  func Close() throws
+}
+
+/// BlobReader is an interface for getting a blob.
+public protocol BlobReader {
+  /// Advance() stages bytes so that they may be retrieved via
+  /// Value(). Returns true iff there are bytes to retrieve. Advance() must
+  /// be called before Value() is called. The caller is expected to read
+  /// until Advance() returns false, or to call Cancel().
+  func advance() -> Bool
+
+  /// Value() returns the bytes that were staged by Advance(). May panic if
+  /// Advance() returned false or was not called. Never blocks.
+  func value() -> NSData
+
+  /// Err() returns any throws encountered by Advance. Never blocks.
+  func err() throws
+
+  /// Cancel notifies the stream provider that it can stop producing
+  /// elements.  The client must call Cancel if it does not iterate through
+  /// all elements (i.e. until Advance returns false). Cancel is idempotent
+  /// and can be called concurrently with a goroutine that is iterating via
+  /// Advance.  Cancel causes Advance to subsequently return false. Cancel
+  /// does not block.
+  func cancel()
+}
+
+/// BlobStatus is an interface for getting the status of a blob transfer.
+public protocol BlobStatus {
+  /// Advance() stages an item so that it may be retrieved via
+  /// Value(). Returns true iff there are items to retrieve. Advance() must
+  /// be called before Value() is called. The caller is expected to read
+  /// until Advance() returns false, or to call Cancel().
+  func advance() -> Bool
+
+  /// Value() returns the item that was staged by Advance(). May panic if
+  /// Advance() returned false or was not called. Never blocks.
+  func value() -> BlobFetchStatus
+
+  /// Err() returns any throws encountered by Advance. Never blocks.
+  func err() -> SyncbaseError?
+
+  /// Cancel notifies the stream provider that it can stop producing
+  /// elements.  The client must call Cancel if it does not iterate through
+  /// all elements (i.e. until Advance returns false). Cancel is idempotent
+  /// and can be called concurrently with a goroutine that is iterating via
+  /// Advance.  Cancel causes Advance to subsequently return false. Cancel
+  /// does not block.
+  func cancel()
+}
+
+//// BlobFetchStatus describes the progress of an asynchronous blob fetch.
+public struct BlobFetchStatus {
+  //// State of the blob fetch request.
+  public let state: BlobFetchState
+  //// Total number of bytes received.
+  public let received: Int64
+  //// Blob size.
+  public let total: Int64
+}
+
+public enum BlobFetchState: Int {
+  case BlobFetchStatePending = 0
+  case BlobFetchStateLocating
+  case BlobFetchStateFetching
+  case BlobFetchStateDone
+}
+
diff --git a/lib/Syncbase/Collection.swift b/lib/Syncbase/Collection.swift
new file mode 100644
index 0000000..a889704
--- /dev/null
+++ b/lib/Syncbase/Collection.swift
@@ -0,0 +1,110 @@
+/// 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.
+
+import Foundation
+
+/// CollectionRow encapsulates a collection id and row key or row prefix.
+public struct CollectionRow {
+  let collectionId: CollectionId
+  let row: String
+}
+
+/// SyncgroupMemberInfo contains per-member metadata.
+public struct SyncgroupMemberInfo {
+  let syncPriority: UInt8
+  let blobDevType: BlobDevType /// See BlobDevType* constants.
+}
+
+/// Collection represents a set of Rows.
+///
+/// TODO(sadovsky): Currently we provide Get/Put/Delete methods on both
+/// Collection and Row, because we're not sure which will feel more natural.
+/// Eventually, we'll need to pick one.
+public protocol Collection {
+  /// Id returns the id of this Collection.
+  var collectionId: CollectionId { get }
+
+  /// FullName returns the object name (encoded) of this Collection.
+  var fullName: String { get }
+
+  /// Exists returns true only if this Collection exists. Insufficient
+  /// permissions cause Exists to return false instead of an throws.
+  /// TODO(ivanpi): Exists may fail with an throws if higher levels of hierarchy
+  /// do not exist.
+  func exists() throws -> Bool
+
+  /// Create creates this Collection.
+  /// TODO(sadovsky): Specify what happens if perms is nil.
+  func create(permissions: Permissions) throws
+
+  /// Destroy destroys this Collection, permanently removing all of its data.
+  /// TODO(sadovsky): Specify what happens to syncgroups.
+  func destroy() throws
+
+  /// GetPermissions returns the current Permissions for the Collection.
+  /// The Read bit on the ACL does not affect who this Collection's rows are
+  /// synced to; all members of syncgroups that include this Collection will
+  /// receive the rows in this Collection. It only determines which clients
+  /// are allowed to retrieve the value using a Syncbase RPC.
+  func getPermissions() throws -> Permissions
+
+  /// SetPermissions replaces the current Permissions for the Collection.
+  func setPermissions(permissions: Permissions) throws
+
+  /// Row returns the Row with the given key.
+  func row(key: String) -> Row
+
+  /**
+   Get loads the value stored under the given key into inout parameter value.
+
+   Sets value to nil if nothing is stored undeder the given key.
+
+   By passing the typed target output value using inout, get is able to cast the value to the
+   desired type automatically. If the types do not match, an exception is thrown.
+
+   For example:
+
+   ```
+   /// Using inout
+   var isRed: Bool?
+   try collection.get("isRed", &isRed)
+
+   /// Using return value
+   let isRed: Bool = try collection.get("isRed")
+   ```
+   */
+  func get<T: SyncbaseJsonConvertible>(key: String, inout value: T?) throws
+
+  /// Get loads the value stored under the given key.
+  func get<T: SyncbaseJsonConvertible>(key: String) throws -> T?
+
+  /// Put writes the given value to this Collection under the given key.
+  func put(key: String, value: SyncbaseJsonConvertible) throws
+
+  /// Delete deletes the row for the given key.
+  func delete(key: String) throws
+
+  /// DeleteRange deletes all rows in the given half-open range [start, limit).
+  /// If limit is "", all rows with keys >= start are included.
+  /// TODO(sadovsky): Document how this deletion is considered during conflict
+  /// detection: is it considered as a range deletion, or as a bunch of point
+  /// deletions?
+  /// See helpers Prefix(), Range(), SingleRow().
+  func deleteRange(r: RowRange) throws
+
+  /// Scan returns all rows in the given half-open range [start, limit). If limit
+  /// is "", all rows with keys >= start are included.
+  /// Concurrency semantics: It is legal to perform writes concurrently with
+  /// Scan. The returned stream reads from a consistent snapshot taken at the
+  /// time of the RPC (or at the time of BeginBatch, if in a batch), and will not
+  /// reflect subsequent writes to keys not yet reached by the stream.
+  /// See helpers Prefix(), Range(), SingleRow().
+  func scan(r: RowRange) -> ScanStream
+}
+
+/// Returns the decoded value, or throws an error if the value could not be decoded.
+public typealias GetValueFromScanStream = () throws -> SyncbaseJsonConvertible
+
+/// Stream resulting from a scan on a scollection for a given row range.
+public typealias ScanStream = AnonymousStream<(String, GetValueFromScanStream)>
diff --git a/lib/Syncbase/Database.swift b/lib/Syncbase/Database.swift
new file mode 100644
index 0000000..d6801e4
--- /dev/null
+++ b/lib/Syncbase/Database.swift
@@ -0,0 +1,107 @@
+// 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.
+
+import Foundation
+
+/// DatabaseHandle is the set of methods that work both with and without a batch.
+/// It allows clients to pass the handle to helper methods that are batch-agnostic.
+public protocol DatabaseHandle {
+  /// Id returns the id of this DatabaseHandle..
+  var databaseId: DatabaseId { get }
+
+  /// FullName returns the object name (encoded) of this DatabaseHandle.
+  var fullName: String { get }
+
+  /// Collection returns the Collection with the given relative name.
+  /// The user blessing is derived from the context.
+  func collection(name: String) -> Collection?
+
+  /// CollectionForId returns the Collection with the given user blessing and name.
+  func collection(collectionId: CollectionId) -> Collection?
+
+  /// ListCollections returns a list of all Collection ids that the caller is
+  /// allowed to see. The list is sorted by blessing, then by name.
+  func listCollections() throws -> [CollectionId]
+
+  /// Returns a ResumeMarker that points to the current end of the event log.
+  func getResumeMarker() throws -> ResumeMarker
+}
+
+public protocol Database: DatabaseHandle, AccessController {
+  /// Create creates this Database.
+  /// TODO(sadovsky): Specify what happens if perms is nil.
+  func create(permissions: Permissions?) throws
+
+  /// Destroy destroys this Database, permanently removing all of its data.
+  /// TODO(sadovsky): Specify what happens to syncgroups.
+  func destroy() throws
+
+  // Exists returns true only if this Database exists. Insufficient permissions
+  // cause Exists to return false instead of an error.
+  func exists() throws -> Bool
+
+  /** BeginBatch creates a new batch. Instead of calling this function directly,
+   clients are encouraged to use the RunInBatch() helper function, which
+   detects "concurrent batch" errors and handles retries internally.
+
+   Default concurrency semantics:
+
+   - Reads (e.g. gets, scans) inside a batch operate over a consistent
+   snapshot taken during BeginBatch(), and will see the effects of prior
+   writes performed inside the batch.
+
+   - Commit() may fail with ErrConcurrentBatch, indicating that after
+   BeginBatch() but before Commit(), some concurrent routine wrote to a key
+   that matches a key or row-range read inside this batch.
+
+   - Other methods will never fail with error ErrConcurrentBatch, even if it
+   is known that Commit() will fail with this error.
+
+   Once a batch has been committed or aborted, subsequent method calls will
+   fail with no effect.
+
+   Concurrency semantics can be configured using BatchOptions.
+   TODO(sadovsky): Use varargs for options.
+   */
+  func beginBatch(options: BatchOptions?) throws -> BatchDatabase
+
+  /// Watch allows a client to watch for updates to the database. For each watch
+  /// request, the client will receive a reliable stream of watch events without
+  /// reordering. See watch.GlobWatcher for a detailed explanation of the
+  /// behavior.
+  ///
+  /// If a nil ResumeMarker is provided, the WatchStream will begin with a Change
+  /// batch containing the initial state. Otherwise, the WatchStream will contain
+  /// only changes since the provided ResumeMarker.
+  ///
+  /// TODO(sadovsky): Watch should return just a WatchStream, similar to how Scan
+  /// returns just a ScanStream.
+  func watch(collection: CollectionId, prefix: String, resumeMarker: ResumeMarker?) throws -> WatchStream
+
+  /// Syncgroup returns a handle to the syncgroup with the given name.
+  func syncgroup(sgName: String) -> Syncgroup
+
+  /// GetSyncgroupNames returns the names of all syncgroups attached to this
+  /// database.
+  /// TODO(sadovsky): Rename to ListSyncgroups, for parity with ListDatabases.
+  func getSyncgroupNames() throws -> [String]
+
+  /// CreateBlob creates a new blob and returns a handle to it.
+  func createBlob() throws -> Blob
+
+  /// Blob returns a handle to the blob with the given BlobRef.
+  func blob(blobRef: BlobRef) -> Blob
+
+  /// PauseSync pauses sync for this database. Incoming sync, as well as outgoing
+  /// sync of subsequent writes, will be disabled until ResumeSync is called.
+  /// PauseSync is idempotent.
+  func pauseSync() throws
+
+  /// ResumeSync resumes sync for this database. ResumeSync is idempotent.
+  func resumeSync() throws
+
+  /// Close cleans up any state associated with this database handle, including
+  /// closing the conflict resolution stream (if open).
+  func close()
+}
diff --git a/lib/Syncbase/Errors.swift b/lib/Syncbase/Errors.swift
new file mode 100644
index 0000000..95bd8ac
--- /dev/null
+++ b/lib/Syncbase/Errors.swift
@@ -0,0 +1,34 @@
+// 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.
+
+import Foundation
+
+public enum SyncbaseError: ErrorType, CustomStringConvertible {
+  case NotInDevMode
+  case UnknownBatch
+  case NotBoundToBatch
+  case ReadOnlyBatch
+  case ConcurrentBatch
+  case BlobNotCommitted
+  case SyncgroupJoinFailed
+  case BadExecStreamHeader
+  case InvalidName(name: String)
+  case CorruptDatabase(path: String)
+
+  public var description: String {
+    switch (self) {
+    case NotInDevMode: return "not running with --dev=true"
+    case UnknownBatch: return "unknown batch, perhaps the server restarted"
+    case NotBoundToBatch: return "not bound to batch"
+    case ReadOnlyBatch: return "batch is read-only"
+    case ConcurrentBatch: return "concurrent batch"
+    case BlobNotCommitted: return "blob is not yet committed"
+    case SyncgroupJoinFailed: return "syncgroup join failed"
+    case BadExecStreamHeader: return "Exec stream header improperly formatted"
+    case InvalidName(let name): return "invalid name: \(name)"
+    case CorruptDatabase(let path):
+      return "database corrupt, moved to path \(path); client must create a new database"
+    }
+  }
+}
\ No newline at end of file
diff --git a/lib/Syncbase/Id.swift b/lib/Syncbase/Id.swift
new file mode 100644
index 0000000..aefec42
--- /dev/null
+++ b/lib/Syncbase/Id.swift
@@ -0,0 +1,15 @@
+// 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.
+
+import Foundation
+
+public struct DatabaseId {
+  let name: String
+  let blessing: String
+}
+
+public struct CollectionId {
+  let name: String
+  let blessing: String
+}
diff --git a/lib/Syncbase/Marshal.swift b/lib/Syncbase/Marshal.swift
new file mode 100644
index 0000000..b9c74dc
--- /dev/null
+++ b/lib/Syncbase/Marshal.swift
@@ -0,0 +1,201 @@
+// 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.
+
+import Foundation
+
+public enum JsonErrors: ErrorType {
+  case ArrayContainsInvalidTypes
+  case DictionaryContainsInvalidTypes
+  case CastError(value: Any, target: Any)
+  case EncodingError
+}
+
+public enum JsonDataType: Int {
+  case Bool = 0,
+    Int, Int8, Int16, Int32, Int64,
+    UInt, UInt8, UInt16, UInt32, UInt64,
+    Float, Double,
+    String,
+    Array, Dictionary,
+    RawJson
+}
+
+public protocol SyncbaseJsonConvertible {
+  func toSyncbaseJson() throws -> (NSData, JsonDataType)
+}
+
+/// Serializes primitives to JSON using Apple's NSJSONSerializer. This function gets around
+/// Apple's limitation of requiring top
+private func hackNSJsonSerializer(obj: AnyObject) throws -> NSData {
+  var data: NSData?
+  try SyncbaseUtil.catchObjcException {
+    data = try? NSJSONSerialization.dataWithJSONObject([obj], options: [])
+  }
+  // Hack of first and last runes, which also happen to be single byte UTF8s
+  guard data != nil else {
+    throw JsonErrors.EncodingError
+  }
+  return data!.subdataWithRange(NSMakeRange(1, data!.length - 2))
+}
+
+extension Bool: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.Bool)
+  }
+}
+
+// Wish we could put an extension on a protocol like IntegerLiterableConvertable or IntegerType
+// but we can't as of Swift 2.2, so we enumerate all the possiblities
+
+extension Int: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.Int)
+  }
+}
+
+extension Int8: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(Int(self)), JsonDataType.Int8)
+  }
+}
+
+extension Int16: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(Int(self)), JsonDataType.Int16)
+  }
+}
+
+extension Int32: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(Int(self)), JsonDataType.Int32)
+  }
+}
+
+extension Int64: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(NSNumber(longLong: self)), JsonDataType.Int64)
+  }
+}
+
+extension UInt: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.UInt)
+  }
+}
+
+extension UInt8: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(UInt(self)), JsonDataType.UInt8)
+  }
+}
+
+extension UInt16: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(UInt(self)), JsonDataType.UInt16)
+  }
+}
+
+extension UInt32: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(UInt(self)), JsonDataType.UInt32)
+  }
+}
+
+extension UInt64: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(NSNumber(unsignedLongLong: self)), JsonDataType.UInt64)
+  }
+}
+
+extension Float: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.Float)
+  }
+}
+
+extension Double: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.Double)
+  }
+}
+
+extension String: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try hackNSJsonSerializer(self), JsonDataType.String)
+  }
+}
+
+// Wish we could do this:
+// extension Array : SyncbaseJsonConvertible where Element: AnyObject {
+// but it's not valid Swift 2.2
+
+extension Array where Element: AnyObject {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try! NSJSONSerialization.dataWithJSONObject(self, options: []), JsonDataType.Array)
+  }
+}
+
+extension NSArray: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try! NSJSONSerialization.dataWithJSONObject(self, options: []), JsonDataType.Array)
+  }
+}
+
+extension NSDictionary: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (try! NSJSONSerialization.dataWithJSONObject(self, options: []), JsonDataType.Dictionary)
+  }
+}
+
+// Annoyingly we can't directly cast an Array that we have no type information on into an AnyObject
+// or similarly the same for Dictionary. So instead we're forced to copy all the elements and test
+// all individual types inside.
+extension Array: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    let copy: [AnyObject] = try self.map { elem in
+      guard let jsonable = elem as? AnyObject else {
+        throw JsonErrors.ArrayContainsInvalidTypes
+      }
+      return jsonable
+    }
+    var data: NSData?
+    try SyncbaseUtil.catchObjcException {
+      data = try? NSJSONSerialization.dataWithJSONObject(copy, options: [])
+    }
+    guard data != nil else {
+      throw JsonErrors.EncodingError
+    }
+    return (data!, JsonDataType.Array)
+  }
+}
+
+extension Dictionary: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    let copy = NSMutableDictionary()
+    try self.forEach { (key, value) in
+      guard let strKey = key as? String else {
+        throw JsonErrors.DictionaryContainsInvalidTypes
+      }
+      guard let jsonable = value as? AnyObject else {
+        throw JsonErrors.DictionaryContainsInvalidTypes
+      }
+      copy[strKey] = jsonable
+    }
+
+    var data: NSData?
+    try SyncbaseUtil.catchObjcException {
+      data = try? NSJSONSerialization.dataWithJSONObject(copy, options: [])
+    }
+    guard data != nil else {
+      throw JsonErrors.EncodingError
+    }
+    return (data!, JsonDataType.Dictionary)
+  }
+}
+
+extension NSData: SyncbaseJsonConvertible {
+  public func toSyncbaseJson() throws -> (NSData, JsonDataType) {
+    return (self, JsonDataType.RawJson)
+  }
+}
diff --git a/lib/Syncbase/Permissions.swift b/lib/Syncbase/Permissions.swift
new file mode 100644
index 0000000..0c8b356
--- /dev/null
+++ b/lib/Syncbase/Permissions.swift
@@ -0,0 +1,64 @@
+// 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.
+
+import Foundation
+
+/// Permissions maps string tags to access lists specifying the blessings
+/// required to invoke methods with that tag.
+///
+/// These tags are meant to add a layer of interposition between the set of
+/// users (blessings, specifically) and the set of methods, much like "Roles" do
+/// in Role Based Access Control.
+/// (http://en.wikipedia.org/wiki/Role-based_access_control)
+public typealias Permissions = [String: BlessingPattern]
+
+/// BlessingPattern is a pattern that is matched by specific blessings.
+///
+/// A pattern can either be a blessing (slash-separated human-readable string)
+/// or a blessing ending in "/$". A pattern ending in "/$" is matched exactly
+/// by the blessing specified by the pattern string with the "/$" suffix stripped
+/// out. For example, the pattern "a/b/c/$" is matched by exactly by the blessing
+/// "a/b/c".
+///
+/// A pattern not ending in "/$" is more permissive, and is also matched by blessings
+/// that are extensions of the pattern (including the pattern itself). For example, the
+/// pattern "a/b/c" is matched by the blessings "a/b/c", "a/b/c/x", "a/b/c/x/y", etc.
+public typealias BlessingPattern = String
+
+public typealias PermissionsVersion = String
+
+/// AccessList represents a set of blessings that should be granted access.
+///
+/// See also: https://vanadium.github.io/glossary.html#access-list
+public struct AcccessList {
+  /// allowed denotes the set of blessings (represented as BlessingPatterns) that
+  /// should be granted access, unless blacklisted by an entry in notAllowed.
+  ///
+  /// For example:
+  /// allowed: {"alice:family"}
+  /// grants access to a principal that presents at least one of
+  /// "alice:family", "alice:family:friend", "alice:family:friend:spouse" etc.
+  /// as a blessing.
+  public let allowed: [BlessingPattern]
+
+  /// notAllowed denotes the set of blessings (and their delegates) that
+  /// have been explicitly blacklisted from the allowed set.
+  ///
+  /// For example:
+  /// allowed: {"alice:friend"}, notAllowed: {"alice:friend:bob"}
+  /// grants access to principals that present "alice:friend",
+  /// "alice:friend:carol" etc. but NOT to a principal that presents
+  /// "alice:friend:bob" or "alice:friend:bob:spouse" etc.
+  public let notAllowed: [BlessingPattern]
+}
+
+/// AccessController provides access control for various syncbase objects.
+public protocol AccessController {
+  /// setPermissions replaces the current Permissions for an object.
+  func setPermissions(perms: Permissions, version: PermissionsVersion) throws
+
+  /// GetPermissions returns the current Permissions for an object.
+  /// For detailed documentation, see Object.GetPermissions.
+  func getPermissions() throws -> (Permissions, PermissionsVersion)
+}
diff --git a/lib/Syncbase/Row.swift b/lib/Syncbase/Row.swift
new file mode 100644
index 0000000..556c7c8
--- /dev/null
+++ b/lib/Syncbase/Row.swift
@@ -0,0 +1,101 @@
+// 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.
+
+import Foundation
+
+public protocol Row {
+  /// Key returns the key for this Row.
+  var key: String { get }
+
+  /// FullName returns the object name (encoded) of this Row.
+  var fullName: String { get }
+
+  /// Exists returns true only if this Row exists. Insufficient permissions cause
+  /// Exists to return false instead of an error.
+  /// TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+  /// do not exist.
+  func exists() throws -> Bool
+
+  /**
+   Get loads the value stored in this Row into the given value. If the given
+   value's type does not match the stored value's type, get will throw an error.
+
+   Expected usage:
+
+   ```
+   var isRed: Bool?
+   try row.get(&isRed)
+   ```
+   */
+  func get<T: SyncbaseJsonConvertible>(inout value: T?) throws
+
+  /**
+   Get returns the value stored in this Row. If the given value's type does not match the
+   requested generic type, get will throw an error.
+
+   Expected usage:
+
+   ```
+   let isRed: Bool? = try row.get()
+   ```
+   */
+  func get<T: SyncbaseJsonConvertible>() throws -> T?
+
+  /// Put writes the given value for this Row.
+  func put(value: SyncbaseJsonConvertible) throws
+
+  /// Delete deletes this Row.
+  func delete() throws
+}
+
+/// RowRange represents all rows with keys in [start, limit).
+/// If limit is "", all rows with keys >= start are included.
+public protocol RowRange {
+  var start: String { get }
+  /// If limit is "", all rows with keys >= start are included.
+  var limit: String { get }
+}
+
+/// StandardRowRange represents all rows with keys in [start, limit).
+/// If limit is "", all rows with keys >= start are included.
+public struct StandardRowRange: RowRange {
+  public let start: String
+  /// If limit is "", all rows with keys >= start are included.
+  public let limit: String
+}
+
+public struct SingleRow: RowRange {
+  public let row: String
+
+  public var start: String {
+    return row
+  }
+
+  public var limit: String {
+    return row + "\0"
+  }
+}
+
+/// PrefixRange represents all rows with keys that have some prefix.
+public struct PrefixRange: RowRange {
+  public let prefix: String
+
+  /// Returns the start of the row range for the given prefix.
+  public var start: String {
+    return prefix
+  }
+
+  public var limit: String {
+    var utf8 = Array(prefix.utf8)
+    while utf8.count > 0 {
+      if utf8.last! == 255 {
+        utf8.removeLast() // chop off what would otherwise be a trailing \x00
+      } else {
+        utf8[utf8.count - 1] += 1 // add 1
+        break // no carry
+      }
+    }
+    return String(bytes: utf8, encoding: NSUTF8StringEncoding)!
+  }
+}
diff --git a/lib/Syncbase/Security.swift b/lib/Syncbase/Security.swift
index 34e1d8d..83d6e92 100644
--- a/lib/Syncbase/Security.swift
+++ b/lib/Syncbase/Security.swift
@@ -8,10 +8,10 @@
 import VanadiumCore
 
 public protocol VanadiumBlesser {
-  func blessingsFromGoogle(googleOauthToken:String) -> Promise<NSData>
+  func blessingsFromGoogle(googleOauthToken: String) -> Promise<NSData>
 }
 
-enum VanadiumUrls : String, URLStringConvertible {
+enum VanadiumUrls: String, URLStringConvertible {
   case DevBlessings = "https://dev.v.io/auth/google/bless"
 
   var URLString: String {
@@ -19,30 +19,30 @@
   }
 }
 
-enum BlessingOutputFormat : String {
+enum BlessingOutputFormat: String {
   case Base64VOM = "base64vom"
 }
 
-public enum VanadiumBlesserError : ErrorType {
+public enum VanadiumBlesserError: ErrorType {
   case EmptyResult
-  case NotBase64Encoded(invalid:String)
+  case NotBase64Encoded(invalid: String)
 }
 
 public extension VanadiumBlesser {
-  public func blessingsFromGoogle(googleOauthToken:String) -> Promise<NSData> {
+  public func blessingsFromGoogle(googleOauthToken: String) -> Promise<NSData> {
     // Make sure the Syncbase instance exists, which inits V23
     let _ = Syncbase.instance
     let p = Promise<NSData>()
     do {
-      let params:[String:AnyObject] = [
-          "token": googleOauthToken,
-          "public_key": try VanadiumCore.Principal.publicKey(),
-          "output_format": BlessingOutputFormat.Base64VOM.rawValue]
+      let params: [String: AnyObject] = [
+        "token": googleOauthToken,
+        "public_key": try VanadiumCore.Principal.publicKey(),
+        "output_format": BlessingOutputFormat.Base64VOM.rawValue]
       let request = Alamofire.request(.GET,
-                        VanadiumUrls.DevBlessings,
-                        parameters: params,
-                        encoding: ParameterEncoding.URLEncodedInURL,
-                        headers:nil)
+        VanadiumUrls.DevBlessings,
+        parameters: params,
+        encoding: ParameterEncoding.URLEncodedInURL,
+        headers: nil)
       request.responseString { resp in
         guard let base64 = resp.result.value else {
           if let err = resp.result.error {
@@ -72,10 +72,10 @@
 }
 
 public protocol OAuthCredentials {
-  var oauthToken:String { get }
+  var oauthToken: String { get }
 }
 
-public struct GoogleCredentials : OAuthCredentials, VanadiumBlesser {
+public struct GoogleCredentials: OAuthCredentials, VanadiumBlesser {
   public let oauthToken: String
 
   public init(oauthToken: String) {
diff --git a/lib/Syncbase/Service.swift b/lib/Syncbase/Service.swift
new file mode 100644
index 0000000..d91508a
--- /dev/null
+++ b/lib/Syncbase/Service.swift
@@ -0,0 +1,22 @@
+// 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.
+
+import Foundation
+
+/// Service represents a Vanadium Syncbase service.
+public protocol Service: AccessController {
+  /// FullName returns the object name (encoded) of this Service.
+  var fullName: String { get }
+
+  /// DatabaseForId returns the Database with the given app blessing and name (from the Id struct).
+  /// This is equivalent to calling database(id.name, id.blessing)
+  func database(databaseId: DatabaseId) -> Database
+
+  /// DatabaseForId returns the Database with the given name and app blessing.
+  func database(name: String) throws -> Database
+
+  /// ListDatabases returns a list of all Database ids that the caller is allowed to see.
+  /// The list is sorted by blessing, then by name.
+  func listDatabases() throws -> [DatabaseId]
+}
diff --git a/lib/Syncbase/Stream.swift b/lib/Syncbase/Stream.swift
new file mode 100644
index 0000000..6d13773
--- /dev/null
+++ b/lib/Syncbase/Stream.swift
@@ -0,0 +1,72 @@
+// 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.
+
+import Foundation
+
+/// Base protocol for iterating through elements of unknown length.
+public protocol Stream: GeneratorType {
+  /// Err returns a non-nil error iff the stream encountered any errors. Err does
+  /// not block.
+  func err() -> SyncbaseError?
+
+  /// Cancel notifies the stream provider that it can stop producing elements.
+  /// The client must call Cancel if it does not iterate through all elements
+  /// (i.e. until Advance returns false). Cancel is idempotent and can be called
+  /// concurrently with a goroutine that is iterating via Advance.
+  /// Cancel causes Advance to subsequently return false. Cancel does not block.
+  mutating func cancel()
+}
+
+/// Typed-stream backed by anonymous callbacks
+public struct AnonymousStream<T>: Stream {
+  public typealias Element = T
+  public typealias FetchNextFunction = Void -> (T?, SyncbaseError?)
+  let fetchNextFunction: FetchNextFunction
+  public typealias CancelFunction = Void -> Void
+  let cancelFunction: CancelFunction
+  private var lastErr: SyncbaseError?
+  private var isCancelled: Bool = false
+  internal init(fetchNextFunction: FetchNextFunction, cancelFunction: CancelFunction) {
+    self.fetchNextFunction = fetchNextFunction
+    self.cancelFunction = cancelFunction
+  }
+
+  /// Advance to the next element and return it, or `nil` if no next
+  /// element exists.
+  ///
+  /// - Requires: `next()` has not been applied to a copy of `self`
+  /// since the copy was made, and no preceding call to `self.next()`
+  /// has returned `nil`.  Specific implementations of this protocol
+  /// are encouraged to respond to violations of this requirement by
+  /// calling `preconditionFailure("...")`.
+  public mutating func next() -> T? {
+    guard !isCancelled else {
+      return nil
+    }
+    let (result, err) = fetchNextFunction()
+    if let ret = result {
+      return ret
+    }
+    lastErr = err
+    return nil
+  }
+
+  /// Err returns a non-nil error iff the stream encountered any errors. Err does
+  /// not block.
+  public func err() -> SyncbaseError? {
+    return lastErr
+  }
+
+  /// Cancel notifies the stream provider that it can stop producing elements.
+  /// The client must call Cancel if it does not iterate through all elements
+  /// (i.e. until Advance returns false). Cancel is idempotent and can be called
+  /// concurrently with a goroutine that is iterating via Advance.
+  /// Cancel causes Advance to subsequently return false. Cancel does not block.
+  public mutating func cancel() {
+    if !isCancelled {
+      cancelFunction()
+      isCancelled = true
+    }
+  }
+}
diff --git a/lib/Syncbase/Syncbase.h b/lib/Syncbase/Syncbase.h
index 514ed51..8e90958 100644
--- a/lib/Syncbase/Syncbase.h
+++ b/lib/Syncbase/Syncbase.h
@@ -9,3 +9,5 @@
 
 //! Project version string for Syncbase.
 FOUNDATION_EXPORT const unsigned char SyncbaseVersionString[];
+
+#import "Util.h"
\ No newline at end of file
diff --git a/lib/Syncbase/Syncbase.swift b/lib/Syncbase/Syncbase.swift
index 66056f0..3681463 100644
--- a/lib/Syncbase/Syncbase.swift
+++ b/lib/Syncbase/Syncbase.swift
@@ -3,44 +3,80 @@
 // license that can be found in the LICENSE file.
 
 import Foundation
-
 import VanadiumCore
 
-public let instance = Syncbase.instance
+//public let instance = Syncbase.instance
 
-public class Syncbase {
-  private static var _instance: Syncbase? = nil
+public struct Syncbase: Service {
+  // TODO(zinman): Figure out what the local name is supposed to be be
+  private static let kLocalName = ""
+  public let fullName: String
+  private static var _localInstance: Syncbase? = nil
 
-  /// The singleton instance of Syncbase. This is the primary class that houses the simplified
-  /// API.
+  /// The singleton instance of Syncbase that represents the local store. This is the primary
+  /// Syncbase client you want to work with, unless you explicitly want to connect to a remote
+  /// Syncbase via RPC (then use the constructor with its object name passed)
   ///
   /// You won't be able to sync with anybody unless you grant yourself a blessing via the authorize
   /// method.
   public static var instance: Syncbase {
     get {
-      if (_instance == nil) {
+      if (_localInstance == nil) {
         do {
-          _instance = try Syncbase()
+          _localInstance = try Syncbase(fullName: kLocalName)
         } catch let err {
           VanadiumCore.log.warning("Couldn't instantiate an instance of Syncbase: \(err)")
         }
       }
-      return _instance!
+      return _localInstance!
     }
+
     set {
-      if (_instance != nil) {
-        fatalError("You cannot create another instance of V23")
+      if (_localInstance != nil) {
+        fatalError("You cannot create another local instance of Syncbase")
       }
-      _instance = newValue
+      _localInstance = newValue
     }
   }
 
-  /// Private constructor for V23.
-  private init() throws {
-    try V23.configure()
+  /**
+   Returns a new client handle to a syncbase service running at the given name. The common scenario
+   is to only use Syncbase.instance for the local store -- this constructor is used for connecting
+   to remote Syncbases.
+
+   - Parameter fullName: full (i.e., object) name of the syncbase service
+   */
+  public init(fullName: String) throws {
+    self.fullName = fullName
+    // STUB
   }
 
-  deinit {
+  /// Create a database using the relative name and user's blessings.
+  public func database(name: String) throws -> Database {
+    return database(DatabaseId(name: name, blessing: try Principal.blessingsDebugString()))
+  }
 
+  /// DatabaseForId returns the Database with the given app blessing and name (from the Id struct).
+  public func database(databaseId: DatabaseId) -> Database {
+    preconditionFailure("Implement me")
+  }
+
+  /// ListDatabases returns a list of all Database ids that the caller is allowed to see.
+  /// The list is sorted by blessing, then by name.
+  public func listDatabases() throws -> [DatabaseId] {
+    preconditionFailure("Implement me")
+  }
+}
+
+extension Syncbase: AccessController {
+  /// setPermissions replaces the current Permissions for an object.
+  public func setPermissions(perms: Permissions, version: PermissionsVersion) throws {
+    preconditionFailure("Implement me")
+  }
+
+  /// getPermissions returns the current Permissions for an object.
+  /// For detailed documentation, see Object.GetPermissions.
+  public func getPermissions() throws -> (Permissions, PermissionsVersion) {
+    preconditionFailure("Implement me")
   }
 }
diff --git a/lib/Syncbase/Syncgroup.swift b/lib/Syncbase/Syncgroup.swift
new file mode 100644
index 0000000..8ea8352
--- /dev/null
+++ b/lib/Syncbase/Syncgroup.swift
@@ -0,0 +1,89 @@
+// 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.
+
+import Foundation
+
+public struct VersionedSpec {
+  let spec: SyncgroupSpec
+  let version: String
+}
+
+public protocol Syncgroup {
+  /// Create creates a new syncgroup with the given spec.
+  ///
+  /// Requires: Client must have at least Read access on the Database; all
+  /// Collections specified in prefixes must exist; Client must have at least
+  /// Read access on each of the Collection ACLs.
+  func create(spec: SyncgroupSpec, myInfo: SyncgroupMemberInfo) throws
+
+  /// Join joins a syncgroup.
+  ///
+  /// Requires: Client must have at least Read access on the Database and on the
+  /// syncgroup ACL.
+  func join(myInfo: SyncgroupMemberInfo) throws -> SyncgroupSpec
+
+  /// Leave leaves the syncgroup. Previously synced data will continue
+  /// to be available.
+  ///
+  /// Requires: Client must have at least Read access on the Database.
+  func leave() throws
+
+  /// Destroy destroys the syncgroup. Previously synced data will
+  /// continue to be available to all members.
+  ///
+  /// Requires: Client must have at least Read access on the Database, and must
+  /// have Admin access on the syncgroup ACL.
+  func destroy() throws
+
+  /// Eject ejects a member from the syncgroup. The ejected member
+  /// will not be able to sync further, but will retain any data it has already
+  /// synced.
+  ///
+  /// Requires: Client must have at least Read access on the Database, and must
+  /// have Admin access on the syncgroup ACL.
+  func eject(member: String) throws
+
+  /// GetSpec gets the syncgroup spec. version allows for atomic
+  /// read-modify-write of the spec - see comment for SetSpec.
+  ///
+  /// Requires: Client must have at least Read access on the Database and on the
+  /// syncgroup ACL.
+  func getSpec() throws -> VersionedSpec
+
+  /// SetSpec sets the syncgroup spec. version may be either empty or
+  /// the value from a previous Get. If not empty, Set will only succeed if the
+  /// current version matches the specified one.
+  ///
+  /// Requires: Client must have at least Read access on the Database, and must
+  /// have Admin access on the syncgroup ACL.
+  func setSpec(versionedSpec: VersionedSpec) throws
+
+  /// GetMembers gets the info objects for members of the syncgroup.
+  ///
+  /// Requires: Client must have at least Read access on the Database and on the
+  /// syncgroup ACL.
+  func getMembers() throws -> [String: SyncgroupMemberInfo]
+}
+
+public struct SyncgroupSpec {
+  /// Human-readable description of this syncgroup.
+  let description: String
+  /// Permissions governing access to this syncgroup.
+  let permissions: Permissions
+  /// Data (collectionId-rowPrefix pairs) covered by this syncgroup.
+  let prefixes: [CollectionRow]
+  /// Mount tables at which to advertise this syncgroup, for rendezvous purposes.
+  /// (Note that in addition to these mount tables, Syncbase also uses
+  /// network-neighborhood-based discovery for rendezvous.)
+  /// We expect most clients to specify a single mount table, but we accept an
+  /// array of mount tables to permit the mount table to be changed over time
+  /// without disruption.
+  /// TODO(hpucha): Figure out a convention for advertising syncgroups in the
+  /// mount table.
+  let mountTables: [String]
+  /// Specifies the privacy of this syncgroup. More specifically, specifies
+  /// whether blobs in this syncgroup can be served to clients presenting
+  /// blobrefs obtained from other syncgroups.
+  let isPrivate: Bool
+}
diff --git a/lib/Syncbase/Util.h b/lib/Syncbase/Util.h
new file mode 100644
index 0000000..f5ddc42
--- /dev/null
+++ b/lib/Syncbase/Util.h
@@ -0,0 +1,9 @@
+// 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.
+
+#import <Foundation/Foundation.h>
+
+@interface SyncbaseUtil : NSObject
++ (BOOL) catchObjcException:(void (^ _Nonnull)())block error:(NSError * _Nullable * _Nonnull)error;
+@end
\ No newline at end of file
diff --git a/lib/Syncbase/Util.m b/lib/Syncbase/Util.m
new file mode 100644
index 0000000..750b0d5
--- /dev/null
+++ b/lib/Syncbase/Util.m
@@ -0,0 +1,24 @@
+// 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.
+
+#import "Util.h"
+
+@implementation SyncbaseUtil
+
++ (BOOL) catchObjcException:(void (^ _Nonnull)())block error:(NSError * _Nullable * _Nonnull)error {
+  @try {
+    block();
+    return true;
+  } @catch (NSException *exception) {
+    if (!error) return false;
+    *error = [NSError errorWithDomain:@"io.v.Syncbase"
+                                 code:-100
+                             userInfo:@{@"name": exception.name,
+                                        @"reason": exception.reason,
+                                        @"userInfo": exception.userInfo}];
+    return false;
+  }
+}
+
+@end
\ No newline at end of file
diff --git a/lib/Syncbase/Util.swift b/lib/Syncbase/Util.swift
new file mode 100644
index 0000000..4398139
--- /dev/null
+++ b/lib/Syncbase/Util.swift
@@ -0,0 +1,122 @@
+// 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.
+
+import Foundation
+
+internal extension NSNumber {
+  /// Returns true if value can be cast to NSNumber or NSNumber?
+  internal static func isNSNumber<V>(value: V) -> Bool {
+    // Can't do this:
+    // if value is NSNumber {
+    // because it will always succeed through type coercion, even if value is an Int.
+    // Instead we use the dynamic (runtime) type
+    let type = value.dynamicType
+    return type is NSNumber.Type || type is NSNumber?.Type
+  }
+
+  /// Returns true if target can be set/cast from this NSNumber without precision-loss or type
+  /// conversion. For example ```NSNumber.init(bool: true) as Float``` will return a Swift Float of
+  /// value 1, where as this function would return false as the types are unrelated -- only
+  /// casting as Bool would return true. This function checks for 32/64-bit correctness with types.
+  ///
+  /// Caveat: Currently this function makes no attempt to determine signed/unsigned correctness of
+  /// the underlying data, although this is sometimes knowable with NSNumber.objCType.
+  internal func isTargetCastable<T>(inout target: T?) -> Bool {
+    // Allow matching types of this size, and bigger. Signed and unsigned of same size are not allowed.
+    // Swift: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html
+    // C types: https://developer.apple.com/library/ios/documentation/General/Conceptual/CocoaTouch64BitGuide/Major64-BitChanges/Major64-BitChanges.html
+    switch CFNumberGetType(self as CFNumberRef) {
+      // Obj-C bool is stored as Char, but if it's a @(YES) or @(NO) they are all a shared instance.
+    case .CharType where (unsafeAddressOf(self) == unsafeAddressOf(kCFBooleanFalse) ||
+      unsafeAddressOf(self) == unsafeAddressOf(kCFBooleanTrue)):
+      // We know we have a bool... make sure it's compatible
+      let type = target.dynamicType
+      guard type == Bool?.self || type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+      // Handle fixed lengths on 32/64 bit
+    case .SInt8Type, .CharType:
+      let type = target.dynamicType
+      guard type == Int?.self || type == UInt?.self ||
+      type == Int8?.self || type == Int16?.self || type == Int32?.self || type == Int64?.self ||
+      type == UInt8?.self || type == UInt16?.self || type == UInt32?.self || type == UInt64?.self ||
+      type == CChar?.self || type == CShort?.self || type == CInt?.self || type == CLong?.self || type == CLongLong?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+    case .SInt16Type, .ShortType:
+      let type = target.dynamicType
+      guard type == Int?.self || type == UInt?.self ||
+      type == Int16?.self || type == Int32?.self || type == Int64?.self ||
+      type == UInt16?.self || type == UInt32?.self || type == UInt64?.self ||
+      type == CShort?.self || type == CInt?.self || type == CLong?.self || type == CLongLong?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+    case .SInt32Type, .IntType:
+      let type = target.dynamicType
+      guard type == Int?.self || type == UInt?.self ||
+      type == Int32?.self || type == Int64?.self ||
+      type == UInt32?.self || type == UInt64?.self ||
+      type == CInt?.self || type == CLong?.self || type == CLongLong?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+    case .SInt64Type, .LongLongType:
+      let type = target.dynamicType
+      guard (type == Int?.self && sizeof(Int) == sizeof(CLongLong)) ||
+      (type == UInt?.self && sizeof(UInt) == sizeof(CLongLong)) ||
+      type == Int64?.self || type == UInt64?.self ||
+      type == CLongLong?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+    case .Float32Type, .FloatType:
+      let type = target.dynamicType
+      guard type == Float?.self ||
+      type == Double?.self ||
+      type == Float32?.self ||
+      type == Float64?.self ||
+      type == CFloat?.self || type == CDouble?.self || type == CGFloat?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+    case .Float64Type, .DoubleType: /* 64-bit IEEE 754 */
+      let type = target.dynamicType
+      guard type == Double?.self ||
+      type == Float64?.self ||
+      type == CDouble?.self || type == CGFloat?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+
+      // Handle 32/64-bit types
+    case .LongType, .NSIntegerType:
+      let type = target.dynamicType
+      guard type == Int?.self || type == UInt?.self ||
+      (type == Int32?.self && sizeof(Int32) == sizeof(NSInteger)) ||
+      (type == UInt32?.self && sizeof(UInt32) == sizeof(NSInteger)) ||
+      type == Int64?.self || type == UInt64?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self ||
+      type == CLong?.self || type == CLongLong?.self else {
+        return false
+      }
+    case .CGFloatType:
+      let type = target.dynamicType
+      guard (type == Float?.self && sizeof(CGFloat) == sizeof(Float)) ||
+      type == Double?.self ||
+      (type == Float32?.self && sizeof(CGFloat) == sizeof(Float32)) ||
+      type == Float64?.self ||
+      type == NSNumber?.self || type == AnyObject?.self || type == NSObject?.self else {
+        return false
+      }
+      // Misc
+    case .CFIndexType:
+      guard target.dynamicType == CFIndex?.self else {
+        return false
+      }
+    }
+    return true
+  }
+}
diff --git a/lib/Syncbase/Vom.swift b/lib/Syncbase/Vom.swift
new file mode 100644
index 0000000..ad4489f
--- /dev/null
+++ b/lib/Syncbase/Vom.swift
@@ -0,0 +1,7 @@
+// 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.
+
+import Foundation
+
+typealias VomRawBytes = NSData
diff --git a/lib/Syncbase/Watch.swift b/lib/Syncbase/Watch.swift
new file mode 100644
index 0000000..3ec0ac6
--- /dev/null
+++ b/lib/Syncbase/Watch.swift
@@ -0,0 +1,48 @@
+// 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.
+
+import Foundation
+
+public struct ResumeMarker {
+  internal let data: [UInt8]
+}
+
+public struct WatchChange {
+  public enum ChangeType: Int {
+    case PutChange = 0, DeleteDelete
+  }
+
+  /// Collection is the id of the collection that contains the changed row.
+  let collectionId: CollectionId
+
+  /// Row is the key of the changed row.
+  let row: String
+
+  /// ChangeType describes the type of the change. If ChangeType is PutChange,
+  /// then the row exists in the collection, and Value can be called to obtain
+  /// the new value for this row. If ChangeType is DeleteChange, then the row was
+  /// removed from the collection.
+  let changeType: ChangeType
+
+  /// value is the new value for the row if the ChangeType is PutChange, or nil
+  /// otherwise.
+  let value: VomRawBytes
+
+  /// ResumeMarker provides a compact representation of all the messages that
+  /// have been received by the caller for the given Watch call.
+  /// This marker can be provided in the Request message to allow the caller
+  /// to resume the stream watching at a specific point without fetching the
+  /// initial state.
+  let resumeMarker: ResumeMarker
+
+  /// FromSync indicates whether the change came from sync. If FromSync is false,
+  /// then the change originated from the local device.
+  let isFromSync: Bool
+
+  /// If true, this WatchChange is followed by more WatchChanges that are in the
+  /// same batch as this WatchChange.
+  let isContinued: Bool
+}
+
+public typealias WatchStream = AnonymousStream<WatchChange>
diff --git a/lib/SyncbaseTests/JsonTests.swift b/lib/SyncbaseTests/JsonTests.swift
new file mode 100644
index 0000000..3e6eaf5
--- /dev/null
+++ b/lib/SyncbaseTests/JsonTests.swift
@@ -0,0 +1,99 @@
+//
+//  JsonTests.swift
+//  Vanadium
+//
+//  Created by zinman on 4/26/16.
+//  Copyright © 2016 Google, Inc. All rights reserved.
+//
+
+import XCTest
+@testable import Syncbase
+
+class JsonTests: XCTestCase {
+  // Emulate syncbase's put
+  func toJson(any:SyncbaseJsonConvertible) -> (NSData, JsonDataType) {
+    return try! any.toSyncbaseJson()
+  }
+
+  func toString(json:NSData) -> String {
+    return String(data:json, encoding: NSUTF8StringEncoding)!
+  }
+
+  func testBasicEncoding() {
+    var (data, type) = try! 5.toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int)
+
+    (data, type) = toJson(5)
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int)
+
+    (data, type) = try! true.toSyncbaseJson()
+    XCTAssertEqual(toString(data), "true")
+    XCTAssertEqual(type, JsonDataType.Bool)
+
+    (data, type) = try! false.toSyncbaseJson()
+    XCTAssertEqual(toString(data), "false")
+    XCTAssertEqual(type, JsonDataType.Bool)
+
+    (data, type) = try! Int8(5).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int8)
+
+    (data, type) = try! Int16(5).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int16)
+
+    (data, type) = try! Int32(5).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int32)
+
+    (data, type) = try! Int64(5).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5")
+    XCTAssertEqual(type, JsonDataType.Int64)
+
+    (data, type) = try! Int64(Int64(Int32.max) + 10).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "\(Int64(Int32.max) + 10)")
+    XCTAssertEqual(type, JsonDataType.Int64)
+
+    (data, type) = try! Float(5.0).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5") // 5 is ok here since we pass knowledge it's a float
+    XCTAssertEqual(type, JsonDataType.Float)
+
+    (data, type) = try! Double(5.1).toSyncbaseJson()
+    XCTAssertEqual(toString(data), "5.1") // 5 is ok here since we pass knowledge it's a float
+    XCTAssertEqual(type, JsonDataType.Double)
+
+    (data, type) = try! "Hello world! 👠".toSyncbaseJson()
+    XCTAssertEqual(toString(data), "\"Hello world! 👠\"")
+    XCTAssertEqual(type, JsonDataType.String)
+
+    (data, type) = try! [1,2,3,4].toSyncbaseJson()
+    XCTAssertEqual(toString(data), "[1,2,3,4]")
+    XCTAssertEqual(type, JsonDataType.Array)
+
+    (data, type) = toJson([1,2,3,4])
+    XCTAssertEqual(toString(data), "[1,2,3,4]")
+    XCTAssertEqual(type, JsonDataType.Array)
+
+    (data, type) = try! ["a", "b", "c"].toSyncbaseJson()
+    XCTAssertEqual(toString(data), "[\"a\",\"b\",\"c\"]")
+    XCTAssertEqual(type, JsonDataType.Array)
+
+    (data, type) = try! ["a":1].toSyncbaseJson()
+    XCTAssertEqual(toString(data), "{\"a\":1}")
+    XCTAssertEqual(type, JsonDataType.Dictionary)
+
+    (data, type) = try! ["b": true].toSyncbaseJson()
+    XCTAssertEqual(toString(data), "{\"b\":true}")
+    XCTAssertEqual(type, JsonDataType.Dictionary)
+
+    (data, type) = try! ["c": "👠"].toSyncbaseJson()
+    XCTAssertEqual(toString(data), "{\"c\":\"👠\"}")
+    XCTAssertEqual(type, JsonDataType.Dictionary)
+
+    (data, type) = toJson(["c": "👠"])
+    XCTAssertEqual(toString(data), "{\"c\":\"👠\"}")
+    XCTAssertEqual(type, JsonDataType.Dictionary)
+  }
+}
diff --git a/lib/SyncbaseTests/NSNumberTests.swift b/lib/SyncbaseTests/NSNumberTests.swift
new file mode 100644
index 0000000..6e91b6b
--- /dev/null
+++ b/lib/SyncbaseTests/NSNumberTests.swift
@@ -0,0 +1,144 @@
+// 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.
+
+import XCTest
+@testable import Syncbase
+
+class NSNumberTests: XCTestCase {
+  func testISNSNumber() {
+    XCTAssertTrue(NSNumber.isNSNumber(NSNumber(bool: true)))
+    XCTAssertFalse(NSNumber.isNSNumber(true))
+    XCTAssertTrue(NSNumber.isNSNumber(true as AnyObject))
+    XCTAssertTrue(NSNumber.isNSNumber(true as NSNumber))
+    XCTAssertFalse(NSNumber.isNSNumber(""))
+    XCTAssertFalse(NSNumber.isNSNumber(5))
+    XCTAssertTrue(NSNumber.isNSNumber(5 as AnyObject))
+  }
+
+  func testConservationOfPrecision() {
+    var anyobj:AnyObject?
+    var nsnumber:NSNumber?
+    var bool:Bool? = true
+    var int:Int? = Int.max
+    var int8:Int8? = Int8.max
+    var int16:Int16? = Int16.max
+    var int32:Int32? = Int32.max
+    var int64:Int64? = Int64.max
+    var float:Float? = Float(Int32.max)
+    var double:Double? = Double(Int64.max)
+    var long:CLong? = CLong.max
+    var uint:UInt? = UInt.max
+    var uint8:UInt8? = UInt8.max
+    var uint16:UInt16? = UInt16.max
+    var uint32:UInt32? = UInt32.max
+    var uint64:UInt64? = UInt64.max
+    var ulong:CUnsignedLong? = CUnsignedLong.max
+
+    // Preserve booleans
+    XCTAssertTrue((true as NSNumber).isTargetCastable(&bool))
+    XCTAssertTrue((true as NSNumber).isTargetCastable(&anyobj))
+    XCTAssertTrue((true as NSNumber).isTargetCastable(&nsnumber))
+    XCTAssertFalse((true as NSNumber).isTargetCastable(&int))
+    XCTAssertFalse((true as NSNumber).isTargetCastable(&float))
+    XCTAssertFalse((true as NSNumber).isTargetCastable(&long))
+
+    // Preserved size
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&int8))
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&int16))
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&int32))
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&int64))
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&int))
+    XCTAssertTrue(NSNumber(char: int8!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(char: int8!).isTargetCastable(&float))
+    XCTAssertFalse(NSNumber(char: int8!).isTargetCastable(&double))
+
+    XCTAssertFalse(NSNumber(short: int16!).isTargetCastable(&int8))
+    XCTAssertTrue(NSNumber(short: int16!).isTargetCastable(&int16))
+    XCTAssertTrue(NSNumber(short: int16!).isTargetCastable(&int32))
+    XCTAssertTrue(NSNumber(short: int16!).isTargetCastable(&int64))
+    XCTAssertTrue(NSNumber(short: int16!).isTargetCastable(&int))
+    XCTAssertTrue(NSNumber(short: int16!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(short: int16!).isTargetCastable(&float))
+    XCTAssertFalse(NSNumber(short: int16!).isTargetCastable(&double))
+
+    XCTAssertFalse(NSNumber(int: int32!).isTargetCastable(&int8))
+    XCTAssertFalse(NSNumber(int: int32!).isTargetCastable(&int16))
+    XCTAssertTrue(NSNumber(int: int32!).isTargetCastable(&int32))
+    XCTAssertTrue(NSNumber(int: int32!).isTargetCastable(&int64))
+    XCTAssertTrue(NSNumber(int: int32!).isTargetCastable(&int))
+    XCTAssertTrue(NSNumber(int: int32!).isTargetCastable(&uint))
+    XCTAssertTrue(NSNumber(int: int32!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(int: int32!).isTargetCastable(&float))
+    XCTAssertFalse(NSNumber(int: int32!).isTargetCastable(&double))
+
+    if sizeof(CLong) == sizeof(Int64) {
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&int8))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&int16))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&int32))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&int64))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&long))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&int))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&uint))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&float))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&double))
+    } else {
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&int8))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&int16))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&int32))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&int64))
+      XCTAssertTrue(NSNumber(long: int!).isTargetCastable(&long))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&float))
+      XCTAssertFalse(NSNumber(long: int!).isTargetCastable(&double))
+    }
+
+    XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&int8))
+    XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&int16))
+    XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&int32))
+    if sizeof(Int) == sizeof(Int64) {
+      XCTAssertTrue(NSNumber(longLong: int64!).isTargetCastable(&int))
+    } else {
+      XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&int))
+    }
+    XCTAssertTrue(NSNumber(longLong: int64!).isTargetCastable(&int64))
+    XCTAssertTrue(NSNumber(longLong: int64!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&float))
+    XCTAssertFalse(NSNumber(longLong: int64!).isTargetCastable(&double))
+
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int8))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int16))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int32))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&uint8))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&uint16))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&uint32))
+    XCTAssertTrue(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&uint64))
+    XCTAssertTrue(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&ulong))
+    // TODO(zinman): Be smarter about when we allow this or not
+    if sizeof(Int) == sizeof(Int64) {
+      XCTAssertTrue(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int))
+    } else {
+      XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int))
+    }
+    XCTAssertTrue(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&int64))
+    XCTAssertTrue(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&float))
+    XCTAssertFalse(NSNumber(unsignedLongLong: uint64!).isTargetCastable(&double))
+
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&int8))
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&int16))
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&int32))
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&int64))
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&int))
+    XCTAssertFalse(NSNumber(float: float!).isTargetCastable(&long))
+    XCTAssertTrue(NSNumber(float: float!).isTargetCastable(&float))
+    XCTAssertTrue(NSNumber(float: float!).isTargetCastable(&double))
+
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&int8))
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&int16))
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&int32))
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&int64))
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&long))
+    XCTAssertFalse(NSNumber(double: double!).isTargetCastable(&float))
+    XCTAssertTrue(NSNumber(double: double!).isTargetCastable(&double))
+  }
+}
diff --git a/lib/SyncbaseTests/SyncbaseTests.swift b/lib/SyncbaseTests/SyncbaseTests.swift
deleted file mode 100644
index 08a20f0..0000000
--- a/lib/SyncbaseTests/SyncbaseTests.swift
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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.
-
-import XCTest
-@testable import Syncbase
-
-class SyncbaseTests: XCTestCase {
-  override func setUp() {
-    super.setUp()
-    // Put setup code here. This method is called before the invocation of each test method in the class.
-  }
-
-  override func tearDown() {
-    // Put teardown code here. This method is called after the invocation of each test method in the class.
-    super.tearDown()
-  }
-}
diff --git a/lib/Vanadium.xcodeproj/project.pbxproj b/lib/Vanadium.xcodeproj/project.pbxproj
index 5c3f4a2..bf40ad1 100644
--- a/lib/Vanadium.xcodeproj/project.pbxproj
+++ b/lib/Vanadium.xcodeproj/project.pbxproj
@@ -7,10 +7,28 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		305A8E751CCF64E7007656D0 /* Batch.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E641CCF64E7007656D0 /* Batch.swift */; };
+		305A8E761CCF64E7007656D0 /* Blob.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E651CCF64E7007656D0 /* Blob.swift */; };
+		305A8E771CCF64E7007656D0 /* Collection.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E661CCF64E7007656D0 /* Collection.swift */; };
+		305A8E781CCF64E7007656D0 /* Database.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E671CCF64E7007656D0 /* Database.swift */; };
+		305A8E791CCF64E7007656D0 /* Errors.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E681CCF64E7007656D0 /* Errors.swift */; };
+		305A8E7A1CCF64E7007656D0 /* Id.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E691CCF64E7007656D0 /* Id.swift */; };
+		305A8E7B1CCF64E7007656D0 /* Marshal.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6A1CCF64E7007656D0 /* Marshal.swift */; };
+		305A8E7C1CCF64E7007656D0 /* Permissions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6B1CCF64E7007656D0 /* Permissions.swift */; };
+		305A8E7D1CCF64E7007656D0 /* Row.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6C1CCF64E7007656D0 /* Row.swift */; };
+		305A8E7E1CCF64E7007656D0 /* Service.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6D1CCF64E7007656D0 /* Service.swift */; };
+		305A8E7F1CCF64E7007656D0 /* Stream.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6E1CCF64E7007656D0 /* Stream.swift */; };
+		305A8E801CCF64E7007656D0 /* Syncgroup.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E6F1CCF64E7007656D0 /* Syncgroup.swift */; };
+		305A8E811CCF64E7007656D0 /* Util.h in Headers */ = {isa = PBXBuildFile; fileRef = 305A8E701CCF64E7007656D0 /* Util.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		305A8E821CCF64E7007656D0 /* Util.m in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E711CCF64E7007656D0 /* Util.m */; };
+		305A8E831CCF64E7007656D0 /* Util.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E721CCF64E7007656D0 /* Util.swift */; };
+		305A8E841CCF64E7007656D0 /* Vom.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E731CCF64E7007656D0 /* Vom.swift */; };
+		305A8E851CCF64E7007656D0 /* Watch.swift in Sources */ = {isa = PBXBuildFile; fileRef = 305A8E741CCF64E7007656D0 /* Watch.swift */; };
+		30B111C41CCEA9C7000F3750 /* NSNumberTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 30B111C31CCEA9C7000F3750 /* NSNumberTests.swift */; };
+		30B1120B1CCF586C000F3750 /* JsonTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 30B1120A1CCF586C000F3750 /* JsonTests.swift */; };
 		93B980D31CAB9B6100CE42E0 /* Principal.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93B980D21CAB9B6100CE42E0 /* Principal.swift */; };
 		93B980DC1CAB9D3D00CE42E0 /* Syncbase.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B980DB1CAB9D3D00CE42E0 /* Syncbase.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		93B980E31CAB9D3D00CE42E0 /* Syncbase.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 93B980D91CAB9D3D00CE42E0 /* Syncbase.framework */; };
-		93B980E81CAB9D3D00CE42E0 /* SyncbaseTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93B980E71CAB9D3D00CE42E0 /* SyncbaseTests.swift */; };
 		93B980F31CAB9D6E00CE42E0 /* Security.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93B980F21CAB9D6E00CE42E0 /* Security.swift */; };
 		93B980F51CAB9D9000CE42E0 /* Syncbase.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93B980F41CAB9D9000CE42E0 /* Syncbase.swift */; };
 		93BC21591C9E199F0074C612 /* VanadiumCore.h in Headers */ = {isa = PBXBuildFile; fileRef = 93BC21581C9E199F0074C612 /* VanadiumCore.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -118,12 +136,30 @@
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXFileReference section */
+		305A8E641CCF64E7007656D0 /* Batch.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Batch.swift; sourceTree = "<group>"; };
+		305A8E651CCF64E7007656D0 /* Blob.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Blob.swift; sourceTree = "<group>"; };
+		305A8E661CCF64E7007656D0 /* Collection.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Collection.swift; sourceTree = "<group>"; };
+		305A8E671CCF64E7007656D0 /* Database.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Database.swift; sourceTree = "<group>"; };
+		305A8E681CCF64E7007656D0 /* Errors.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Errors.swift; sourceTree = "<group>"; };
+		305A8E691CCF64E7007656D0 /* Id.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Id.swift; sourceTree = "<group>"; };
+		305A8E6A1CCF64E7007656D0 /* Marshal.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Marshal.swift; sourceTree = "<group>"; };
+		305A8E6B1CCF64E7007656D0 /* Permissions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Permissions.swift; sourceTree = "<group>"; };
+		305A8E6C1CCF64E7007656D0 /* Row.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Row.swift; sourceTree = "<group>"; };
+		305A8E6D1CCF64E7007656D0 /* Service.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Service.swift; sourceTree = "<group>"; };
+		305A8E6E1CCF64E7007656D0 /* Stream.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Stream.swift; sourceTree = "<group>"; };
+		305A8E6F1CCF64E7007656D0 /* Syncgroup.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Syncgroup.swift; sourceTree = "<group>"; };
+		305A8E701CCF64E7007656D0 /* Util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Util.h; sourceTree = "<group>"; };
+		305A8E711CCF64E7007656D0 /* Util.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Util.m; sourceTree = "<group>"; };
+		305A8E721CCF64E7007656D0 /* Util.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Util.swift; sourceTree = "<group>"; };
+		305A8E731CCF64E7007656D0 /* Vom.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Vom.swift; sourceTree = "<group>"; };
+		305A8E741CCF64E7007656D0 /* Watch.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Watch.swift; sourceTree = "<group>"; };
+		30B111C31CCEA9C7000F3750 /* NSNumberTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NSNumberTests.swift; sourceTree = "<group>"; };
+		30B1120A1CCF586C000F3750 /* JsonTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JsonTests.swift; sourceTree = "<group>"; };
 		93B980D21CAB9B6100CE42E0 /* Principal.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = Principal.swift; path = security/Principal.swift; sourceTree = "<group>"; };
 		93B980D91CAB9D3D00CE42E0 /* Syncbase.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Syncbase.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		93B980DB1CAB9D3D00CE42E0 /* Syncbase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Syncbase.h; sourceTree = "<group>"; };
 		93B980DD1CAB9D3D00CE42E0 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		93B980E21CAB9D3D00CE42E0 /* SyncbaseTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SyncbaseTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		93B980E71CAB9D3D00CE42E0 /* SyncbaseTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SyncbaseTests.swift; sourceTree = "<group>"; };
 		93B980E91CAB9D3D00CE42E0 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		93B980F21CAB9D6E00CE42E0 /* Security.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Security.swift; sourceTree = "<group>"; };
 		93B980F41CAB9D9000CE42E0 /* Syncbase.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Syncbase.swift; sourceTree = "<group>"; };
@@ -202,10 +238,27 @@
 		93B980DA1CAB9D3D00CE42E0 /* Syncbase */ = {
 			isa = PBXGroup;
 			children = (
-				93B980DB1CAB9D3D00CE42E0 /* Syncbase.h */,
+				305A8E641CCF64E7007656D0 /* Batch.swift */,
+				305A8E651CCF64E7007656D0 /* Blob.swift */,
+				305A8E661CCF64E7007656D0 /* Collection.swift */,
+				305A8E671CCF64E7007656D0 /* Database.swift */,
+				305A8E681CCF64E7007656D0 /* Errors.swift */,
+				305A8E691CCF64E7007656D0 /* Id.swift */,
 				93B980DD1CAB9D3D00CE42E0 /* Info.plist */,
+				305A8E6A1CCF64E7007656D0 /* Marshal.swift */,
+				305A8E6B1CCF64E7007656D0 /* Permissions.swift */,
+				305A8E6C1CCF64E7007656D0 /* Row.swift */,
 				93B980F21CAB9D6E00CE42E0 /* Security.swift */,
+				305A8E6D1CCF64E7007656D0 /* Service.swift */,
+				305A8E6E1CCF64E7007656D0 /* Stream.swift */,
+				93B980DB1CAB9D3D00CE42E0 /* Syncbase.h */,
 				93B980F41CAB9D9000CE42E0 /* Syncbase.swift */,
+				305A8E6F1CCF64E7007656D0 /* Syncgroup.swift */,
+				305A8E701CCF64E7007656D0 /* Util.h */,
+				305A8E711CCF64E7007656D0 /* Util.m */,
+				305A8E721CCF64E7007656D0 /* Util.swift */,
+				305A8E731CCF64E7007656D0 /* Vom.swift */,
+				305A8E741CCF64E7007656D0 /* Watch.swift */,
 			);
 			path = Syncbase;
 			sourceTree = "<group>";
@@ -213,8 +266,9 @@
 		93B980E61CAB9D3D00CE42E0 /* SyncbaseTests */ = {
 			isa = PBXGroup;
 			children = (
-				93B980E71CAB9D3D00CE42E0 /* SyncbaseTests.swift */,
 				93B980E91CAB9D3D00CE42E0 /* Info.plist */,
+				30B111C31CCEA9C7000F3750 /* NSNumberTests.swift */,
+				30B1120A1CCF586C000F3750 /* JsonTests.swift */,
 			);
 			path = SyncbaseTests;
 			sourceTree = "<group>";
@@ -365,6 +419,7 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				305A8E811CCF64E7007656D0 /* Util.h in Headers */,
 				93B980DC1CAB9D3D00CE42E0 /* Syncbase.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -612,8 +667,24 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				305A8E7C1CCF64E7007656D0 /* Permissions.swift in Sources */,
+				305A8E7A1CCF64E7007656D0 /* Id.swift in Sources */,
+				305A8E781CCF64E7007656D0 /* Database.swift in Sources */,
+				305A8E831CCF64E7007656D0 /* Util.swift in Sources */,
+				305A8E761CCF64E7007656D0 /* Blob.swift in Sources */,
+				305A8E801CCF64E7007656D0 /* Syncgroup.swift in Sources */,
+				305A8E821CCF64E7007656D0 /* Util.m in Sources */,
+				305A8E851CCF64E7007656D0 /* Watch.swift in Sources */,
+				305A8E771CCF64E7007656D0 /* Collection.swift in Sources */,
+				305A8E7E1CCF64E7007656D0 /* Service.swift in Sources */,
+				305A8E751CCF64E7007656D0 /* Batch.swift in Sources */,
+				305A8E7D1CCF64E7007656D0 /* Row.swift in Sources */,
 				93B980F31CAB9D6E00CE42E0 /* Security.swift in Sources */,
+				305A8E7F1CCF64E7007656D0 /* Stream.swift in Sources */,
+				305A8E841CCF64E7007656D0 /* Vom.swift in Sources */,
 				93B980F51CAB9D9000CE42E0 /* Syncbase.swift in Sources */,
+				305A8E7B1CCF64E7007656D0 /* Marshal.swift in Sources */,
+				305A8E791CCF64E7007656D0 /* Errors.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -621,7 +692,8 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				93B980E81CAB9D3D00CE42E0 /* SyncbaseTests.swift in Sources */,
+				30B111C41CCEA9C7000F3750 /* NSNumberTests.swift in Sources */,
+				30B1120B1CCF586C000F3750 /* JsonTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
diff --git a/lib/VanadiumCoreTests/PromiseTests.swift b/lib/VanadiumCoreTests/PromiseTests.swift
index ae132cd..3590085 100644
--- a/lib/VanadiumCoreTests/PromiseTests.swift
+++ b/lib/VanadiumCoreTests/PromiseTests.swift
@@ -5,7 +5,7 @@
 import XCTest
 import VanadiumCore
 
-enum TestErrors : ErrorType {
+enum TestErrors: ErrorType {
   case SomeError
   case SomeOtherError
 }
@@ -25,7 +25,7 @@
       }
     try! p.resolve(5)
     XCTAssertTrue(alwaysRan)
-    
+
     var ranNow = false
     p.onResolve { obj in
       ranNow = true
@@ -68,7 +68,7 @@
     }
     try! p.reject(TestErrors.SomeError)
   }
-  
+
   func testRejectionDoesntRunOnResolve() {
     let p = Promise<Int>()
     p.onReject { err in
@@ -76,12 +76,12 @@
     }
     try! p.resolve(5)
   }
-  
+
   func testThenTransforms() {
     let p = Promise<Int>()
     try! p.resolve(5)
-    
-    var finalResult:String = ""
+
+    var finalResult: String = ""
     p.then { obj -> String in
       XCTAssertEqual(obj, 5)
       return "hello"
@@ -94,7 +94,7 @@
 
   func testThenPropagatesError() {
     let p = Promise<Int>()
-    
+
     var didReject = false
     p.then { obj -> String in
       XCTAssertEqual(obj, 5)
@@ -105,7 +105,7 @@
     try! p.reject(TestErrors.SomeError)
     XCTAssertTrue(didReject)
   }
-  
+
   func testThenReturningPromiseWorks() {
     let p = Promise<Int>()
     let bgQueue = dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0)
@@ -116,7 +116,7 @@
       }
       return newP
     }
-    
+
     try! p.resolve(5)
     let finalStatus = try! finalP.await()
     switch (finalStatus) {