diff --git a/package.json b/package.json
index ef22340..ced45b4 100644
--- a/package.json
+++ b/package.json
@@ -21,6 +21,7 @@
     "htmlencode": "^0.0.4",
     "jquery": "^2.1.4",
     "lodash": "^3.10.1",
+    "multimap": "^0.1.1",
     "query-string": "^2.4.0",
     "raf": "^3.1.0",
     "uuid": "^2.0.1"
diff --git a/src/casting-manager.js b/src/casting-manager.js
new file mode 100644
index 0000000..4b861c5
--- /dev/null
+++ b/src/casting-manager.js
@@ -0,0 +1,185 @@
+// 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.
+
+require('es6-shim');
+
+var $ = require('./util/jquery');
+var defineClass = require('./util/define-class');
+
+var Multimap = require('multimap');
+
+var DeviceSync = require('./sync-util/device-sync');
+
+/**
+ * TODO(rosswang): The future of this helper method is a bit unclear given that
+ * someday we will want to support actual vectors.
+ */
+function getGestureDirection(v) {
+    if (v.y < 0 && -v.y > Math.abs(v.x)) {
+      return DeviceSync.UP;
+    }
+    if (v.y > 0 && v.y > Math.abs(v.x)) {
+      return DeviceSync.DOWN;
+    }
+    if (v.x < 0) {
+      return DeviceSync.LEFT;
+    }
+    if (v.x > 0) {
+      return DeviceSync.RIGHT;
+    }
+}
+
+/**
+ * Multimap union.
+ */
+function union(a, b) {
+  var result = new Multimap();
+  function add(value, key) {
+    if (!result.has(key, value)) {
+      result.set(key, value);
+    }
+  }
+  a.forEach(add);
+  b.forEach(add);
+  return result;
+}
+
+/**
+ * Multimap difference.
+ */
+function difference(u, c) {
+  var result = new Multimap();
+  u.forEach(function(value, key) {
+    if (!c.has(key, value)) {
+      result.set(key, value);
+    }
+  });
+  return result;
+}
+
+var CastingManager = defineClass({
+  publics: {
+    /* TODO(rosswang): For now, let's do two-button click and drag as the
+     * casting gesture. Eventually, we'll want to evaluate and support others.
+     */
+    makeCastable: function($handle, opts) {
+      var self = this;
+
+      var castHandler = {
+        buttons: 0
+      };
+
+      $handle.mousedown(function(e) {
+        castHandler.buttons |= 1 << (e.which - 1);
+        if (castHandler.buttons === 5 || castHandler.buttons === 2) {
+          castHandler.origin = {
+            x: e.pageX,
+            y: e.pageY
+          };
+        }
+      });
+
+      function processMouseUpdate(e) {
+        if (castHandler.buttons === 0 && castHandler.origin) {
+          self.interpretCastVector({
+            x: e.pageX - castHandler.origin.x,
+            y: e.pageY - castHandler.origin.y
+          }, opts.spec);
+          delete castHandler.origin;
+        }
+      }
+
+      $(global.document).mousemove(function(e) {
+        if (e.which === 0) {
+          castHandler.buttons = 0;
+          processMouseUpdate(e);
+        }
+      }).mouseup(function(e) {
+        castHandler.buttons &= ~(1 << (e.which - 1));
+        processMouseUpdate(e);
+      });
+    }
+  },
+
+  privates: {
+    getRelatedDevices: function(direction) {
+      switch(direction) {
+      case DeviceSync.UP:
+        return union(this.travelSync.getRelatedDevices(DeviceSync.UP),
+          this.travelSync.getRelatedDevices(DeviceSync.FORWARDS));
+      case DeviceSync.DOWN:
+        return union(this.travelSync.getRelatedDevices(DeviceSync.DOWN),
+          this.travelSync.getRelatedDevices(DeviceSync.BACKWARDS));
+      default:
+        return this.travelSync.getRelatedDevices(direction);
+      }
+    },
+
+    interpretCastVector: function(v, spec) {
+      var self = this;
+
+      var direction = getGestureDirection(v);
+      var related = this.getRelatedDevices(direction);
+      if (related.size === 1) {
+        related.forEach(function(deviceName, owner) {
+          self.cast(owner, deviceName, spec).catch(self.onError);
+        });
+      } else {
+        var unknown = this.travelSync.getUnconnectedCastTargets();
+
+        if (related.size === 0 && unknown.size === 1) {
+          unknown.forEach(function(deviceName, owner) {
+            Promise.all([
+              self.cast(owner, deviceName, spec),
+              self.travelSync.relateDevice(owner, deviceName, {
+                direction: direction,
+                magnitude: DeviceSync.NEAR
+              })
+            ]).catch(self.onError);
+          });
+        } else {
+          var all = this.travelSync.getPossibleCastTargets();
+          var other = difference(all, related);
+
+          if (related.size > 0 || unknown.size > 0 || other.size > 0) {
+            this.onAmbiguousCast(related, unknown, other);
+          } else {
+            this.onNoNearbyDevices();
+          }
+        }
+      }
+    },
+
+    cast: function(targetOwner, targetDeviceName, spec) {
+      var self = this;
+
+      return this.travelSync.cast(targetOwner, targetDeviceName, spec)
+        .then(function() {
+          self.onCast(spec);
+        }, this.onError);
+    }
+  },
+
+  events: {
+    onCast: '',
+    /**
+     * @param related owner => device multimap of related cast candidates
+     * @param unknown owner => device multimap of unconnected cast candidates
+     * @param other owner => device multimap of unrelated connected cast
+     *  candidates
+     */
+    onAmbiguousCast: '',
+    /**
+     * Triggered when a cast is attempted but there are no known nearby devices.
+     */
+    onNoNearbyDevices: '',
+    onError: 'memory'
+  },
+
+  init: function(travelSync, domRoot) {
+    this.travelSync = travelSync;
+  }
+});
+
+module.exports = CastingManager;
\ No newline at end of file
diff --git a/src/components/map-widget.js b/src/components/map-widget.js
index b89c528..6659ad3 100644
--- a/src/components/map-widget.js
+++ b/src/components/map-widget.js
@@ -85,6 +85,10 @@
       this.ensureGeomsVisible(geoms);
     },
 
+    fitBounds: function(bounds) {
+      this.map.fitBounds(bounds);
+    },
+
     ensureVisible: function(place) {
       this.ensureGeomsVisible([place.getGeometry()]);
     },
diff --git a/src/ifc/ops.vdl b/src/ifc/ops.vdl
index 5cab7f3..55dbca2 100644
--- a/src/ifc/ops.vdl
+++ b/src/ifc/ops.vdl
@@ -4,51 +4,7 @@
 
 package ifc
 
-const (
-  Read = "R"
-  Write = "W"
-  Collaborate = "C"
-)
-
-// Stub multicast RPCs to mock Syncbase storage.
-// TODO: allow multiple trips (e.g. multiple planned trips).
-type TravelSync interface {
-  // Gets the current trip.
-  Get() (Trip | error) { Read }
-
-  // Pushes a trip plan to the server instance, optionally with a notification
-  // message (ex. "X has accepted Y's destination proposal.").
-  // To simplify the API, this is the sole API through which the trip plan may
-  // actually be altered.
-  UpdatePlan(plan TripPlan, message string) error { Write }
-
-  // Pushes the current trip status to the server instance, leaving the trip
-  // plan unchanged.
-  UpdateStatus(status TravellerStatus) error { Write }
-
-  // Posts a suggestion to add a destination to the trip plan.
-  SuggestDestinationAddition(
-    destination Destination, at TripStatus, message string) (
-    SuggestionId | error) { Collaborate }
-
-  // Posts a suggestion to add a waypoint to the trip plan.
-  SuggestWaypointAddition(
-    waypoint Waypoint, at TripStatus, message string) (
-    SuggestionId | error) { Collaborate }
-
-  // Posts a suggestion to remove a waypoint or destination from the trip plan.
-  SuggestRemoval(at TripStatus, message string) (
-    SuggestionId | error) { Collaborate }
-
-  // Comments on an existing suggestion.
-  Comment(suggestion SuggestionId, message string) error { Collaborate }
-
-  // Deletes an existing suggestion.
-  DeleteSuggestion(
-    suggestion SuggestionId, message string) error { Collaborate }
-}
-
 type Travel interface {
-  TravelSync
-  // TODO: casting if warranted
+  Cast(spec CastSpec) error
 }
+
diff --git a/src/ifc/types.vdl b/src/ifc/types.vdl
index c8d51c4..9dc1401 100644
--- a/src/ifc/types.vdl
+++ b/src/ifc/types.vdl
@@ -4,46 +4,7 @@
 
 package ifc
 
-type Location complex64
-type Waypoint Location
-type LegId int16
-type WaypointId int16
-type SuggestionId int16
-
-type Destination struct {
-  // TODO; may or may not have an embedded Waypoint
+type CastSpec struct {
+  PanelName string
 }
 
-/*
- * A leg of travel. Each leg has one destination of significance but may be
- * routed through any number of waypoints.
- */
-type Leg struct {
-  Waypoints []Waypoint
-  // Logically, the last waypoint. However, it contains metadata that other
-  // waypoints do not (see Destination struct).
-  Destination Destination
-  // TODO: timeline data
-}
-
-type TripPlan []Leg
-
-type TripStatus struct {
-  CurrentLeg LegId
-  // ID of the next waypoint on the current leg. The leg destination is
-  // considered the last waypoint.
-  NextWaypoint WaypointId
-}
-
-/*
- * Status actually varies by agent/user.
- */
-type TravellerStatus struct {
-  TripStatus TripStatus
-  Location Location
-}
-
-type Trip struct {
-  Plan TripPlan
-  Status map[string]TravellerStatus
-}
diff --git a/src/invitation-manager.js b/src/invitation-manager.js
index f6e4cb7..00db106 100644
--- a/src/invitation-manager.js
+++ b/src/invitation-manager.js
@@ -10,35 +10,13 @@
 var defineClass = require('./util/define-class');
 var debug = require('./debug');
 
-// TODO(rosswang): generalize this
-var ESC = {
-  '_': '_',
-  '.': 'd',
-  '@': 'a'
-};
-
-var INV = {};
-$.each(ESC, function(k, v) {
-  INV[v] = k;
-});
-
-function escapeUsername(str) {
-  return str.replace(/_|\.|@/g, function(m) {
-    return '_' + ESC[m];
-  });
-}
-
-function unescapeUsername(str) {
-  return str.replace(/_(.)/g, function(m, p1) {
-    return INV[p1];
-  });
-}
+var SyncbaseWrapper = require('./vanadium-wrapper/syncbase-wrapper');
 
 function invitationKey(recipient, owner, tripId) {
   return [
     'invitations',
-    escapeUsername(recipient),
-    escapeUsername(owner),
+    SyncbaseWrapper.escapeKeyElement(recipient),
+    SyncbaseWrapper.escapeKeyElement(owner),
     tripId
   ];
 }
@@ -160,7 +138,7 @@
       this.manageTripSyncGroups(data.trips);
 
       var toMe = data.invitations &&
-        data.invitations[escapeUsername(this.username)];
+        data.invitations[SyncbaseWrapper.escapeKeyElement(this.username)];
       if (toMe) {
         $.each(toMe, function(owner, ownerRecords) {
           var ownerInvites = self.invitations[owner];
@@ -176,7 +154,7 @@
               record.seen = true;
             } else {
               if (!uOwner) {
-                uOwner = unescapeUsername(owner);
+                uOwner = SyncbaseWrapper.unescapeKeyElement(owner);
               }
 
               debug.log('Received invite from ' + sender + ' to ' + uOwner +
@@ -233,7 +211,8 @@
 
     sgmPromise.then(function(sgm) {
       sgm.createSyncGroup('invitations',
-          [['invitations', escapeUsername(self.username)]], ['...'])
+          [['invitations', SyncbaseWrapper.escapeKeyElement(self.username)]],
+          ['...'])
         .catch(self.onError);
     });
   }
diff --git a/src/naming.js b/src/naming.js
index cc371c6..02a23ef 100644
--- a/src/naming.js
+++ b/src/naming.js
@@ -18,11 +18,16 @@
   return vanadium.naming.join(appMount(username), deviceName);
 }
 
+function rpcMount(username, deviceName) {
+  return vanadium.naming.join(deviceMount(username, deviceName), 'rpc');
+}
+
 function mountNames(id) {
   return {
     user: userMount(id.username),
     app: appMount(id.username),
-    device: deviceMount(id.username, id.deviceName)
+    device: deviceMount(id.username, id.deviceName),
+    rpc: rpcMount(id.username, id.deviceName)
   };
 }
 
@@ -30,5 +35,6 @@
   userMount: userMount,
   appMount: appMount,
   deviceMount: deviceMount,
+  rpcMount: rpcMount,
   mountNames: mountNames
 };
diff --git a/src/strings.js b/src/strings.js
index 96f726d..6f4ac8d 100644
--- a/src/strings.js
+++ b/src/strings.js
@@ -26,6 +26,9 @@
     add: function(object) {
       return 'Add ' + object.toLowerCase();
     },
+    castingTooltip: 'To cast a panel to a nearby device, middle-click and ' +
+      'drag (or left-right-click and drag) the panel towards the target ' +
+      'device.',
     change: function(object) {
       return 'Change ' + object.toLowerCase();
     },
@@ -69,6 +72,7 @@
         sender + ' invited ' + recipient + ' to join the trip.' :
         'Invited ' + recipient + ' to join the trip.';
     },
+    noNearbyDevices: 'Cannot cast: no nearby devices.',
     'Not connected': 'Not connected',
     notReachable: function(username) {
       return username + ' is not reachable or is not a Travel Planner user.';
diff --git a/src/sync-util/deferred-sb-wrapper.js b/src/sync-util/deferred-sb-wrapper.js
index 9d1d105..8c268bc 100644
--- a/src/sync-util/deferred-sb-wrapper.js
+++ b/src/sync-util/deferred-sb-wrapper.js
@@ -28,6 +28,12 @@
       return this.sbPromise.then(function(syncbase) {
         return syncbase.getData();
       });
+    },
+
+    pull: function(prefix) {
+      return this.sbPromise.then(function(syncbase) {
+        return syncbase.pull(prefix);
+      });
     }
   },
 
diff --git a/src/sync-util/device-sync.js b/src/sync-util/device-sync.js
new file mode 100644
index 0000000..da1b06b
--- /dev/null
+++ b/src/sync-util/device-sync.js
@@ -0,0 +1,451 @@
+// 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.
+
+require('es6-shim');
+
+var $ = require('../util/jquery');
+var defineClass = require('../util/define-class');
+
+var _ = require('lodash');
+var Multimap = require('multimap');
+
+var marshalling = require('./marshalling');
+var SyncbaseWrapper = require('../vanadium-wrapper/syncbase-wrapper');
+var escape = SyncbaseWrapper.escapeKeyElement;
+var unescape = SyncbaseWrapper.unescapeKeyElement;
+
+var HEARTBEAT_PERIOD = 2500; //ms
+var DEVICE_SEEN_RECENTLY = 5000; //ms
+
+var LEFT = 'left';
+var RIGHT = 'right';
+var UP = 'up';
+var DOWN = 'down';
+var FORWARDS = 'forwards';
+var BACKWARDS = 'backwards';
+
+var NEAR = 'near';
+var FAR = 'far';
+
+var RE = 6.371e6;
+
+function cartesian(geo) {
+  var lat = geo.latitude * Math.PI / 180;
+  var lng = geo.longitude * Math.PI / 180;
+  var planeFactor = Math.cos(lng);
+
+  return {
+    x: RE * Math.cos(lat) * planeFactor,
+    y: RE * Math.sin(lat) * planeFactor,
+    z: RE * Math.sin(lng)
+  };
+}
+
+function negateVector(vector) {
+  return {
+    x: -vector.x,
+    y: -vector.y,
+    z: -vector.z
+  };
+}
+
+function negateDirection(direction) {
+  switch(direction) {
+  case LEFT:
+    return RIGHT;
+  case RIGHT:
+    return LEFT;
+  case UP:
+    return DOWN;
+  case DOWN:
+    return UP;
+  case FORWARDS:
+    return BACKWARDS;
+  case BACKWARDS:
+    return FORWARDS;
+  default:
+    return {
+      mean: negateVector(direction.mean),
+      margin: direction.margin
+    };
+  }
+}
+
+var DeviceSync = defineClass({
+  statics: {
+    LEFT: LEFT,
+    RIGHT: RIGHT,
+    UP: UP,
+    DOWN: DOWN,
+    FORWARDS: FORWARDS,
+    BACKWARDS: BACKWARDS,
+    NEAR: NEAR,
+    FAR: FAR,
+
+    deviceKey: function(owner, device) {
+      var mutableArgs = _.flattenDeep(arguments);
+      //arguments 0 and 1 are a username and device ID, respectively
+      //if present, arguments 3 and 4 are that way too
+      for (var i = 0; i <= 4; i++) {
+        if (mutableArgs[i] && i !== 2) {
+          mutableArgs[i] = escape(mutableArgs[i]);
+        }
+      }
+      return ['devices'].concat(mutableArgs);
+    },
+
+    negateRelativePosition: function(relativePosition) {
+      return {
+        direction: negateDirection(relativePosition.direction),
+        magnitude: relativePosition.magnitude
+      };
+    }
+  },
+
+  publics: {
+    relate: function(remoteOwner, remoteDevice, relativePosition) {
+      var self = this;
+
+      return this.identityPromise.then(function(identity) {
+        return self.sbw.batch(function(ops) {
+          return Promise.all([
+            self.relateUnidirectional(ops,
+              identity.username, identity.deviceName,
+              remoteOwner, remoteDevice,
+              relativePosition),
+            self.relateUnidirectional(ops,
+              remoteOwner, remoteDevice,
+              identity.username, identity.deviceName,
+              self.negateRelativePosition(relativePosition))]);
+        });
+      });
+    },
+
+    getRelatedDevices: function(direction) {
+      return this.relatedDevices.get(direction) || new Multimap();
+    },
+
+    getUnconnectedCastTargets: function() {
+      return this.unconnectedCastTargets;
+    },
+
+    getPossibleCastTargets: function() {
+      return this.possibleCastTargets;
+    },
+
+    processDevices: function(data) {
+      var self = this;
+      var now = Date.now();
+      var possibleCastTargets = new Multimap();
+      var unconnectedCastTargets = new Multimap();
+      var connections;
+
+      this.identityPromise.then(function(identity) {
+        var hasCastTargets;
+        $.each(data, function(owner, devices) {
+          owner = unescape(owner);
+
+          $.each(devices, function(deviceName, deviceData) {
+            deviceName = unescape(deviceName);
+            if (owner === identity.username &&
+                deviceName === identity.deviceName) {
+              connections = deviceData.connections;
+            } else if (now - deviceData.lastSeen <= DEVICE_SEEN_RECENTLY) {
+              var deviceLocation = marshalling.unmarshal(deviceData.location);
+              var isNearby = self.isNearby(deviceLocation);
+
+              if (isNearby !== false) {
+                hasCastTargets = true;
+                possibleCastTargets.set(owner, deviceName);
+                unconnectedCastTargets.set(owner, deviceName);
+              }
+            }
+          });
+        });
+
+        /* This could just be a multimap of direction => {owner, deviceName},
+         * but to keep the interface consistent we should have the RHS be a
+         * multimap of owner => deviceName. */
+        var relatedDevices = new Map();
+
+        if (connections) {
+          $.each(connections, function(owner, devices) {
+            owner = unescape(owner);
+            $.each(devices, function(deviceName, relPos) {
+              deviceName = unescape(deviceName);
+              if (unconnectedCastTargets.has(owner, deviceName)) {
+                relPos = marshalling.unmarshal(relPos);
+                // TODO(rosswang): handle vector directions
+                var bucket = relatedDevices.get(relPos.direction);
+                if (!bucket) {
+                  relatedDevices.set(relPos.direction, bucket = new Multimap());
+                }
+
+                bucket.set(owner, deviceName);
+                unconnectedCastTargets.delete(owner, deviceName);
+              }
+            });
+          });
+        }
+
+        if (hasCastTargets && !self.hasCastTargets) {
+          self.onPossibleNearbyDevices();
+        }
+
+        self.hasCastTargets = hasCastTargets;
+        self.possibleCastTargets = possibleCastTargets;
+        self.unconnectedCastTargets = unconnectedCastTargets;
+        self.relatedDevices = relatedDevices;
+      }).catch(this.onError);
+    },
+
+    /*
+     * Adds or updates an "extend" screencast with the given control points.
+     * @param remoteName the Vanadium name of the remote RPC server.
+     * @param adjustment normalized adjustment in local coordinates, { x, y }
+     *
+    extendTo: function(remoteName, adjustment) {
+      if (!this.deviceSetId) {
+        this.deviceSetId = uuid.v4();
+      }
+
+      return this.sbw.put(
+        this.deviceSetKey(this.deviceSetId, this.localName, remoteName),
+        marshalling.marshal(adjustment));
+    },
+
+    handleBoundsUpdate: function(newBounds) {
+      var self = this;
+      var deviceSetId = this.deviceSetId;
+      this.localBounds = newBounds;
+
+      if (this.currentBoundsUpdate) {
+        return this.currentBoundsUpdate;
+      } else {
+        if (deviceSetId) {
+          this.currentBoundsUpdate = this.runOrQueueBoundsUpdate()
+            .catch(function(err) {
+              delete self.currentBoundsUpdate;
+              throw err;
+            });
+          return this.currentBoundsUpdate;
+        } else {
+          return Promise.resolve();
+        }
+      }
+    }*/
+  },
+
+  privates: {
+    relateUnidirectional: function(dao, fromOwner, fromDevice,
+        toOwner, toDevice, relativePosition) {
+      return dao.put(this.deviceKey(
+        fromOwner, fromDevice, 'connections', toOwner, toDevice),
+        marshalling.marshal(relativePosition));
+    },
+
+    heartbeat: function() {
+      var self = this;
+      return this.identityPromise.then(function(identity) {
+        return self.sbw.put(
+          self.deviceKey(identity.username, identity.deviceName, 'lastSeen'),
+          Date.now());
+      });
+    },
+
+    updateGeolocation: function(geolocation) {
+      var self = this;
+
+      this.geolocation = geolocation;
+
+      return this.identityPromise.then(function(identity) {
+        return self.sbw.put(
+          self.deviceKey(identity.username, identity.deviceName, 'location'),
+          self.serializeGeolocation(geolocation));
+      });
+    },
+
+    /**
+     * The properties on these objects don't appear to be enumerable, so
+     * serialize them explicitly here.
+     */
+    serializeGeolocation: function(geolocation) {
+      var coords = geolocation.coords;
+      return marshalling.marshal({
+        coords: {
+          accuracy: coords.accuracy,
+          altitude: coords.altitude,
+          altitudeAccuracy: coords.altitudeAccuracy,
+          heading: coords.heading,
+          latitude: coords.latitude,
+          longitude: coords.longitude,
+          speed: coords.speed
+        },
+        timestamp: geolocation.timestamp
+      });
+    },
+
+    /**
+     * The true calculation here would involve the distance between two
+     * cylinders in spherical space... let's just punt on that for now.
+     *
+     * TODO(rosswang): find a library or factor this out.
+     * location-math seems ideal but doesn't seem to contain any code
+     * coordinate-systems may be suitable
+     *
+     * Also, if we keep doing this based on Cartesian coordinates, cache the
+     * current Cartesian location.
+     */
+    isNearby: function(geolocation) {
+      var a = this.geolocation && this.geolocation.coords || {};
+      var b = geolocation && geolocation.coords || {};
+
+      if (typeof a.altitude === 'number' && typeof b.altitude === 'number' &&
+          typeof a.altitudeAccuracy === 'number' &&
+          typeof b.altitudeAccuracy === 'number' &&
+          Math.abs(a.altitude - b.altitude) >
+          a.altitudeAccuracy + b.altitudeAccuracy + 50) {
+        return false;
+      }
+
+      if (typeof a.latitude === 'number' && typeof b.latitude === 'number' &&
+          typeof a.longitude === 'number' && typeof b.longitude === 'number' &&
+          typeof a.accuracy === 'number' && typeof b.accuracy === 'number') {
+        var va = cartesian(a);
+        var vb = cartesian(b);
+
+        var vd = {
+          x: va.x - vb.x,
+          y: va.y - vb.y,
+          z: va.z - vb.z
+        };
+        var tolerance = a.accuracy + b.accuracy + 50;
+
+        return vd.x * vd.x + vd.y * vd.y + vd.z * vd.z <= tolerance * tolerance;
+      }
+
+      //else return undefined
+    }
+
+    /*
+    runOrQueueBoundsUpdate: function() {
+      var self = this;
+      var delay = this.lastBoundsUpdate === undefined? 0 :
+        MIN_UPDATE_PERIOD - (Date.now() - this.lastBoundsUpdate);
+      console.debug(delay);
+      if (delay > 0) {
+        return new Promise(function(resolve, reject) {
+          setTimeout(function() {
+            resolve(self.runCurrentBoundsUpdate());
+          }, delay);
+        });
+      } else {
+        return this.runCurrentBoundsUpdate();
+      }
+    },
+
+    runCurrentBoundsUpdate: function() {
+      var self = this;
+      var deviceSetId = this.deviceSetId;
+      if (deviceSetId) {
+        console.debug('update');
+        this.lastBoundsUpdate = Date.now();
+
+        return this.sbw.pull(this.deviceSetKey(deviceSetId))
+        .then(function(data) {
+          var update = self.updateNeighborsBounds(
+            data.deviceSets[deviceSetId], self.localBounds);
+          delete self.currentBoundsUpdate;
+          return update;
+        });
+      } else {
+        delete this.currentBoundsUpdate;
+        return Promise.resolve();
+      }
+    },
+
+    updateNeighborsBounds: function(deviceSetData, bounds) {
+      var self = this;
+
+      var promises = [];
+
+      var lnEsc = SyncbaseWrapper.escapeKeyElement(this.localName);
+
+      var forwardsNeighbors = deviceSetData[lnEsc];
+      $.each(forwardsNeighbors, function(neighborName, adjustment) {
+        promises.push(self.updateNeighborBounds(
+          SyncbaseWrapper.unescapeKeyElement(neighborName),
+          bounds, marshalling.unmarshal(adjustment)));
+      });
+
+      $.each(deviceSetData, function(neighborName, neighborNeighbors) {
+        if (neighborName !== lnEsc) {
+          var invAdjustment = marshalling.unmarshal(neighborNeighbors[lnEsc]);
+          if (invAdjustment) {
+            var adjustment = {
+              x: -invAdjustment.x,
+              y: -invAdjustment.y
+            };
+            promises.push(self.updateNeighborBounds(
+              SyncbaseWrapper.unescapeKeyElement(neighborName),
+              bounds, adjustment));
+          }
+        }
+      });
+
+      return Promise.all(promises);
+    },
+
+    transform: function(bounds, adjustment) {
+      var sw = bounds.getSouthWest();
+      var ne = bounds.getNorthEast();
+      var span = bounds.toSpan();
+
+      var offset = new this.maps.LatLng(
+        adjustment.y * span.lat(),
+        adjustment.x * span.lng());
+
+      return new this.maps.LatLngBounds(
+        new this.maps.LatLng(sw.lat() + offset.lat(), sw.lng() + offset.lng()),
+        new this.maps.LatLng(ne.lat() + offset.lat(), ne.lng() + offset.lng()));
+    },
+
+    updateNeighborBounds: function(name, bounds, adjustment) {
+      var neighborBounds = this.transform(bounds, adjustment);
+      return this.updateRemoteBounds(name, neighborBounds);
+    },
+
+    handleMouseMove: function(e) {
+    }*/
+  },
+
+  events: {
+    onError: 'memory',
+    /**
+     * Triggered when devices are discovered (possibly) nearby, where none were
+     * present before.
+     */
+    onPossibleNearbyDevices: ''
+  },
+
+  init: function(maps, identityPromise, deferredSyncbaseWrapper) {
+    var self = this;
+
+    this.maps = maps;
+    this.identityPromise = identityPromise;
+    this.sbw = deferredSyncbaseWrapper;
+
+    function heartbeatLoop() {
+      self.heartbeat();
+      setTimeout(heartbeatLoop, HEARTBEAT_PERIOD);
+    }
+    process.nextTick(heartbeatLoop);
+
+    if (global.navigator && global.navigator.geolocation) {
+      global.navigator.geolocation.watchPosition(this.updateGeolocation);
+    }
+  }
+});
+
+module.exports = DeviceSync;
\ No newline at end of file
diff --git a/src/travel.js b/src/travel.js
index 8699200..6985013 100644
--- a/src/travel.js
+++ b/src/travel.js
@@ -16,6 +16,7 @@
 var Message = require('./components/message');
 var Timeline = require('./components/timeline');
 
+var CastingManager = require('./casting-manager');
 var Destinations = require('./destinations');
 var Identity = require('./identity');
 var TravelSync = require('./travelsync');
@@ -467,6 +468,9 @@
     });
 
     sync.onError.add(error);
+    sync.onPossibleNearbyDevices.add(function() {
+      self.info(strings.castingTooltip);
+    });
     sync.onMessages.add(function(messages) {
       self.messages.push.apply(self.messages, messages);
     });
@@ -545,6 +549,22 @@
 
     this.initMiniFeedback();
 
+    var castingManager = new CastingManager(sync);
+    castingManager.makeCastable($timelineContainer, {
+      spec: {
+        panelName: 'timeline'
+      }
+    });
+    castingManager.onAmbiguousCast.add(function(related, unknown) {
+      console.debug('ambiguous cast');
+      console.debug(related);
+      console.debug(unknown);
+    });
+    castingManager.onNoNearbyDevices.add(function() {
+      self.error(strings.noNearbyDevices);
+    });
+    castingManager.onError.add(error);
+
     destinations.add();
     miniDestinationSearch.focus();
 
diff --git a/src/travelsync.js b/src/travelsync.js
index 3c00064..cf80718 100644
--- a/src/travelsync.js
+++ b/src/travelsync.js
@@ -8,11 +8,14 @@
 
 var defineClass = require('./util/define-class');
 
+var naming = require('./naming');
+
 var SyncgroupManager = require('./syncgroup-manager');
 var InvitationManager = require('./invitation-manager');
 
 var DeferredSbWrapper = require('./sync-util/deferred-sb-wrapper');
 var DestinationSync = require('./sync-util/destination-sync');
+var DeviceSync = require('./sync-util/device-sync');
 var MessageSync = require('./sync-util/message-sync');
 var TripManager = require('./sync-util/trip-manager');
 
@@ -57,11 +60,40 @@
 
     joinTripSyncGroup: function(owner, tripId) {
       return this.tripManager.joinTripSyncGroup(owner, tripId);
+    },
+
+    getRelatedDevices: function(direction) {
+      return this.deviceSync.getRelatedDevices(direction);
+    },
+
+    getUnconnectedCastTargets: function() {
+      return this.deviceSync.getUnconnectedCastTargets();
+    },
+
+    getPossibleCastTargets: function() {
+      return this.deviceSync.getPossibleCastTargets();
+    },
+
+    relateDevice: function(owner, device, relativePosition) {
+      return this.deviceSync.relate(owner, device, relativePosition);
+    },
+
+    cast: function(owner, device, spec) {
+      var self = this;
+      return this.clientPromise(naming.rpcMount(owner, device))
+        .then(function(s) {
+          return self.vanadiumWrapperPromise.then(function(vanadiumWrapper) {
+            return s.cast(vanadiumWrapper.context(),
+              new vdlTravel.CastSpec(spec));
+          });
+        });
     }
   },
 
   privates: {
     processUpdates: function(data) {
+      this.deviceSync.processDevices(data.devices);
+
       this.tripManager.processTrips(data.user && data.user.tripMetadata,
         data.trips);
 
@@ -72,14 +104,16 @@
       this.tripManager.setUpstream();
     },
 
+    getRpcEndpoint: function(args) {
+      return vanadium.naming.join(args.mountNames.device, 'rpc');
+    },
+
     serve: function(args) {
       var self = this;
-      var mountNames = args.mountNames;
       var vanadiumWrapper = args.vanadiumWrapper;
 
       this.status.rpc = 'starting';
-      return vanadiumWrapper.server(
-          vanadium.naming.join(mountNames.device, 'rpc'), this.server)
+      return vanadiumWrapper.server(args.mountNames.rpc, this.server)
         .then(function(server) {
           self.status.rpc = 'ready';
           return server;
@@ -126,7 +160,66 @@
           self.status.userSyncGroup = 'failed';
           throw err;
         });
+    },
+
+    handleCast: function(ctx, serverCall, spec) {
+      console.debug('Cast target for ' + spec.panelName);
+    },
+
+    clientPromise: function(endpoint) {
+      var clientPromise = this.clients[endpoint];
+      if (!clientPromise) {
+        clientPromise = this.clients[endpoint] = this.vanadiumWrapperPromise
+          .then(function(vanadiumWrapper) {
+            return vanadiumWrapper.client(endpoint);
+          });
+      }
+
+      return clientPromise;
     }
+
+    /*
+    updateRemoteBounds: function(name, bounds) {
+      var self = this;
+      var client = this.clients[name];
+      if (!client) {
+        client = this.clients[name] = this.prereqs.then(function(args) {
+          return args.vanadiumWrapper.client(name);
+        });
+      }
+
+      var sw = bounds.getSouthWest();
+      var ne = bounds.getNorthEast();
+
+      return client.then(function(s) {
+        return self.prereqs.then(function(args) {
+          var vBounds = new vdlTravel.LatLngBounds({
+            southWest: new vdlTravel.LatLng({
+              lat: sw.lat(),
+              lng: sw.lng()
+            }),
+            northEast: new vdlTravel.LatLng({
+              lat: ne.lat(),
+              lng: ne.lng()
+            })
+          });
+
+          return s.setBounds(args.vanadiumWrapper.context(), vBounds);
+        });
+      });
+    },
+
+    rpcSetBounds: function(vBounds) {
+      var bounds = new this.maps.LatLngBounds(
+        new this.maps.LatLng(vBounds.southWest.lat,
+          vBounds.southWest.lng),
+        new this.maps.LatLng(vBounds.northEast.lat,
+          vBounds.northEast.lng));
+
+      console.debug('in: ' + bounds);
+
+      this.onSetBounds(bounds);
+    }*/
   },
 
   constants: [ 'invitationManager', 'startup', 'status' ],
@@ -145,6 +238,12 @@
     onError: 'memory',
 
     /**
+     * Triggered when devices are discovered (possibly) nearby, where none were
+     * present before.
+     */
+    onPossibleNearbyDevices: '',
+
+    /**
      * @param messages array of {content, timestamp} pair objects.
      */
     onMessages: '',
@@ -164,11 +263,16 @@
     var self = this;
 
     this.syncbaseName = syncbaseName;
+    this.maps = mapsDependencies.maps;
 
     this.tripStatus = {};
     this.status = {};
+    this.clients = {};
 
-    this.server = new vdlTravel.TravelSync();
+    this.server = new vdlTravel.Travel();
+    this.server.cast = function(ctx, serverCall, spec) {
+      self.handleCast(ctx, serverCall, spec);
+    };
     var startRpc = prereqs.then(this.serve);
     var startSyncbase = prereqs.then(this.connectSyncbase);
 
@@ -184,6 +288,9 @@
     var createPrimarySyncGroup = this.startSyncgroupManager
       .then(this.createPrimarySyncGroup);
 
+    this.vanadiumWrapperPromise = prereqs.then(function(args) {
+      return args.vanadiumWrapper;
+    });
     var usernamePromise = prereqs.then(function(args) {
       return args.identity.username;
     });
@@ -196,6 +303,12 @@
 
     this.messageSync.onMessages.add(this.onMessages);
 
+    this.deviceSync = new DeviceSync(mapsDependencies.maps,
+        prereqs.then(function(args) { return args.identity; }),
+        self.sbw);
+    this.deviceSync.onError.add(this.onError);
+    this.deviceSync.onPossibleNearbyDevices.add(this.onPossibleNearbyDevices);
+
     this.startup = Promise.all([
         startRpc,
         startSyncbase,
diff --git a/src/vanadium-wrapper/index.js b/src/vanadium-wrapper/index.js
index 45b4c0d..076d643 100644
--- a/src/vanadium-wrapper/index.js
+++ b/src/vanadium-wrapper/index.js
@@ -89,6 +89,10 @@
         this.runtime.getContext(), name, perms);
     },
 
+    context: function() {
+      return this.runtime.getContext();
+    },
+
     /**
      * @param endpoint Vanadium name
      * @returns a promise resolving to a client or rejecting with an error.
diff --git a/src/vanadium-wrapper/syncbase-wrapper.js b/src/vanadium-wrapper/syncbase-wrapper.js
index 972d290..9143d7d 100644
--- a/src/vanadium-wrapper/syncbase-wrapper.js
+++ b/src/vanadium-wrapper/syncbase-wrapper.js
@@ -9,6 +9,7 @@
 var vanadium = require('vanadium');
 var verror = vanadium.verror;
 
+var $ = require('../util/jquery');
 var defineClass = require('../util/define-class');
 
 var debug = require('../debug');
@@ -75,6 +76,21 @@
 
 var SG_MEMBER_INFO = new syncbase.nosql.SyncGroupMemberInfo();
 
+// TODO(rosswang): generalize this
+// If this is updated, the regex in escapeKeyElement needs updating too.
+var ESC = {
+  '_': '_',
+  '.': 'd',
+  '@': 'a',
+  '/': 's',
+  ':': 'c'
+};
+
+var INV = {};
+$.each(ESC, function(k, v) {
+  INV[v] = k;
+});
+
 var SyncbaseWrapper = defineClass({
   statics: {
     start: function(context, mountName) {
@@ -85,6 +101,18 @@
       return setUp(context, app, db).then(function() {
         return new SyncbaseWrapper(context, db, mountName);
       });
+    },
+
+    escapeKeyElement: function(str) {
+      return str.replace(/_|\.|@|\/|:/g, function(m) {
+        return '_' + ESC[m];
+      });
+    },
+
+    unescapeKeyElement: function(str) {
+      return str.replace(/_(.)/g, function(m, p1) {
+        return INV[p1];
+      });
     }
   },
 
@@ -177,6 +205,75 @@
       return current;
     },
 
+    /**
+     * @see refresh
+     */
+    pull: function(prefix) {
+      var self = this;
+
+      function repull() {
+        return self.pull(prefix);
+      }
+
+      if (this.writes.size) {
+        debug.log('Syncbase: deferring refresh due to writes in progress');
+        return Promise.all(this.writes)
+          .then(repull, repull);
+
+      } else {
+        this.dirty = false;
+
+        return new Promise(function(resolve, reject) {
+          var newData = {};
+          var abort = false;
+
+          var isHeader = true;
+
+          var query = 'select k, v from t';
+          if (prefix) {
+            query += ' where k like "' + joinKey(prefix) + '%"';
+          }
+
+          self.db.exec(self.context, query, function(err) {
+            if (err) {
+              reject(err);
+            } else if (abort) {
+              //no-op
+            } else if (self.dirty) {
+              debug.log('Syncbase: aborting refresh due to writes');
+              resolve(repull()); //try/wait for idle again
+            } else {
+              resolve(newData);
+            }
+          }).on('data', function(row) {
+            if (isHeader) {
+              isHeader = false;
+              return;
+            }
+
+            if (abort) {
+              //no-op
+            } else if (self.dirty) {
+              abort = true;
+              debug.log('Syncbase: aborting refresh due to writes');
+              resolve(repull()); //try/wait for idle again
+              /* TODO(rosswang): can we abort this stream for real? We could
+               * detach this event handler but then we'd just buffer needless
+               * data until garbage collection, wouldn't we? */
+            } else {
+              recursiveSet(newData, row[0], row[1]);
+            }
+          }).on('error', reject);
+        }).catch(function(err) {
+          if (err instanceof verror.InternalError) {
+            console.error(err);
+          } else {
+            throw err;
+          }
+        });
+      }
+    },
+
     syncGroup: function(sgAdmin, name) {
       var self = this;
 
@@ -312,66 +409,6 @@
       k = joinKey(k);
       debug.log('Syncbase: delete ' + k);
       return fn(this.context, syncbase.nosql.rowrange.prefix(k));
-    },
-
-    /**
-     * @see refresh
-     */
-    pull: function() {
-      var self = this;
-
-      if (this.writes.size) {
-        debug.log('Syncbase: deferring refresh due to writes in progress');
-        return Promise.all(this.writes)
-          .then(this.pull, this.pull);
-
-      } else {
-        this.dirty = false;
-
-        return new Promise(function(resolve, reject) {
-          var newData = {};
-          var abort = false;
-
-          var isHeader = true;
-
-          self.db.exec(self.context, 'select k, v from t', function(err) {
-            if (err) {
-              reject(err);
-            } else if (abort) {
-              //no-op
-            } else if (self.dirty) {
-              debug.log('Syncbase: aborting refresh due to writes');
-              resolve(self.pull()); //try/wait for idle again
-            } else {
-              resolve(newData);
-            }
-          }).on('data', function(row) {
-            if (isHeader) {
-              isHeader = false;
-              return;
-            }
-
-            if (abort) {
-              //no-op
-            } else if (self.dirty) {
-              abort = true;
-              debug.log('Syncbase: aborting refresh due to writes');
-              resolve(self.pull()); //try/wait for idle again
-              /* TODO(rosswang): can we abort this stream for real? We could
-               * detach this event handler but then we'd just buffer needless
-               * data until garbage collection, wouldn't we? */
-            } else {
-              recursiveSet(newData, row[0], row[1]);
-            }
-          }).on('error', reject);
-        }).catch(function(err) {
-          if (err instanceof verror.InternalError) {
-            console.error(err);
-          } else {
-            throw err;
-          }
-        });
-      }
     }
   },
 
diff --git a/test/travel.js b/test/travel.js
index 01ee827..71da800 100644
--- a/test/travel.js
+++ b/test/travel.js
@@ -30,6 +30,7 @@
  */
 var STABLE_SLA = 2500;
 var SYNC_SLA = MockSyncbaseWrapper.SYNC_SLA;
+var DEVICE_DISCOVERY_SLA = 5000;
 
 function cleanDom() {
   $('body').empty();
@@ -227,6 +228,14 @@
   t.deepEqual(simplifyPlace(p2), simplifyPlace(p1), 'markers synced');
 }
 
+function getMessage(instance, index) {
+  var $messageItems = instance.$domRoot.find('.messages ul').children();
+  if (index < 0) {
+    index = $messageItems.length + index;
+  }
+  return $($messageItems[index]);
+}
+
 test('two devices', function(t) {
   failOnError(t);
 
@@ -238,6 +247,16 @@
     assertSameSingletonMarkers(t, ad1, ad2);
     t.equal(ad2.travel.getActiveTripId(), ad1.travel.getActiveTripId(),
       'trips synced');
+
+    setTimeout(afterDisco, DEVICE_DISCOVERY_SLA);
+  }
+
+  function afterDisco() {
+    t.equal(getMessage(ad2, -1).text(),
+      'To cast a panel to a nearby device, middle-click and drag ' +
+      '(or left-right-click and drag) the panel towards the target device.',
+      'casting prompt');
+
     t.end();
   }
 });
@@ -298,7 +317,7 @@
   timeoutify(Promise.all([
     startWithGeo(t, bd1, 'bob', PLACES.GOLDEN_GATE),
     startWithGeo(t, bd2, 'bob', PLACES.SPACE_NEEDLE)
-  ]), t, afterSync, SYNC_SLA);
+  ]), t, afterSync, DEVICE_DISCOVERY_SLA);
 
   function afterSync() {
     t.equal(bd1.map.markers.size, 1, 'one marker (no sync with Alice)');
@@ -307,14 +326,6 @@
   }
 });
 
-function getMessage(instance, index) {
-  var $messageItems = instance.$domRoot.find('.messages ul').children();
-  if (index < 0) {
-    index = $messageItems.length + index;
-  }
-  return $($messageItems[index]);
-}
-
 function invite(senderInstance, recipientUser) {
   senderInstance.$domRoot.find('.send input')
     .prop('value', '/invite ' + recipientUser + '@foogle.com')
@@ -326,7 +337,7 @@
 
   invite(ad2, 'bob');
 
-  t.equal(getMessage(ad2, 1).text(),
+  t.equal(getMessage(ad2, 2).text(),
     'Inviting bob@foogle.com to join the trip...',
     'local invite message');
 
@@ -374,7 +385,7 @@
   }
 
   function afterInvite2() {
-    $invite = getMessage(bd2, 2);
+    $invite = getMessage(bd2, 3);
     $invite.find('a[name=accept]').click();
 
     setTimeout(afterAccept, UI_SLA);
@@ -389,7 +400,7 @@
   }
 
   function afterAcceptSync() {
-    t.equal(getMessage(bd1, 2).text(),
+    t.equal(getMessage(bd1, 3).text(),
       'alice@foogle.com has invited you to join a trip. (Expired)',
       'user accept message');
 
diff --git a/test/travelsync.js b/test/travelsync.js
deleted file mode 100644
index 7721166..0000000
--- a/test/travelsync.js
+++ /dev/null
@@ -1,14 +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.
-
-var test = require('tape');
-
-var Deferred = require('vanadium/src/lib/deferred');
-
-var TravelSync = require('../src/travelsync');
-
-test('init', function(t) {
-  t.ok(new TravelSync(new Deferred().promise), 'initializes');
-  t.end();
-});
\ No newline at end of file